Retrofit+OkHttp+ViewModel

目录
中规中矩的 Retrofit+OkHttp+ViewModel 使用介绍。
为什么选择 LiveData、Retrofit 和 OkHttp？
项目依赖
配置 OkHttpClient 和 Retrofit
创建数据模型和 API 接口
创建 Repository 类
创建 ViewModel 类
在 Activity 中使用 ViewModel 和 LiveData
Mvvm模式使用,下面应该算是一个完整封装框架。
Retrofit Xml本领
1. 添加必要的依赖项
2. 创建数据模型
3. 创建 API 接口
4. 配置 Retrofit 实例
5. 发起哀求

---

中规中矩的 Retrofit+OkHttp+ViewModel 使用介绍。

在现代 Android 开发中，使用 LiveData、Retrofit 和 OkHttp 进行网络哀求和数据处理已经成为一种标准做法。这篇博文将详细介绍如何将这三者结合起来，构建一个高效、可维护的网络哀求框架。
为什么选择 LiveData、Retrofit 和 OkHttp？

• LiveData：LiveData 是一种可观察的数据持有者类，具有生命周期感知本领。它能与 Android 的生命周期组件无缝集成，确保 UI 组件只在活泼状态下更新，从而避免内存泄漏和崩溃问题。
  
• Retrofit：Retrofit 是一个强大的类型安全的 HTTP 客户端，用于 Android 和 Java。它简化了网络哀求的创建和处理过程，支持多种数据转换器（如 Gson、SimpleXML），并与 OkHttp 无缝集成。
  
• OkHttp：OkHttp 是一个高效的 HTTP 客户端，支持毗连池、缓存、重定向和失败重试等功能。它为 Retrofit 提供了底层支持，而且可以通过拦截器进行机动的哀求和响应处理。
  

项目依赖

起首，在你的 build.gradle 文件中添加以下依赖项：

1. dependencies {
2.     implementation 'com.squareup.retrofit2:retrofit:2.9.0'
3.     implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
4.     implementation 'com.squareup.okhttp3:logging-interceptor:4.9.3'
5.     implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.3.1'
6.     implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.3.1'
7. }

复制代码

配置 OkHttpClient 和 Retrofit

创建一个 ApiClient 类来配置 OkHttpClient 和 Retrofit 实例：

1. public class ApiClient {
2.     private static final String BASE_URL = "https://api.example.com/";
3.     private static Retrofit retrofit = null;
5.     public static Retrofit getClient() {
6.         if (retrofit == null) {
7.             HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
8.             logging.setLevel(HttpLoggingInterceptor.Level.BODY);
9.             
10.             OkHttpClient client = new OkHttpClient.Builder()
11.                     .addInterceptor(logging)
12.                     .build();
14.             retrofit = new Retrofit.Builder()
15.                     .baseUrl(BASE_URL)
16.                     .client(client)
17.                     .addConverterFactory(GsonConverterFactory.create())
18.                     .build();
19.         }
20.         return retrofit;
21.     }
22. }

复制代码

创建数据模型和 API 接口

界说一个数据模型类和一个 API 接口来描述网络哀求：

1. public class User {
2.     @SerializedName("id")
3.     private int id;
5.     @SerializedName("name")
6.     private String name;
8.     @SerializedName("email")
9.     private String email;
11.     // Getters and Setters
12. }

复制代码

1. public interface ApiService {
2.     @GET("users")
3.     Call<List<User>> getUsers();
4. }

复制代码

创建 Repository 类

创建一个 UserRepository 类来管理数据操作：

1. public class UserRepository {
2.     private ApiService apiService;
4.     public UserRepository() {
5.         apiService = ApiClient.getClient().create(ApiService.class);
6.     }
8.     public LiveData<List<User>> getUsers() {
9.         final MutableLiveData<List<User>> data = new MutableLiveData<>();
10.         apiService.getUsers().enqueue(new Callback<List<User>>() {
11.             @Override
12.             public void onResponse(Call<List<User>> call, Response<List<User>> response) {
13.                 if (response.isSuccessful()) {
14.                     data.setValue(response.body());
15.                 }
16.             }
18.             @Override
19.             public void onFailure(Call<List<User>> call, Throwable t) {
20.                 data.setValue(null);
21.             }
22.         });
23.         return data;
24.     }
25. }

