Java 通过Websocket 实现消息推送

一、WebSocket?

WebSocket协议是基于的一种新的网络协议。它实现了浏览器与服务器全双工(full-duplex)通信——允许服务器主动发送信息给客户端。

二、实践：

注：主启动类需要加上@EnableScheduling，否则不生效。

还有需要 SecurityConfig 类配置过滤掉

  【导入maven】

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

【创建WeSocket的配置类】

package com.dataanalysis.web.config;

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

@Configuration
public class WebSocketConfig {
    /**
     * 如果使用Springboot默认内置的tomcat容器，则必须注入ServerEndpoint的bean；
     * 如果使用外置的web容器，则不需要提供ServerEndpointExporter，下面的注入可以注解掉
     */
    @Bean
    public ServerEndpointExporter serverEndpointExporter(){
        return new ServerEndpointExporter();
    }
}

【Spring注入service】

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.text.ParseException;
import java.util.Base64;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;


@Slf4j  //用于日志
@ServerEndpoint(value = "/websocket/xxx/xxx")   //将该类定义为一个webSocket的服务端
@Component  //实例化到spring容器，泛指各种组件，不需要归类的时候，需要加上。在websocket必加
public class testWebSocket{


    //开始
    public static TestService testService ;  //前文有讲过，需要注入【跳转在上面】

    @Autowired
    public void setSenderService(TestService testService){
        testWebSocket.testService= testService;
    }
    //结束

   
    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(8);


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

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

    @PostConstruct
    public  void init(){
        //新建定时线程池
        Task task = new Task();
        //用于定时发送
        scheduledExecutorService.scheduleAtFixedRate(task,1,10, TimeUnit.SECONDS);
    }


    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session) {
        onlineCount.incrementAndGet(); // 在线数加1
        clients.put(session.getId(), session);
    }


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


    @OnError
    public void onError(Session session, Throwable error) {
        log.error("发生错误");
        error.printStackTrace();
    }


     /**
      * 服务端发送消息给客户端
      */
    private void sendMessage(String message, Session toSession) {
        try {
            log.info("服务端给客户端[{}]发送消息[{}]", toSession.getId(), message);
            toSession.getBasicRemote().sendText(message);
        } catch (Exception e) {
            log.error("服务端发送消息给客户端失败：{}", e);
        }
    }





     /**
      * 收到客户端消息后调用的方法
      *
      * @param message
      * 客户端发送过来的消息
      */
    @OnMessage
    public void onMessage(String message, Session session) throws ParseException {
        log.info("服务端收到客户端[{}]的消息[{}]", session.getId(), message);
        this.params = message;
        clientParmas.put(session.getId(),message);
        if(!StringUtils.isEmpty(message)){
            //前端传输过来是一个base64的字符，转换成一个map
           String deStr = new String(Base64.getDecoder().decode(parmas));
           Map<Object,Object> map = JSON.parseObject(deStr,Map.class);

            //具体业务编写。
            List<String> list = ....;
            //然后推送回前端
           sendMessage(JSON.toJSONString(list), session);
            
        }
    }


  public void sendMessageAll(String message) throws IOException {
        for (Session item : clients.values()) {
            item.getAsyncRemote().sendText(message);
        }
    }

    public static void broadcastAllUsers(String message) {

        try {
            for (Session item: clients.values()) {
                item.getAsyncRemote().sendText(message);
            }
        } catch (Exception e) {
            log.error("广播消息失败！！！");
        }
    }


    //定时自动推送数据
    class Task implements Runnable {
        @Override
        public void run() {
            clients.keySet().forEach(key -> {
                Session toSession = clients.get(key);
                if (toSession != null) {
                    String parmas = clientParmas.get(toSession.getId());
                    if (!StringUtils.isEmpty(parmas)) {
                        String deStr = new String(Base64.getDecoder().decode(parmas));
                        Map<Object,Object> map = JSON.parseObject(deStr,Map.class);
                       //具体业务编写。
                        List<String> list = ....;
                        //然后推送回前端
                        sendMessage(JSON.toJSONString(list), toSession);
                    }
                }
            });

        }
    }

}

注：也是边学边写，如有错误请指出，有不懂的，可留言，互相交流学习。