Aktualisieren des OAuth-Tokens mithilfe von Retrofit, ohne alle Aufrufe zu ändern

Wir verwenden Retrofit in unserer Android-App, um mit einem OAuth2-gesicherten Server zu kommunizieren. Alles funktioniert hervorragend. Wir verwenden den RequestInterceptor, um das Zugriffstoken bei jedem Aufruf einzuschließen. Es wird jedoch Zeiten geben, in denen das Zugriffstoken abläuft und das Token aktualisiert werden muss. Wenn das Token abläuft, wird der nächste Aufruf mit einem nicht autorisierten HTTP-Code zurückgegeben, sodass die Überwachung einfach ist. Wir können jeden Retrofit-Aufruf folgendermaßen ändern: Überprüfen Sie im Fehlerrückruf, ob der Fehlercode Unauthorized entspricht, aktualisieren Sie das OAuth-Token und wiederholen Sie den Retrofit-Aufruf. Zu diesem Zweck sollten jedoch alle Anrufe geändert werden, was keine leicht zu wartende und gute Lösung ist. Gibt es eine Möglichkeit, dies zu tun, ohne alle Retrofit-Aufrufe zu ändern?

Bitte nicht verwenden Interceptors, um mit der Authentifizierung umzugehen.

Derzeit ist der beste Ansatz für die Authentifizierung die Verwendung der neuen AuthenticatorAPI, die speziell für diesen Zweck entwickelt wurde .

OkHttp fragt automatisch nach den AuthenticatorAnmeldeinformationen, wenn eine Antwort die 401 Not Authorised letzte fehlgeschlagene Anforderung mit ihnen wiederholt .

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;
    }

Befestigen Sie ein Authenticatoran einem, OkHttpClientwie Sie es tunInterceptors

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

Verwenden Sie diesen Client beim Erstellen Ihres Retrofit RestAdapter

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

Wenn Sie Retrofit > = 1.9.0verwenden, können Sie den neuen Interceptor von OkHttp verwenden , der in eingeführt wurde OkHttp 2.2.0. Sie möchten einen Application Interceptor verwenden , mit dem Sie dies tun können retry and make multiple calls.

Ihr Interceptor könnte ungefähr so ​​aussehen wie dieser Pseudocode:

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;
    }

}

Nachdem Sie Ihre definiert haben Interceptor, erstellen Sie eine OkHttpClientund fügen Sie den Interceptor als Application Interceptor hinzu .

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

Und schließlich verwenden Sie dies OkHttpClientbeim Erstellen Ihrer RestAdapter.

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

Warnung: Wie Jesse Wilson(von Square) hier erwähnt , ist dies eine gefährliche Menge an Kraft.

Angesichts dessen denke ich definitiv, dass dies der beste Weg ist, so etwas jetzt zu handhaben. Wenn Sie Fragen haben, zögern Sie bitte nicht, in einem Kommentar zu fragen.

TokenAuthenticator hängt von einer Serviceklasse ab. Die Serviceklasse hängt von einer OkHttpClient-Instanz ab. Um einen OkHttpClient zu erstellen, benötige ich den TokenAuthenticator. Wie kann ich diesen Kreislauf durchbrechen? Zwei verschiedene OkHttpClients? Sie werden verschiedene Verbindungspools haben.

Wenn Sie beispielsweise eine Nachrüstung haben TokenService, die Sie in Ihrem AuthenticatorGerät benötigen, aber nur eine einrichten möchten, für die OkHttpClientSie eine TokenServiceHolderals Abhängigkeit verwenden können TokenAuthenticator. Sie müssten einen Verweis darauf auf Anwendungsebene (Singleton) pflegen. Dies ist einfach, wenn Sie Dolch 2 verwenden. Andernfalls erstellen Sie einfach ein Klassenfeld in Ihrer Anwendung.

Im 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;
    }
}

Client-Setup:

//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);

Wenn Sie Dagger 2 oder ein ähnliches Framework für die Abhängigkeitsinjektion verwenden, finden Sie in den Antworten auf diese Frage einige Beispiele

Die Verwendung von TokenAuthenticatorlike @ theblang answer ist eine korrekte Methode für den Umgang refresh_token.

Hier ist mein Gerät (ich habe Kotlin, Dagger, RX verwendet, aber Sie können diese Idee für die Implementierung in Ihrem Fall verwenden).
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()
    }
}

Um einen Abhängigkeitszyklus wie @Brais Gabin Kommentar zu verhindern, erstelle ich 2 Schnittstellen wie

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>
}

und

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

AccessTokenWrapper Klasse

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 Klasse

data class AccessToken(
        @Expose
        var token: String,

        @Expose
        var refreshToken: String)