复制代码

创建 ViewModel 类

1. public class UserViewModel extends ViewModel {
2.     private UserRepository userRepository;
3.     private LiveData<List<User>> users;
5.     public UserViewModel() {
6.         userRepository = new UserRepository();
7.         users = userRepository.getUsers();
8.     }
10.     public LiveData<List<User>> getUsers() {
11.         return users;
12.     }
13. }

复制代码

在 Activity 中使用 ViewModel 和 LiveData

在 Activity 中使用 ViewModel 和 LiveData 来观察数据厘革：

1. public class MainActivity extends AppCompatActivity {
2.     private UserViewModel userViewModel;
4.     @Override
5.     protected void onCreate(Bundle savedInstanceState) {
6.         super.onCreate(savedInstanceState);
7.         setContentView(R.layout.activity_main);
9.         userViewModel = new ViewModelProvider(this).get(UserViewModel.class);
10.         userViewModel.getUsers().observe(this, new Observer<List<User>>() {
11.             @Override
12.             public void onChanged(List<User> users) {
13.                 // Update UI with the list of users
14.             }
15.         });
16.     }
17. }

复制代码

通过这些步骤，你可以在 Android 项目中使用 LiveData 与 Retrofit 和 OkHttp 来实现网络哀求框架，并将数据绑定到 UI。这种架构筹划不仅进步了代码的可读性和可维护性，还能有用地管理网络哀求和数据更新。
以上就是基本使用，如果你有点追求，就是共同框架使用网络本领。
Mvvm模式使用,下面应该算是一个完整封装框架。

1. public class MainActivity extends BaseMvvmAc<AcMainBinding, HomeViewModel>  {
2.   @Override
3.     protected int initContentView(Bundle savedInstanceState) {
4.         return R.layout.ac_main;
5.     }
7.     @Override
8.     protected int initVariableId() {
9.         return BR.viewModel;
10.     }
11. }

复制代码

1. public abstract class BaseMvvmAc<V extends ViewDataBinding, VM extends BaseViewModel> extends BaseAc {
3.     protected VM viewModel;
4.     protected V binding;
6.   private void initViewDataBinding(Bundle savedInstanceState) {
7.         binding = DataBindingUtil.setContentView(this, initContentView(savedInstanceState));
9.         if (viewModel == null) {
10.             Class modelClass;
11.             Type type = getClass().getGenericSuperclass();
12.             if (type instanceof ParameterizedType) {
13.                 modelClass = (Class) ((ParameterizedType) type).getActualTypeArguments()[1];
14.             } else {
15.                 //如果没有指定泛型参数，则默认使用BaseViewModel
16.                 modelClass = BaseViewModel.class;
17.             }
18.             viewModel = (VM) new ViewModelProvider(this,
19.                     ViewModelProvider.AndroidViewModelFactory.getInstance(getApplication()))
20.                     .get(modelClass);
21.         }
22.         if (initVariableId() > 0) {
23.             binding.setVariable(initVariableId(), viewModel);
24.         }
26.         viewModel.uiChangeLiveData().onBackPressedEvent().observe(this, o -> {
27.             onBackPressed();
28.         });
29.     }
30.     /**
31.      * 初始化根布局
32.      *
33.      * @param savedInstanceState
34.      * @return 布局layout的id
35.      */
36.     protected abstract int initContentView(Bundle savedInstanceState);
38.     /**
39.      * 初始化ViewModel的id
40.      *
41.      * @return BR的id
42.      */
43.     protected abstract int initVariableId();
45. }

复制代码

• 设置布局并获取布局实例。
  
• 检查viewModel是否为空，如果为空则根据泛型参数创建对应的ViewModel实例。
  
• 如果指定了ViewModel的BR id，则将ViewModel绑定到布局中。
  
• 监听ViewModel中的返回按键变乱，触发onBackPressed方法。
  

