编码妙♂妙♂屋
首页 > 未分类 > 传统@ServerEndpoint方式开发WebSocket应用和SpringBoot构建WebSocket应用程序。

传统@ServerEndpoint方式开发WebSocket应用和SpringBoot构建WebSocket应用程序。

WebSocket一次握手就可以使客户端和服务端建立长连接，并进行双向数据传输。
由于其双向传输特性，服务端可主动向客户端发送信息，实时性很高。
而与HTTP协议比起来WebSocket 协议每次数据传输的头信息都较小，节约带宽。
在获取实时数据这方面时，那是比ajax轮询方式高到不知道哪去了。
 
在SpringBoot架构下进行WebSocket服务开发的话,首先还是要导入这个
就算是使用Tomcat 7 的@ServerEndpoint进行 WebSocket开发,也得导。不然在SpringBoot环境下会有bug。
普通java web应用开发WebSocket就不需要了,@ServerEndpoint直接用就行。

compile('org.springframework.boot:spring-boot-starter-websocket:2.0.4.RELEASE')

maven仓库: spring-boot-starter-websocket
 
这是使用@ServerEndpoint进行的传统WebSocket开发:
由于我是在SpringBoot环境,所以得先写个能扫描@ServerEndpoint的配置,不然在客户端连接的时候会一直连不上。不是在SpringBoot下开发的可以跳过这一环节。
ServerEndpointExporter这个类偏偏还是 spring-boot-starter-websocket 提供的。所以必须要导入这个依赖。

package com.skypyb.websocket;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
@Configuration
public class WebSocketConfigOne {
    /**
     * 这个bean会自动注册使用了@ServerEndpoint注解声明的对象
     * 没有的话会报404
     *
     * @return
     */
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

@ServerEndpoint 注解中写上客户端连接的地址。
在类层次上,还得加上 @Component 注解才行。普通java web项目不用加。
这个方式开发的WebSocket服务器，每个连接加入都会为该连接新建一个服务器对象绑定。

package com.skypyb.websocket;
import org.springframework.stereotype.Component;
import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;
/**
 * @ServerEndpoint 该注解可以将类定义成一个WebSocket服务器端，
 * @OnOpen 表示有浏览器链接过来的时候被调用
 * @OnClose 表示浏览器发出关闭请求的时候被调用
 * @OnMessage 表示浏览器发消息的时候被调用
 * @OnError 表示报错了
 */
@ServerEndpoint("/ws/serverOne")
@Component
public class WebSocketServerOne {
    //concurrent包下线程安全的Set
    private static final CopyOnWriteArraySet<WebSocketServerOne> SESSIONS = new CopyOnWriteArraySet<>();
    private Session session;
    @OnOpen
    public void onOpen(Session session) {
        this.session = session;
        SESSIONS.add(this);
        System.out.println(String.format("成功建立连接~ 当前总连接数为:%s", SESSIONS.size()));
        System.out.println(this);
    }
    @OnClose
    public void onClose() {
        SESSIONS.remove(this);
        System.out.println(String.format("成功关闭连接~ 当前总连接数为:%s", SESSIONS.size()));
    }
    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println(message);
    }
    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
    }
    /**
     * 指定发消息
     *
     * @param message
     */
    public void sendMessage(String message) {
        try {
            this.session.getBasicRemote().sendText(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 群发消息
     *
     * @param message
     */
    public static void fanoutMessage(String message) {
        SESSIONS.forEach(ws -> ws.sendMessage(message));
    }
}

这时，一个传统的WebSocket应用就开发完毕了。由于我是在SpringBoot下开发的，所以有一些调整。
启动应用后搞个普通的html页面直接本地打开就可以试验是否能够连接上了。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>webSocket</title>
    <style type="text/css">
    </style>
</head>
<body>
<h1>WebSocket Demo.</h1>
<h1>WebSocket Demo..</h1>
<h1>WebSocket Demo...</h1>
<input type="button" onclick="websocket.send('666666666')" value="点我发消息"/>
</body>
<script type="application/javascript">
    var websocket = {
        send: function (str) {
        }
    };
    window.onload = function () {
        if (!'WebSocket' in window) return;
        webSocketInit();
    };
    function webSocketInit() {
        websocket = new WebSocket("ws://127.0.0.1:8080/ws/serverOne");
        //成功建立连接
        websocket.onopen = function () {
            websocket.send("成功连接到服务器");
        };
        //接收到消息
        websocket.onmessage = function (event) {
            console.log(event.data)
        };
        //连接发生错误
        websocket.onerror = function () {
            alert("WebSocket连接发生错误");
        };
        //连接关闭
        websocket.onclose = function () {
            alert("WebSocket连接关闭");
        };
        //监听窗口关闭事件，当窗口关闭时，主动关闭websocket连接
        window.onbeforeunload = function () {
            websocket.close()
        };
    }
</script>
</html>

 
 
不过…我既然都导入了spring-boot-starter-websocket 依赖，自然最好还是用SprinBoot推荐的方法比较好。
这是使用SpringBoot的形式构建WebSocket应用程序:
 
这是核心配置类。实现WebSocketConfigurer接口实现它提供的注册方法。
这个方法就厉害了, 可以配置websocket入口，允许访问的域、注册Handler、定义拦截器等等等等。
@EnableWebSocket用于开启注解接收和发送消息

package com.skypyb.springboot_websocket;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import org.springframework.web.socket.server.HandshakeInterceptor;
import java.util.Map;
@Configuration
@EnableWebSocket
public class WebSocketConfigTwo implements WebSocketConfigurer {
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new MyWebSocketHandler(), "/ws/serverTwo")//设置连接路径和处理
                .setAllowedOrigins("*")
                .addInterceptors(new MyWebSocketInterceptor());//设置拦截器
    }
    /**
     * 自定义拦截器拦截WebSocket请求
     */
    class MyWebSocketInterceptor implements HandshakeInterceptor {
        //前置拦截一般用来注册用户信息，绑定 WebSocketSession
        @Override
        public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response,
                                       WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception {
            System.out.println("前置拦截~~");
            if (!(request instanceof ServletServerHttpRequest)) return true;
//            HttpServletRequest servletRequest = ((ServletServerHttpRequest) request).getServletRequest();
//            String userName = (String) servletRequest.getSession().getAttribute("userName");
            String userName = "Koishipyb";
            attributes.put("userName", userName);
            return true;
        }
        @Override
        public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response,
                                   WebSocketHandler wsHandler, Exception exception) {
            System.out.println("后置拦截~~");
        }
    }
}

