Aggiornamento del token OAuth mediante Retrofit senza modificare tutte le chiamate

Stiamo utilizzando Retrofit nella nostra app Android per comunicare con un server protetto OAuth2. Tutto funziona alla grande, utilizziamo RequestInterceptor per includere il token di accesso ad ogni chiamata. Tuttavia, ci saranno momenti in cui il token di accesso scadrà e il token dovrà essere aggiornato. Alla scadenza del token, la chiamata successiva verrà restituita con un codice HTTP non autorizzato, quindi è facile da monitorare. È possibile modificare ogni chiamata di Retrofit nel modo seguente: Nel callback di errore, verificare il codice di errore, se è uguale a Non autorizzato, aggiornare il token OAuth, quindi ripetere la chiamata di Retrofit. Tuttavia, per questo, tutte le chiamate dovrebbero essere modificate, il che non è facilmente gestibile e una buona soluzione. C'è un modo per farlo senza modificare tutte le chiamate di Retrofit?

Si prega di non utilizzare Interceptorsper gestire l'autenticazione.

Attualmente, l'approccio migliore per gestire l'autenticazione è utilizzare la nuova AuthenticatorAPI, progettata appositamente per questo scopo .

OkHttp chiederà automaticamente le Authenticatorcredenziali quando una risposta 401 Not Authorised riprova con loro l' ultima richiesta non riuscita .

public class TokenAuthenticator implements Authenticator {
    @Override
    public Request authenticate(Proxy proxy, Response response) throws IOException {
        // Refresh your access_token using a synchronous api request
        newAccessToken = service.refreshToken();

        // Add new header to rejected request and retry it
        return response.request().newBuilder()
                .header(AUTHORIZATION, newAccessToken)
                .build();
    }

    @Override
    public Request authenticateProxy(Proxy proxy, Response response) throws IOException {
        // Null indicates no attempt to authenticate.
        return null;
    }

Attaccalo Authenticatorallo OkHttpClientstesso modo in cui lo faiInterceptors

OkHttpClient okHttpClient = new OkHttpClient();
okHttpClient.setAuthenticator(authAuthenticator);

Usa questo client quando crei il tuo Retrofit RestAdapter

RestAdapter restAdapter = new RestAdapter.Builder()
                .setEndpoint(ENDPOINT)
                .setClient(new OkClient(okHttpClient))
                .build();
return restAdapter.create(API.class);

Se stai usando Retrofit > = 1.9.0allora puoi usare il nuovo Interceptor di OkHttp , che è stato introdotto in OkHttp 2.2.0. Si desidera utilizzare un intercettore di applicazioni , che consente di retry and make multiple calls.

Il tuo Interceptor potrebbe assomigliare a questo pseudocodice:

public class CustomInterceptor implements Interceptor {

    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();

        // try the request
        Response response = chain.proceed(request);

        if (response shows expired token) {

            // get a new token (I use a synchronous Retrofit call)

            // create a new request and modify it accordingly using the new token
            Request newRequest = request.newBuilder()...build();

            // retry the request
            return chain.proceed(newRequest);
        }

        // otherwise just pass the original response on
        return response;
    }

}

Dopo aver definito il tuo Interceptor, crea un OkHttpCliente aggiungi l'interceptor come Application Intercceptor .

    OkHttpClient okHttpClient = new OkHttpClient();
    okHttpClient.interceptors().add(new CustomInterceptor());

E infine, usalo OkHttpClientquando crei il tuo RestAdapter.

    RestService restService = new RestAdapter().Builder
            ...
            .setClient(new OkClient(okHttpClient))
            .create(RestService.class);

Avvertenza: come Jesse Wilson(da Square) menziona qui , questa è una quantità pericolosa di potenza.

Detto questo, penso sicuramente che questo sia il modo migliore per gestire qualcosa del genere ora. Se avete domande, non esitate a chiedere in un commento.

TokenAuthenticator dipende una classe di servizio. La classe di servizio dipende da un'istanza di OkHttpClient. Per creare un OkHttpClient ho bisogno del TokenAuthenticator. Come posso interrompere questo ciclo? Due diversi client OkHttp? Avranno diversi pool di connessioni ..

Se hai, diciamo, un Retrofit di TokenServicecui hai bisogno all'interno del tuo, Authenticatorma ti piacerebbe crearne uno OkHttpClientper il quale puoi utilizzare TokenServiceHoldercome dipendenza TokenAuthenticator. Dovresti mantenere un riferimento ad esso a livello di applicazione (singleton). Questo è facile se stai usando Dagger 2, altrimenti crea semplicemente un campo di classe all'interno della tua Applicazione.

Nel TokenAuthenticator.java

public class TokenAuthenticator implements Authenticator {

