Rénovation de 2 manière Élégante d'ajouter des en-têtes au niveau de l'api

Mon Rénovation 2 (2.0.2 actuellement) le client a besoin d'ajouter des en-têtes personnalisés à la demande.

Je suis en utilisant un Interceptor pour ajouter ces en-têtes à toutes les demandes:

OkHttpClient httpClient = new OkHttpClient();
httpClient.networkInterceptors().add(new Interceptor() {
    @Override
    public Response intercept(Chain chain) throws IOException {
        final Request request = chain.request().newBuilder()
                .addHeader("CUSTOM_HEADER_NAME_1", "CUSTOM_HEADER_VALUE_1")
                .addHeader("CUSTOM_HEADER_NAME_2", "CUSTOM_HEADER_VALUE_2")
                ...
                .addHeader("CUSTOM_HEADER_NAME_N", "CUSTOM_HEADER_VALUE_N")
                .build();

        return chain.proceed(request);
    }
});


Retrofit retrofitClient = new Retrofit.Builder()
        .baseUrl(baseUrl)
        .client(httpClient)
        .build();

Certains en-têtes j'ai toujours envie d'ajouter, mais certains en-têtes que j'ai seulement besoin d'ajouter basant sur les exigences propres à un point de terminaison, par exemple si l'utilisateur doit être authentifié ou non.

J'aimerais avoir la capacité de contrôle au niveau de l'api, par exemple à l'aide d'une annotation, quelque chose comme:

public interface MyApi {
    @NO_AUTH
    @POST("register")
    Call<RegisterResponse> register(@Body RegisterRequest data);

    @GET("user/{userId}")
    Call<GetUserResponse> getUser(@Path("userId") String userId);
}

Lors de l'envoi d'une demande de register il n'y a pas besoin d'ajouter le jeton d'authentification, mais les demandes qui n'ont pas la @NO_AUTH annotation aura le jeton d'en-tête.

De ce que je comprends de Rénovation 2 ne prend pas en charge personnalisée des annotations, et alors que je trouve cette solution de contournement pour Personnalisé avec Annotations de Rénovation 2, il semble un peu trop.

Je voudrais éviter la nécessité de transmettre ces en-têtes par demande, comme:

public interface MyApi {
    @POST("register")
    Call<RegisterResponse> register(@Body RegisterRequest data);

    @GET("user/{userId}")
    Call<GetUserResponse> getUser(@Header("AuthToken") String token, @Path("userId") String userId);
}

Il se sent juste redondant de le faire chaque fois que j'appelle la méthode au lieu de le faire dans l'intercepteur (depuis que j'ai accès à l'en-tête de valeurs statique).
J'ai juste un peu besoin de savoir dans mon Interceptor.intercept mise en œuvre de savoir si ou non de cette demande spécifique doit avoir un en-tête spécifique(s).

Aucune idée de comment je peux faire ce travail?
Je préfère une solution générique et pas seulement pour l'auth jeton cas, mais une solution spécifique est la bienvenue.
Grâce

OriginalL'auteur Nitzan Tomer | 2016-06-10

  1. 26

    Je suis venu avec une très simple et élégant (à mon avis) de solution à mon problème, et probablement pour d'autres scénarios.

    - Je utiliser le Headers annotation de passer mon custom annotations, et depuis OkHttp exige d'eux qu'ils suivent la Name: Value format, j'ai décidé que mon format: @: ANNOTATION_NAME.

    Donc en gros:

    public interface MyApi {
    @POST("register")
    @HEADERS("@: NoAuth")
    Call<RegisterResponse> register(@Body RegisterRequest data);

    @GET("user/{userId}")
    Call<GetUserResponse> getUser(@Path("userId") String userId);
}

    Alors je peux intercepter la demande, vérifier si j'ai une annotation avec le nom @. Si oui, j'obtiens la valeur et de supprimer l'en-tête de la demande.

    Cela fonctionne bien, même si vous voulez avoir plus d'un "annotations personnalisées":

    @HEADERS({
    "@: NoAuth",
    "@: LogResponseCode"
})

    Voici comment extraire tous ces "personnalisé annotations" et de les retirer de la demande:

    new OkHttpClient.Builder().addNetworkInterceptor(new Interceptor() {
    @Override
    public okhttp3.Response intercept(Chain chain) throws IOException {
        Request request = chain.request();

        List<String> customAnnotations = request.headers().values("@");

        //do something with the "custom annotations"

        request = request.newBuilder().removeHeader("@").build();
        return chain.proceed(request);
    }
});
    Est-ce à dire que vous êtes en utilisant de nouveaux OkHttpClient pour chaque demande ?
    Pas de. C'était juste pour l'exemple, vous pouvez avoir un seul client.
    C'est la solution la plus propre en fait, merci pour le partage 🙂
    bien conçu solution. il fonctionne bien, mais je me demandais pourquoi le HttpLoggingInterceptor montre encore @: NoAuth dans l'en-tête. est-ce parce qu'il est intercepté avant d'être retiré ?
    Pouvez-vous ajouter le HttpLoggingInterceptor après celui-ci, ou est-ce un problème?

    OriginalL'auteur Nitzan Tomer

  2. 4

    Peut-être que vous pouvez le faire que par la création de différents Rénovation objet d'usine méthode comme ceci.

    public class RestClient {
    public static <S> S createService(Class<S> serviceClass) {
        OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
        OkHttpClient client = httpClient.build();

        Retrofit retrofit = new Retrofit.Builder().baseUrl(APIConfig.BASE_URL)
                .client(client)
                .build();
        return retrofit.create(serviceClass);
    }

    public static <S> S createServiceWithAuth(Class<S> serviceClass) {
        Interceptor interceptor = new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                final Request request = chain.request().newBuilder()
                        .addHeader("CUSTOM_HEADER_NAME_1", "CUSTOM_HEADER_VALUE_1")
                        .addHeader("CUSTOM_HEADER_NAME_2", "CUSTOM_HEADER_VALUE_2")
                        .build();

                return chain.proceed(request);
            }
        };
        OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
        httpClient.addInterceptor(interceptor);
        OkHttpClient client = httpClient.build();

        Retrofit retrofit = new Retrofit.Builder().baseUrl(APIConfig.BASE_URL)
                .client(client)
                .build();
        return retrofit.create(serviceClass);
    }
}

    si vous souhaitez appeler l'api sans en-tête d'authentification, vous pouvez les appeler createService méthode:

    YourApi api = RestClient.createService(YourApi.class);

    Et l'utilisation createServiceWithAuth méthode si vous voulez appeler l'api d'authentification:

    YourApiWithAuth api = RestClient.createServiceWithAuth(YourApiWithAuth.class);
    Merci, c'est une bonne solution, mais il m'oblige à regrouper les points de terminaison dans les différentes classes en fonction de si oui ou non les demandes doivent être authentifiés, et ce n'est pas très pratique.

    OriginalL'auteur ikhsan