springboot使用webssocket,在nginx配置websocket代理

目录

maven依赖

websocket配置

websocket服务端

发送消息

nginx配置

---

maven依赖

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

websocket配置

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

/**
 * 开启WebSocket支持
 *
 */
@Configuration
public class WebSocketConfig {
	
    @Bean  
    public ServerEndpointExporter serverEndpointExporter() {  
        return new ServerEndpointExporter();  
    }  
  
}

websocket服务端

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.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArraySet;


@ServerEndpoint("/webSocketServer/{sendObj}")
@Component
@Slf4j(topic = "webSocketLog")
public class WebSocketServer {


    /**
     * 静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
     */
    private static int onlineCount = 0;

    /**
     * 
     * 外层map存储的是发送对象，里面的set存储的是连接至该对象的所有用户，因此订阅该类消息的用户都可以收到这种类型的消息
     */
    private static ConcurrentHashMap<String, CopyOnWriteArraySet<Session>> websocketMap = new ConcurrentHashMap<>();


    /**
     * 与某个客户端的连接会话，需要通过它来给客户端发送数据
     */
    private Session session;

    private String sendObj;

    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("sendObj") String sendObj) {
        this.session = session;
        this.sendObj = sendObj;
        CopyOnWriteArraySet<Session> sessions = new CopyOnWriteArraySet<>();
        if (websocketMap.containsKey(sendObj)) {
            sessions = websocketMap.get(sendObj);
        }
        sessions.add(session);
        websocketMap.put(sendObj, sessions);
        addOnlineCount();           //在线数加1
        log.info("有新连接加入！当前在线人数为" + getOnlineCount());

    }

    /**
     * 连接关闭调用的方法
     * <p>
     * 参考dwrsession摧毁方法
     */
    @OnClose
    public void onClose(Session session,@PathParam("sendObj") String sendObj) {
        CopyOnWriteArraySet<Session> sessions = websocketMap.get(sendObj);
        sessions.remove(session);
        if (sessions.size()==0) websocketMap.remove(sendObj);
        subOnlineCount();           //在线数减1
        log.info("有一连接关闭！当前在线人数为" + getOnlineCount());
    }

    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        log.info("来自客户端的消息:" + message);
    }

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

    // 发送消息
    public void sendMessage(String message) throws IOException {
        this.session.getAsyncRemote().sendText(message);

    }


    public static synchronized int getOnlineCount() {
        return onlineCount;
    }

    public static synchronized void addOnlineCount() {
        WebSocketServer.onlineCount++;
    }

    public static synchronized void subOnlineCount() {
        WebSocketServer.onlineCount--;
    }


    public Session getSession() {
        return session;
    }

    public void setSession(Session session) {
        this.session = session;
    }

    public static ConcurrentHashMap<String, CopyOnWriteArraySet<Session>> getWebsocketMap() {
        return websocketMap;
    }

    public static void setWebsocketMap(ConcurrentHashMap<String, CopyOnWriteArraySet<Session>> map) {
        WebSocketServer.websocketMap = map;
    }
}

发送消息

            ConcurrentHashMap<String, CopyOnWriteArraySet<Session>> webSocketSet = WebSocketServer.getWebsocketMap();
            if (webSocketSet.containsKey(type) && webSocketSet.get(type).size() > 0) {
                CopyOnWriteArraySet<Session> sessions = webSocketSet.get(type);
                Map message = new HashMap();
                message.put("desc", desc);
                message.put("reqBody", reqBody);
                message.put("respBody",respBody);
                for (Session session : sessions) {
                    session.getAsyncRemote().sendText(JSON.toJSONString(message,SerializerFeature.WriteMapNullValue));
                }
            }

nginx配置

#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    client_max_body_size 0;

    #gzip  on;

    map $http_upgrade $connection_upgrade {
        default upgrade;
        ''      close;
    }

    server {
        listen       18880;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   html/dist;
	        try_files $uri $uri/ /index.html;
            index  index.html index.htm;
        }

        location /file {
          alias /home;
          #开启子目录访问
          autoindex on;
        }

        location /wapi {
            proxy_pass http://localhost:18887/app;
            # 5分钟内没有数据交互自动断开连接
            proxy_read_timeout 600;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection $connection_upgrade;
        }
        
        

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

 


    }


}