【0119】【项目实战】-【组件化封装思想实战Android App】-【2】App公共模块之网络请求组件

1. 网络请求组件-okHttp的简单使用

2.基本的okhttp请求的发送

【说明】下面的事例代码是完成一个okhttp的请求；

【封装的意义】必须要进行封装，否则，

【1】多次请求网络会出现代码冗余，一次性创建三个对象OkHttpClient，Request，Call

【2】如果okhttp出现新的类的更改，则需要大量修改代码，不合理；

【3】如果更换网络请求框架，则工作量巨大；

 1 package com.youdu.testBySelf;
 2 
 3 import android.os.Bundle;
 4 import android.support.annotation.Nullable;
 5 import android.support.v7.app.AppCompatActivity;
 6 
 7 import java.io.IOException;
 8 
 9 import okhttp3.Call;
10 import okhttp3.Callback;
11 import okhttp3.OkHttpClient;
12 import okhttp3.Request;
13 import okhttp3.Response;
14 
15 
16 /**
17  * Created by Administrator on 2018-04-15.
18  */
19 
20 public class BaseOkhttpTestActyivity extends AppCompatActivity {
21     @Override
22     protected void onCreate(@Nullable Bundle savedInstanceState) {
23         super.onCreate(savedInstanceState);
24     }
25 
26     /**
27      * 使用okhttp发送一个最基本的请求
28      */
29 
30     private void sendRequest() {
31         //创建okHttpClient对象；
32         OkHttpClient mOkHttpClient = new OkHttpClient();
33         //创建一个request
34         final Request request = new Request.Builder()
35                 .url("https://www.imooc.com/")
36                 .build();
37 
38         //new call
39         Call call = mOkHttpClient.newCall(request);
40         //请求加入调度
41         call.enqueue(new Callback() {
42             //请求失败
43             @Override
44             public void onFailure(Call call, IOException e) {
45 
46             }
47 
48             //请求成功
49             @Override
50             public void onResponse(Call call, Response response) throws IOException {
51 
52             }
53         });
54 
55 
56     }
57 
58 
59 }

3.网络请求组件封转思路讲解

【思路】封装三大块：request请求；okhttp核心；callBack回调处理；

【request封转的思路】封住一个类，可以接收请求的参数和url，返回一个创建好的request对象；

【okHttp的核心】具有三个功能：①发送/get/post请求，②请求相关的参数设置；③https的支持；

【callBack的封装处理】

4.request的封装

【封装的目录】支持cookie的处理；

4.1 requst参数的封转

【源码】G:\q0pwzp\Client_Code\vuandroidadsdk\src\main\java\com\youdu\okhttp\request\RequestParams.java

 1 package com.youdu.okhttp.request;
 2 
 3 import java.io.FileNotFoundException;
 4 import java.util.HashMap;
 5 import java.util.Map;
 6 import java.util.concurrent.ConcurrentHashMap;
 7 
 8 /**
 9  * 本文件的来源：根据volly的请求框架生成的文件类；
10  * @author vision
11  * 功能：将请求的参数封装在两个线程安全的HashMap中；
12  */
13 public class RequestParams {
14 
15 //    创建两个线程安全的HashMap;
16     public ConcurrentHashMap<String, String> urlParams = new ConcurrentHashMap<String, String>();
17     public ConcurrentHashMap<String, Object> fileParams = new ConcurrentHashMap<String, Object>();
18 
19     /**
20      * Constructs a new empty {@code RequestParams} instance.
21      */
22     public RequestParams() {
23         this((Map<String, String>) null);
24     }
25 
26     /**
27      * Constructs a new RequestParams instance containing the key/value string
28      * params from the specified map.
29      *
30      * @param source the source key/value string map to add.
31      */
32     public RequestParams(Map<String, String> source) {
33         if (source != null) {
34             for (Map.Entry<String, String> entry : source.entrySet()) {
35                 put(entry.getKey(), entry.getValue());
36             }
37         }
38     }
39 
40     /**
41      * Constructs a new RequestParams instance and populate it with a single
42      * initial key/value string param.
43      *
44      * @param key   the key name for the intial param.
45      * @param value the value string for the initial param.
46      */
47     public RequestParams(final String key, final String value) {
48         this(new HashMap<String, String>() {
49             {
50                 put(key, value);
51             }
52         });
53     }
54 
55     /**
56      * Adds a key/value string pair to the request.
57      * 核心的方法：以key放置value；
58      * @param key   the key name for the new param.
59      * @param value the value string for the new param.
60      */
61     public void put(String key, String value) {
62         if (key != null && value != null) {
63             urlParams.put(key, value);
64         }
65     }
66 
67     public void put(String key, Object object) throws FileNotFoundException {
68 
69         if (key != null) {
70             fileParams.put(key, object);
71         }
72     }
73 
74     public boolean hasParams() {
75         if(urlParams.size() > 0 || fileParams.size() > 0){
76 
77             return true;
78         }
79         return false;
80     }
81 }

4.2 post请求的封装

【封装的三部曲】①建立FormBody；②在FormBody中添加参数，然后通过FormBody的构建者对象真正的生成一个FormBody对象；③由FormBody生成request对象；

4.3 get请求的封装

5.okHttpClient的封装

【参考博客】https://blog.csdn.net/lmj623565791/article/category/2210589

【添加对https的支持】

【生成client】

【发送具体的请求】

【关于static关键字的说明】在android的使用static不会造成内存的泄露；在android的源码中和工具类的封装中，都会使用static关键字；

【目前对于发送请求的封装】

6.response封装

6.1 listener接口

【封装监听的作用】

【1】防止因为官方源码的改变导致整个项目的源码进行改变；

【2】可以便于扩展，在提供的okhttp中是没有对于文件的实时进度的状态的返回的，因此需要自定义监听下载进度的方法；此处只是对json的解析，没有进行对进度的监听；

6.2【对于json的解析返回】

【异常的处理】

【异常类源码】

 1 package com.youdu.okhttp.exception;
 2 
 3 /**********************************************************
 4  * @文件描述：自定义异常类,返回ecode,emsg到业务层
 5  **********************************************************/
 6 public class OkHttpException extends Exception {
 7     private static final long serialVersionUID = 1L;
 8 
 9     /**
10      * the server return code
11      * 非常关键：是应用层需要判断的返回状态码；
12      */
13     private int ecode;
14 
15     /**
16      * the server return error message
17      */
18     private Object emsg;
19 
20     public OkHttpException(int ecode, Object emsg) {
21         this.ecode = ecode;
22         this.emsg = emsg;
23     }
24 
25     public int getEcode() {
26         return ecode;
27     }
28 
29     public Object getEmsg() {
30         return emsg;
31     }
32 }