1. public class HomeViewModel extends BaseViewModel<HomeRepository> {
3.     public HomeViewModel(@NonNull Application application) {
4.         super(application);
5.     }
6. }

复制代码

1. public class BaseViewModel<M extends BaseModel> extends AndroidViewModel implements IBaseViewModel, Consumer<Disposable> {
3.     private UiChangeLiveData uiChangeLiveData;
4.     private CompositeDisposable mCompositeDisposable;
5.     protected M model;
7.     public BaseViewModel(@NonNull Application application) {
8.         super(application);
9.         model = createModel();
10.     }
12.     private M createModel() {
13.         try {
14.             Type superClass = getClass().getGenericSuperclass();
15.             Type type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
16.             Class<?> clazz = getRawType(type);
17.             return (M) clazz.newInstance();
18.         } catch (Exception e) {
19.             e.printStackTrace();
20.         }
22.         return null;
23.     }
24. //获取当前类的父类类型。
25. //获取父类的第一个泛型参数类型。
26. //将该类型转换为具体的类类型。
27. //使用 newInstance 方法创建该类的实例并返回。
28. //如果过程中出现异常，则打印堆栈信息并返回 null。
32.     // type不能直接实例化对象，通过type获取class的类型，然后实例化对象
33.     private Class<?> getRawType(Type type) {
34.         if (type instanceof Class) {
35.             return (Class) type;
36.         } else if (type instanceof ParameterizedType) {
37.             ParameterizedType parameterizedType = (ParameterizedType) type;
38.             Type rawType = parameterizedType.getRawType();
39.             return (Class) rawType;
40.         } else if (type instanceof GenericArrayType) {
41.             Type componentType = ((GenericArrayType) type).getGenericComponentType();
42.             return Array.newInstance(getRawType(componentType), 0).getClass();
43.         } else if (type instanceof TypeVariable) {
44.             return Object.class;
45.         } else if (type instanceof WildcardType) {
46.             return getRawType(((WildcardType) type).getUpperBounds()[0]);
47.         } else {
48.             String className = type == null ? "null" : type.getClass().getName();
49.             throw new IllegalArgumentException("Expected a Class, ParameterizedType, or GenericArrayType, but <" + type + "> is of type " + className);
50.         }
51.     }
53.     protected void addDisposable(Disposable disposable) {
54.         if (this.mCompositeDisposable == null) {
55.             this.mCompositeDisposable = new CompositeDisposable();
56.         }
57.         this.mCompositeDisposable.add(disposable);
58.     }
60.     public UiChangeLiveData uiChangeLiveData() {
61.         if (uiChangeLiveData == null) {
62.             uiChangeLiveData = new UiChangeLiveData();
63.         }
64.         return uiChangeLiveData;
65.     }
67.     @Override
68.     protected void onCleared() {
69.         super.onCleared();
70.         if (mCompositeDisposable != null && !mCompositeDisposable.isDisposed()) {
71.             mCompositeDisposable.clear();
72.         }
73.         if (model != null) {
74.             model.onCleared();
75.         }
76.     }
78.     @Override
79.     public void onAny(LifecycleOwner owner, Lifecycle.Event event) {
81.     }
83.     @Override
84.     public void onCreate() {
85.     }
87.     @Override
88.     public void onDestroy() {
89.     }
91.     @Override
92.     public void onStart() {
94.     }
96.     @Override
97.     public void onStop() {
99.     }
101.     @Override
102.     public void onResume() {
104.     }
106.     @Override
107.     public void onPause() {
109.     }
112.     @Override
113.     public void accept(Disposable disposable) throws Exception {
114.         addDisposable(disposable);
115.     }
117.     public void onBackPressed() {
118.         uiChangeLiveData.onBackPressedEvent.call();
119.     }
121.     public final class UiChangeLiveData extends SingleLiveEvent {
122.         private SingleLiveEvent<Void> onBackPressedEvent;
124.         public SingleLiveEvent<Void> onBackPressedEvent() {
125.             return onBackPressedEvent = createLiveData(onBackPressedEvent);
126.         }
128.         private <T> SingleLiveEvent<T> createLiveData(SingleLiveEvent<T> liveData) {
129.             if (liveData == null) {
130.                 liveData = new SingleLiveEvent<>();
131.             }
132.             return liveData;
133.         }
134.     }
135. }

