Spring+Websocket实现消息的推送

来源：互联网发布：帝国cms收费吗编辑：程序博客网时间：2024/05/17 01:38

摘要本文主要有三个步骤 1、用户登录后建立websocket连接，默认选择websocket连接，如果浏览器不支持，则使用sockjs进行模拟连接 2、建立连接后，服务端返回该用户的未读消息 3、服务端进行相关操作后，推送给某一个用户或者所有用户新消息相关环境 Spring4.0.6(要选择4.0+),tomcat7.0.55

Spring springmvc websocket

目录[-]

Websocet服务端实现

用户登录建立websocket连接

返回用户未读的消息

服务端推送消息给用户

Websocet服务端实现

WebSocketConfig.java

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Configuration
@EnableWebMvc
@EnableWebSocket
publicclass WebSocketConfig extendsWebMvcConfigurerAdapter implementsWebSocketConfigurer {
    @Override
    publicvoid registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(systemWebSocketHandler(),"/webSocketServer").addInterceptors(newWebSocketHandshakeInterceptor());
 
        registry.addHandler(systemWebSocketHandler(),"/sockjs/webSocketServer").addInterceptors(newWebSocketHandshakeInterceptor())
                .withSockJS();
    }
 
    @Bean
    publicWebSocketHandler systemWebSocketHandler(){
        returnnew SystemWebSocketHandler();
    }
 
}

不要忘记在springmvc的配置文件中配置对此类的自动扫描

?
1
<context:component-scanbase-package="com.ldl.origami.websocket"/>

@Configuration

@EnableWebMvc
@EnableWebSocket
这三个大致意思是使这个类支持以@Bean的方式加载bean，并且支持springmvc和websocket，不是很准确大致这样，试了一下@EnableWebMvc不加也没什么影响，@Configuration本来就支持springmvc的自动扫描

?
1
registry.addHandler(systemWebSocketHandler(),"/webSocketServer").addInterceptors(newWebSocketHandshakeInterceptor())

用来注册websocket server实现类，第二个参数是访问websocket的地址

?
1
2
3
registry.addHandler(systemWebSocketHandler(),"/sockjs/webSocketServer").addInterceptors(newWebSocketHandshakeInterceptor())
                .withSockJS();
    }

这个是使用Sockjs的注册方法

首先SystemWebSocketHandler.java

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
publicclass SystemWebSocketHandler implementsWebSocketHandler {
 
    privatestatic final Logger logger;
 
    privatestatic final ArrayList<WebSocketSession> users;
 
    static{
        users = newArrayList<>();
        logger = LoggerFactory.getLogger(SystemWebSocketHandler.class);
    }
 
    @Autowired
    privateWebSocketService webSocketService;
 
    @Override
    publicvoid afterConnectionEstablished(WebSocketSession session) throwsException {
        logger.debug("connect to the websocket success......");
        users.add(session);
        String userName = (String) session.getAttributes().get(Constants.WEBSOCKET_USERNAME);
        if(userName!=null){
            //查询未读消息
            intcount = webSocketService.getUnReadNews((String) session.getAttributes().get(Constants.WEBSOCKET_USERNAME));
 
            session.sendMessage(newTextMessage(count + ""));
        }
    }
 
    @Override
    publicvoid handleMessage(WebSocketSession session, WebSocketMessage<?> message) throwsException {
 
        //sendMessageToUsers();
    }
 
    @Override
    publicvoid handleTransportError(WebSocketSession session, Throwable exception) throwsException {
        if(session.isOpen()){
            session.close();
        }
        logger.debug("websocket connection closed......");
        users.remove(session);
    }
 
    @Override
    publicvoid afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throwsException {
        logger.debug("websocket connection closed......");
        users.remove(session);
    }
 
    @Override
    publicboolean supportsPartialMessages() {
        returnfalse;
    }
 
    /**
     * 给所有在线用户发送消息
     *
     * @param message
     */
    publicvoid sendMessageToUsers(TextMessage message) {
        for(WebSocketSession user : users) {
            try{
                if(user.isOpen()) {
                    user.sendMessage(message);
                }
            }catch(IOException e) {
                e.printStackTrace();
            }
        }
    }
 
    /**
     * 给某个用户发送消息
     *
     * @param userName
     * @param message
     */
    publicvoid sendMessageToUser(String userName, TextMessage message) {
        for(WebSocketSession user : users) {
            if(user.getAttributes().get(Constants.WEBSOCKET_USERNAME).equals(userName)) {
                try{
                    if(user.isOpen()) {
                        user.sendMessage(message);
                    }
                }catch(IOException e) {
                    e.printStackTrace();
                }
                break;
            }
        }
    }
}

