安卓学习笔记 retrofit+okhttp+rxJava

Retrofit网络访问框架

基于Java的类型安全的HTTP客户端。

Retrofit的一个重要特性是能够异步处理API调用，可以使用回调或RxJava Observables来实现。这使得开发者能够在后台线程上执行网络请求，而不会阻塞主线程的UI操作。

Retrofit的核心原理

• 接口定义：在使用Retrofit时，首先需要定义一个接口，用于描述API的端点和请求参数。这些接口方法通常使用注解来标记请求类型、URL路径、请求参数等信息。
• 动态代理：Retrofit使用Java的动态代理机制，将定义的接口动态地生成实现类。这样，在运行时，Retrofit可以动态地创建和执行API请求。
• 请求构建：当调用接口方法时，Retrofit会根据注解和方法参数来构建请求。它将请求的URL路径、请求方法、请求头、请求体等信息组装起来，形成一个完整的HTTP请求。
• 网络请求：Retrofit使用底层的HTTP客户端（如OkHttp）来执行网络请求。它将构建好的请求传递给HTTP客户端，并接收到服务器的响应。
• 响应解析：Retrofit支持多种数据格式的响应，如JSON、XML等。它可以使用配置的序列化库（如Gson或Jackson）将响应数据转换为Java对象。
• 异步处理：Retrofit支持异步处理网络请求，可以使用回调或RxJava Observables来处理响应。这样可以避免在主线程上执行网络请求，防止阻塞UI操作。

Retrofit的源码关键模块

除了以上核心模块外，Retrofit还有其他辅助模块，用于处理拦截器、请求头、请求参数等特定的功能。整个源码结构清晰，易于理解和扩展。

1. retrofit：该模块包含了Retrofit的核心实现代码。其中，Retrofit类是整个框架的入口点，用于创建和配置Retrofit实例。另外，ServiceMethod类负责解析接口方法的注解信息，并构建请求对象；OkHttpCall类则负责执行网络请求并返回响应结果。
2. converter-gson、converter-jackson等：这些模块是Retrofit的数据转换器，用于将服务器的响应数据转换为Java对象。其中，GsonConverterFactory和JacksonConverterFactory分别使用Gson和Jackson库来进行数据转换。
3. adapter-rxjava、adapter-java8等：这些模块是Retrofit的适配器，用于支持异步处理网络请求。RxJavaCallAdapterFactory和Java8CallAdapterFactory分别支持使用RxJava和Java8的CompletableFuture来处理响应结果。
4. okhttp：这个模块是Retrofit所依赖的OkHttp库的源码。Retrofit使用OkHttp作为底层的HTTP客户端执行网络请求。

Retrofit使用详细解析

1.添加依赖：首先，在项目的build.gradle文件中添加Retrofit的依赖

implementation 'com.squareup.retrofit2:retrofit:2.9.0'

 2.创建接口：定义一个接口，用于描述API的端点和请求参数。接口中的方法使用注解来标记请求类型、URL路径、请求参数等信息。

public interface ApiService {
    @GET("users/{username}")
    Call<User> getUser(@Path("username") String username);
}

3.创建Retrofit实例：使用Retrofit.Builder创建一个Retrofit实例，并配置相关参数。例如，设置服务器的base URL、添加数据转换器、添加适配器等。

 Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl("https://api.github.com/")
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();

4.创建API服务：使用Retrofit.create方法，根据定义的接口创建一个API服务实例。

5.发起网络请求：通过调用API服务实例的方法，发起网络请求。Retrofit会根据接口方法的注解信息，构建请求对象并执行网络请求。

ApiService apiService = retrofit.create(ApiService.class);
Call<User> call = apiService.getData();
call.enqueue(new Callback<User>() {
    @Override    
    public void onResponse(Call<User> call, Response<User> response) {
        if (response.isSuccessful()) {
            User user = response.body();
            // 处理响应结果        
            } else {
            // 处理请求失败        
            }
    }
​
    @Override    
    public void onFailure(Call<User> call, Throwable t) {
        // 处理请求失败    
    }
});

