安卓网络请求框架搭建Retrofit+OkHttp+RxJava+MVVM

Retrofit：网络请求框架

OkHttp3：Retrofit 底层网络请求库

RxJava2：响应式编程，处理异步流

MVVM 架构：解耦视图和数据逻辑

ViewModel + LiveData：生命周期感知组件

🔧 一、依赖配置（build.gradle）

// Retrofit 核心
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

// OkHttp3 + 日志拦截器
implementation 'com.squareup.okhttp3:okhttp:4.12.0'
implementation 'com.squareup.okhttp3:logging-interceptor:4.12.0'

// RxJava2 + Retrofit 支持
implementation 'io.reactivex.rxjava2:rxjava:2.2.21'
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.9.0'

// MVVM 架构核心
implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
implementation 'androidx.lifecycle:lifecycle-viewmodel:2.6.2'
🧱 二、Retrofit 初始化封装（ApiClient.java）


import android.util.Log;

import okhttp3.OkHttpClient;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;

/**
 * @author xqm
 * @date 2025/7/12 16:20
 * @description https://jsonplaceholder.typicode.com/
 * retrofit+okhttp
 */
public class ApiClient {
    private static final String BASE_URL = "https://xxxxx/";
    private static Retrofit retrofit;

    public static Retrofit getInstance() {
        if (retrofit == null) {
            // 添加日志拦截器
            HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
//            HttpLoggingInterceptor logging = new HttpLoggingInterceptor(
//                    message -> Log.e("xqm", message) // 你可以自定义日志输出位置
//            );
            logging.setLevel(HttpLoggingInterceptor.Level.BODY);

            logging.setLevel(HttpLoggingInterceptor.Level.BODY); // 打印完整请求和响应

            OkHttpClient client = new OkHttpClient.Builder()
                    .addInterceptor(new HeaderInterceptor())
                    .addInterceptor(logging)
                    .build();

            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL)
                    .client(client)
                    .addConverterFactory(GsonConverterFactory.create())
                    .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // Rx 支持
                    .build();
        }
        return retrofit;
    }
}

🔐 三、自定义请求头拦截器（HeaderInterceptor.java）


import java.io.IOException;

import okhttp3.Interceptor;
import okhttp3.Request;
import okhttp3.Response;

/**
 * @author xqm
 * @date 2025/7/12 16:21
 * @description 用于自动在所有请求中附加 token 认证信息，可在登录成功后设置。
 */
public class HeaderInterceptor implements Interceptor {
    private static String token = "";

    public static void setToken(String t) {
        token = t;
    }

    @Override
    public Response intercept(Interceptor.Chain chain) throws IOException {
        Request request = chain.request();
        Request.Builder builder = request.newBuilder()
                .addHeader("Content-Type", "application/json")
                .addHeader("Authorization", token.isEmpty() ? "" : "Bearer " + token);

        return chain.proceed(builder.build());
    }
}



🔌 四、API 接口定义（ApiService.java）





import io.reactivex.Observable;
import retrofit2.http.Body;
import retrofit2.http.GET;
import retrofit2.http.POST;
import retrofit2.http.Query;

/**
 * @author xqm
 * @date 2025/7/12 16:20
 * @description ApiService 接口定义
 * 支持 GET 和 POST 请求
 * 支持 @Query 参数和 @Body 参数
 * 使用 RxJava 返回 Observable<T>
 */
public interface ApiService {

    @GET("todos/1")
    Observable<UserModel> getUserInfo();

    @GET("access/auth/login")
    Observable<UserModel> getlogin(@Query("username") String username, @Query("password") String password);

    @POST("user/login")
    Observable<LoginResponse> login(@Body LoginRequest request);
}



📦 五、数据访问封装（UserRepository.java）


import io.reactivex.Observable;

/**
 * @author xqm
 * @date 2025/7/12 16:21
 * @description 将数据访问封装在 Repository 层，如网络请求，本地数据库访问等
 */
public class UserRepository {

    private final ApiService api;

    public UserRepository() {
        api = ApiClient.getInstance().create(ApiService.class);
    }

