等待 Android Studio 中 Retrofit2 回调中的请求

Question

I try to get better with retrofit requests and custom callbacks in my application. When I log in, my backend generates a token for the user. Every X seconds/minutes , my token becomes deprecated and I need to generate/refresh a new token when I do a new request.

The problem I have is that when the token is deprecated, I can't generate a new one before the request.

In MainActivity.java

ApiService mApiService = RetrofitClientInstance.getRetrofitInstance().create(ApiService.class);

Call < Data > call = mApiService.getData(config.token, params); //My actual token and some custom parameters

call.enqueue(new MyCallback < Data > () {
            @Override
            public void onResponse(Call < Data > call, Response < Data > response) {
                super.onResponse(call, response);
                config.data = response.body(); //configuration class where I store the result of the request
                startActivity(new Intent(this, NewActivity.class);
                }

                @Override
                public void onFailure(Call < Data > call, Throwable t) {
                    super.onFailure(call, t);
                }
            });

In MyCallback.java

public class MyCallback < T > implements Callback < T > {

   private String TAG = "MyCallback";
   private ApiService mApiService = ConnectionsRequest.getApiService();
   @Override
   public void onResponse(Call < T > call, Response < T > response) {
       if (new Gson().toJson(response.body()).contains("needrefreshtoken")) {
           Log.i(TAG, "Generate new token");
           mApiService.getRefreshToken(config.login.getRefreshToken()).enqueue(new Callback() {
               @Override
               public void onResponse(Call < RefreshToken > call, Response < RefreshToken > response) {
                   config.token = response.body().getNewToken();
                   Log.i(TAG, "New token generated");
               }

               @Override
               public void onFailure(Call < RefreshToken > call, Throwable t) {
                   super.onFailure(call, t);
               }
           });
       }

   }

   @Override
   public void onFailure(Call < T > call, Throwable t) {
       Log.e(TAG, t.toString());
   }
}

It seems like I do the main request before (or during) the refresh token request.

How can I improve my code to do this step by step (refresh the token then do the main request)?

Thanks for your help.

Answer 1

We have remember below things when using dynamic header integration (tokens).

1. Token may be expiry at any time when we using app
2. Error 401 in api's.

so we need the callback for detect token expired when calling api, so we use Authendicator , It's will trigger when our api getting 401(add authenticator class if you have send token with api).

If you getting 401, call your refresh api and then again recall your existing api with new token.

Authendicator:

class TokenAuthenticator implements Authenticator {

        @Nullable
        @Override
        public Request authenticate(@NonNull Route route, @NonNull Response response) throws IOException {
           //call your refersh token api 

            //returned new request with updated header
            return response.request().newBuilder()
                    .header("AUTHORIZATION", "new token from refresh token api")
                    .build();
        }
    }

Then add Authendicator to your okhttp client

 .authenticator(new TokenAuthenticator())

Answer 2

So i have found a custom solution that works. I hope I will help people with that. I wanted to simplify as much as I can the requests, so this is how looks an http request :

MainActivity.java

@OnClick(R.id.button)
@Optional
void onClickButton()
{
        JsonObject params = new JsonObject();
        params.addProperty("key", "value");

        Call < MyModel > call = myApiService.postCustomRequest(params);
        RetrofitCallback.enqueue(call, new Callback < MyModel >() {
            @Override
            public void onResponse(@NonNull Call<NewIncidentData> call, @NonNull Response<NewIncidentData> response) {
                //Do you stuff here, no need to add custom request code
            }

            @Override
            public void onFailure(@NonNull Call<NewIncidentData> call, @NonNull Throwable t) {
                  //Same here
            }
        });

}

RetrofitCallback.java

public class RetrofitCallback {
    public static <T> void enqueue(Call<T> call, final Callback<T> callback) {
        Log.i(TAG, "HTTP Request : " + call.request().url());
        call.enqueue(new CustomCallback<T>(call) {
            @Override
            public void onResponse(Call<T> call,  Response<T> response) {
                super.onResponse(call, response);
                if(call.isCanceled())
                    return;
                callback.onResponse(call, response);
            }

            @Override
            public void onFailure(Call<T> call, Throwable t) {
                super.onFailure(call, t);
                callback.onFailure(call, t);
            }
        });
    }
}

CustomCallback.java

public class CustomCallback<T> implements Callback<T> {

    private String TAG = "CustomCallback";
    private ApiService mApiService = ConnectionsRequest.getApiService();
    private Config config = Config.getInstance();

    public CustomCallback(Call<T> call) {
        this.call = call;
    }

    @Override
    public void onResponse(Call<T> main_call, Response<T> response) {
        //Check if the token is still valid
        if (new Gson().toJson(response.body()).contains("needrefreshtoken")) {
            Log.i(TAG, "Generate new token");
            main_call.cancel();
            RetrofitCallback.enqueue(mApiService.getToken(config.refreshtoken()), new Callback<TokenModel>() {
                @Override
                public void onResponse(@NonNull Call<TokenModel> call, @NonNull Response<TokenModel> response) {
                    config.token = response.body().getToken();
                    Log.i(TAG, "New token generated and saved");
                    retryMainRequest();
                }

                @Override
                public void onFailure( @NonNull Call<TokenModel> call, @NonNull Throwable t) {

                }
            });

        }

    }

    @Override
    public void onFailure(Call<T> call, Throwable t) {
        Log.e(TAG, t.toString());
    }

    private void retryMainRequest() {
        Log.i(TAG, "Retry request");
        call.clone().enqueue(this);
    }
}

EDIT : I forget some code :

RetrofitClientInstance.java

public class RetrofitClientInstance {
    private static Retrofit retrofit;
    private static final String BASE_URL = "myurl.com";

    public static Retrofit getRetrofitInstance() {

        OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
        httpClient.addNetworkInterceptor(new AuthInterceptor()); // I added that

            retrofit = new retrofit2.Retrofit.Builder()
                    .baseUrl(BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create())
                    .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                    .client(httpClient.build())
                    .build();
        return retrofit;
    }
}

AuthInterceptor.java

public class AuthInterceptor implements Interceptor {

    Config config = Config.getInstance();
    @Override
    public Response intercept(Chain chain) throws IOException
    {

        Request request = chain.request();
        request = request.newBuilder()
                .addHeader("X-AUTH-TOKEN", config.token).build();

        return chain.proceed(request);
    }
}