OkHttp3.0(Retrofit2/Rxjava 결합) 차단기를 이용하여 전역 시간 초과 자동 로그인, 통일된 매개 변수 추가

장면 적용: 1.서비스 측은 각 플랫폼, 버전의 사용 상황을 통계하기 위해 인터페이스에 버젼(클라이언트 버전),os(클라이언트 플랫폼 android/iOS),userId 등 통일된 매개 변수를 전달해야 할 때가 있다. 이때 인터페이스에 일일이 추가하면 비교적 번거롭고 전역 처리를 고려한다.또한 한 번 로그인에 성공하면 로그인 상태가 시효가 있기 때문에 로그인 실효가 발생하면 자동으로 로그인 상태를 다시 갱신해야 한다. 또한 일반적인 상황에서 단일 요청은 발송하기 전에 로그인 시간이 초과되었는지 판단할 수 없기 때문에 전체적인 처리 방안이 필요하다.
사실 이것은 Retrofit2/Rxjava와 관련이 없는 것 같습니다. 제목에서 이 항목을 언급한 것은 제 프로젝트가 이 두 라이브러리와 결합해서 사용했기 때문입니다. 제가 이런 문제의 해결 방법을 검색할 때 Retrofit2/Rxjava의retryWhen 방법에서 손을 댔는데 나중에 OkHttpClient에 차단기를 직접 추가하면 원하는 효과를 실현할 수 있고 전체적인 효과를 얻을 수 있다는 것을 발견했습니다.이것은 이런 문제의 가장 간단한 해결 방식일 것이다.
기본 코드는 다음과 같습니다. Network.java

import android.text.TextUtils;
import android.util.Log;

import com.google.gson.Gson;
import com.google.gson.JsonObject;

import org.greenrobot.eventbus.EventBus;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

import okhttp3.Cookie;
import okhttp3.CookieJar;
import okhttp3.FormBody;
import okhttp3.HttpUrl;
import okhttp3.Interceptor;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;
import okhttp3.logging.HttpLoggingInterceptor;
import okio.BufferedSource;
import retrofit2.Call;
import retrofit2.CallAdapter;
import retrofit2.Converter;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava.RxJavaCallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;

public class Network {

    private static final String TAG = "Network";

    private static APIService apis;
    private static ReLoginService reLoginService;

    private static Converter.Factory mExtraGsonConverterFactory = ExtraGsonConverterFactory.create();
    private static CallAdapter.Factory rxJavaCallAdapterFactory = RxJavaCallAdapterFactory.create();

    public static APIService getAPIService() {
        if (apis == null) {
            // TODO       
            HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
            loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);

            // OkHttp3.0     
            OkHttpClient okHttpClient = new OkHttpClient.Builder()
                    .retryOnConnectionFailure(true)
                    .addInterceptor(new Interceptor() {
                        @Override
                        public Response intercept(Chain chain) throws IOException {
                            Request original = chain.request();
                            Request.Builder requestBuilder = original.newBuilder();
                            if (original.body() instanceof FormBody) {
                                FormBody.Builder newFormBody = new FormBody.Builder();
                                FormBody oldFormBody = (FormBody) original.body();
                                for (int i = 0; i < oldFormBody.size(); i++) {
                                    newFormBody.addEncoded(oldFormBody.encodedName(i), oldFormBody.encodedValue(i));
                                }
                                newFormBody.add("os", "android");
                                requestBuilder.method(original.method(), newFormBody.build());
                            } else if (original.body() instanceof MultipartBody) {
                                MultipartBody.Builder newFormBody = new MultipartBody.Builder();
                                //    multipart/mixed，  【     php            】
                                newFormBody.setType(MediaType.parse("multipart/form-data"));
                                MultipartBody oldFormBody = (MultipartBody) original.body();
                                for (int i = 0; i < oldFormBody.size(); i++) {
                                    newFormBody.addPart(oldFormBody.part(i));
                                }
                                newFormBody.addFormDataPart("os", "android");
                                requestBuilder.method(original.method(), newFormBody.build());
                            } else if (TextUtils.equals(original.method(), "POST")) {
                                FormBody.Builder newFormBody = new FormBody.Builder();
                                newFormBody.add("os", "android");
                                requestBuilder.method(original.method(), newFormBody.build());
                            }

                            Request request = requestBuilder.build();
                            return chain.proceed(request);
                        }
                    })
                    .addInterceptor(new Interceptor() {
                        @Override
                        public Response intercept(final Chain chain) throws IOException {
                            //     
                            Request request = chain.request();
                            Response response = chain.proceed(request);
                            ResponseBody responseBody = response.body();
                            BufferedSource source = responseBody.source();
                            source.request(Long.MAX_VALUE);
                            String respString = source.buffer().clone().readString(Charset.defaultCharset());
                            Log.d(TAG, "--->    ，respString = " + respString);
                            // TODO               
                            JSONObject j = null;
                            try {
                                j = new JSONObject(respString);
                            } catch (JSONException e) {
                                e.printStackTrace();
                            }
                            //            700      【   java，       cookie，  token  。       token，     】
                            if (j!= null && j.optInt("status") == 700) {
                                Log.d(TAG, "--->    ，      ");
                                // TODO         user  
                                UserInfo  user = SysApplication.getInstance().getDB().getCurrentUser();
                                if (user == null) {
                                    Log.d(TAG, "--->             ");
                                    //              （BaseSubscriber   ）
                                    throw new ExtraApiException(700, "   ");
                                }
                                String phoneNum = user.getPhoneNum();
                                String password = user.getPass();
                                Call call = getReloginService().reLogin(phoneNum, password);
                                JsonObject json = call.execute().body();
                                //          
                                if (json.get("status").getAsInt() == 200) {
                                    // TODO      ，          、     
                                    //                 !!!
                                    response = chain.proceed(request);
                                    Log.d(TAG, "--->      ");
                                } else {
                                    Log.d(TAG, "--->      ");
                                    // TODO              （BaseSubscriber   ，              ，              ）
                                    throw new ExtraApiException(700, "     ");
                                }
                            }
                            return response;
                        }
                    })
                    .cookieJar(new CookieJar() {
                        List cookies;
                        @Override
                        public void saveFromResponse(HttpUrl url, List cookies) {
                             // TODO           ，  cookies
                        }

                        @Override
                        public List loadForRequest(HttpUrl url) {

                            return cookies;
                        }
                    })
                    .addInterceptor(loggingInterceptor)
                    .build();

            Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl(Constant.HOST_APP)
                    .addConverterFactory(mExtraGsonConverterFactory)
                    .addCallAdapterFactory(rxJavaCallAdapterFactory)
                    .client(okHttpClient)
                    .build();
            apis = retrofit.create(APIService.class);
        }
        return apis;
    }


    //              interface ，                Gson   ，             status，       
    //      ，        ，   cookie   
    public static ReLoginService getReloginService() {
        if (reLoginService == null) {
            // TODO       
            HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
            loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);

            // OkHttp3.0     
            OkHttpClient okHttpClient = new OkHttpClient.Builder()
                    .addInterceptor(loggingInterceptor)
                    .cookieJar(new CookieJar() {
                        @Override
                        public void saveFromResponse(HttpUrl url, List cookies) {
                            // TODO
                        }

                        @Override
                        public List loadForRequest(HttpUrl url) {
                            return new ArrayList<>();
                        }
                    })
                    .build();

            Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl(Constant.HOST_APP)
                    .addConverterFactory(GsonConverterFactory.create())
                    .client(okHttpClient)
                    .build();
            reLoginService = retrofit.create(ReLoginService.class);
        }
        return reLoginService;

    }
}