关于他这个拦截器,是非常重要的，最好还是设置一个。他可以在连接进入到Handler处理时进行一些操作。
比如从session中拿出用户登陆信息作为唯一标识符等等…
我把我的拦截器实现写成内部类了，反正也没多少东西。
这个配置注册的处理器和拦截器，都是只有一个的，无论你多少连接进来，都是用相同的对象处理。
那么就不好用传统的WebSocket开发那样用个集合类容器来存了。
用前置拦截设置进去的某些唯一标识作为key，session作为value用键值对映射类容器来存储连接是比较好的方案。
 
这是我实现的处理器,也是WebSocket开发的核心:
需要实现WebSocketHandler 接口,该接口提供了五个方法。
1、 afterConnectionEstablished():建立新的socket连接后回调的方法。
2、handleMessage():接收客户端发送的Socket。
3、handleTransportError():连接出错时，回调的方法。
4、afterConnectionClosed():连接关闭时，回调的方法。
5、supportsPartialMessages():这个是WebSocketHandler是否处理部分消息，没什么卵用 返回false就完事了。

package com.skypyb.springboot_websocket;
import org.springframework.web.socket.*;
import java.io.IOException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class MyWebSocketHandler implements WebSocketHandler {
    private static final Map<String, WebSocketSession> SESSIONS = new ConcurrentHashMap<>();
    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        String userName = session.getAttributes().get("userName").toString();
        SESSIONS.put(userName, session);
        System.out.println(String.format("成功建立连接~ userName: %s", userName));
    }
    @Override
    public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
        String msg = message.getPayload().toString();
        System.out.println(msg);
    }
    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        System.out.println("连接出错");
        if (session.isOpen()) {
            session.close();
        }
    }
    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception {
        System.out.println("连接已关闭,status:" + closeStatus);
    }
    @Override
    public boolean supportsPartialMessages() {
        return false;
    }
    /**
     * 指定发消息
     *
     * @param message
     */
    public static void sendMessage(String userName, String message) {
        WebSocketSession webSocketSession = SESSIONS.get(userName);
        if (webSocketSession == null || !webSocketSession.isOpen()) return;
        try {
            webSocketSession.sendMessage(new TextMessage(message));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 群发消息
     *
     * @param message
     */
    public static void fanoutMessage(String message) {
        SESSIONS.keySet().forEach(us -> sendMessage(us, message));
    }
}

至此，SpringBoot 与 WebSocket 已经集成完了。客户端仍然使用我上边那个HTML文件就行，访问地址改一下就完事了。
我的这个WebSocket项目整体源码地址:  Github

           


CAPTCHAis initialing...
EA PLAYER &

历史记录 [ 注意：部分数据仅限于当前浏览器 ]清空

      00:00/00:00