1.webSocket簡介

WebSocket 是 HTML5 開始提供的一種在單個 TCP 連接上進行全雙工通訊的協議，

WebSocket 使得客戶端和服務器之間的資料交換變得更加簡單，允許服務端主動向客戶端推送資料，在 WebSocket API 中，瀏覽器和服務器只需要完成一次握手，兩者之間就直接可以創建持久性的連接，并進行雙向資料傳輸，

在 WebSocket API 中，瀏覽器和服務器只需要做一個握手的動作，然后，瀏覽器和服務器之間就形成了一條快速通道，兩者之間就直接可以資料互相傳送，

簡單的說，就是一次握手，持續通信，

2.使用場景

采用java實作的websocket客戶端與服務端除聊天室實作外，因其互動只需建立一次鏈接關系，極大的節省了記憶體與帶寬，所以也常用于實時資料傳輸與獲取，
某些業務需要在較短的時間間隔下，不斷的去獲取或傳輸資料，便可以考慮采用webSocket，
如：實時公交位置的獲取，實時人員位置的獲取，暴雨天氣中水庫的水位，某設備的實時溫度等等，

3.工程簡介

本專案共分兩個模塊

1. websocket服務端，采用java語言實作，繼承springboot框架，使用maven依賴
2. websocket測驗用客戶端，采用java語言實作，使用maven依賴

不必過分糾結專案中依賴所使用的版本，根據各自專案所需，切換合適的版本即可

3.服務端webSocketServer

首先我們來貼上關鍵代碼，然后再進行解讀
以下代碼共三部分：

• 所需pom依賴
• 開啟webSocket所需要的配置支持
• webSocket服務端

接下來我們依次來看：

所需pom依賴

 <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-websocket</artifactId>
 </dependency>
 <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.47</version>
 </dependency>

springboot集成了對webSocket的操作，此處我們使用的版本為2.3.3，同時涉及到資料通信，難免用到json決議，所以此處我們添加alibaba的fastjson依賴，用作決議json資料

開啟webSocket所需要的配置支持

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;


/**
 * @author zhaiLiMing
 * @version 2020-9-16
 * webSocket配置開啟websocket支持
 */
@Configuration
public class WebSocketConfig {

    @Bean
    public ServerEndpointExporter serverEndpointExporter(){
        return new ServerEndpointExporter();
    }
}

webSocket服務端

服務端基于5個注解實作，分別是：

1. @ServerEndpoint("/url") 該注解用于注釋服務端的類，被該注解注釋的類，將會被標注為webSocket的服務類，引數value為訪問的路徑
2. @OnOpen 被該注解注釋的方法，將在客戶端與服務端建立連接時執行
3. @OnMessage 被該注解注釋的方法，將在服務端收到訊息時執行
4. @OnClose 被該注解注釋的方法，將在鏈接關閉時執行
5. @OnError 被該注解注釋的方法，將在鏈接發生錯誤時執行

package com.modules.web;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.modules.service.StudentServiceImpl;
import com.modules.utils.DataTranslate;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * @author zhaiLiMing
 * @version 2020-9-16
 * webSocket服務端
 * @ServerEndpoint 將本類注解為webSocket服務端，其value為客戶端訪問URI
 * @Compoent 使得客戶端在spring容器啟動時候就被加載
 */
@ServerEndpoint("/endpoint")
@Component
public class WebSocketServer {

    public WebSocketServer()
    {
        System.out.println("EchoSocket:start");
    }

    private Session session;

    /**
     * 實體化service層，此處不能使用autowired等注解自動注入，
     * 因spring的bean是默認單例模式
     */
    private static StudentServiceImpl studentService=new StudentServiceImpl();

    /**
     * 打開連接時執行
     */
    @OnOpen
    public void onOpen(Session session) {
        this.session = session;
        System.out.println("連接已經打開");
    }

