springboot使用websocket做定时刷新任务 · 教程和websocket连接测试

来一杯Java☕

已于 2022-08-02 09:29:14 修改

阅读量2.5k

点赞数 5

文章标签： websocket spring boot java

于 2022-05-31 14:22:32 首次发布

本文链接：https://blog.csdn.net/weixin_45095396/article/details/125053021

版权

任务背景：前端需要定时刷新获得数据库表中的最新数据，当指定表中新增了一条记录后将新增的数据返回给前端

方法一：前端定时轮询调接口。
方法二：使用websocket连接。
由于定时轮询的周期是不固定的，如果前端写死刷新周期不太合适，所以本文中使用websocket连接来完成。

直接上代码

java代码，springboot项目。

1.pom.xml添加WebSocke依赖

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

2.WebSocke配置类

@Configuration
public class WebSocketConfig {
 
    /**
     * 这个bean的注册,用于扫描带有@ServerEndpoint的注解成为websocket  ,如果你使用外置的tomcat就            
        不需要该配置文件
     */
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
 
}

3.WebSocke服务类


@Slf4j
@ServerEndpoint(value = "/websocket/{authorization}")
@Component
public class WebSocketServer {

    /**
     * 记录当前在线连接数
     */
    private static final AtomicInteger ONLINE_COUNT = new AtomicInteger(0);

    /**
     * 存放所有在线的客户端
     */
    private static final Map<String, Session> CLIENTS = new ConcurrentHashMap<>();
    

    /**
     * 存放最近信息
     */
    private static final Queue<String> MESSAGES = new LinkedList<>();

    /**
     * 最近信息容量
     */
    private static final int ALARM_CAPACITY = 1;

    private static AssessmentRecordMapper assessmentRecordMapper;

   
    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam(value = "authorization") String authorization) {
        if (null == authorization) {
            throw new BusinessException(ErrorCodeEnum.GL99990401);
        }

        ONLINE_COUNT.incrementAndGet(); // 在线数加1
        CLIENTS.put(session.getId(), session);
        log.info("有新连接加入：{}，当前在线人数为：{}", session.getId(), ONLINE_COUNT.get());
        
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose(Session session) {
        ONLINE_COUNT.decrementAndGet(); // 在线数减1
        CLIENTS.remove(session.getId());
        log.info("有一连接关闭：{}，当前在线人数为：{}", session.getId(), ONLINE_COUNT.get());
    }

    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message, Session session) {
       //做自己的业务
    }

    @OnError
    public void onError(Session session, Throwable error) {
        log.error("发生错误" + (null == session ? "" : ",客户端id为: " + session.getId()));
        error.printStackTrace();
    }

    /**
     * 发送消息给指定客户端
     */
    public static void sendMessage(String sessionId, String message) {
        if (sessionId == null || message == null) {
            return;
        }
        synchronized (IdLockUtil.getLock("WebSocket:send" + sessionId)) {
            log.info("服务端给客户端[{}]发送消息", sessionId);
            try {
                Session session = CLIENTS.get(sessionId);
                if (ObjectUtil.isNotNull(session)) {
                    session.getBasicRemote().sendText(message);
                }
            } catch (Exception e) {
                log.error("服务端发送消息给客户端[{}]失败：{}", sessionId, e);
            }
        }
    }

    public static void sendMessage(String sessionId, Object message) {
        sendMessage(sessionId, JSONUtil.toJsonStr(message));
    }

    /**
     * 发送消息给全部客户端
     */
    public static void sendMessageToAll(String message) {
        //群发消息
       CLIENTS.forEach((sessionId, client) -> sendMessage(sessionId, message));

    }


}

其中OnOpen,OnClose等方法可以根据自己的业务来确定里面写什么内容，我这里主要是使用sendMessageToAll()方法，在别的接口中调用这个发消息的方法

上面的代码中，有些工具类或内部类（比如IdLockUtil，Message）如果直接复制代码过去会报红，请删除相关代码，在对应方法中写自己的业务。

IdLockUtil代码如下：

public class IdLockUtil {

    private static HashMap<String, String> mMapId = new HashMap<>();
    private static HashMap<String, String> mMapIdCache = new HashMap<>();

    /**
     * 缓存切换的开始时间，等待{@link #M_CACHE_DELETE_TIME}时间后将清空切换数据
     */
    private static long mCacheCreatTime;

    /**
     * 最大缓存数(当超出这一数值时，会自动清空)，缓存切换等待时间
     */
    private static final int M_MAX_CACHE = 1000;
    private static final int M_CACHE_DELETE_TIME = 10000;

    public static synchronized String getLock(String oldId) {
        String returnSt;
        if (mMapId.size() < M_MAX_CACHE) {
            //数据比较少，普通的返回锁
            if (!mMapId.containsKey(oldId)) {
                mMapId.put(oldId, oldId);
            }
            returnSt = mMapId.get(oldId);
        } else {
            //累加的残留数据太多，切换至缓存

            //缓存开始时间
            long nowMills = System.currentTimeMillis();
            if (mMapIdCache.size() == 0) {
                mCacheCreatTime = nowMills;
            }
            if (!mMapIdCache.containsKey(oldId)) {
                mMapIdCache.put(oldId, mMapId.getOrDefault(oldId, oldId));
            }
            returnSt = mMapIdCache.get(oldId);

            //等待mCacheChangeTime时间后清除原始数据
            if (nowMills - mCacheCreatTime > M_CACHE_DELETE_TIME) {
                mMapId.clear();
                //原始和缓存对调即可实现切换
                HashMap<String, String> change = mMapId;
                mMapId = mMapIdCache;
                mMapIdCache = change;
            }
        }
        return returnSt;
    }
}

使用方法示例

我是直接在别的接口调用sendMessageToAll()方法就可以给全部连接的客户端发送消息了。

 @Override
    public Boolean save(XxxVO vo) {
       
       /*
       * 新增数据逻辑
       */
       
        //发送websocket消息
        WebSocketServer.sendMessageToAll(JSONUtil.toJsonStr(xxxDO));

        return i == 1;
    }