websocket简单使用

websocket简单使用

<!-- webSocket start-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-websocket</artifactId>
		</dependency>
		<!-- webSocket end-->
    <!-- 微信支付api-->
    <dependency>
			<groupId>com.github.wechatpay-apiv3</groupId>
			<artifactId>wechatpay-apache-httpclient</artifactId>
			<version>0.2.2</version>
		</dependency>

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

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.hikvision.pgmrs.entity.MessageInfoEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

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

/**
 * 事件订阅websocket服务端
 * @author 
 * @date 2020/8/3
 * @param
 * @return
 */
@ServerEndpoint(value = "/webSocket/message/{personId}")
@Component
@Slf4j
public class WebSocketServer {

    /**客户端在线连接数量，静态变量，线程安全。*/
    private static AtomicInteger onlineNum = new AtomicInteger();

    /** session池，，用来存放每个客户端对应的WebSocket session对象。*/
    private static ConcurrentHashMap<String, Session> sessionPools = new ConcurrentHashMap<>();

    /**接收personId*/
    private String personId="";

    public void  sendMessage(MessageInfoEntity messageInfoEntity){
        log.info("websocket推送给前端实时消息: {}",JSONObject.toJSON(messageInfoEntity));
        String message = JSONObject.toJSONString(messageInfoEntity,SerializerFeature.WriteMapNullValue);
        Integer messageType = messageInfoEntity.getMessageType();
        switch (messageType){
            case 1:
            case 6:
                String originalPersonId = messageInfoEntity.getOriginalPersonId();
                if(Objects.nonNull(originalPersonId)){
                    sendInfoToPerson(originalPersonId, message);
                }
                break;

            case 3:
            case 5:
                String applyPersonId = messageInfoEntity.getApplyPersonId();
                if(Objects.nonNull(applyPersonId)){
                    sendInfoToPerson(applyPersonId, message);
                }
                break;

            case 7:
//            case 9:
                String meetingDelayPersonId = messageInfoEntity.getMeetingDelayPersonId();
                if(Objects.nonNull(meetingDelayPersonId)){
                    sendInfoToPerson(meetingDelayPersonId, message);
                }
                break;

            case 2:
            case 4:
            case 8:
            case 9:
                sendInfoToAll(message);
                break;
            case 10:
            case 11:
                String presentPersonId = messageInfoEntity.getPresentPersonId();
                if(Objects.nonNull(presentPersonId)){
                    sendInfoToPerson(presentPersonId, message);
                }
            default:
                log.info("未匹配到对应的消息类型: {}", message);
        }
    }


    /**
     *   发送消息
     * @author 
     * @date 2020/8/3
     * @param session, message
     * @return void
     */
    private void sendMessage(Session session, String message) throws IOException {
        if(session != null){
            synchronized (session) {
                session.getBasicRemote().sendText(message);
            }
        }
    }
    /*
     *  给指定用户发送信息
     * @author 
     * @date 2020/8/3
     * @param personId, message
     * @return void
     */

    public void sendInfoToPerson(String personId, String message){
        Session session = sessionPools.get(personId);
        if(Objects.nonNull(session)){
            try {
                sendMessage(session, message);
                log.info("推送个人消息: {}, 到{}", message, personId);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }else{
            log.info("推送个人消息: {}, 到{}, session中未找到对应人员", message, personId);
        }
    }

    /*
     *  给指定角色发送信息
     * @author 
     * @date 2020/8/3
     * @param personId, message
     * @return void
     */

    public void sendInfoToAll(String message){
        Collection<Session> sessionList = sessionPools.values();
        for(Session session : sessionList){
            try {
                sendMessage(session, message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        log.info("推送全部消息: {}", message);
    }

    /**
     * 建立连接成功调用   @PathParam(value = "personId") String personId
     * @author 
     * @date 2020/8/3
     * @param session, personId
     * @return void
     */
    @OnOpen
    public void onOpen(Session session, @PathParam(value = "personId") String personId){
        this.personId = personId;
        sessionPools.put(personId, session);
        addOnlineCount();
        log.info("用户{}通过webSocket订阅消息成功, 当前总在线用户为{}", personId, onlineNum);
    }

    /**
     * 关闭连接时调用
     * @author 
     * @date 2020/8/3
     * @param
     * @return void
     */
    @OnClose
    public void onClose(Session session){
        if(sessionPools.containsKey(personId)){
            sessionPools.remove(personId);
            subOnlineCount();
        }
        log.info("用户{}退出, 当前总在线用户为{}", personId, onlineNum);
    }

    /**
     * 收到客户端信息
     * @author 
     * @date 2020/8/3
     * @param message
     * @return void
     */
    @OnMessage
    public void onMessage(String message){
        log.info("接收到客户端消息:{}",message);
    }

    /**
     * 错误时调用
     * @author 
     * @date 2020/8/3
     * @param session, throwable
     * @return void
     */
    @OnError
    public void onError(Session session, Throwable throwable){
        log.info("websocket发生错误，摘要{}，堆栈{}",throwable.getMessage(),throwable.getStackTrace());
        throwable.printStackTrace();
    }

    public static void addOnlineCount(){
        onlineNum.incrementAndGet();
    }

    public static void subOnlineCount() {
        onlineNum.decrementAndGet();
    }
}