Retrofit2+OkHttp3+RxJava构建网络框架

最新推荐文章于 2023-05-09 14:56:40 发布

YY-Ywh

最新推荐文章于 2023-05-09 14:56:40 发布

阅读量720

点赞数 1

分类专栏： Android

本文链接：https://blog.csdn.net/xiaoyao20161314/article/details/60960935

版权

Android 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

Retrofit2+OkHttp3+RxJava搭建网络框架

首先封装一个获取Retrofit,并集成0kHttp3的抽象基类

  public abstract class RetrofitUtils {

    //服务器路径
    private static final String API_SERVER = "http://192.168.16.147:8080";

    private static Retrofit mRetrofit;
    private static OkHttpClient mOkHttpClient;

    /**
     * 获取Retrofit对象
     *
     * @return
     */
    protected static Retrofit getRetrofit() {

        if (null == mRetrofit) {

            if (null == mOkHttpClient) {
                mOkHttpClient = OkHttp3Utils.getOkHttpClient();
            }
            mRetrofit = new Retrofit.Builder()
                    .baseUrl(API_SERVER + "/")
                    .addConverterFactory(GsonConverterFactory.create())
                    .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                    .client(mOkHttpClient)
                    .build();

        }

        return mRetrofit;
    }

}
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

从Retrofit升级到2.0之后，就使用了build设计模式(生产者模式)，将一个复杂的构建与其表示相分离。

baseUrl(API_SERVER + “/”)：设置服务器路径
addConverterFactory(GsonConverterFactory.create())：添加转化库，默认是Gson
addCallAdapterFactory(RxJavaCallAdapterFactory.create())：添加回调库，采用RxJava
client(mOkHttpClient)：设置使用okhttp网络请求

设置服务器就不多说了，是为了方便大家管理。添加转化库，为了能把网络数据直接解析成我们想要的javabeam,方便操作。添加回调库，这里采用的是RxJava，关于为什么使用RxJava,大家网上一搜就知道了，我就不多说啥了。最后是设置okhttp为网络请求，okhttp是高性能的http库，拥有队列线程池，轻松解决并发，自动维护socket连接池，所以这里使用okhttp可谓是更上一层楼。

然后就是要设置OkHttpClient请求的

public class OkHttp3Utils {

    private static OkHttpClient mOkHttpClient;

    //设置缓存目录
    private static File cacheDirectory = new File(MyApplication.getInstance().getApplicationContext().getCacheDir().getAbsolutePath(), "MyCache");
    private static Cache cache = new Cache(cacheDirectory, 10 * 1024 * 1024);


    /**
     * 获取OkHttpClient对象
     *
     * @return
     */
    public static OkHttpClient getOkHttpClient() {

        if (null == mOkHttpClient) {
            mOkHttpClient = new OkHttpClient.Builder()
                    .cookieJar(new CookiesManager())
                    //.addInterceptor(new MyIntercepter())
                    //.addNetworkInterceptor(new CookiesInterceptor(MyApplication.getInstance().getApplicationContext()))
                    //设置请求读写的超时时间
                    .connectTimeout(10, TimeUnit.SECONDS)
                    .writeTimeout(30, TimeUnit.SECONDS)
                    .readTimeout(30, TimeUnit.SECONDS)
                    .cache(cache)
                    .build();
        }
        return mOkHttpClient;
    }
}

   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

同样升级到okhttp3后，也使用build设计模式。

cookieJar(new CookiesManager())：设置一个自动管理cookies的管理器
addInterceptor(new MyIntercepter())：添加拦截器 addNetworkInterceptor(new
CookiesInterceptor(MyApplication.getInstance().getApplicationContext()))：添加网络连接器
connectTimeout(30, TimeUnit.SECONDS):请求超时时间 writeTimeout(30,
TimeUnit.SECONDS):写入超时时间 readTimeout(30, TimeUnit.SECONDS):读取超时时间

OkHttp相信已经有好多人都在用它了，我就不多说什么了。

前面两部做完了现在就可以使用了。

public class NetWorks extends RetrofitUtils {

    //创建实现接口调用
    protected static final NetService service = getRetrofit().create(NetService.class);

    //设缓存有效期为1天
    protected static final long CACHE_STALE_SEC = 60 * 60 * 24 * 1;
    //查询缓存的Cache-Control设置，使用缓存
    protected static final String CACHE_CONTROL_CACHE = "only-if-cached, max-stale=" + CACHE_STALE_SEC;
    //查询网络的Cache-Control设置。不使用缓存
    protected static final String CACHE_CONTROL_NETWORK = "max-age=0";

