Java集成websocket，并利用redis进行消息发送_java集成websocket,并利用redis进行消息发送-优快云博客

@Configuration
public class WebSocketConfiguration {

    //注入ServerEndpointExporter，这个bean会自动注册使用了@ServerEndpoint注解声明的WebsocketEndpoint
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

2.3 WebSocketService.java

import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;
import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

import com.trendytech.atm.config.AtmServiceProperties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.listener.ChannelTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.stereotype.Component;

@ServerEndpoint("/websocket")
@Component
public class WebSocketServer {

    /**
     * 日志对象
     */
    private static Logger logger = LoggerFactory.getLogger(WebSocketServer.class);


    /**
     * redis消息监听者容器，此处不好直接注入
     */
    private static RedisMessageListenerContainer redisMessageListenerContainer;

    @Autowired
    public void setRedisMessageListenerContainer(RedisMessageListenerContainer redisMessageListenerContainer) {
        WebSocketServer.redisMessageListenerContainer = redisMessageListenerContainer;
    }

    /**
     * concurrent包的线程安全Set，用来存放每个客户端对应的webSocket对象。若要实现服务端与单一客户端通信的话，可以使用Map来存放，其中Key可以为用户标识
     */
    private static CopyOnWriteArraySet<WebSocketServer> webSocketSet = new CopyOnWriteArraySet<>();

    /**
     * websocket订阅监听器
     */
    private WebSocketSubscribeListener subscribeListener;

    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session) {

        webSocketSet.add(this);

        subscribeListener = new WebSocketSubscribeListener();
        subscribeListener.setSession(session);

        // 设置订阅topic
        redisMessageListenerContainer.addMessageListener(subscribeListener, new ChannelTopic("WEBSOCKET_MSG_TOPIC"));
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose(Session session) {
        // 移除session对象
        webSocketSet.remove(this);
        // 移除订阅对象
        redisMessageListenerContainer.removeMessageListener(subscribeListener);
    }

    /**
     * 收到客户端消息后调用的方法
     * @param message 客户端发送过来的消息
     * @param session 可选的参数
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        logger.info("get msg from websocket client: {}", message);
    }

    /**
     * 发生错误时调用
     * @param session    session对象
     * @param error      错误信息
     */
    @OnError
    public void onError(Session session, Throwable error){
        logger.error("websocket server error", error);
    }

    /**
     * 发送消息
     * @param session session对象
     * @param message 发送的消息
     */
    private void sendMessage(Session session, String message) {
        try {
            session.getBasicRemote().sendText(message);
        } catch (IOException e) {
            logger.error("websocket send message error, {}", message);
        }
    }
}

2.4 WebSocketSubscribeListener.java

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;

import javax.websocket.Session;
import java.io.IOException;

/**
 * websocket消息订阅监听器
 */
public class WebSocketSubscribeListener implements MessageListener {

    /**
     * 日志对象
     */
    private Logger logger = LoggerFactory.getLogger(WebSocketSubscribeListener.class);

    /**
     * websocket连接对象
     */
    private Session session;

    /**
     * 获取websocket连接对象
     * @return websocket连接对象
     */
    public Session getSession() {
        return session;
    }

    /**
     * 设置websocket连接对象
     * @param session websocket连接对象
     */
    public void setSession(Session session) {
        this.session = session;
    }


    @Override
    public void onMessage(Message message, byte[] bytes) {
        // 获取消息
        String msg = new String(message.getBody());
        // 发送websocket消息
        if (null != session && session.isOpen()) {
            try {
                session.getBasicRemote().sendText(msg);
            } catch (IOException e) {
                logger.error("send websocket message error: ", e);
            }
        }
    }
}

三、redis消息发送

3.1 redis的基础配置在此不做细述

3.2 封装消息对象

import java.io.Serializable;

/**
 * websocket消息
 */
public class WebSocketMessage implements Serializable {

    /**
     * 消息类型
     */
    private String msgType;

    /**
     * 模块类型
     */
    private String moduleType;

    /**
     * 消息体
     */
    private Object body;

    /**
     * 构造方法
     * @param msgType       消息类型
     * @param moduleType    模块类型
     * @param body          消息体
     */
    public WebSocketMessage(String msgType, String moduleType, Object body) {
        this.msgType = msgType;
        this.moduleType = moduleType;
        this.body = body;
    }

    public String getMsgType() {
        return msgType;
    }

    public void setMsgType(String msgType) {
        this.msgType = msgType;
    }

    public String getModuleType() {
        return moduleType;
    }

    public void setModuleType(String moduleType) {
        this.moduleType = moduleType;
    }

    public Object getBody() {
        return body;
    }

    public void setBody(Object body) {
        this.body = body;
    }
}

3.3 发送消息

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 发布websocket消息
     *
     * @param webSocketMessage websocket消息
     */
    @RedisTemplateException
    public void sendWebSocketMessage(WebSocketMessage webSocketMessage) {
        redisTemplate.convertAndSend("WEBSOCKET_MSG_TOPIC", webSocketMessage);
    }