    /**
     * 收到訊息時執行
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("從客戶端收到的訊息：" + message);
   	    sendMessage(JSON.toJSONString(JSONArray.toJSONString(“回傳給客戶端的訊息”)));
    }

    /**
     * 關閉連接時執行
     */
    @OnClose
    public void onClose(Session session) {
        System.out.println("連接已經關閉");
    }

    /**
     * 連接發生錯誤時執行
     */
    @OnError
    public void onError(Throwable error, Session session) {
        System.out.println("連接發生錯誤");
    }

    /**
      websocket session發送文本訊息有兩個方法：getAsyncRemote()和getBasicRemote()
      getAsyncRemote()和getBasicRemote()是異步與同步的區別，
      大部分情況下，推薦使用getAsyncRemote()，
    */
    public void sendMessage(String message) throws IOException {
        this.session.getAsyncRemote().sendText(message);
    }
}

需要注意的問題及常見例外

如果需要在webSocket服務類中呼叫service層，使用注解（如@Autowired等）自動注入，會拋出空指標例外，
此處原因是，websocket每接收到一個客戶端的握手請求，就會開啟一個新的執行緒來處理該客戶端，然而，spring的bean默認是singleton單例模式，所以就會導致此類問題，
針對其的解決方法，可以采用傳統的new方式去創建javaBean，或者修改spring的bean為prototype，

4.客戶端webSocketClient

所需pom依賴

  <dependency>
      <groupId>org.java-websocket</groupId>
      <artifactId>Java-Websocket</artifactId>
      <version>1.3.8</version>
  </dependency>
  
  <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.47</version>
  </dependency>

針對所使用的依賴不再過多贅述

webSocket客戶端

webSocket客戶端的實作基于webSocketClient類實作，實體化webSocketClient并重寫以下四個方法：

1. onOpen 與服務端建立連接時執行
2. onMessage 收到服務端訊息時執行
3. onClose 連接關閉時執行
4. onError 發生錯誤時執行

import com.alibaba.fastjson.JSON;
import modules.entry.student.Student;
import modules.service.StudentService;
import modules.service.StudentServiceImpl;
import modules.utils.JsonFormat;
import org.java_websocket.WebSocket;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author zhaiLiMing
 * @version 2020-9-21
 * webSocketClient客戶端
 */
public class WebsocketClient {

    //創建webSocketClient客戶端
    private static WebSocketClient client;

    //實體化service層
    private static StudentService studentService=new StudentServiceImpl();

    //創建一個5個執行緒的執行緒池，用來接收onMessage
    private static ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);

    public static void main(String[] args) throws URISyntaxException, InterruptedException {



        //實體化webSocketClient，以ws或wss形式發送請求，重寫4個方法
        client=new WebSocketClient(new URI("ws://localhost:8080/endpoint")) {

            //創建連接時執行
            @Override
            public void onOpen(ServerHandshake serverHandshake) {
                System.out.println("建立連接");
            }

            //接收到訊息時執行
            @Override
            public void onMessage(String s) {

                Runnable runnable = new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(JSON.parseObject(s).getString("code"));
                        //業務處理，接識訓傳的訊息，決議JSON字串，存入資料庫
                        if (JSON.parseObject(s).getString("code").equals("1100")){
                            String data=JSON.parseObject(s).getString("data");
                             //JsonFormat是自己寫的工具類
                            List<Student> studentList= JsonFormat.jsonFormatStudent(data);
                            //呼叫service接收結果
                            int result=studentService.insert(studentList);
                            System.out.println("插入成功:"+result+"條資料！");
                        }else{
                            System.err.println("服務器出錯！");
                        }
                    }
                };

                fixedThreadPool.submit(runnable);
            }

            //連接關閉時執行
            @Override
            public void onClose(int i, String s, boolean b) {
                System.out.println("鏈接關閉");
            }

            //連接出錯時執行
            @Override
            public void onError(Exception e) {
                System.out.println("鏈接出錯");
            }
        };
        client.connect();

        //檢測連接狀態，重復嘗試連接
        while (!client.getReadyState().equals(WebSocket.READYSTATE.OPEN)) {
            System.out.println("before reconnect statte:"+client.getReadyState());
            Thread.sleep(2000);
            if(client.getReadyState().equals(WebSocket.READYSTATE.CLOSING) || client.getReadyState().equals(WebSocket.READYSTATE.CLOSED)){
                client.reconnect();
            }
            System.out.println("After reconnect statte:"+client.getReadyState());
        }

        //發送資料
        client.send("getStudent");

    }
}