复制代码

1. public class HomeRepository extends BaseModel {
3.     public void unCollect(String id, ApiCallback<Object> callback) {
4.         ApiUtil.getArticleApi().unCollect(id).enqueue(callback);
5.     }
7. }

复制代码

1. /**
2. * Description: 不同模块BASE_URL可能不同
3. */
4. public class ApiUtil {
6.     public static ProjectApi getProjectApi() {
7.         return RetrofitCreateHelper.getInstance().create(U.BASE_URL, ProjectApi.class);
8.     }
10. }

复制代码

1. public interface ProjectApi {
4.     /**
5.      * 项目分类
6.      *
7.      * @return
8.      */
9.     @RetryCount(value = 3)
10.     @GET("project/tree/json")
11.     ApiCall<List<ProjectListRes>> listProjectsTab();
13. }

复制代码

1. public class ApiCall <R> {
3.     private final Observable<Response<ApiResponse<R>>> mEnqueueObservable;
4.     private int mRetryCount;
5.     private long mRetryDelay;
6.     private long mRetryIncreaseDelay;
7.     private Disposable mDisposable;
8.     private Call<ApiResponse<R>> mCall;
10.     ApiCall(Annotation[] annotations, Call<ApiResponse<R>> call) {
11.         mCall = call;
12.         mEnqueueObservable = RxJavaPlugins.onAssembly(new CallEnqueueObservable<>(call));
13.         for (Annotation annotation : annotations) {
14.             Class<? extends Annotation> clazz = annotation.annotationType();
15.             if (clazz == RetryCount.class) {
16.                 RetryCount retryCount = (RetryCount) annotation;
17.                 mRetryCount = retryCount.value();
18.             } else if (clazz == RetryDelay.class) {
19.                 RetryDelay retryDelay = (RetryDelay) annotation;
20.                 mRetryDelay = retryDelay.value();
21.             } else if (clazz == RetryIncreaseDelay.class) {
22.                 RetryIncreaseDelay retryIncreaseDelay = (RetryIncreaseDelay) annotation;
23.                 mRetryIncreaseDelay = retryIncreaseDelay.value();
24.             }
25.         }
26.     }
28.     /**
29.      * 进入请求队列
30.      * 不绑定activity生命周期
31.      * 建议使用传入activity的方式，以绑定生命周期
32.      *
33.      * @param callback 请求回调
34.      */
35.     public <T extends ApiCallback<R>> void enqueue(T callback) {
36.         enqueue(null, ProgressType.NONE, false, callback);
37.     }
39.     /**
40.      * 进入请求队列
41.      * 不绑定activity生命周期
42.      * 建议使用传入activity的方式，以绑定生命周期
43.      *
44.      * @param callback 请求回调
45.      */
46.     public <T extends ApiCallback<R>> void enqueue(T callback, ProgressType type) {
47.         enqueue(null, type, false, callback);
48.     }
50.     /**
51.      * 进入请求队列
52.      * 无进度框，无toast
53.      * 自动绑定activity生命周期
54.      *
55.      * @param callback 请求回调
56.      */
57.     public void enqueue(Context activity, final ApiCallback<R> callback) {
58.         enqueue(activity, ProgressType.NONE, false, callback);
59.     }
61.     /**
62.      * 进入请求队列
63.      * 带可取消进度框，有toast
64.      * 自动绑定activity生命周期
65.      *
66.      * @param callback 请求回调
67.      */
68.     public void enqueue2(Context activity, final ApiCallback<R> callback) {
69.         enqueue(activity, ProgressType.CANCELABLE, true, callback);
70.     }
72.     /**
73.      * 进入请求队列
74.      *
75.      * @param activity     界面
76.      * @param progressType 进度框类型
77.      * @param callback     请求回调
78.      */
79.     public void enqueue(Context activity, ProgressType progressType, final ApiCallback<R> callback) {
80.         enqueue(activity, progressType, false, callback);
81.     }
83.     /**
84.      * 进入请求队列
85.      *
86.      * @param activity   界面
87.      * @param toastError 是否弹错误toast
88.      * @param callback   请求回调
89.      */
90.     public void enqueue(Context activity, boolean toastError, final ApiCallback<R> callback) {
91.         enqueue(activity, ProgressType.NONE, toastError, callback);
92.     }
94.     /**
95.      * 进入请求队列
96.      *
97.      * @param activity     界面
98.      * @param progressType 进度框类型
99.      * @param toastError   是否弹错误toast
100.      * @param callback     请求回调
101.      */
102.     public void enqueue(Context activity, ProgressType progressType, final boolean toastError,
103.                         final ApiCallback<R> callback) {
104.         Observable<Response<ApiResponse<R>>> observable;
105.         /*if (activity instanceof RxAppCompatActivity) {
106.             RxAppCompatActivity rxAppCompatActivity = (RxAppCompatActivity) activity;
107.             observable = mEnqueueObservable.compose(rxAppCompatActivity.<Response<ApiResponse<R>>>bindToLifecycle());
108.         } else {
109.             observable = mEnqueueObservable;
110.         }*/
111.         observable = mEnqueueObservable;
112.         mDisposable = observable.retryWhen(new RetryHandler<R>(mRetryCount, mRetryDelay, mRetryIncreaseDelay))
113.                 .subscribeOn(Schedulers.io())
114.                 .doOnSubscribe(new Consumer<Disposable>() {
115.                     @Override
116.                     public void accept(Disposable disposable) throws Exception {
117.                         callback.onStart();
118.                     }
119.                 })
120.                 .subscribeOn(AndroidSchedulers.mainThread())
121.                 .observeOn(AndroidSchedulers.mainThread())
122.                 .subscribe(new Consumer<Response<ApiResponse<R>>>() {
123.                     @Override
124.                     public void accept(Response<ApiResponse<R>> response) throws Exception {
125.                         ApiResponse<R> body = response.body();
126.                         if (!response.isSuccessful() || body == null) {
127.                             onError(callback, new HttpException(response), toastError);
128.                             cancel();
129.                             return;
130.                         }
131.                         callback.onSuccess(body);
132.                         cancel();
133.                     }
134.                 }, new Consumer<Throwable>() {
135.                     @Override
136.                     public void accept(Throwable throwable) throws Exception {
137.                         onError(callback, throwable, toastError);
138.                         cancel();
139.                     }
140.                 });
141.     }
143.     /**
144.      * Synchronously send the request and return its response.
145.      *
146.      * @throws IOException if a problem occurred talking to the server.
147.      */
148.     public Response<ApiResponse<R>> exectue() throws IOException {
149.         return mCall.clone().execute();
150.     }
153.     /**
154.      * 处理错误
155.      *
156.      * @param callback  回调
157.      * @param throwable 错误
158.      */
159.     private void onError(ApiCallback<R> callback, Throwable throwable, boolean toast) {
160.         callback.onError(throwable);
161.     }
163.     public void cancel() {
164.         if (mDisposable != null) {
165.             mDisposable.dispose();
166.         }
167.     }
169.     /**
170.      * 进度条类型
171.      */
172.     public enum ProgressType {
174.         /**
175.          * 无进度条
176.          */
177.         NONE,
178.         /**
179.          * 可取消进度条
180.          */
181.         CANCELABLE,
182.         /**
183.          * 不可取消进度条
184.          */
185.         UN_CANCELABLE
187.     }
188. }