Mein Abfangjäger

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())
    }
}

Fügen Sie schließlich Interceptorund Authenticatorzu Ihrem OKHttpClientbeim Erstellen des Dienstes hinzuFügen Sie PotoAuthApi hinzu

Demo

https://github.com/PhanVanLinh/AndroidMVPKotlin

Hinweis

• Beispiel API gibt getImage()401 Fehlercode zurück
• authenticateMethode im Inneren TokenAuthenticatorwird ausgelöst
• Synchronisieren noneAuthAPI.refreshToken(...)aufgerufen
• Nach der noneAuthAPI.refreshToken(...)Antwort -> wird ein neues Token zum Header hinzugefügt
• getImage()wird AUTO mit neuem Header aufgerufen (wird diesen Anruf HttpLogging NICHT protokollieren ) ( interceptinnen wird AuthInterceptor NICHT aufgerufen )

• Wenn getImage()immer noch mit Fehler 401, gescheitert authenticateMethode innerhalb TokenAuthenticatorWillen feuerte wieder und wieder , dann wird es Fehler über Call - Methode viel Zeit werfen ( java.net.ProtocolException: Too many follow-up requests). Sie können dies verhindern, indem Sie die Antwort zählen . Beispiel : Wenn Sie return nullin authenticatenach 3 - mal wiederholt, getImage()wird beenden undreturn response 401

• Wenn die getImage()Antwort erfolgreich ist =>, erhalten wir das Ergebnis normal (wie Sie es getImage()ohne Fehler aufrufen ).

Hoffe es hilft

Ich weiß, dass dies ein alter Thread ist, aber nur für den Fall, dass jemand darüber stolpert.

TokenAuthenticator hängt von einer Serviceklasse ab. Die Serviceklasse hängt von einer OkHttpClient-Instanz ab. Um einen OkHttpClient zu erstellen, benötige ich den TokenAuthenticator. Wie kann ich diesen Kreislauf durchbrechen? Zwei verschiedene OkHttpClients? Sie werden verschiedene Verbindungspools haben.

Ich hatte das gleiche Problem, aber ich wollte nur einen OkHttpClient erstellen, da ich nicht glaube, dass ich nur für den TokenAuthenticator selbst einen anderen benötige. Ich habe Dagger2 verwendet, sodass ich die Serviceklasse als Lazy in den TokenAuthenticator, können Sie mehr über faule Injektion in Dolch 2 lesen hier , aber es ist wie im Grunde zu Dagger sagen zu nicht gehen und den Service des TokenAuthenticator sofort benötigt erstellen.

In diesem SO-Thread finden Sie Beispielcode: Wie kann eine zirkuläre Abhängigkeit aufgelöst werden, während Dagger2 noch verwendet wird?

Sie können versuchen, eine Basisklasse für alle Ihre Loader zu erstellen, in der Sie eine bestimmte Ausnahme abfangen und dann nach Bedarf handeln können. Stellen Sie sicher, dass sich alle Ihre verschiedenen Lader von der Basisklasse aus erstrecken, um das Verhalten zu verbreiten.

Nach langer Recherche habe ich den Apache-Client so angepasst, dass er das Aktualisieren von AccessToken für die Nachrüstung übernimmt, in dem Sie das Zugriffstoken als Parameter senden.

Initiieren Sie Ihren Adapter mit Cookie Persistent Client

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

Cookie Persistenter Client, der Cookies für alle Anforderungen verwaltet und bei jeder Anforderungsantwort prüft. Wenn es sich um einen nicht autorisierten Zugriff handelt, ERROR_CODE = 401, aktualisiert das Zugriffstoken und ruft die Anforderung ab, andernfalls verarbeitet er nur die Anforderung.

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;
    }
}

Die Verwendung eines Interceptors (Injizieren des Tokens) und eines Authenticators (Aktualisierungsvorgänge) erledigt den Job, aber:

Ich hatte auch ein Problem mit einem doppelten Anruf: Der erste Anruf gab immer einen 401 zurück : Das Token wurde beim ersten Anruf (Interceptor) nicht injiziert und der Authentifikator wurde aufgerufen: Es wurden zwei Anforderungen gestellt.

Das Update bestand nur darin, die Anforderung an den Build im Interceptor erneut zu aktivieren:

VOR:

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

NACH DEM:

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

IN EINEM BLOCK:

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

Ich hoffe es hilft.

Bearbeiten: Ich habe keine Möglichkeit gefunden, den ersten Aufruf zu vermeiden, immer 401 nur mit dem Authentifikator und ohne Interceptor zurückzugeben

Für alle, die gleichzeitige / parallele Anrufe beim Aktualisieren des Tokens lösen möchten. Hier ist eine Problemumgehung

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
    }
}