ExtraGsonResponseBodyConverter.java 이것은 사용자 정의 해석기로서 서비스 측이 되돌아오는 가장 바깥쪽 정보를 제거하고 내부의 유효한 정보체만 보존하는 역할을 한다.또한 되돌아오는 status를 통일적으로 처리하고 사용자 정의 이상을 던진 다음에 전역적으로 통일된 Subscriber에서 onError 처리를 할 수 있다.

import android.text.TextUtils;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;

import org.json.JSONException;
import org.json.JSONObject;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.charset.Charset;

import okhttp3.MediaType;
import okhttp3.ResponseBody;
import retrofit2.Converter;

import static okhttp3.internal.Util.UTF_8;

final class ExtraGsonResponseBodyConverter implements Converter {
    private final Gson gson;
    private final TypeAdapter adapter;

    ExtraGsonResponseBodyConverter(Gson gson, TypeAdapter adapter) {
        this.gson = gson;
        this.adapter = adapter;
    }

    @Override
    public T convert(ResponseBody value) throws IOException {
        try {
            JSONObject response = new JSONObject(value.string());


            //        ，      ，  Subscriber onError    
            if (response.optInt("status") != 200) {
                value.close();
                throw new ExtraApiException(response.optInt("status"), response.optString("message"));
            }

            //        、   ，        ……
            String info = response.optString("json");
            if (TextUtils.isEmpty(info)) {
                info = response.optString("resultList");
            }
            if (TextUtils.isEmpty(info) || TextUtils.equals(info.toLowerCase(), "null")) {
                info = "{}";
            }

            MediaType contentType = value.contentType();
            Charset charset = contentType != null ? contentType.charset(UTF_8) : UTF_8;


            InputStream inputStream = new ByteArrayInputStream(info.getBytes());
            Reader reader = new InputStreamReader(inputStream, charset);
            JsonReader jsonReader = gson.newJsonReader(reader);

            return adapter.read(jsonReader);
        } catch (JSONException e) {
            throw new IOException();
        } finally {
            value.close();
        }
    }
}

ReLoginService.java 별도의 재로그인 요청에 사용되며 서버에서 돌아오는 모든 정보체를 보존합니다.

import com.google.gson.JsonObject;

import retrofit2.Call;
import retrofit2.http.Field;
import retrofit2.http.FormUrlEncoded;
import retrofit2.http.POST;


public interface ReLoginService {

    /**
     *   
     *
     * @param name    
     * @param pass ，  
     */
    @FormUrlEncoded
    @POST("msLogin")
    Call reLogin(
            @Field("name") String name,
            @Field("pass") String pass
    );
}

이로써 문제 해결의 주요 사고방식은 OkHttpClient의 OkHttpClient 방법을 이용하는 것이다.

기존 요청을 재조립

응답 정보를 미리 처리하고 대응하는 것이 로그인이 효력을 상실하면 다시 로그인하고 로그인에 성공하면 원래의 요청을 다시 실행한다.로그인에 성공하지 못하면 사용자가 직접 로그인하도록 알림

이 밖에 몇 가지 설명이 있다.

사용자 정의ConverterFactory는 반환된 정보의 잘못된 정보나 과도한 등급을 통일적으로 처리하고 단일 요청이 성공한 후의 처리 논리를 간소화하는 데 유리하다

사용자 정의 Exception은 전역적으로 통일된 Subscriber(RxJava 결합)에서 이상을 처리하는 데 유리하다

요청 정보를 보조적으로 볼 수 있는 Http Logging Interceptor입니다. 마지막으로ddInterceptor를 진행해야 합니다. 그렇지 않으면 이전에 처리한 (cookie, 추가된 매개 변수)를 로그에서 볼 수 없습니다