WebSocket实现大屏数据实时推送

目录

配置类WebSocketConfiguration 

配置类连接池WebSocketServerPool

WebSocket应用实现

实体编码器

使用场景

---

配置类WebSocketConfiguration 

@Configuration
public class WebSocketConfiguration {

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

配置类连接池WebSocketServerPool

import javax.websocket.EncodeException;
import javax.websocket.Session;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * @author HFL
 * Websocket连接池、对连接池内连接操作 和数据推送方法
 */
public class WebSocketServerPool {

    /**
     * WebSocket连接池
     */
    private static ConcurrentMap<Session, String> dataConnect = new ConcurrentHashMap<>();

    /**
     * 将websocket连接，放入连接池
     * @param session websocket连接
     * @param screen 场景ID
     */
    public static void addDataConnect(Session session, String screen){
        dataConnect.put(session, screen);
        Iterator<Map.Entry<Session, String>> iterator = dataConnect.entrySet().iterator();
        synchronized (iterator){
            //移除失效连接
            while(iterator.hasNext()){
                Map.Entry<Session, String> entry = iterator.next();
                Session sessionNew = entry.getKey();
                Map<String, Object> userProperties = sessionNew.getUserProperties();
                if(null != userProperties && null != userProperties.get("ReadyState") && "0" != String.valueOf(userProperties.get("ReadyState"))){
                    iterator.remove();
                }
            }
        }
    }

    /**
     * 将websocket连接从连接池中移除
     * @param session websocket连接
     */
    public static void removeConnect(Session session){
        Iterator<Map.Entry<Session, String>> iterator = dataConnect.entrySet().iterator();
        synchronized (iterator){
            //主动移除连接
            while (iterator.hasNext()){
                if(session.equals(iterator.next().getKey())){
                    iterator.remove();
                }
            }
        }
    }

    /**
     * 获取连接池中所有连接
     * @return 连接池所有数据
     */
    public static ConcurrentMap<Session, String> getDataConnect(){
        return dataConnect;
    }

    /**
     * Websocket消息推送主要方法 进行消息推送就用这个方法
     * @param session 连接
     * @param message 消息主体
     * @throws IOException I/O异常
     */
    public static void sendMessage(Session session, String message) throws IOException {
        try {
            session.getBasicRemote().sendObject(message);
        } catch (EncodeException e) {
            throw new RuntimeException(e);
        }
    }
}

WebSocket应用实现类

import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson2.JSONObject;
import com.jr.device.controller.IotDeviceAlarmController;
import com.jr.device.domain.DeviceRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;

/**
 * @author HFL
 * Websocket应用实现:
 *  1.建立连接，连接放入连接池
 *  2.关闭连接，连接移出连接池
 *  3.接收客户端发送的消息，并做出相应处理
 *  4.注入业务层的service
 *  [注意：Spring管理的Bean是单例模式的，而WebSocket不是单例，注入时需要处理一下]
 *  5.异常处理，连接移除连接池
 *  tips：规定实体编码器encoders = {BaseModelEncoder.class}
 */
@Component
@ServerEndpoint(value = "/ws/{screen}",encoders = {BaseModelEncoder.class})
public class WebSocketServer {

    private static final Logger log = LoggerFactory.getLogger(DeviceRecord.class);

    //业务层的类 根据实际情况注入，一般通过类下的方法获取要推送的数据
    private static IotDeviceAlarmController iotDeviceAlarmController;

    @Resource
    public void setConfigurationScreenService(IotDeviceAlarmController largeScreenController){
        WebSocketServer.iotDeviceAlarmController = largeScreenController;
    }
    /**
     * 建立连接成功调用 (Session + 场景)
     */
    @OnOpen
    public void onOpen(Session session,@PathParam("screen") String screen) throws IOException {
        log.info("[onOpen][session({}) 接入, [screen: {}]", session, screen);
        WebSocketServerPool.addDataConnect(session, screen);
        //获取要推送的方法
        JSONObject jsonObject = iotDeviceAlarmController.sendLargeMessage();
        //首次数据推送
        if (ObjectUtil.isNotNull(jsonObject)){
            WebSocketServerPool.sendMessage(session, jsonObject.toString());
        }
    }