复制代码

从使用角度，直接copy以上的代码就可以。
Retrofit Xml本领

1. 添加必要的依赖项

起首，在你的 build.gradle 文件中添加 Retrofit 和转换器的依赖项：

1. dependencies {
2.     implementation 'com.squareup.retrofit2:converter-simplexml:2.9.0'
3. }

复制代码

2. 创建数据模型

创建一个数据模型类，它将被转换为 XML 格式：

1. @Root(name = "restrict")
2. public class Restrict {
3.     @Attribute(name = "Type")
4.     private int type;
6.     // Constructor
7.     public Restrict(int type) {
8.         this.type = type;
9.     }
11.     // Getter and Setter
12.     public int getType() {
13.         return type;
14.     }
16.     public void setType(int type) {
17.         this.type = type;
18.     }
19. }

复制代码

3. 创建 API 接口

界说一个接口来描述你的 API 端点：

1. public interface ApiService {
2.     @Headers({
3.         "Content-Type: application/xml",
4.     })
5.     @POST("xxxx")
6.     Call<Void> sendRestrict(@Body Restrict restrict);
7. }

复制代码

4. 配置 Retrofit 实例

配置 Retrofit 实例并创建 API 服务：

1. public class RetrofitClient {
2.     private static final String BASE_URL = "xxxxxxxxx";
3.     private static Retrofit retrofit = null;
5.     public static Retrofit getClient() {
6.         if (retrofit == null) {
7.             retrofit = new Retrofit.Builder()
8.                 .baseUrl(BASE_URL)
9.                 .addConverterFactory(SimpleXmlConverterFactory.create())
10.                 .build();
11.         }
12.         return retrofit;
13.     }
15.     public static ApiService getApiService() {
16.         return getClient().create(ApiService.class);
17.     }
18. }

