java - Patrones de diseño de Android Retrofit

retrofit2

Question

Estoy usando Retrofit para interactuar con mi API REST, y me preguntaba si alguien tiene alguna sugerencia de diseño.

Mi aplicación tiene los siguientes paquetes:

1. modelos
2. servicios
3. ocupaciones
4. fragmentos

El paquete de servicios contiene las interfaces para Retrofit. Por ejemplo:

public interface FooService {
    @FormUrlEncoded
    @POST("foo/do")
    @Headers("Content-Type: application/x-www-form-urlencoded; charset=UTF-8")
    Call<FooBar> do();
}

Modelos contiene ... bueno, los diferentes modelos. Por ejemplo, FooBar . Hasta ahora todo bien, de acuerdo con la documentación de Retrofit.

He creado una clase API, que maneja la lógica de compilación Retrofit ( Retrofit retrofit = new Retrofit.Builder() etc.), y expone un campo estático: retrofit. En mis actividades, puedo realizar mis solicitudes de la siguiente manera:

FooService service = API.retrofit.create(FooService.class);
Call<FooBar> call = service.do();

try {
    retrofit2.Response response = call.execute();
    // ...do stuff...
} catch(IOException) {}

Y aquí viene mi pregunta: ¿Sería mejor resumir más lo anterior? ¿Para que no necesite repetir lo anterior en todas partes? Por ejemplo, algo como:

MyOtherFooService service = new  MyOtherFooService();
FooBar fooBar = service.do();

¿Alguna idea? Recomendaciones?

Answer 1

Usualmente uso el patrón singleton con la siguiente estructura:

Primero defina ServiceHelper siguiente manera:

public class ServiceHelper {

private static final String ENDPOINT = "http://test.com";

private static OkHttpClient httpClient = new OkHttpClient();
private static ServiceHelper instance = new ServiceHelper();
private IPlusService service;


private ServiceHelper() {

    Retrofit retrofit = createAdapter().build();
    service = retrofit.create(IPlusService.class);
}

public static ServiceHelper getInstance() {
    return instance;
}

private Retrofit.Builder createAdapter() {

    httpClient.setReadTimeout(60, TimeUnit.SECONDS);
    httpClient.setConnectTimeout(60, TimeUnit.SECONDS);
    HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
    interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
    httpClient.interceptors().add(interceptor);

    return new Retrofit.Builder()
            .baseUrl(ENDPOINT)
            .client(httpClient)
            .addConverterFactory(GsonConverterFactory.create());
}

public Call<List<CategoryModel>> getAllCategory() {
    return service.getAllCategory();
}

Luego ponga todos sus servicios en IService (en mi caso es IPlusService )

    public interface IPlusService {
    //@Headers( "Content-Type: application/json" ) in Post method may use this
    @GET("/api/category")
    Call<List<CategoryModel>> getAllCategory();
}

Luego llame a su singleton como a continuación en su actividad / fragmento:

ServiceHelper.getInstance().getAllCategory().enqueue(new Callback<List<CategoryModel>>() {
        @Override
        public void onResponse(Response<List<CategoryModel>> response, Retrofit retrofit) {
            processResponse(response);
        }

        @Override
        public void onFailure(Throwable t) {
            processResponse(null);
        }
    });

Answer 2

Yo diría que no lo hagas. Especialmente porque la mayoría de las llamadas necesitarán usar el .enqueue asíncrono y tratar las respuestas de error de manera diferente.

Puede hacer su propia clase de Retrofit Callback abstracta y abstraer las devoluciones de llamada ''personalizadas'' para que se ahorre la duplicación de código.

Pero, en general, me gustaría ver que la lógica de la aplicación trate la respuesta en el mismo lugar donde realizo la solicitud.

No caigas en la trampa de pensarlo demasiado o aplicar algún patrón abusado que realmente no encaja en Android.

Y si realmente necesita transmitir esa respuesta de su actividad / fragmento, simplemente use RxJava o incluso LocalBroadcast. También intente leer el libro leanpub.com/retrofit-love-working-with-apis-on-android .