    private final TokenServiceHolder tokenServiceHolder;

    public TokenAuthenticator(TokenServiceHolder tokenServiceHolder) {
        this.tokenServiceHolder = tokenServiceHolder;
    }

    @Override
    public Request authenticate(Proxy proxy, Response response) throws IOException {

        //is there a TokenService?
        TokenService service = tokenServiceHolder.get();
        if (service == null) {
            //there is no way to answer the challenge
            //so return null according to Retrofit's convention
            return null;
        }

        // Refresh your access_token using a synchronous api request
        newAccessToken = service.refreshToken().execute();

        // Add new header to rejected request and retry it
        return response.request().newBuilder()
                .header(AUTHORIZATION, newAccessToken)
                .build();
    }

    @Override
    public Request authenticateProxy(Proxy proxy, Response response) throws IOException {
        // Null indicates no attempt to authenticate.
        return null;
    }

In TokenServiceHolder.java:

public class TokenServiceHolder {

    TokenService tokenService = null;

    @Nullable
    public TokenService get() {
        return tokenService;
    }

    public void set(TokenService tokenService) {
        this.tokenService = tokenService;
    }
}

Configurazione client:

//obtain instance of TokenServiceHolder from application or singleton-scoped component, then
TokenAuthenticator authenticator = new TokenAuthenticator(tokenServiceHolder);
OkHttpClient okHttpClient = new OkHttpClient();    
okHttpClient.setAuthenticator(tokenAuthenticator);

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .client(okHttpClient)
    .build();

TokenService tokenService = retrofit.create(TokenService.class);
tokenServiceHolder.set(tokenService);

Se si utilizza Dagger 2 o un framework di iniezione di dipendenza simile, ci sono alcuni esempi nelle risposte a questa domanda

L' TokenAuthenticatoruso della risposta like @theblang è un modo corretto per gestire refresh_token.

Ecco il mio attrezzo (ho usato Kotlin, Dagger, RX ma puoi usare questa idea come attrezzo per il tuo caso)
TokenAuthenticator

class TokenAuthenticator @Inject constructor(private val noneAuthAPI: PotoNoneAuthApi, private val accessTokenWrapper: AccessTokenWrapper) : Authenticator {

    override fun authenticate(route: Route, response: Response): Request? {
        val newAccessToken = noneAuthAPI.refreshToken(accessTokenWrapper.getAccessToken()!!.refreshToken).blockingGet()
        accessTokenWrapper.saveAccessToken(newAccessToken) // save new access_token for next called
        return response.request().newBuilder()
                .header("Authorization", newAccessToken.token) // just only need to override "Authorization" header, don't need to override all header since this new request is create base on old request
                .build()
    }
}

Per prevenire il ciclo di dipendenza come il commento di @Brais Gabin, creo 2 interfacce come

interface PotoNoneAuthApi { // NONE authentication API
    @POST("/login")
    fun login(@Body request: LoginRequest): Single<AccessToken>

    @POST("refresh_token")
    @FormUrlEncoded
    fun refreshToken(@Field("refresh_token") refreshToken: String): Single<AccessToken>
}

e

interface PotoAuthApi { // Authentication API
    @GET("api/images")
    fun getImage(): Single<GetImageResponse>
}

AccessTokenWrapper classe

class AccessTokenWrapper constructor(private val sharedPrefApi: SharedPrefApi) {
    private var accessToken: AccessToken? = null

    // get accessToken from cache or from SharePreference
    fun getAccessToken(): AccessToken? {
        if (accessToken == null) {
            accessToken = sharedPrefApi.getObject(SharedPrefApi.ACCESS_TOKEN, AccessToken::class.java)
        }
        return accessToken
    }

    // save accessToken to SharePreference
    fun saveAccessToken(accessToken: AccessToken) {
        this.accessToken = accessToken
        sharedPrefApi.putObject(SharedPrefApi.ACCESS_TOKEN, accessToken)
    }
}

AccessToken classe

data class AccessToken(
        @Expose
        var token: String,

        @Expose
        var refreshToken: String)

Il mio intercettore

class AuthInterceptor @Inject constructor(private val accessTokenWrapper: AccessTokenWrapper): Interceptor {

