WebSocket使用

WebSocket推送之路

1、什么是WebSocket?

WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议，浏览器和服务器只需要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。浏览器通过 JavaScript 向服务器发出建立 WebSocket 连接的请求，连接建立以后，客户端和服务器端就可以通过 TCP 连接直接交换数据。

当你获取 Web Socket 连接后，你可以通过 send() 方法来向服务器发送数据，并通过 onmessage 事件来接收服务器返回的数据。

2、使用方法

a、pom依赖

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

b、建立服务端（附下方代码）

@ServerEndpoint("/webSocket/{policeId}")
@Component
public class WebSocketServer {

//有内置方法:@OnOpen、@OnClose、@OnMessage、@OnError

}

c、配置添加websocket支持

@Configuration
public class WebConfig {

@Bean
public ServerEndpointExporter serverEndpointExporter() {
    return new ServerEndpointExporter(); 　　// 开启webSocket支持
}}

d、前端发起：ws://IP:端口/webSocket/，https内使用wss 【访问神器：http://www.bejson.com/httputil/websocket】

 

坑点：

1、连接时的数据推送

2、弱网、断网时的数据处理

3、发送失败时的数据处理

4、登录后心跳处理，连接关闭和发送错误的时候重连，打开和接收消息心跳

5、退出可添加方法调用关闭

 

连接工具类使用如下：

/**
 * WebSocket服务端
 */
@Slf4j
@ServerEndpoint("/webSocket/{number}")
@Component
public class WebSocketServer {

    //静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
    private static int onlineCount = 0;
    //concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
    private static ConcurrentHashMap <String, WebSocketServer> webSocketSet = new ConcurrentHashMap <String, WebSocketServer>();
    //与某个客户端的连接会话，需要通过它来给客户端发送数据
    private Session session;
    //接收number
    private String number = "";

    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("number") String number) {
        try {
            this.openConnection(session, number);
        } catch(IOException e) {
            log.error("webSocket的I/O异常");
        }
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose() {
        this.close(number);
    }

    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message) throws IOException {
        for(String key : webSocketSet.keySet()) {
            if(!number.equals(key)) {
                webSocketSet.get(key).sendMessage(new SimpleDateFormat("MM/dd HH:mm:ss").format(new Date()) + "用户" + number + "发来消息：" + message);
            }
        }
    }

    /**
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        List <String> list = session.getRequestParameterMap().get("number");
        String policeNumber = list.get(0);
        List <String> caCheList = AdminCache.get(policeNumber);
        if(caCheList != null) {
            for(int i = 0; i < caCheList.size(); i++) {
                if(!StringUtil.isEmpty(caCheList.get(i))) {
                    OfflineRecordingService offlineRecordingService = SpringUtil.getBean(OfflineRecordingService.class);
                    OfflineRecording offlineRecording = new OfflineRecording();
                    offlineRecording.setMessage(caCheList.get(i));
                    offlineRecording.setPoliceNumber(policeNumber);
                    offlineRecordingService.insert(offlineRecording);
                    caCheList.remove(i);
                }
            }
        }
        AdminCache.set(policeNumber, caCheList);
        error.printStackTrace();
    }

    /**
     * 实现服务器主动推送
     */
    public void sendMessage(String message) throws IOException {
        this.session.getBasicRemote().sendText(message);
    }

    /**
     * 推送消息
     *
     * @param numberList 编号list或adminList
     * @param message    消息
     * @param type       0-推送至APP端、1-推送至web端 、3-推送至小程序端
     */
    public static void sendToUser(List <String> numberList, String message, Integer type) {
        if(type == 0) {
            for(int i = 0; i < numberList.size(); i++) {
                String sendPoliceNumber = numberList.get(i);
                try {
                    if(webSocketSet.get(sendPoliceNumber) != null) {
                        webSocketSet.get(sendPoliceNumber).sendMessage(message);
                        List <String> list = AdminCache.get(sendPoliceNumber);
                        if(list == null) list = new ArrayList <>();
                        list.add(message);
                        AdminCache.set(sendPoliceNumber, list);
                    } else {
                        log.info(sendPoliceNumber + "警员不在岗");
                        OfflineRecordingService offlineRecordingService = SpringUtil.getBean(OfflineRecordingService.class);//注入方式
                       　//保存数据库或者redis
                    }
                } catch(IOException e) {
                    log.error("推送APP端异常");
                }
            }
        } else if(type == 1) {
            for(int i = 0; i < numberList.size(); i++) {
                String sendAdminNumber = numberList.get(i);
                try {
                    if(webSocketSet.get(sendAdminNumber) != null) {
                        webSocketSet.get(sendAdminNumber).sendMessage(message);
                    }
                } catch(IOException e) {
                    log.error("推送web端异常");
                }
            }
        }
    }

    /**
     * 打开连接
     *
     * @param session
     * @param number
     * @throws IOException
     */
    private void openConnection(Session session, String number) throws IOException {
        this.session = session;
        this.number = number;
        if(number.contains(Constant.ADMIN_PREFIX)) {//后台登录admin+id
            AdminService adminService = SpringUtil.getBean(AdminService.class);
            String[] split = number.split("&");
            if(split.length < 3 || !StringUtil.isNumber(split[1])) return;
            boolean isKicked = adminService.adminIsKicked(Integer.valueOf(split[1]), split[2]);
            if(isKicked){
                this.sendMessage(JSON.toJSONString(new WebPushVo().setType(2).setMessage("您的账号已在其他设备登录")));
                return;
            }else {
                webSocketSet.put(number, this);
                log.info("管理员监听:" + number);
            }
        } else { //app警员连接
            PoliceManService policeManService = SpringUtil.getBean(PoliceManService.class);
            Boolean isExist = policeManService.isExistPolice(number);
            if(isExist) {//系统用户是否存在,避免资源浪费
                webSocketSet.put(number, this);//加入map中
                log.info("警员监听:" + number);
                OfflineRecordingService offlineRecordingService = SpringUtil.getBean(OfflineRecordingService.class);
                List <OfflineRecording> list = offlineRecordingService.selectList(number);
                Integer[] arr = new Integer[list.size() + 1];
                for(int i = 0; i < list.size(); i++) {
                    OfflineRecording offlineRecording = list.get(i);
                    webSocketSet.get(number).sendMessage(offlineRecording.getMessage());
                    arr[i] = offlineRecording.getId();
                }
                offlineRecordingService.deleteOff(arr);
            }
        }
        log.info("当前在线人数为" + getOnlineCount());
    }

    /**
     * 手动关闭连接
     *
     * @param number
     */
    public static void close(String number) {
        if(webSocketSet.get(number) != null) {
            webSocketSet.remove(number);//从set中删除
            if(number.contains(Constant.ADMIN_PREFIX)) {
                log.info("管理员连接关闭:" + number);
            } else {
                log.info("警员连接关闭：" + number);
            }
            log.info("当前在线人数为" + getOnlineCount());
        }
    }

    public static synchronized int getOnlineCount() {
        onlineCount = webSocketSet.size();
        return onlineCount;
    }

    public static synchronized void addOnlineCount() {
        WebSocketServer.onlineCount++;
    }

    public static synchronized void subOnlineCount() {
        WebSocketServer.onlineCount--;
    }
}