需要注意的問題及常見例外

實體化webSocketClient時，有一個引數URI，URI中傳入地址，有兩種請求方式

1. ws請求：其類似于http請求，非安全
2. wss請求：其類似于https請求，安全

請求方式不同時，可能會拋出例外，兩種請求方式具體區別在此不做解釋，可查閱別的文章

5.繼續了解webSocket

在java中webSocket的5種狀態

參閱過webSocket API檔案的部分朋友或許會疑惑，為什么是5種呢？API檔案寫的4種呀！
實際上我們仔細看就會發現，java中（基于其他語言的websocket沒有研究，所以只說java），webSocket的原始碼里定義了內部列舉類READYSTATE，其中包含以下5種狀態

1. NOT_YET_CONNECTED 尚未鏈接
2. CONNECTING 鏈接中
3. OPEN 鏈接已打開
4. CLOSING 鏈接正在關閉
5. CLOSED 鏈接已經關閉

public static enum READYSTATE {
        NOT_YET_CONNECTED,
        CONNECTING,
        OPEN,
        CLOSING,
        CLOSED;

        private READYSTATE() {
        }
    }

不難看出，5種狀態表明著webSocket的整個生命周期，這對于我們在使用webSocket時解決一些問題是非常關鍵的

connect()與reconnect()

當webSocketClient初始化完畢之后，webSocketClient提供了兩種鏈接方式，封裝為兩個方法，分別是

1. connect()
2. reconnect()

那么這兩者有什么區別呢？這便設計到了上一個問題，webSocket的5種狀態，
起始時，webSocket狀態為 NOT_YET_CONNECTED ,尚未鏈接，而當一次鏈接關閉之后，其狀態為 CLOSED ，這兩者雖然都是沒有鏈接的狀態，但本質上是有區別的，
NOT_YET_CONNECTED 表示該webSocket實體還未開始鏈接，并處于等待鏈接的狀態，形象的講，就是初生的嬰兒；
而 CLOSED 則表示鏈接關閉，雖然也不是鏈接狀態，但其表示已經完成了一次生命周期，該webSocket實體到了消亡的時候，形象的講，就是垂暮的老人，
而webSocket想要鏈接，則只能在 NOT_YET_CONNECTED 狀態下進行，一旦狀態改變，則無法再次鏈接，這便是connect()鏈接，針對其解決方法，就是reconnect()鏈接，
reconnect()鏈接的實作，便是在connect之前呼叫了reset()方法，重置了當前webSocket，使得狀態又改變成了 NOT_YET_CONNECTED ，從而可以再次執行connect()方法，我們看一下原始碼：

  public void reconnect() {
        this.reset();
        this.connect();
    }

心跳機制及斷線重連方法

了解了webSocket的5種狀態以及connect()與reconnect()的區別后，就不難理解斷線重連和心跳機制，
所謂心跳機制，即為每隔一定時間，由客戶端發送特定的心跳包給服務器，服務器也回應訊息，雙方互相確認對方還"活著"，
例如我們每隔10秒則呼叫 webSocket.send("心跳包")
同時在onMessage中接收到回傳的內容，如果能接收到預期回傳的內容，則證明雙方都存在，反之則證明有一方掛掉，
至于重連機制，則可以利用reconnect()方法，在檢測到斷線后，重新嘗試鏈接服務端

//開啟一個新執行緒
new Thread(){
    @Override
    public void run(){
         try{
         //間隔10秒發送心跳
             Thread.sleep(10000);
             webSocketClient.send("心跳包");
         }catch (Exception e){
         //捕獲例外進行重連
             webSocketClient.reconnect();
         }
     }
   }.start();