复制代码

5. 发起哀求

最后，使用创建的 ApiService 发起哀求：

1. public class MainActivity extends AppCompatActivity {
2.     @Override
3.     protected void onCreate(Bundle savedInstanceState) {
4.         super.onCreate(savedInstanceState);
5.         setContentView(R.layout.activity_main);
7.         ApiService apiService = RetrofitClient.getApiService();
9.                 String xmlData = "";
10.         MediaType xmlMediaType = MediaType.parse("application/xml");
11.         RequestBody xmlBody = RequestBody.create(xmlData, xmlMediaType);
12.         Call<Void> call = apiService.sendRestrict(xmlBody);
14.         call.enqueue(new Callback<Void>() {
15.             @Override
16.             public void onResponse(Call<Void> call, Response<Void> response) {
17.                 if (response.isSuccessful()) {
18.                     Log.d("MainActivity", "Request successful");
19.                 } else {
20.                     Log.e("MainActivity", "Request failed");
21.                 }
22.             }
24.             @Override
25.             public void onFailure(Call<Void> call, Throwable t) {
26.                 Log.e("MainActivity", "Error: " + t.getMessage());
27.             }
28.         });
29.     }
30. }

复制代码

XML哀求本领重要就两点：
1、添加内置的 simplexml 依赖，添加Retrofit转换器  .addConverterFactory(SimpleXmlConverterFactory.create())
2、使用 MediaType.parse 方法界说哀求体的媒体类型为 application/xml

比较简单，但是我还是在这个功能上泯灭了两个小时时间差点翻车，重要是几个同事需要立即使用。按照步骤死活无法乐成，
我使用的方式是 bean转 xml 哀求。

1.         String xml = "<xxx></xxx>";
3.         Serializer serializer = new Persister();
5.         Restrict restrict = serializer.read(Restrict.class, xml);

复制代码

我甚至猜疑接口是错误的，都没有猜疑这种方式有问题，用终端跑一下，乐成返回数据。
然后猜疑参数问题，猜疑网络问题都没有猜疑如许的写法有什么问题。最后没办法给Okhttp添加了拦截器打印哀求参数，发现 为啥是 json形式哀求？说实在的至今没搞清晰为什么~

1.            String xmlData = "";
2.         MediaType xmlMediaType = MediaType.parse("application/xml");
3.         RequestBody xmlBody = RequestBody.create(xmlData, xmlMediaType);

复制代码

1.         if (request.body() != null && request.body().contentType() != null) {
2.             MediaType contentType = request.body().contentType();
3.             if (contentType.subtype().equals("xml") || contentType.subtype().equals("json")) {
4.                 Buffer buffer = new Buffer();
5.                 request.body().writeTo(buffer);
6.                 Log.e(TAG,"Request body (" + contentType + "): " + buffer.readUtf8());
7.             }
8.         }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。