Android 10大开源常用框架源码解析 系列 网络框架之一 OkHttp杂题

Posted 2020-11-17 想不起来的角落

1、android基础网络编程：socket、HttpClient、HttpURLConnection

    1.1 Socket 定义

    是一个对TCP/IP协议进行封装的编程调用接口，本身不是一种协议是接口Api！！

    成堆出现，一对套接字：包括ip地址和端口号

 

    基于应用层和传输层抽象出来的一个层。App可以通过该层发送、接收数据，并通过Socket将App添加到网络当中

    简单来说就是应用与外部通信的端口，提供了两端数据的传输的通道

 

    1.2 Socket通信模型

    基于TCP和UDP协议的两种模型

•     TCP：采用字节流协议来提供可靠的字节流服务
•     UDP：采用数据报文的形势提供数据，打包的形势发送服务

 

    1.3 Socket与Http对比

   Android与服务器的通信方式

    （1）Http通信

        基于请求-响应方式；属于应用层；解决如何包装数据的问题

    （2）Socket通信

        采用服务器主动发送数据的方式，Socket属于传输层；解决数据如何在网络中传输

 

    1.4 Socket实现

/**

* Tcp 客户端Socket

*/

public void TcpSendMessage(String msg) {

    Socket socket = null;

    OutputStream outputStream = null;

    InputStream inputStream = null;

    try {

        //1、创建客户端Socket对象，传入目标主机名orId地址和端口号

        socket = new Socket("192.168.1.1", 8080);

        //2、通过socket获取输出流

        outputStream = socket.getOutputStream();

        //3、写入输出流操作

        outputStream.write(msg.getBytes());

        //4、关闭socket操作,msg写入结束 ps：不调用会造成服务器端消息返回的无法获取

        socket.shutdownOutput();

        //5、msg的IO流读取操作

        inputStream = socket.getInputStream();

        byte[] b = new byte[1024];

        int len = -1;

        final StringBuffer sb = new StringBuffer();

        while ((len = inputStream.read(b)) != -1) {

            sb.append(new String(b, 0, len, Charset.forName("gbk")));

        }

        //todo 在主线程中更新Ui

    } catch (UnknownHostException e) {

        e.printStackTrace();

    } catch (IOException e) {

        e.printStackTrace();

    } finally {

        //注意，输出流不需要关闭，因为它不是创建的而是通过Socket中得到输出流对象获取的

        if ((socket != null)) {

            try {

                socket.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

}

/**

* Tcp 服务器Socket

*/

public void ServerMessage() {

    ServerSocket server = null;

    Socket socket = null;

    try {

        //1、创建服务器Socket对象并监听需要的端口号

        server = new ServerSocket(8888);

        while (true) {

            //2、接收客户端发送的请求；ps：若客户端没有发送数据，该线程会停滞,accept中会阻塞

            socket = server.accept();

            //3、获取输入流

            InputStream inputStream = socket.getInputStream();

            //4、创建缓存输入流进行数据的读入

            BufferedInputStream bis = new BufferedInputStream(inputStream);

            byte[] b = new byte[1024];

            int len = -1;

            while ((len = bis.read()) != -1) {

                System.out.println(new String(b, 0, len, "UTF-8"));

            }

            socket.shutdownInput();

            OutputStream outputStream = socket.getOutputStream();

            outputStream.write("收到".getBytes());

 

            bis.close();

            socket.close();//serverSocket不能被关闭！

            socket = null;

        }

    } catch (IOException e) {

        e.printStackTrace();

    }

}

  1.4 HttpClient 和 HttpURLConnection

基本的HttpURLConnection链接  一个简单Get实例：

/**

* HttpURLConnection

*/

public static void readContentFromGet() throws IOException {

    //1、拼接get请求字符串

    String getURL = "GET_URL" + "？username= " + URLEncoder.encode("fat-man", "UTF-8");

    //2、创建URL对象

    URL getUrl = new URL(getURL);

    //3、表明这个connection只能发送一个请求

    HttpURLConnection connection = (HttpURLConnection) getUrl.openConnection();

    //4、建立链接，这时并没有将真正请求发送给服务器端

    connection.connect();

    //取得输入流，并使用Reader读取,getInputStream()方法将真正的请求发送给服务器端

    BufferedReader reader = new BufferedReader(new InputStreamReader

            (connection.getInputStream()));

    String lines;

    while ((lines = reader.readLine()) != null) {

        System.out.println(lines);

    }

    reader.close();

    //断开链接,关闭底层Socket链接

    connection.disconnect();

}

 

2、了解WebSocket？知道和Socket的区别？OkHttp是如何处理WebSocket的相关问题

 

    2.1 WebSocket

   推送-轮询 是特定的时间间隔，由浏览器对服务器发送Http请求，然后由服务器返回最新的数据给客户端的浏览器。

 

短轮询

提交表单的形势进行数据传递；

   缺陷：在某个时间段Server没有更新数据，但Client端仍然每隔一段时间发送请求来询问，所以这段时间内的询问都是无效的，冗余数据。

 

长轮询

    服务器端接收request请求后不会立即返回数据response给客户端，会检查数据是否有更新。如果有更新了就会返回给客户端数据，如果没有更新则不返回。

 

缺陷：

•             浪费带宽 
•             Http Head 过大实际body缺不大
•             消耗服务器CPU占用

 

WebSocket

  WebSocket一旦建立了两端的连接，可以不断的进行通信，是一种全双通的通信模式。

 

    2.2 WebSocket 与Http

Http是 懒惰的协议，有接收才有响应

WebSocket是全双向通信网络协议，server主动向client发送数据

 

   2.3 WebSocket 与Socket

Socket 首先要明白是一种接口 并不是一向协议

WebSocket是同等级的网络协议

两者没有任何关系

    

•     本质上是一个基于TCP的协议
  
•     向服务器发起一个HTTP请求 /“Upgrade WebSocket”
  
•     服务器端解析头信息

   

 2.4 OkHttp是如何处理WebSocket的

        

  private Handler handler = new Handler() {

        @Override

        public void handleMessage(Message msg) {

            super.handleMessage(msg);

        }

    };

 

    /**

     * WebSocketListener 运行在工作线程的

     */

    private final class EchoWebSocketListener extends WebSocketListener {

 

        //WebSocket 和远程 服务器端建立链接

        @Override

        public void onOpen(WebSocket webSocket, Response response) {

//            super.onOpen(webSocket, response);

            //OkHttp使用自己的后台发送数据，不用担心sendMessage1会阻塞当前线程的问题

            webSocket.send("xxx");

            //发送消息已经完成

            webSocket.close(1000, "ss");

        }

 

        /**

         * onMessage()中与主线程的交互要非常非常小心！！与主线程用handler交互可以

         */

        @Override

        public void onMessage(WebSocket webSocket, String text) {

//            super.onMessage(webSocket, text);

            setText("onMessage :" + text);

            handler.sendEmptyMessage(0);

        }

 

        //远端已经没有数据的情况,准备关闭WebSocket链接但是还没有关闭

        @Override

        public void onClosing(WebSocket webSocket, int code, String reason) {

//            super.onClosing(webSocket, code, reason);

            setText("onClosed:" + code + "/" + reason);

        }

 

        //这个链接已经完全被关闭了

        @Override

        public void onClosed(WebSocket webSocket, int code, String reason) {

//            super.onClosed(webSocket, code, reason);

            setText("onClosed:" + code + "/" + reason);

        }

 

        @Override

        public void onFailure(WebSocket webSocket, Throwable t, Response response) {

//            super.onFailure(webSocket, t, response);

            setText("onFailure:" + t + "/" + response);

        }

    }

 

3、Http如何处理缓存？OkHttp如何处理缓存相关问题？

 

• 强制缓存

（1）Expires 过期时间 —Http1.0 

    值表示服务器端返回的到期时间；

    下一次请求时候，请求的时间 <  服务端返回的到期时间 —》会直接使用缓存数据

缺陷：

    到期时间是由服务器端生成的，会与客户端的时间造成误差

 

（2）Cache-Control

    Cache-control 是由服务器返回的Response中添加的头信息；

   作用是告诉用户是从本地读取缓存还是从服务端获取消息

 

Cache-Control的取值：   

•         private ：表示客户端可以取缓存
•         public  ：表示客户端和代理服务器都可以缓存
•         max-age：表示缓存内容在多少秒后失效
•         no-cache：表示强制缓存的标识无法处理缓存
•         no-store：表示不进行缓存

 

• 对比缓存——网络协议

 

    1、首先需要进行比较判断是否可以使用缓存

    2、服务器会将缓存标识与数据一起返回给客户端

 

流程：

    再次请求数据——>

            if(有缓存 != null) {

                    if(是否过期 ？){

                            没过期直接从缓存读取数据

                      }else if(无法判断是否已经过期){

                       // 进行对比缓存检查

                                if(判断ETag 标准){

                                  向web服务器请求带If-None-Match—— 两者进行匹配！     

                                       资源 有改动返回200，请求响应； 无改动返回304 直接从缓存读取    

                                  }else if(ETag != null){

                                    if(Last-Modified == null ){

                                        向服务器请求带If-Modified-Since

                                            有改动返回200 ，请求响应；无改动返回304 直接从缓存读取

                                    }

                                 }

                      }

             }

    

 

当前资源是否被改动过，改动过返回200，再去请求响应，没有改动过返回304

 

ETag / If-None-Match 成对出现

 

• ETag   :            服务器端响应请求时候，告诉浏览器当前资源在服务器的唯一标识

   ps：生成规则由服务器端决定唯一标识 与下面的进行匹配

 

• If-None-Match：再次请求服务器时候，通过此字段通知服务器客户端缓存数据的唯一标识

 

Last-Modified / If-Modefied-Since 成对出现

 

• Last-Modified    :   服务器在响应请求时，告诉浏览器资源的最后修改时间
• If-Modefied-Since ：再次请求服务器时，浏览器通知服务器端上次请求时，服务器返回的资源最后修改时间

 

 

4、断点续传的原理？如何实现？OkHttp中如何实现相关原理？

    4.1 断点续传

   断点续传：从文件已经下载完的地方开始继续下载

    实现：客户端发送给浏览器端的请求头报文当中，添加这次下载从什么位置开始的新条件

RANGE:bytes = 200080 - 

        表明这次从 资源的 200080位置开始下载

 

在Java中用HttpURLConnection 实现：

public void doBreakDownLoadJava() {

    URL url = null;

    try {

       //1、创建URL对象

        url = new URL("http://www.sjtu.edu.cn/down.zip");

        //2、通过URL创建 HttpURLConnection,由它完成网络请求

        HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();

       //3、通过setRequestProperty ,创建请求头部信息，设置断点续传的开始位置

        httpURLConnection.setRequestProperty("RANGE", "bytes=2000080”);

        InputStream inputStream = httpURLConnection.getInputStream();

        //4、获取到流信息保存到文件中,用字节进行指定的读取

        RandomAccessFile oSaveFile = new RandomAccessFile("down.zip", "rw");

        long nPos = 2000070;

        //5、表明文件读取的位置

        oSaveFile.seek(nPos);

        //常规IO流读写操作

        byte[] b = new byte[1024];

        int nRead;

        while ((nRead = inputStream.read(b, 0, 1024)) > 0) {

         //6、对文件写入操作

            oSaveFile.write(b, 0, nRead);

        }

    } catch (MalformedURLException e) {

        e.printStackTrace();

    } catch (IOException e) {

        e.printStackTrace();

    }

}

 

OkHttp中相关实现实例：

/**

* OkHttp断点续传

*/

public void doDownloadWithOkHttp() {

    InputStream is = null;

    RandomAccessFile savedFie = null;

    File file;

    //1、首先记录已经下载的文件长度

    long downloadLength = 0;

    String downloadUrl = "www.baidu.com/wenku/o2232.txt";

    String filename = downloadUrl.substring(downloadUrl.lastIndexOf("/"));

    File directory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);

    file = new File(directory + filename);

   //2、判断下载的文件是否存在 ，存在的话下载长度范围赋值

    if (file.exists()) {

        downloadLength = file.length();

    }

    long contentLength = getContentLength(downloadUrl);

    //3、创建OkHttpClient对象

    OkHttpClient client = new OkHttpClient();

   //4、创建Request对象,通过addHeader加头部信息添加到请求里,表明下载的范围

    Request request = new Request.Builder()

            .addHeader("RANGE", "bytes=" + downloadLength + "-")

            .url(downloadUrl)

            .build();

    //5、开启一个同步请求

    try {

        Response response = client.newCall(request).execute();

        //6、根据Response进行判断

        if (request != null) {

            is = request.body().byteStream();

            savedFie = new RandomAccessFile(file, "rw");

            //7、跳过已经下载的字节

            savedFie.seek(downloadLength);

            byte[] b = new byte[1024];

            int total = 0;

            int len;

            while ((len = is.read()) != -1) {

                total += len;

                savedFie.write(b, 0, len);

               //8、计算已经下载的百分比

                int progress = (int) ((total + downloadLength) * 100 / contentLength);

            }

        }

    } catch (IOException e) {

        e.printStackTrace();

    }

}

 

5、多线程下载原理，OkHttp如何实现？

 

多线程下载：每个线程只负责下载文件的一部分，也就是分段加载。

5.1 Java中多线程

在Java中多线程的下载 实例：

    

    /**

     * 多线程下载

     */

   public void download() throws Exception {

        URL url = new URL(path);

        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        connection.setRequestMethod("GET");

        connection.setConnectTimeout(10000);

       //根据connection的ResponseCode来进行相应的操作

        int code = connection.getResponseCode();

        if (code == 200) {

            //获取资源文件大小

            int connectionLength = connection.getContentLength();

            //在本地创建一个与资源同样大小的文件来占位

            RandomAccessFile randomAccessFile = new RandomAccessFile(

                    new File(targetfilePath, getFilePath));

            //在本地创建一个占位文件

            randomAccessFile.setLength(connectionLength);

 

            //计算每一个线程加载的数量

            int blockSize = connectionLength / threadCount;

            //为每一个线程分配任务

            for (int threadId = 0; threadId < threadCount; threadId++) {

                //线程开始/结束下载的位置

                int startIndex = threadId * blockSize;

                int endIndex = (threadId + 1) * blockSize - 1;

                if (threadId == (threadCount - 1)) {

                   //将所有任务交给endIndex完成

                    endIndex = connectionLength - 1;

                }

                //开始正式多线程的实现

                new DownloadThread(threadId, startIndex, endIndex).start();

            }

            randomAccessFile.close();

        }

    }

 

    /**

     * 开始正式多线程的实现

     */

   private class DownloadThread extends Thread {

        private int threadID, startIndex, endIndex;

 

        public DownloadThread(int threadID, int startIndex, int endIndex) {

            this.threadID = threadID;

            this.startIndex = startIndex;

            this.endIndex = endIndex;

        }

 

        @Override

        public void run() {

            System.out.println("线程" + threadID + "开始下载");

            try {

                //1、分段下载也需要分段的获取URL 将文件保存到本地

                URL url = new URL(path);

                //2、加载下载位置的文件,获取文件大小

                File downThreadFile = new File(targetFilePath, "downThread_" + threadID + ".dt");

                //3、创建一个新的RandomAccessFile

                RandomAccessFile downThreadStream = null;

                if (downThreadFile.exists()) {

                    //4、如果文件不存在

                    downThreadStream = new RandomAccessFile(downThreadFile, "rwd");

                    String startIndex_str = downThreadStream.readLine();

                    if (startIndex_str != unll || !"".equals(startIndex_str)) {

                        this.startIndex = Integer.parseInt(startIndex_str) - 1;//下载起点

                    }

                } else {

                    downThreadStream = new RandomAccessFile(downThreadFile, "rwd");

                }

                HttpURLConnection connection = (HttpURLConnection) url.openConnection();

                connection.setRequestMethod("GET");

                connection.setConnectTimeout(10000);

               //5、设置分段下载头信息

                connection.setRequestProperty("RANGE", "bytes=" + startIndex + "-" + endIndex);

                if (connection.getResponseCode() == 206) {//6、部分资源请求成功

                    InputStream inputStream = connection.getInputStream();

                    //7、获取创建的文件

                    RandomAccessFile randomAccessFile = new RandomAccessFile(

                            new File(targetFilePath, getFileName(url), "rw")

                    );

                    //8、文件写入的计算位置

                    randomAccessFile.seek(startIndex);

                   //IO流读写操作

                    byte[] buffer = new byte[1024];

                    int length = -1;

                    int total = 0;//记录本次下载文件的大小

                    while ((length = inputStream.read(buffer)) > 0) {

                        randomAccessFile.write(buffer, 0, length);

                        total += length;

                        downThreadStream.seek(0);

                        downThreadStream.write((startIndex + total + "").getBytes("UTF-8"));

                    }

                    //9、关闭IO流操作

                    downThreadStream.close();

                    inputStream.close();

                    randomAccessFile.close();

                    cleanTemp(downThreadFile);//删除创建的占位临时文件

                    System.out.println("线程：" + threadID + "下载完毕");

                } else {

                    System.out.println("响应码：" + connection.getResponseCode() + "服务器不支持");

                }

            } catch (FileNotFoundException e) {

                e.printStackTrace();

            } catch (IOException e) {

                e.printStackTrace();

            } catch (FileNotFoundException e) {

                e.printStackTrace();

            }

        }

    }

 

5.2 OkHttp 多线程下载的实现：

    

/**

* OkHttp断点续传

*/

public void doDownloadWithOkHttp() {

    InputStream is = null;

    RandomAccessFile savedFie = null;

    File file;

   //1、记录已经下载的文件长度

    long downloadLength = 0;

    String downloadUrl = "www.baidu.com/wenku/o2232.txt";

    String filename = downloadUrl.substring(downloadUrl.lastIndexOf("/"));

    File directory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);

    file = new File(directory + filename);

    if (file.exists()) {

        downloadLength = file.length();

    }

    long contentLength = getContentLength(downloadUrl);

    //2、创建OkHttpClient对象

    OkHttpClient client = new OkHttpClient();

    //3、创建Request对象,通过addHeader加头部信息添加到请求里,表明下载的范围

    Request request = new Request.Builder()

            .addHeader("RANGE", "bytes=" + downloadLength + "-")

            .url(downloadUrl)

            .build();

    //4、开启一个同步请求

    try {

        Response response = client.newCall(request).execute();

        //5、根据Response进行判断

        if (request != null) {

            is = request.body().byteStream();

            savedFie = new RandomAccessFile(file, "rw");

            //6、跳过已经下载的字节

            savedFie.seek(downloadLength);

            byte[] b = new byte[1024];

            int total = 0;

            int len;

            while ((len = is.read()) != -1) {

                total += len;

                savedFie.write(b, 0, len);

                //7、计算已经下载的百分比

                int progress = (int) ((total + downloadLength) * 100 / contentLength);

            }

        }

    } catch (IOException e) {

        e.printStackTrace();

    }

}

 

6、文件上传如何做？原理？OkHttp如何完成文件上传

     6.1 文件上传

 Java中的文件上传 ：在UrlConnection中使用post方法 然后在请求头时候添加Http之 Content-Type

指定请求和响应的HTTP内容类型 ，比如：

    Content-Type : multipart / form-data;

     boundary = ———(分割数据)WebkKitFormBoundaryOGKWPJsJCPWjZP

 

     6.2 OkHttp 文件上传的简单操作

public <T> void upLoadFile( String actionUrl ,HashMap<String,Object> paramsMap){

String requestUrl = String.format (“%s/%s”,”upload”,cationUrl);

//0、通过MultipartBody创建文件上传的body体

MultipartBody.Builder builder = new MultipartBody.Builder()

.addPart(Headers.of(

         "Content-Disposition", 

         "form-data; name="mFile"; 

         filename="1.txt""), fileBody)

     .build();

;

    builder.setType(MultipartBody.FORM);

    for (String key : paramsMap.keySet() ){

        Object object =paramsMap.get(key);

            if( ! ( object instanceof File) ){

                builder.addFormDataPart (key, object.toString() );

            } else {

                File file = (File)object ;

                builder .addFormDataPart(key,file.getName(),

                                RequestBody.create(MediaType.parse(“application/octet-stream”)) );

            }    

        }

    //1、构建RequestBody

    RequestBody body = builder.build();

    //2、构建Request

   Request request = new Request.Builder().url(“…”).post(body).build();

    //3、构建Call

    Call call = client . newBuilder().writeTimeout(60,TimeUnit.xxx);

    //4、构建异步回调

        call.enqueue(new Callback(){

            ...

        });

 

 

7、json数据如何解析？OkHttp如何解析json类型数据

   7.1 json数据的JAVA 解析

json：文本形式的数据交换格式

 

1、传统的JSON解析——— JSObject和JSArray

2、GSON————

3、FastJSON——

 

GSON 的两种解析方式：

/**

** 将json数据解析成list

*/

public void doGson(){

    //构建Gson对象

   Gson gson = new Gson();

    //通过fromJson 实现反序列化

      List<T> list = gson.fromJson(jsonData ,new TypeToken<List<T>>(){}.getType());

}

 

public void doGson(){

    //1、构建JsonParser 解析对象

 JsonParser parser = new JsonParser();

    //2、通过解析对象 将String类型json数组转化成JsonArray

JsonArray jsonArray  = parser .parse (stringjson). getAsJsonArray():

    //3、构建Gson对象 list对象

    Gson gson = new Gson();

    ArrayList<T> list = new ArrayList<>();

    //4、开始一个for循环 循环遍历jsonArray，获取jsonArray的每一个元素

for ( JsonElement je : jsonArray ){

     T  t1 = gson .fromJson(je , T.class);

        list .add ( t1) ;

    }

}

 

7.2 OkHttp中的json解析

    a、封装一个工具类HttpUtil

       public class HttpUtil {

            public static void sendOkHttpRequest (final String address ,final okhttp3.Callback callback){

                OkHttpClient client = new OkHttpClient();

                Request request = new Request.Builder().url(address).build();

                client.newCall(request).enqueue(callback);

    b、在响应中的调用

        private void sendRequestWithOkHttp(){

            new Thread(new Runnable(){

                @Override

                public void run(){

                    //子线程中执行http请求，并将最终的请求结果回调到Callback中

                    HttpUtil.sendOkHttpRequest( url, new okhttp3.Callback(){

                        @Override

                       public void onResponse(Call call, Response response) throws IOException{

                               String responseData = response.body().string();

                               //解析json数据

                                parseJsonWithGson(responseData);

                                //显示UI界面，通知主线程更新ui

                                showResponse( responseData.toString() );

                           }

                        @Override

                       public void onFailure(Call call ,IOException e){

                           }

                   )};

                  }

            }).start();

    }

private void parseJsonWithGson (String jsonData){

     //使用轻量级的Gson解析得到json

    Gson gson = new Gson();

    List<T> list = gson.fromJson(jsonData ,new TypeToken<List<T>>(){}.getType());

}

private void showResponse (final String response) {

    //在自线程中通知ui更新

    runOnUiThread (new Runnable() {

        @Override

        public void run(){

           //在此进行UI处理操作

            text .setText ( response);

        }

    )};

}

Lambda表达式的操作样式

    private void showResponse(final String response) {

        runOnUiThread( () -> {

            text.setText (response);

        });

}

 

8、Https协议处理？

 Https协议

    Https是一种基于SSL/TLS的Http协议，是属于应用层协议；

•         添加SSL/TLS 握手过程
  
•         两者数据加密传输
  

 

所有传输的内容都经过加密（对称加密+不对称加密）

 

对称加密

 是指加密和解密使用的密钥匙同一个密钥，两者可以互相推算。真正传输的数据进行加密

 

不对称加密

    不对称加密和解密使用的密钥不是同一密钥，对外公开其中一个密钥叫公钥。该加密是用于握手阶段的！

 

传送模式：

对称加密所使用的密钥我们可以通过非对称加密的方式发送出去

 

实例：

    一笔交易流程：

1、客户端生成一个随机对称密钥

2、客户端向服务器端请求一个公共密钥 -不对称加密所需要的公钥，给外界用的

3、服务端返回公钥给客户端

4、客户端接收到公钥后，通过该公钥对自己生成的随机对称密钥进行加密

5、将加密过的对称密钥发送给服务端

6、服务端接收该对称密钥后会用自己的私钥对其进行解密

7、进行传输 使用对称加密进行

 

Https 握手过程：

    1、客户端发起Https链接请求获取不对称加密的公钥（客户端支持的加密规则发送给服务端--不对称加密）

    2、服务端接收到请求后，从规则中选出一个不对称加密算法和一个hash算法（验证数据完整性的）

    3、服务端将自己的身份信息以证书的形式返回给客户端 -含有不对称加密的公钥

    4、客户端生成随机数-对称密钥 需要客户端和服务端双方保存

    5、客户端使用不对称加密的公钥对 “随机生成的对称密钥 进行加密”

    6、客户端将加密过的密钥发送给服务端

    7、服务端通过私钥对获取的加密过的密钥进行解密

    8、之后均是： 通过对称密钥加密的密纹通信