OkHttp网络框架简用

优势

• 谷歌在6.0以后加入okhttp，获的官方支持
• 内置连接池，支持连接服用，减少请求延迟
• 内置队列线程池，轻松写并发
• 支持GZip压缩
• 拥有完善的缓存策略，减少重复请求
• 责任链模式易于拓展
• 支持http2，对同一台机器的所有请求共享同一个socket
• 支持SPDY（谷歌基于TCP的应用层协议，用于优化网络体验）
• 功能全面，满足了大部门的应用场景

OkHttp使用

build.gradle配置：

dependencies {
    implementation("com.squareup.okhttp3:okhttp:4.10.0")
}

Get同步请求：

OkHttpClient okHttpClient = new OkHttpClient();
Request request = new Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build();
Response response = okHttpClient.newCall(request).execute();
if (!response.isSuccessful()) {
    Log.d(TAG, "Unexpected code " + response);
    return;
}
Log.d(TAG, response.body().string());

创建OkHttpClient()对象，调用newCall(request: Request) 创建RealCall对象，Call的execute()为同步函数，返回Response对象。

Get异步请求：

OkHttpClient okHttpClient = new OkHttpClient();
Request request = new Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build();
okHttpClient.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(@NonNull Call call, @NonNull IOException e) {
        e.printStackTrace();
    }

    @Override
    public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
        if (!response.isSuccessful()) {
            Log.d(TAG, "Unexpected code " + response);
            return;
        }
        Log.d(TAG, response.body().string());
    }
});

创建OkHttpClient()对象，调用newCall(request: Request) 创建RealCall对象，Call的函数enqueue(responseCallback: Callback)为异步函数，回调返回Response。

RxJava

 是一个响应式编程库，它可以与 Retrofit 和 OkHttp 配合使用，提供了更强大的异步编程能力和链式操作。

RxJava 通过 Observables 和 Subscribers（或者是 Observers）来实现异步和事件驱动的编程。它使用一系列的操作符进行数据的变换和处理，使得处理异步任务、数据流和事件传递变得更加简洁和灵活。

与 Retrofit 和 OkHttp 相关联，RxJava 可以用于处理这些网络请求的异步操作，以及对请求结果的变换和处理。

RxJava、Retrofit 和 OkHttp 结合使用

下面是 RxJava、Retrofit 和 OkHttp 结合使用的示例：

public interface ApiService {
    @GET("data")
    Observable<DataResponse> getData();
}

OkHttpClient client = new OkHttpClient();
Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://api.example.com/")
        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
        .client(client)
        .build();
ApiService apiService = retrofit.create(ApiService.class);
apiService.getData()
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<DataResponse>() {
            @Override
            public void onSubscribe(Disposable d) {
                // 订阅开始
            }

            @Override
            public void onNext(DataResponse dataResponse) {
                // 处理响应数据
            }

            @Override
            public void onError(Throwable e) {
                // 处理请求失败
            }

            @Override
            public void onComplete() {
                // 请求完成
            }
        });

在这个示例中，我们通过 Retrofit 配置了 RxJava 的适配器，使得接口中的请求方法返回的是一个 Observable 对象。然后，我们使用 RxJava 的操作符进行链式操作，指定了请求的线程和响应数据的处理逻辑。

总结一下 RxJava、Retrofit 和 OkHttp 的联系和区别：

• RxJava 是一个响应式编程库，可以与 Retrofit 和 OkHttp 配合使用，提供异步和事件驱动的编程能力。
• Retrofit 是一个基于 OkHttp 的 RESTful HTTP 客户端，RxJava 可以作为其适配器，添加异步和链式操作功能。
• OkHttp 是一个强大的 HTTP 客户端，可以与 RxJava 和 Retrofit 直接配合使用，用于发送和接收 HTTP 请求和响应。
• RxJava 提供了更强大的异步和链式操作能力，使得处理网络请求和响应数据的流程更加简洁和灵活。