    override fun intercept(chain: Interceptor.Chain): Response {
        val originalRequest = chain.request()
        val authorisedRequestBuilder = originalRequest.newBuilder()
                .addHeader("Authorization", accessTokenWrapper.getAccessToken()!!.token)
                .header("Accept", "application/json")
        return chain.proceed(authorisedRequestBuilder.build())
    }
}

Infine, aggiungi Interceptore Authenticatoral tuo OKHttpClientquando crei il servizio PotoAuthApi

dimostrazione

https://github.com/PhanVanLinh/AndroidMVPKotlin

Nota

• Esempio di getImage()codice di ritorno 401 errore API
• authenticateil metodo all'interno TokenAuthenticatorverrà attivato
• Sincronizza noneAuthAPI.refreshToken(...)chiamato
• Dopo la noneAuthAPI.refreshToken(...)risposta -> il nuovo token verrà aggiunto all'intestazione
• getImage()verrà chiamato AUTO con la nuova intestazione ( HttpLogging NON registrerà questa chiamata) ( interceptall'interno AuthInterceptor NON verrà CHIAMATO )

• Se il problema getImage()persiste con l'errore 401, il authenticatemetodo interno TokenAuthenticatorverrà nuovamente AGAIN e AGAIN, quindi verrà generato più volte il metodo call ( java.net.ProtocolException: Too many follow-up requests). Puoi prevenirlo contando la risposta . Esempio, se return nullnel authenticatedopo 3 volte riprovare, getImage()sarà finire ereturn response 401

• Se la getImage()risposta ha esito positivo => si otterrà il risultato normalmente (come si chiama getImage()senza errori)

Spero che sia d'aiuto

Conosco questo vecchio thread, ma nel caso qualcuno ci fosse inciampato.

TokenAuthenticator dipende una classe di servizio. La classe di servizio dipende da un'istanza di OkHttpClient. Per creare un OkHttpClient ho bisogno del TokenAuthenticator. Come posso interrompere questo ciclo? Due diversi client OkHttp? Avranno diversi pool di connessioni ..

Stavo affrontando lo stesso problema, ma volevo creare solo un OkHttpClient perché non penso di averne bisogno solo per il TokenAuthenticator stesso, stavo usando Dagger2, quindi ho finito per fornire la classe di servizio come Lazy iniettato nel TokenAuthenticator, puoi leggere di più sull'iniezione Lazy nel pugnale 2 qui , ma è come dire sostanzialmente a Dagger di NON andare subito a creare il servizio necessario per TokenAuthenticator.

È possibile fare riferimento a questo thread SO per il codice di esempio: come risolvere una dipendenza circolare mentre si utilizza ancora Dagger2?

Puoi provare a creare una classe base per tutti i tuoi caricatori in cui sarai in grado di catturare una particolare eccezione e quindi agire di cui hai bisogno. Fai estendere tutti i tuoi diversi caricatori dalla classe base per diffondere il comportamento.

Dopo lunghe ricerche, ho personalizzato il client Apache per gestire AccessToken di aggiornamento per il retrofit in cui si invia il token di accesso come parametro.

Avvia il tuo adattatore con cookie Client persistente

restAdapter = new RestAdapter.Builder()
                .setEndpoint(SERVER_END_POINT)
                .setClient(new CookiePersistingClient())
                .setLogLevel(RestAdapter.LogLevel.FULL).build();

Cookie Client persistente che mantiene i cookie per tutte le richieste e verifica con ogni risposta richiesta, se si tratta di accesso non autorizzato ERROR_CODE = 401, aggiorna il token di accesso e richiama la richiesta, altrimenti elabora solo la richiesta.

private static class CookiePersistingClient extends ApacheClient {

    private static final int HTTPS_PORT = 443;
    private static final int SOCKET_TIMEOUT = 300000;
    private static final int CONNECTION_TIMEOUT = 300000;

    public CookiePersistingClient() {
        super(createDefaultClient());
    }

    private static HttpClient createDefaultClient() {
        // Registering https clients.
        SSLSocketFactory sf = null;
        try {
            KeyStore trustStore = KeyStore.getInstance(KeyStore
                    .getDefaultType());
            trustStore.load(null, null);

            sf = new MySSLSocketFactory(trustStore);
            sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (UnrecoverableKeyException e) {
            e.printStackTrace();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (CertificateException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        HttpParams params = new BasicHttpParams();
        HttpConnectionParams.setConnectionTimeout(params,
                CONNECTION_TIMEOUT);
        HttpConnectionParams.setSoTimeout(params, SOCKET_TIMEOUT);
        SchemeRegistry registry = new SchemeRegistry();
        registry.register(new Scheme("https", sf, HTTPS_PORT));
        // More customization (https / timeouts etc) can go here...

        ClientConnectionManager cm = new ThreadSafeClientConnManager(
                params, registry);
        DefaultHttpClient client = new DefaultHttpClient(cm, params);

        // Set the default cookie store
        client.setCookieStore(COOKIE_STORE);

        return client;
    }

    @Override
    protected HttpResponse execute(final HttpClient client,
            final HttpUriRequest request) throws IOException {
        // Set the http context's cookie storage
        BasicHttpContext mHttpContext = new BasicHttpContext();
        mHttpContext.setAttribute(ClientContext.COOKIE_STORE, COOKIE_STORE);
        return client.execute(request, mHttpContext);
    }

    @Override
    public Response execute(final Request request) throws IOException {
        Response response = super.execute(request);
        if (response.getStatus() == 401) {

            // Retrofit Callback to handle AccessToken
            Callback<AccessTockenResponse> accessTokenCallback = new Callback<AccessTockenResponse>() {

                @SuppressWarnings("deprecation")
                @Override
                public void success(
                        AccessTockenResponse loginEntityResponse,
                        Response response) {
                    try {
                        String accessToken =  loginEntityResponse
                                .getAccessToken();
                        TypedOutput body = request.getBody();
                        ByteArrayOutputStream byte1 = new ByteArrayOutputStream();
                        body.writeTo(byte1);
                        String s = byte1.toString();
                        FormUrlEncodedTypedOutput output = new FormUrlEncodedTypedOutput();
                        String[] pairs = s.split("&");
                        for (String pair : pairs) {
                            int idx = pair.indexOf("=");
                            if (URLDecoder.decode(pair.substring(0, idx))
                                    .equals("access_token")) {
                                output.addField("access_token",
                                        accessToken);
                            } else {
                                output.addField(URLDecoder.decode(
                                        pair.substring(0, idx), "UTF-8"),
                                        URLDecoder.decode(
                                                pair.substring(idx + 1),
                                                "UTF-8"));
                            }
                        }
                        execute(new Request(request.getMethod(),
                                request.getUrl(), request.getHeaders(),
                                output));
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                }

                @Override
                public void failure(RetrofitError error) {
                    // Handle Error while refreshing access_token
                }
            };
            // Call Your retrofit method to refresh ACCESS_TOKEN
            refreshAccessToken(GRANT_REFRESH,CLIENT_ID, CLIENT_SECRET_KEY,accessToken, accessTokenCallback);
        }

        return response;
    }
}

Utilizzando un intercettore (iniettare il token) e un autenticatore (operazioni di aggiornamento) eseguono il lavoro ma:

Ho anche avuto un doppio problema di chiamata: la prima chiamata restituiva sempre un 401 : il token non veniva iniettato alla prima chiamata (intercettore) e veniva chiamato l'autenticatore: venivano fatte due richieste.

La correzione era solo per riapplicare la richiesta alla build in Interceptor:

PRIMA:

private Interceptor getInterceptor() {
    return (chain) -> {
        Request request = chain.request();
        //...
        request.newBuilder()
                .header(AUTHORIZATION, token))
                .build();
        return chain.proceed(request);
    };
}

DOPO:

private Interceptor getInterceptor() {
    return (chain) -> {
        Request request = chain.request();
        //...
        request = request.newBuilder()
                .header(AUTHORIZATION, token))
                .build();
        return chain.proceed(request);
    };
}

IN UN BLOCCO:

private Interceptor getInterceptor() {
    return (chain) -> {
        Request request = chain.request().newBuilder()
                .header(AUTHORIZATION, token))
                .build();
        return chain.proceed(request);
    };
}

Spero che sia d'aiuto.

Modifica: non ho trovato un modo per evitare che la prima chiamata restituisse sempre 401 usando solo l'autenticatore e nessun intercettore

A chiunque volesse risolvere chiamate simultanee / parallele durante l'aggiornamento del token. Ecco una soluzione alternativa

class TokenAuthenticator: Authenticator {

    override fun authenticate(route: Route?, response: Response?): Request? {
        response?.let {
            if (response.code() == 401) {
                while (true) {
                    if (!isRefreshing) {
                        val requestToken = response.request().header(AuthorisationInterceptor.AUTHORISATION)
                        val currentToken = OkHttpUtil.headerBuilder(UserService.instance.token)

                        currentToken?.let {
                            if (requestToken != currentToken) {
                                return generateRequest(response, currentToken)
                            }
                        }

                        val token = refreshToken()
                        token?.let {
                            return generateRequest(response, token)
                        }
                    }
                }
            }
        }

        return null
    }

    private fun generateRequest(response: Response, token: String): Request? {
        return response.request().newBuilder()
                .header(AuthorisationInterceptor.USER_AGENT, OkHttpUtil.UA)
                .header(AuthorisationInterceptor.AUTHORISATION, token)
                .build()
    }

    private fun refreshToken(): String? {
        synchronized(TokenAuthenticator::class.java) {
            UserService.instance.token?.let {
                isRefreshing = true

                val call = ApiHelper.refreshToken()
                val token = call.execute().body()
                UserService.instance.setToken(token, false)

                isRefreshing = false

                return OkHttpUtil.headerBuilder(token)
            }
        }

        return null
    }

    companion object {
        var isRefreshing = false
    }
}