相关内容大家一看就能明白，就不多解释了

然后WebSocketHandshakeInterceptor.java

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
publicclass WebSocketHandshakeInterceptor implementsHandshakeInterceptor {
 
    privatestatic Logger logger = LoggerFactory.getLogger(HandshakeInterceptor.class);
    @Override
    publicboolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object
                > attributes) throwsException {
        if(request instanceofServletServerHttpRequest) {
            ServletServerHttpRequest servletRequest = (ServletServerHttpRequest) request;
            HttpSession session = servletRequest.getServletRequest().getSession(false);
            if(session != null) {
                //使用userName区分WebSocketHandler，以便定向发送消息
                String userName = (String) session.getAttribute(Constants.SESSION_USERNAME);
                attributes.put(Constants.WEBSOCKET_USERNAME,userName);
            }
        }
        returntrue;
    }
 
    @Override
    publicvoid afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) {
 
    }
}

这个的主要作用是取得当前请求中的用户名，并且保存到当前的WebSocketHandler中，以便确定WebSocketHandler所对应的用户，具体可参考HttpSessionHandshakeInterceptor

用户登录建立websocket连接

index.jsp

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<script type="text/javascript"src="http://localhost:8080/Origami/websocket/sockjs-0.3.min.js"></script>
        <script>
            varwebsocket;
            if('WebSocket'in window) {
                websocket = newWebSocket("ws://localhost:8080/Origami/webSocketServer");
            }elseif ('MozWebSocket'in window) {
                websocket = newMozWebSocket("ws://localhost:8080/Origami/webSocketServer");
            }else{
                websocket = newSockJS("http://localhost:8080/Origami/sockjs/webSocketServer");
            }
            websocket.onopen = function(evnt) {
            };
            websocket.onmessage = function(evnt) {
                $("#msgcount").html("(<font color='red'>"+evnt.data+"</font>)")
            };
            websocket.onerror = function(evnt) {
            };
            websocket.onclose = function(evnt) {
            }
 
        </script>

使用sockjs时要注意

1、这两个的写法

?
1
<script type="text/javascript"src="http://localhost:8080/Origami/websocket/sockjs-0.3.min.js"></script>

?
1
websocket = newSockJS("http://localhost:8080/Origami/sockjs/webSocketServer");

2、web.xml中

?
1
2
3
<web-appversion="3.0"xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_1.xsd">

?
1
version

?
1
web-app_3_1.xsd

这两个的版本都要是3.0+

然后在这个servlet中加入

?
1
<async-supported>true</async-supported>

?
1
2
3
4
5
6
7
8
9
10
<servlet>
        <servlet-name>appServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath*:servlet-context.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
        <async-supported>true</async-supported>
    </servlet>

然后所有的filter中也加入

?
1
<async-supported>true</async-supported>

3、添加相关依赖

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.3.1</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.3.3</version>
        </dependency>

好了，现在websocket可以正常建立起来了

返回用户未读的消息

当连接建立后，会进入SystemWebSocketHandler的afterConnectionEstablished方法，代码看上边，取出WebSocketHandshakeInterceptor中保存的用户名

查询信息后使用session.sendMessage(new TextMessage(count + ""));返回给用户，从哪来回哪去

服务端推送消息给用户

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Controller
publicclass AdminController {
 
    staticLogger logger = LoggerFactory.getLogger(AdminController.class);
 
    @Autowired(required = false)
    privateAdminService adminService;
 
    @Bean
    publicSystemWebSocketHandler systemWebSocketHandler() {
        returnnew SystemWebSocketHandler();
    }
 
 
    @RequestMapping("/auditing")
    @ResponseBody
    publicString auditing(HttpServletRequest request){
        //无关代码都省略了
        intunReadNewsCount = adminService.getUnReadNews(username);
        systemWebSocketHandler().sendMessageToUser(username,newTextMessage(unReadNewsCount + ""));
        returnresult;
    }
}

在这里可以使用sendMessageToUser给某个用户推送信息，也可以使用sendMessageToUsers给所有用户推送信息。

转自：http://my.oschina.net/ldl123292/blog/304360?fromerr=Uxv8khV7

1 0