Retrofit2 MVP Android

Question

我在我的项目中使用改造，我想知道是否有办法在不同的类上分离对 api 的调用，例如： 仅登录活动 /api/users/login 仅限电影活动 /api/movies/all 我都在同一个界面上，我发现这不是一个好方法......你能指导我如何让它更干净吗？我正在使用 MVP 架构来做到这一点。

这是我的NetworkService.class

public class NetworkService {

    private NetworkAPI networkAPI;
    private OkHttpClient okHttpClient;
    private LruCache<Class<?>, Observable<?>> apiObservables;

    public NetworkService() {
        this(BASE_URL);
    }

    public NetworkService(String baseUrl) {
        okHttpClient = buildClient();
        apiObservables = new LruCache<>(10);

        Gson gson = new GsonBuilder()
                .setLenient()
                .setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
                .create();
        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        // set your desired log level
        //logging.setLevel(Level.BASIC);
        logging.setLevel(HttpLoggingInterceptor.Level.BODY);

        Builder httpClient = new Builder()
                .connectTimeout(100, TimeUnit.SECONDS)
                .readTimeout(100, TimeUnit.SECONDS);

        httpClient.addInterceptor(logging);
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(baseUrl)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .client(httpClient.build())
                .build();

        networkAPI = retrofit.create(NetworkAPI.class);
    }

    /**
     * Method to return the API interface.
     *
     * @return
     */
    public NetworkAPI getAPI() {
        return networkAPI;
    }


    /**
     * Method to build and return an OkHttpClient so we can set/get
     * headers quickly and efficiently.
     *
     * @return
     */
    public OkHttpClient buildClient() {

        Builder builder = new Builder();

        builder.addInterceptor(new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Response response = chain.proceed(chain.request());
                // Do anything with response here
                //if we want to grab a specific cookie or something..
                return response;
            }
        });

        builder.addInterceptor(new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                //this is where we will add whatever we want to our request headers.
                Request request = chain.request().newBuilder().addHeader("Accept", "application/json").build();
                return chain.proceed(request);
            }
        });

        return builder.build();
    }

    /**
     * Method to clear the entire cache of observables
     */
    public void clearCache() {
        apiObservables.evictAll();
    }
}

我的NetworkAPI.class 有这个

public interface NetworkAPI {


    @POST(LOGIN)
    Call<LoginResponse> login(@Body LoginRequest loginRequest);
    //And more calls...
}

你们知道我能不能做得更干净吗？

Answer 1

制作retrofit 实例单例，然后您可以为登录电影创建服务，例如

   LoginService login =  retrofit.create(LoginService.class);
   login.login(loginRequest)

   MovieService movie =  retrofit.create(MovieService.class);
   movie.movies(movieRequest)

你的界面是这样的

public interface LoginService {


    @POST(LOGIN)
    Call<LoginResponse> login(@Body LoginRequest loginRequest);
    //And more calls...
}

public interface MovieService {


    @POST(MOVIE)
    Call<MovieResponse> movies(@Body MovieRequest movieRequest);
    //And more calls...
}

Answer 2

肯定需要优化的一件事是您应该重用 OkHttpClient，而不是为每个 API 创建一个。

Retrofit API 创建也应该重构为实用程序类：

public class RetrofitFactory {

    private static OkHttpClient baseClient = new Builder().addInterceptor(new Interceptor() {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Response response = chain.proceed(chain.request());
            // Do anything with response here
            //if we want to grab a specific cookie or something..
            return response;
        }
    }).addInterceptor(new Interceptor() {
        @Override
        public Response intercept(Chain chain) throws IOException {
            //this is where we will add whatever we want to our request headers.
            Request request = chain.request().newBuilder().addHeader("Accept", "application/json").build();
            return chain.proceed(request);
        }
    }).build();

    private static Gson gson = new GsonBuilder()
            .setLenient()
            .setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
            .create();

    private static Retrofit.Builder baseRetrofitBuilder = new Retrofit.Builder()
            .addConverterFactory(GsonConverterFactory.create(gson));


    public Builder baseClientBuilder() {
        return baseClient.newBuilder();
    }

    public static <T> T createApi(String url, Class<T> apiClass) {
        return baseRetrofitBuilder.baseUrl(url).build().create(apiClass);
    }

    public static <T> T createApi(String url, Class<T> apiClass, OkHttpClient client) {
        return baseRetrofitBuilder.baseUrl(url).client(client).build().create(apiClass);
    }
}