    /**
     * 关闭连接时调用
     * @param session 连接
     */
    @OnClose
    public void onClose(Session session, CloseReason closeReason) {
        log.info("[onClose][session({}) 连接关闭。关闭原因是({})}]", session, closeReason);
        WebSocketServerPool.removeConnect(session);
    }

    /**
     * 错误时调用
     * @param session 连接
     * @param throwable 异常
     */
    @OnError
    public void onError(Session session, Throwable throwable) {
        log.info("[onClose][session({}) 发生异常]", session, throwable);
        WebSocketServerPool.removeConnect(session);
    }

    /**
     * 收到客户端信息后，根据接收到的信息进行处理
     * @param session 连接
     * @param message 数据消息
     */
    @OnMessage
    public void onMessage(Session session, String message) throws IOException {
        log.info("[onOpen][session({}) 接收到一条消息({})]", session, message);
    }

}

实体编码器

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.json.JsonMapper;

import javax.websocket.EncodeException;
import javax.websocket.Encoder;
import javax.websocket.EndpointConfig;

/**
 * @author YUSHENGDADA
 * @title: BaseModelEncoder
 * @projectName v2_lab
 * @description: 实体编码器
 */
public class BaseModelEncoder implements Encoder.Text<String> {
    @Override
    public String encode(String string) throws EncodeException {
        try {
            JsonMapper jsonMapper = new JsonMapper();
            return jsonMapper.writeValueAsString(string);

        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public void init(EndpointConfig endpointConfig) {

    }

    @Override
    public void destroy() {

    }
}

Encoder.Text<String>这里的场景需要的是String，也就是在推送消息的时候为String类型的数据，这里可以换成任何类型的对象。

使用场景

import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson2.JSONObject;

import com.jr.device.controller.IotDeviceAlarmController;
import com.jr.device.domain.IotDeviceAlarm;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;

import javax.websocket.Session;
import java.io.IOException;
import java.util.Set;
import java.util.concurrent.ConcurrentMap;

@Configuration
@EnableScheduling
public class SendLarge {

   @Autowired
   private IotDeviceAlarmController iotDeviceAlarmController;
    private static final Logger log = LoggerFactory.getLogger(IotDeviceAlarm.class);
    
    //设置没15秒调用该接口实现数据实时更新
    @Scheduled(cron = "0/15 * * * * ?")
    public void sendTestMessage() {
        //判断是否有数据连接
        if(WebSocketServerPool.getDataConnect().size()>0){
            log.info("发送数据");
            //获取链接信息
            ConcurrentMap<Session, String> dataConnects = WebSocketServerPool.getDataConnect();
            //获取session
            Set<Session> sessions = dataConnects.keySet();
            if (ObjectUtil.isNotNull(sessions)&&sessions.size()>0){
                for (Session session : sessions) {
                    String s = dataConnects.get(session);
                    //判断是否为数据大屏的链接
                    if ("Large".equals(s)){
                        //获取要返回的信息
                        JSONObject jsonObject = iotDeviceAlarmController.sendLargeMessage();
                        if (ObjectUtil.isNotNull(jsonObject)){
                            try {
                                //消息推送主要方法
                                WebSocketServerPool.sendMessage(session, jsonObject.toString());
                            } catch (IOException e) {
                                throw new RuntimeException(e);
                            }
                        }

                    }

                }
            }

        }
    }

}

上面代码使用场景为大屏数据的实时刷新推送，其中主要实现发送数据的是

 WebSocketServerPool.sendMessage(session, jsonObject.toString());

当然可以任何场景下使用，使用步骤是首先判断连接池是否有有连接，然后获取连接信息， 当初存入连接池的结构为<session,String>，现在我们可以通过String来判断是不是你想要的连接，当同时有多个连接时可以通过他分别去执行不同的业务，其中String来源与建立连接路径内所带的参数。

@ServerEndpoint(value = "/ws/{screen}",encoders = {BaseModelEncoder.class})