    private interface NetService {

        //POST请求
        @FormUrlEncoded
        @POST("bjws/app.user/login")
        Observable<Verification> getVerfcationCodePost(@Field("tel") String tel, @Field("password") String pass);

        //POST请求
        @FormUrlEncoded
        @POST("bjws/app.user/login")
        Observable<Verification> getVerfcationCodePostMap(@FieldMap Map<String, String> map);

        //GET请求
        @GET("bjws/app.user/login")
        Observable<Verification> getVerfcationGet(@Query("tel") String tel, @Query("password") String pass);


        //GET请求，设置缓存
        @Headers("Cache-Control: public," + CACHE_CONTROL_CACHE)
        @GET("bjws/app.user/login")
        Observable<Verification> getVerfcationGetCache(@Query("tel") String tel, @Query("password") String pass);


        @Headers("Cache-Control: public," + CACHE_CONTROL_NETWORK)
        @GET("bjws/app.menu/getMenu")
        Observable<MenuBean> getMainMenu();

    }

    //POST请求
    public static void verfacationCodePost(String tel, String pass,Observer<Verification> observer){
        setSubscribe(service.getVerfcationCodePost(tel, pass),observer);
    }


    //POST请求参数以map传入
    public static void verfacationCodePostMap(Map<String, String> map,Observer<Verification> observer) {
       setSubscribe(service.getVerfcationCodePostMap(map),observer);
    }

    //Get请求设置缓存
    public static void verfacationCodeGetCache(String tel, String pass,Observer<Verification> observer) {
        setSubscribe(service.getVerfcationGetCache(tel, pass),observer);
    }

    //Get请求
    public static void verfacationCodeGet(String tel, String pass,Observer<Verification> observer) {
        setSubscribe(service.getVerfcationGet(tel, pass),observer);
    }

    //Get请求
    public static void verfacationCodeGetsub(String tel, String pass, Observer<Verification> observer) {
        setSubscribe(service.getVerfcationGet(tel, pass),observer);
    }

    //Get请求
    public static void Getcache( Observer<MenuBean> observer) {
        setSubscribe(service.getMainMenu(),observer);
    }

    public static <T> void setSubscribe(Observable<T> observable, Observer<T> observer) {
        observable.subscribeOn(Schedulers.io())
                .subscribeOn(Schedulers.newThread())//子线程访问网络
                .observeOn(AndroidSchedulers.mainThread())//回调到主线程
                .subscribe(observer);
    }

}

   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

接口已经创建出来了，Retrofit是用注解来完成设置的，要访问的url，请求方式，请求头。
常用的注解：
@GET GET请求方式
@POST POST请求方式
@Query GET请求参数
@Header用来添加Header请求头
@FormUrlEncoded post请求头标示
其他注解请求方式：
@PUT 表示这是一个PUT请求
@DELETE 表示这是一个DELETE请求
@HEAD 表示这是一个HEAD请求
@OPTIONS 表示这是一个OPTION请求
@PATCH 表示这是一个PAT请求

把网络接口统一放到一个接口类中，让Retrofit创建实现接口来方便调用。setSubscribe方法其实就是插入观察者。

最后就是在activity中调用。

public class MainActivity extends AppCompatActivity {

    private TextView mTv,mTv2;

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

        mTv =(TextView) findViewById(R.id.main_tv);
        mTv2 =(TextView) findViewById(R.id.main_tv2);


        NetWorks.verfacationCodePost("15910435235", "123456", new Observer<Verification>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {
                mTv.setText(e.getLocalizedMessage());
                Log.e("MAIN2",e.getLocalizedMessage()+"--"+e.getMessage());
            }

            @Override
            public void onNext(Verification verification) {
                mTv.setText(verification.getUser().toString());
            }
        });






 NetWorks.Getcache(new Observer<MenuBean>() {
     @Override
     public void onCompleted() {
        //完成
     }

     @Override
     public void onError(Throwable e) {
         //异常
         mTv2.setText(e.getLocalizedMessage());
         Log.e("MAIN2",e.getLocalizedMessage()+"--"+e.getMessage());
     }

     @Override
     public void onNext(MenuBean baseBean) {
         //成功
         mTv2.setText(baseBean.toString());
     }
 });
    }
}

   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58