要使用额外的拦截器创建 NetworkAPI，您可以：

    HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
    // set your desired log level
    //logging.setLevel(Level.BASIC);
    logging.setLevel(HttpLoggingInterceptor.Level.BODY);

    OkHttpClient httpClient = RetrofitFactory.baseClientBuilder()
            .connectTimeout(100, TimeUnit.SECONDS)
            .readTimeout(100, TimeUnit.SECONDS)
            .addInterceptor(logging);
    networkApi = RetrofitFactory.createApi(url, NetworkApi.class, httpClient);

使用默认设置创建 XApi：

    xApi = RetrofitFactory.createApi(url, XApi.class);

Answer 3

也许您可以创建不同的接口并修改您的 NetworkService 以创建改造适配器，具体取决于您希望在不同情况下使用的接口。

让我告诉你这个想法：

接口：

  public interface LoginInterface { 

        @POST(LOGIN) 
        Call<LoginResponse> login(@Body LoginRequest loginRequest); 
    }

    public interface MovieInterface {

        @GET(MOVIE) 
        Call<MovieResponse> getMovies(); 
    }

NetworkService 类

在这里您可以看到 NetworkService 的 Singleton 和使用此方法创建的方法，您可以使用单例实例创建不同的接口：

public class NetworkService {
    private final String API_BASE_URL = "";

    private static NetworkService INSTANCE = null;
    private static Retrofit retrofit;

    private OkHttpClient okHttpClient;
    private LruCache<Class<?>, Observable<?>> apiObservables;


    public NetworkService() {
        createInstance();
    }

    public static NetworkService getInstance() {

        if(INSTANCE == null){
            return new NetworkService();
        }

        return INSTANCE;
    }

    private void createInstance(){
        okHttpClient = buildClient();
        apiObservables = new LruCache<>(10);

        Gson gson = new GsonBuilder()
                .setLenient()
                .setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
                .create();

        retrofit = new Retrofit.Builder()
                .baseUrl(API_BASE_URL)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .client(httpClient.build())
                .build();


        }

    public static <T> T create(Class<T> apiClass) {
        return retrofit.create(apiClass);
    }

    private OkHttpClient buildClient() {

        HttpLoggingInterceptor loggingInterceptor = new     HttpLoggingInterceptor();
        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);

        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        builder.addInterceptor(loggingInterceptor)
                .connectTimeout(100, TimeUnit.SECONDS)
                .readTimeout(100, TimeUnit.SECONDS);

        builder.addInterceptor(new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Response response = chain.proceed(chain.request());
                // Do anything with response here
                //if we want to grab a specific cookie or something..
                return response;
            }
        });

        builder.addInterceptor(new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                //this is where we will add whatever we want to our request headers.
                Request request = chain.request().newBuilder().addHeader("Accept", "application/json").build();
                return chain.proceed(request);
            }
        });


        return builder.build();
    }

    /**
     * Method to clear the entire cache of observables
     */
    public void clearCache() {
        apiObservables.evictAll();
    }
}

然后您可以使用修改后的 NetworService 实例化它来实例化您想要使用的接口：

网络服务实例化：

public class LoginActiviy extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_login);

            //Instantiation of LoginInterface
            LoginInterface loginInterface = 
            NetworkService.getInstance().create(LoginInterface.class);
            //Then we use the method for login
            loginInterface.login(/* Handling the callback here*/);

            }
        }

public class MoviesActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_movies);

            //Instantiation of MovieInterface
            MovieInterface movieInterface = 
            NetworkService.getInstance().create(MovieInterface.class);
            //Then we use the method for login
            loginInterface.getMovies(/* Handling the callback here*/);

            }
        }

我希望它可以帮助您获得更好的想法。