Retrofit+RxJava封装

清疚 2022-05-08 09:26 193阅读 0赞

# 1、RetrofitUtils工具类 #

public class RetrofitUtils {
    
        private static Retrofit mRetrofit;
    
        public static void init(String baseUrl) {
            if (mRetrofit == null) {
                synchronized (RetrofitUtils.class) {
                    if (mRetrofit == null) {
                        OkHttpClient.Builder builder = new OkHttpClient.Builder()
                                .connectTimeout(30, TimeUnit.SECONDS);
    
                        builder.addInterceptor(new Interceptor() {
                            @Override
                            public Response intercept(Chain chain) throws IOException {
                                Request request = chain.request();
                                Request requestBuilder = request.newBuilder()
                                        .addHeader("os", "android")
                                        .build();
                                return chain.proceed(requestBuilder);
                            }
                        });
    
                        mRetrofit = new Retrofit.Builder()
                                .client(builder.build())
                                .addConverterFactory(ResponseConverterFactory.create())
                                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                                .baseUrl(baseUrl)
                                .build();
                    }
                }
            }
        }
    
        public static Retrofit getInstance() {
            if (mRetrofit == null) {
                throw new NullPointerException("must init RetrofitUtils");
            }
    
            return mRetrofit;
        }
    }

在application中就要调用RetrofitUtils的init方法初始化，不然使用的时候报抛出指针异常。初始化的时候可以指定根域名BaseUrl。

转换器是自定义的ResponseConverterFactory类，对返回的数据进行格式化，后面详细说这个ResponseConverterFactory类。

# 2、使用RetrofitUtils（使用登录接口模拟） #

## 2.1 新建一个ApiService ##

public interface ApiService {
    
        @POST("org/login/valid")
        @FormUrlEncoded
        Observable<User> login(@Field("userCode") String name, @Field("userPwd") String psw, @Field("UUID") String uuid);
    
    }

声明接口和三个参数，返回一个Observable<User>。

User是一个bean，很简单。

public class User {
    
        public String userName;
        public String userId;
    
    }

## 2.2 用Api类创建ApiService单例 ##

public class Api {
    
        private static ApiService apiService;
    
        public static ApiService getInstance() {
            if (apiService == null) {
                synchronized (Api.class) {
                    if (apiService == null) {
                        apiService = RetrofitUtils.getInstance().create(ApiService.class);
                    }
                }
            }
    
            return apiService;
        }
    }

这里使用了双重锁机制，保重多线程情况下使用安全。

## 2.3 使用retrofit进行网络请求 ##

Api.getInstance().login(name, psw, "1")
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new ApiSubscriber<User>(context) {
                @Override
                public void onNext(User user) {
                    Toast.makeText(context, "登录成功！", Toast.LENGTH_SHORT).show();
                }
            });

是不是很容易就从服务器拿到我们想要的bean了。这里的ApiSubscriber也是自定义的，它的作用主要就是处理异常（比如token过期这些异常肯定都是统一处理的），这个我也放在方面说吧，因为和转换器有一定的联系。

# 3、Retrofit自定义转换器 #

现在反过来说说这个转换器。

## 3.1 为什么要自定义转换器？ ##

因为我在使用的时候，只喜欢返回一个我想要的bean，而服务器返回的参数肯定是带有状态码的，这里需要做一个转换。

这是服务器返回的json数据格式：

{
    	"code": 0,
    	"data": {
    		"userId": "ABC",
    		"userName": "123",
    	},
    	"message": "登录成功"
    }

而正常情况下，我只需要data里面的内容，于是需要做一个转换。

## 3.2 代码分析 ##

public class ResponseConverterFactory extends Converter.Factory {
    
        private Gson gson;
    
        public static ResponseConverterFactory create() {
            return create(new Gson());
        }
    
        public static ResponseConverterFactory create(Gson gson) {
            return new ResponseConverterFactory(gson);
        }
    
        private ResponseConverterFactory(Gson gson) {
            if (gson == null) {
                throw new NullPointerException("gson can not null!");
            }
            this.gson = gson;
        }
    
        @Override
        public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
            TypeAdapter<?> typeAdapter = gson.getAdapter(TypeToken.get(type));
            return new ResponseBodyConverter<>(typeAdapter);
        }
    
        public class ResponseBodyConverter<T> implements Converter<ResponseBody, T> {
            private TypeAdapter<T> typeAdapter;
    
            public ResponseBodyConverter(TypeAdapter<T> typeAdapter) {
                this.typeAdapter = typeAdapter;
            }
    
            @Override
            public T convert(ResponseBody value) throws IOException {
                String json = value.string();
                value.close();
                ResponseBean bean = gson.fromJson(json, ResponseBean.class);
                if (bean.code != 0) {
                    // 错误
                    throw new ApiException(bean.code, bean.message);
                }
                // 成功
                return typeAdapter.fromJson(gson.toJson(bean.data));
            }
        }
    }

使用工厂模式创建转换器的对象，好处就是解耦，当转换器类的构造方法发生改变时，只需要create方法调整就是了，其他代码不用改变。

TypeAdapter我理解就是与实体类的桥梁，Gson根据它才能生成我们需要的User对象。

在convert方法中做我们想做的事情。当服务器返回的状态码为0时，正常返回bean，当不是0时，走异常处理流程。

ResponseBean是我新建的一个bean:

public class ResponseBean {
    
        public int code;
        public String message;
        public JsonObject data;
    
    }

有没有很眼熟，对，就是服务器返回的格式。通过一次中转，就可以拿到要返回的bean。

# 4、异常处理 #

在上面转换器中，当服务器返回状态码不为0时，抛出一个api异常，进入我们自定义异常处理流程。

public class ApiException extends RuntimeException {
    
        public int code;
        public String message;
    
        public ApiException(int code, String message) {
            super(message);
            this.code = code;
            this.message = message;
        }
    }

ApiException是自定义的异常类，继承自RuntimeException，RuntimeException和Exception有上面区别呢？

RuntimeException继承自Exception，非RuntimeException必要自己写catch块处理掉。  
RuntimeException不用try catch捕捉将会导致程序运行中断，若用则不会中断。

那上面时候处理异常呢，当然是RxJava订阅的时候

public abstract class ApiObserver<T> implements Observer<T> {
    
        Context context;
    
        public ApiObserver(Context context) {
            this.context = context;
        }
    
        @Override
        public void onSubscribe(Disposable d) {
    
        }
    
        @Override
        public void onError(Throwable t) {
            if (t instanceof ApiException) {
                ApiException exception = (ApiException)t;
                Toast.makeText(context, exception.message, Toast.LENGTH_SHORT).show();
                // TODO 异常处理
            }
        }
    
        @Override
        public void onComplete() {
    
        }
    }

在这里我们捕获到抛出的异常，进行处理，只返回正常的结果进行下一步逻辑操作。

参考：

[Retrofit网络请求，工具类的封装（二）][Retrofit]

[Retrofit 进阶篇 自定义转换器][Retrofit _]

[Retrofit自定义GsonConverter处理所有请求错误情况][Retrofit_GsonConverter]

[Retrofit]: https://www.jianshu.com/p/7f843d65a7c6
[Retrofit _]: https://www.jianshu.com/p/fa41acdf9714
[Retrofit_GsonConverter]: https://www.jianshu.com/p/5b8b1062866b