Java springboot使用webscoket包含心跳机制

augisTrench

已于 2024-01-15 02:23:40 修改

阅读量905

点赞数 10

文章标签： java spring boot 开发语言

于 2024-01-15 01:58:34 首次发布

本文链接：https://blog.csdn.net/zjhzyw/article/details/135591719

版权

本文介绍了如何在SpringBoot应用中使用WebSocket，通过枚举类型管理消息类型，实现根据不同消息类型调用对应接口。展示了如何配置WebSocket服务器端点，以及如何通过参数验证进行安全消息发送和接收。

摘要由CSDN通过智能技术生成

在发送消息时候可以将消息类型让前端传过来，根据消息类型找到对应的枚举值，在根据枚举去调用接口信息。枚举中封装公共的server，实现方式进行继承，将会自动寻找到对应的impl方法。
由于很晚了，博主就不写出来了，思路给你们写出来，你们自己去完成。

package com.example.simplepoolsize.cofig;

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

@Configuration
public class WebsocketConfig {

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

package com.example.simplepoolsize;

public enum WebSocketMessageEnum {
    HEART_CHECK("欢迎光临", 1);

    private Object jsonValue;
    private int code;

    public Object getJsonValue() {
        return jsonValue;
    }

    public void setJsonValue(Object jsonValue) {
        this.jsonValue = jsonValue;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    WebSocketMessageEnum(Object jsonValue, int code) {
        this.jsonValue = jsonValue;
        this.code = code;
    }
}

package com.example.simplepoolsize;

public enum WebSocketStatus {
    one(1, "单人聊天"),
    two(2, "多人聊天");
    /*。。。。。。。。。。。。。。。。。。。。。。。。加很多*/

    private Object jsonValue;
    private int code;

    public Object getJsonValue() {
        return jsonValue;
    }

    public void setJsonValue(Object jsonValue) {
        this.jsonValue = jsonValue;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    WebSocketStatus( int code,Object jsonValue) {
        this.jsonValue = jsonValue;
        this.code = code;
    }
}

package com.example.simplepoolsize.server;

import com.example.simplepoolsize.WebSocketMessageEnum;
import com.sun.istack.internal.NotNull;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
@Service
@ServerEndpoint("/websocket/{uid}")
public class WebSocketServer {

    private static final long sessionTimeout = 50000;
    // 用来存放每个客户端对应的WebSocketServer对象
    private static ConcurrentHashMap<String, WebSocketServer> webSocketMap = new ConcurrentHashMap<>();

    // 与某个客户端的连接会话，需要通过它来给客户端发送数据
    private Session session;

    // 接收id
    private String uid;

    // 连接建立成功调用的方法
    @OnOpen
    public void onOpen(Session session, @PathParam("uid") String uid) {
        session.setMaxIdleTimeout(sessionTimeout);
        this.session = session;
        this.uid = uid;
        if (webSocketMap.containsKey(uid)) {
            webSocketMap.remove(uid);
        }
        webSocketMap.put(uid, this);
        log.info("websocket连接成功编号uid: " + uid + "，当前在线数: " + getOnlineClients());
        try {
            sendMessage(uid);
        } catch (IOException e) {
            log.error("websocket发送连接成功错误编号uid: " + uid + "，网络异常!!!");
        }
    }

    // 连接关闭调用的方法
    @OnClose
    public void onClose() {
        try {
            if (webSocketMap.containsKey(uid)) {
                webSocketMap.remove(uid);
            }
            log.info("websocket退出编号uid: " + uid + "，当前在线数为: " + getOnlineClients());
        } catch (Exception e) {
            log.error("websocket编号uid连接关闭错误: " + uid + "，原因: " + e.getMessage());
        }
    }

    /**
     * 收到客户端消息后调用的方法
     * @param message 客户端发送过来的消息
     * @param session
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        log.info("websocket收到客户端编号uid消息: " + uid + ", 报文: " + message);
        try {
            if (!StringUtils.isEmpty(message)){
                //JSONObject jsonObject = JSON.parseObject(message);
                //将数据进行转换处理
                this.sendMessage(message);
            }
        }catch (Exception e){
            e.printStackTrace();
            log.error("websocket收到客户端信息错误");
        }

    }

    /**
     * 发生错误时调用
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        log.error("websocket编号uid错误: " + this.uid + "原因: " + error.getMessage());
        error.printStackTrace();
    }

    /**
     * 外部接口通过指定的客户id向该客户推送消息
     * @param key
     * @param message
     * @return boolean
     */
    public static boolean sendMessageByWayBillId(@NotNull String key, String message) {
        WebSocketServer webSocketServer = webSocketMap.get(key);
        if (Objects.nonNull(webSocketServer)) {
            try {
                webSocketServer.sendMessage(message);
                log.info("websocket发送消息编号uid为: " + key + "发送消息: " + message);
                return true;
            } catch (Exception e) {
                log.error("websocket发送消息失败编号uid为: " + key + "消息: " + message);
                return false;
            }
        } else {
            log.error("websocket未连接编号uid号为: " + key + "消息: " + message);
            return false;
        }
    }