    public Observable<LoginResponse> login(String username, String password) {
        return api.login(new LoginRequest(username, password));
    }

    public Observable<UserModel> getUserInfo() {
        return api.getUserInfo();
    }

    public Observable<UserModel> getLogin(String userName,String pwd) {
        return api.getlogin(userName,pwd);
    }
}



🧠 六、ViewModel 逻辑层（UserViewModel.java）



import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;


/**
 * @author xqm
 * @date 2025/7/12 16:22
 * @description 调用 Repository 提供的数据接口，处理线程调度和生命周期管理。
 */
public class UserViewModel extends BaseViewModel {
    private final UserRepository repository = new UserRepository();

    public void login(String username, String password, RxObserver<LoginResponse> observer) {
        Disposable disposable =  repository.login(username, password)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeWith(observer);
        addDisposable(disposable);
    }

    public void getUserInfo(RxObserver<UserModel> observer) {
        Disposable disposable = repository.getUserInfo()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeWith(observer);
        addDisposable(disposable);
    }

    public void getLogin(String userName,String pwd,RxObserver<UserModel> observer) {
        Disposable disposable = repository.getLogin(userName,pwd)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeWith(observer);
        addDisposable(disposable);
    }
}



🧼 七、BaseViewModel（统一管理 Disposable）


/**
 * @author xqm
 * @date 2025/7/12 16:22
 * @description 避免内存泄漏，销毁 ViewModel 时自动清理订阅。
 */
public abstract class BaseViewModel extends ViewModel {
    protected CompositeDisposable compositeDisposable = new CompositeDisposable();

    protected void addDisposable(Disposable d) {
        compositeDisposable.add(d);
    }

    @Override
    protected void onCleared() {
        compositeDisposable.clear();
        super.onCleared();
    }
}


🧪 八、自定义 Observer 示例（RxObserver）


/**
 * @author xqm
 * @date 2025/7/12 16:43
 * @description 可自我管理订阅生命周期的 Observer，既能收数据，又能自己取消订阅
 */
import io.reactivex.observers.DisposableObserver;

public abstract class RxObserver<T> extends DisposableObserver<T> {
    @Override
    public void onNext(T t) {
        onSuccess(t);
    }

    @Override
    public void onError(Throwable e) {
        onFailure(e);
    }

    @Override
    public void onComplete() {}

    public void onStart() {}

    public abstract void onSuccess(T t);
    public abstract void onFailure(Throwable e);
}


可以在回调里更新 UI，比如：
viewModel = new ViewModelProvider(this).get(UserViewModel.class);
viewModel.login(user, pwd, new RxObserver<LoginResponse>() {
    @Override
    public void onNext(LoginResponse response) {
        if (response.getCode() == 200) {
            // 登录成功
            HeaderInterceptor.setToken(response.getToken());
            Toast.makeText(context, "登录成功", Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(context, "登录失败：" + response.getMsg(), Toast.LENGTH_SHORT).show();
        }
    }

    @Override
    public void onError(Throwable e) {
        Toast.makeText(context, "请求出错: " + e.getMessage(), Toast.LENGTH_SHORT).show();
    }
});

✅ 总结
层级 类名 作用
网络配置 ApiClient Retrofit 初始化，添加拦截器
拦截器 HeaderInterceptor 动态添加统一请求头
API 接口 ApiService 定义 Retrofit 请求
数据层 UserRepository 请求封装、解耦逻辑
ViewModel UserViewModel 调用 Repository 并分发到界面
Observer RxObserver 自定义网络回调处理逻辑
📁 项目目录结构

├── activity/ # UI 层 Activity 或 Fragment
├── model/ # 数据模型类（Bean）
├── network/ # 网络核心配置（Retrofit + 拦截器）
│ ├── ApiClient.java
│ ├── ApiService.java
│ ├── HeaderInterceptor.java
│ └── RxObserver.java
├── repository/ # 数据仓库层
│ └── UserRepository.java
├── viewmodel/ # ViewModel 层
│ ├── BaseViewModel.java
│ └── UserViewModel.java