Rafraîchissant jeton OAuth à l'aide de Rénovation sans modifier tous les appels

S'il vous plaît ne pas utiliser Interceptors pour s'occuper d'authentification.

Actuellement, la meilleure approche pour gérer l'authentification consiste à utiliser la nouvelle Authentificateur API, conçu spécifiquement pour les cet effet.

OkHttp sera automatiquement demander la Authenticator pour les informations d'identification lorsqu'une réponse est 401 Not Authorised nouvelle tentative de la dernière demande en échec avec eux.

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

Joindre un Authenticator à un OkHttpClient de la même manière que vous le faites avec Interceptors

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

Utiliser ce client lors de la création de votre Retrofit RestAdapter

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

TokenAuthenticator dépend de la classe du service. La classe de service dépend d'une OkHttpClient instance. Pour créer un OkHttpClient j'ai besoin de la TokenAuthenticator. Comment puis-je briser ce cycle? Deux OkHttpClients? Ils vont avoir des différents pools de connexion..

Si vous avez, disons, une Rénovation TokenService que vous avez besoin à l'intérieur de votre Authenticator mais seulement comme un OkHttpClient vous pouvez utiliser un TokenServiceHolder comme une dépendance de TokenAuthenticator. Vous devez conserver une référence à l'application (singleton) niveau. C'est facile si vous êtes à l'aide de la Dague à 2, sinon, il suffit de créer une classe de terrain à l'intérieur de votre Application.

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

Dans TokenServiceHolder.java:

public class TokenServiceHolder {

    TokenService tokenService = null;

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

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

L'installation du 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);

Si vous êtes à l'aide de la Dague à 2 ou similaire à celle de l'injection de dépendances cadre il y a quelques exemples dans les réponses aux cette question

Je sais que ce un vieux thread, mais juste au cas où quelqu'un a trébuché en elle.

TokenAuthenticator dépend de la classe du service. La classe de service dépend d'une OkHttpClient instance. Pour créer un OkHttpClient j'ai besoin de la TokenAuthenticator. Comment puis-je briser ce cycle? Deux OkHttpClients? Ils vont avoir des différents pools de connexion..

J'ai été confrontée au même problème, mais je voulais créer un seul OkHttpClient parce que je ne pense pas que j'ai besoin d'un autre pour tout le TokenAuthenticator lui-même, j'ai été en utilisant Dagger2, j'ai donc fini par fournir le service de classe comme Paresseux injecté dans le TokenAuthenticator, vous pouvez en lire plus à propos de Paresseux injection dans dague 2 ici, mais c'est comme le dit essentiellement à la Dague, à PAS aller et de créer le service requis par la TokenAuthenticator tout de suite.

Vous pouvez vous référer à ce fil pour un exemple de code: Comment résoudre une dépendance circulaire, tout en utilisant Dagger2?

Après de Longues recherches, je l'ai adapté Apache client pour gérer Rafraîchissante AccessToken De Rénovation Dans lequel vous envoyer jeton d'accès en tant que paramètre.

Lancer votre Carte avec cookie Persistant Client

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

Cookie Persistant client qui gère les cookies pour toutes les demandes et vérifie à chaque demande de réponse, si c'est un accès non autorisé CODE_ERREUR = 401, actualiser jeton d'accès et de rappel de la demande, d'autre juste processus de demande.

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

À tous ceux qui voulaient résoudre simultanée/parallèle des appels lors de l'actualisation de jeton. Voici une solution de contournement

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