    // 此为单点消息(多人)
    public static void sendMoreMessage(String[] userIds, String message) {
        for(String userId:userIds) {
                try {
                    log.info("【websocket消息】 单点消息:"+message);
                    WebSocketServer webSocketServer = webSocketMap.get(userId);
                    webSocketServer.sendMessage(message);
                } catch (Exception e) {
                    e.printStackTrace();
                }
        }

    }

    // 全体消息
    public static void sendInfo(String message) {
        webSocketMap.forEach((k, v) -> {
            WebSocketServer webSocketServer = webSocketMap.get(k);
            try {
                webSocketServer.sendMessage(message);
                log.info("websocket群发消息编号uid为: " + k + "，消息: " + message);
            } catch (IOException e) {
                log.error("群发自定义消息失败: " + k + "，message: " + message);
            }
        });
    }

    /**
     * 服务端群发消息-心跳包
     * @param message
     * @return int
     */
    public static synchronized int sendPing(String message) {
        if (webSocketMap.size() <= 0) {
            return 0;
        }
        StringBuffer uids = new StringBuffer();
        AtomicInteger count = new AtomicInteger();
        webSocketMap.forEach((uid, server) -> {
            count.getAndIncrement();
            if (webSocketMap.containsKey(uid)) {
                WebSocketServer webSocketServer = webSocketMap.get(uid);
                try {
                    webSocketServer.sendMessage(message);
                    if (count.equals(webSocketMap.size() - 1)) {
                        uids.append("uid");
                        return; // 跳出本次循环
                    }
                    uids.append(uid).append(",");
                } catch (IOException e) {
                    webSocketMap.remove(uid);
                    log.info("客户端心跳检测异常移除: " + uid + "，心跳发送失败，已移除！");
                }
            } else {
                log.info("客户端心跳检测异常不存在: " + uid + "，不存在！");
            }
        });
        log.info("客户端心跳检测结果: " + uids + "连接正在运行");
        return webSocketMap.size();
    }

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


    // 获取客户端在线数
    public static synchronized int getOnlineClients() {
        if (Objects.isNull(webSocketMap)) {
            return 0;
        } else {
            return webSocketMap.size();
        }
    }

    /**
     * 连接是否存在
     * @param uid
     * @return boolean
     */
    public static boolean isConnected(String uid) {
        if (Objects.nonNull(webSocketMap) && webSocketMap.containsKey(uid)) {
            return true;
        } else {
            return false;
        }
    }

}
@Component
@Slf4j
@EnableScheduling
class WebSocketTask {

    /**
     * 每1秒进行一次websocket心跳检测
     */
    //这里可以写成线程去监听，但是太晚了，本人困了。剩下你们来操作
    @Scheduled(cron = "0/4 * * * * ?")
    public void clearOrders() {
        int num = 0;
        try {
            Object jsonObject = WebSocketMessageEnum.HEART_CHECK.getJsonValue();
            num = WebSocketServer.sendPing(jsonObject.toString());
        } finally {
            log.info("websocket心跳检测结果，共【" + num + "】个连接");
        }
    }
}

```bash
package com.example.simplepoolsize.coll;

import com.example.simplepoolsize.server.WebSocketServer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class WebSocketController  {
    @Value("${mySocket.myPwd}")
    private String myPwd;

    @Value("${mySocket.myPassword}")
    private String myPassword;


    //这里其实还可以在加上时间搓和token进行校验

    /**
     * webSocket链接是否成功
     * @param webSocketId
     * @return Res<Boolean>
     */
    @GetMapping("/webSocketIsConnect/{webSocketId}")
    public Res<Boolean> webSocketIsConnect(@PathVariable("webSocketId") String webSocketId) {
        return Res.success(WebSocketServer.isConnected(webSocketId));
    }

    /**
     * webSocket发送客户端消息
     * @param webSocketId
     * @param message
     * @param myPassword
     * @return Res<Boolean>
     */
    @GetMapping("/sendMessageByWayBillId")
    public Res<Boolean> sendMessageByWayBillId(String webSocketId, String message, String pwd,String myPassword) {
        boolean flag = false;
        if (myPwd.equals(pwd)&&myPwd.equals(myPassword)) {
            flag = WebSocketServer.sendMessageByWayBillId(webSocketId, message);
        }
        return Res.success(flag);
    }

    /**
     * 多人消息
     * @param message
     * @param pwd
     * @param myPassword
     */
    @GetMapping("/sendMoreMessage")
    public void sendInfo(String message, String pwd,String myPassword,String [] userIDs) {
        if (myPwd.equals(pwd)&&myPwd.equals(myPassword)) {
            WebSocketServer.sendMoreMessage(userIDs,message);
        }
    }

    /**
     * 广播消息
     * @param message
     * @param pwd
     * @param myPassword
     */
    @GetMapping("/sendInfo")
    public void sendInfo(String message, String pwd,String myPassword) {
        if (myPwd.equals(pwd)&&myPwd.equals(myPassword)) {
            WebSocketServer.sendInfo(message);
        }
    }
}



```bash
server:
  port: 8080

mySocket:
  myPwd: trench
  myPassword: 231231231231231

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