springMVC4使用websocket

最新推荐文章于 2022-12-02 08:15:00 发布
最新推荐文章于 2022-12-02 08:15:00 发布
阅读量915 收藏 1
点赞数
分类专栏： webSocket 文章标签： websocket

转载自：http://blog.csdn.net/stickallthetime/article/details/44587413

一、测试环境 
1. Tomcat8.0.18 
2. JDK1.8 
3. Spring4.1 
二、新建一个SpringMVC的工程 
1. 使用Maven新建一个web工程，添加SpringMVC和spring websocket依赖，pom.xml文件如下

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>daybreak</groupId>
  <artifactId>spring-websocket</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>spring-websocket Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>4.1.4.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.1.0</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.1.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-websocket</artifactId>
        <version>4.1.4.RELEASE</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>spring-websocket</finalName>
    <defaultGoal>package</defaultGoal>
    <plugins>    
         <!-- 更改maven默认的打包目录 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId> 
            <artifactId>maven-war-plugin</artifactId>
            <version>2.5</version>
            <configuration>
                <webappDirectory>src/main/webapp</webappDirectory>
                <warSourceDirectory>target</warSourceDirectory>
            </configuration>
        </plugin>      
    </plugins>
  </build>
</project>
 
 
  • 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

 
 
  • 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
  1. 修改web.xml文件如下
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns="http://java.sun.com/xml/ns/javaee" 
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationContext-*.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <servlet>
    <servlet-name>spring-websocket</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/applicationContext-servlet.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>spring-websocket</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

   <welcome-file-list>
    <welcome-file>/index.jsp</welcome-file>
  </welcome-file-list>  
</web-app>
 
 
  • 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

 
 
  • 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
  1. 配置springMVC如下applicationContext-servlet.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-4.1.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
    http://www.springframework.org/schema/websocket
    http://www.springframework.org/schema/websocket/spring-websocket-4.1.xsd">

    <context:annotation-config/>

    <!-- Enables the Spring MVC @Controller programming model -->
    <mvc:annotation-driven /> 
    <bean id="mappingJacksonHttpMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
    <bean class ="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" >
        <property name="messageConverters">  
            <list>  
                <ref bean="mappingJacksonHttpMessageConverter" /> 
            </list>  
        </property> 
    </bean> 

    <context:component-scan base-package="cn.com"/>

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>  
        <property name="prefix" value="/view/"/>  
        <property name="suffix" value=".jsp"/>  
    </bean>      

</beans>
 
 
  • 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

 
 
  • 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

三、配置Spring Websocket 
1. 新建一个自己的HandShakeInterceptor类 
HandShakeInterceptor是websocket握手拦截器，用于拦截websocket初始化连接的请求 
package cn.com.websocket.hello; 
import org.springframework.web.socket.CloseStatus; 
import org.springframework.web.socket.TextMessage; 
import org.springframework.web.socket.WebSocketMessage; 
import org.springframework.web.socket.WebSocketSession; 
import org.springframework.web.socket.handler.TextWebSocketHandler; 
public class HelloHandler extends TextWebSocketHandler{ 
@Override 
public void handleTextMessage(WebSocketSession session, TextMessage message) { 
//接收到客户端消息时调用 
System.out.println(“text message: ” + session.getId() + “-” + message.getPayload()); 
}

@Override 
public void afterConnectionEstablished(WebSocketSession session) 
throws Exception { 
// 与客户端完成连接后调用 
System.out.println(“afterConnectionEstablished”); 
System.out.println(“getId:” + session.getId()); 
System.out.println(“getLocalAddress:” + session.getLocalAddress().toString()); 
System.out.println(“getTextMessageSizeLimit:” + session.getTextMessageSizeLimit()); 
System.out.println(“getUri:” + session.getUri().toString()); 
System.out.println(“getPrincipal:” + session.getPrincipal()); 
session.sendMessage(new TextMessage(“你好”.getBytes())); 
}

@Override 
public void handleTransportError(WebSocketSession session, 
Throwable exception) throws Exception { 
// 消息传输出错时调用 
System.out.println(“handleTransportError”); 
}

@Override 
public void afterConnectionClosed(WebSocketSession session, 
CloseStatus closeStatus) throws Exception { 
// 一个客户端连接断开时关闭 
System.out.println(“afterConnectionClosed”); 
}

@Override 
public boolean supportsPartialMessages() { 
// TODO Auto-generated method stub 
return false; 
} 
} 
2. 新建一个自己的WebSocketHandler类 
WebSocketHandler接口主要是用来与websocket客户端来进行交互的接口，Spring WebSocket提供了一些实现类，可以根据自己的需求进行选择与重写

package cn.com.websocket.hello;

import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;

public class HelloHandler extends TextWebSocketHandler{
    @Override
    public void handleTextMessage(WebSocketSession session, TextMessage message) {
        //接收到客户端消息时调用
        System.out.println("text message: " + session.getId() + "-" + message.getPayload());
    }

    @Override
    public void afterConnectionEstablished(WebSocketSession session)
            throws Exception {
        // 与客户端完成连接后调用
        System.out.println("afterConnectionEstablished");
        System.out.println("getId:" + session.getId());
        System.out.println("getLocalAddress:" + session.getLocalAddress().toString());
        System.out.println("getTextMessageSizeLimit:" + session.getTextMessageSizeLimit());
        System.out.println("getUri:" + session.getUri().toString());
        System.out.println("getPrincipal:" + session.getPrincipal());
        session.sendMessage(new TextMessage("你好".getBytes()));
    }

    @Override
    public void handleTransportError(WebSocketSession session,
            Throwable exception) throws Exception {
        // 消息传输出错时调用
        System.out.println("handleTransportError");
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session,
            CloseStatus closeStatus) throws Exception {
        // 一个客户端连接断开时关闭
        System.out.println("afterConnectionClosed");
    }

    @Override
    public boolean supportsPartialMessages() {
        // TODO Auto-generated method stub
        return false;
    }
}
 
 
  • 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

 
 
  • 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
  1. 配置Spring WebSocket 
    在spring的配置文件 applicationContext-servlet.xml中添加如下配置：
<!-- websocket消息处理bean -->
<bean id="HelloHandler" class="cn.com.websocket.hello.HelloHandler"/>
<websocket:handlers>
    <!-- 配置消息处理bean和路径的映射关系 -->
    <websocket:mapping path="/hello" handler="HelloHandler"/>
    <!-- 配置握手拦截器 -->
    <websocket:handshake-interceptors>
        <bean class="cn.com.websocket.hello.HandShakeInterceptor"/>
    </websocket:handshake-interceptors>
    <!-- 开启sockjs，去掉则关闭sockjs -->
    <websocket:sockjs/>
</websocket:handlers>
<!-- 配置websocket消息的最大缓冲区长度 -->
<bean class="org.springframework.web.socket.server.standard.ServletServerContainerFactoryBean">
    <property name="maxTextMessageBufferSize" value="8192"/>
    <property name="maxBinaryMessageBufferSize" value="8192"/>
</bean>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

注意上述配置中sockjs的开启配置，如果去掉这一配置，则表示不开启sockjs，那么JavaScript客户端的调用就要采用标准的HTML的WebSocketAPI。开启了sockjs，则要使用sockjs的javascript接口。 
4. 部署启动tomcat 
将上述的工程编译好后部署在tomcat中，一个websocket服务端就开始运行了 
四、WebSocket的js客户端 
1. 非sockjs客户端 
在上述配置websocket中，如果不加入<websocket:sockjs/>这一配置，那么就采用HTML5的WebSocketAPI来进行通信，需要注意的是必须考虑浏览器是否支持，浏览器的支持情况如下： 
这里写图片描述 
示例代码如下：

<!DOCTYPE html>  
<html>  
<head>  
    <title>WebSocket/SockJS Echo Sample (Adapted from Tomcat's echo sample)</title>  
    <script src="./sockjs.js"></script>  

    <script type="text/javascript">  
         var  wsServer = 'ws://127.0.0.1:8080/test/hello'; 
         var  websocket = new WebSocket(wsServer); 
         websocket.onopen = function (evt) { onOpen(evt) }; 
         websocket.onclose = function (evt) { onClose(evt) }; 
         websocket.onmessage = function (evt) { onMessage(evt) }; 
         websocket.onerror = function (evt) { onError(evt) }; 
         function onOpen(evt) { 
            console.log("Connected to WebSocket server."); 
         } 
         function onClose(evt) { 
            console.log("Disconnected"); 
         } 
         function onMessage(evt) { 
            console.log('Retrieved data from server: ' + evt.data); 
         } 
         function onError(evt) { 
            console.log('Error occured: ' + evt.data); 
         }
         /*
        var sock = new SockJS('http://localhost:8080/test/hello/test/1');
         sock.onopen = function() {
            console.log('open');
            sock.send('test');
            setTimeout(function(){sock.send('later');},3000);
         };
         sock.onmessage = function(e) {
             console.log('message', e.data);
         };
         sock.onclose = function() {
             console.log('close');
         };*/
    </script>  
</head>  
<body>  

</body>  
</html>  
 
 
  • 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

 
 
  • 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

其中wsServer = ‘ws://127.0.0.1:8080/test/hello’中的地址要根据自己的实际情况来定，一般形式为：ws://域名:端口/应用路径/WebSocket配置的path。“应用路径”是应用部署在tomcat中的文件夹路径，“WebSocket配置的path”是配置文件中<websocket:mapping path="/hello" handler="HelloHandler"/>这条配置项配置的路径。

将这个html页面放入tomcat中运行，在浏览器中访问这个html页面，可以查看浏览器的控制台日志： 
这里写图片描述
WebSocket服务器后台输出入下图： 
这里写图片描述 
2. sockjs客户端 
在上述配置websocket中，如果加入这一配置，则表示开启sockjs支持，那么js客户端就必须采用sockjs提供的javascript接口,代码如下：

<!DOCTYPE html>  
<html>  
<head>  
    <title>WebSocket/SockJS Echo Sample (Adapted from Tomcat's echo sample)</title>  
    <script src="./sockjs.js"></script>  

    <script type="text/javascript">  
         /*var  wsServer = 'ws://127.0.0.1:8080/test/hello'; 
         var  websocket = new WebSocket(wsServer); 
         websocket.onopen = function (evt) { onOpen(evt) }; 
         websocket.onclose = function (evt) { onClose(evt) }; 
         websocket.onmessage = function (evt) { onMessage(evt) }; 
         websocket.onerror = function (evt) { onError(evt) }; 
         function onOpen(evt) { 
            console.log("Connected to WebSocket server."); 
         } 
         function onClose(evt) { 
            console.log("Disconnected"); 
         } 
         function onMessage(evt) { 
            console.log('Retrieved data from server: ' + evt.data); 
         } 
         function onError(evt) { 
            console.log('Error occured: ' + evt.data); 
         }*/

        var sock = new SockJS('http://127.0.0.1:8080/test/hello');
         sock.onopen = function() {
            console.log('open');
            sock.send('test');
            setTimeout(function(){sock.send('later');},3000);
         };
         sock.onmessage = function(e) {
             console.log('message', e.data);
         };
         sock.onclose = function() {
             console.log('close');
         };
    </script>  
</head>  
<body>  

</body>  
</html>  
 
 
  • 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

 
 
  • 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

注意var sock = new SockJS(‘http://127.0.0.1:8080/test/hello‘);这里的地址是http地址，与上面的非sockjs不同。

将这个html页面放入tomcat中运行，在浏览器中访问这个html页面，可以查看浏览器的控制台日志： 
这里写图片描述
后台输出为：

这里写图片描述

lkx94
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringMVC整合websocket实现消息推送及触发功能
08-27
主要为大家详细介绍了SpringMVC整合websocket实现消息推送及触发功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Spring MVC的WebSocket使用
weixin_43415481的博客
03-08 3303
Spring MVC的WebSocket使用 文章目录Spring MVC的WebSocket使用一、WebSocket概述1.1 建立WebSocket基本流程1.2 WebSocket和HTTP的区别二、Spring的WebSocket使用2.1 WebSocket API2.1.1 WebSocketHandler2.1.2 HandshakeInterceptor 和 WebSocketConfigurer2.1.3 设置跨域请求——setAllowedOrigins2.1.4 SockJS支持——
利用Spring MVC实现WebSocket实时通信
weixin_42176639的博客
07-10 2425
利用Spring MVC实现WebSocket实时通信，可以集成到SSH项目中 配置的修改： 1.struts.xml，不拦截socket的请求，我的位置为：/pages/mess/gc <constant name="struts.action.excludePattern" value="/pages/mes/TakePhoto.html,/pages/mess/gc"/> ...
java websocket框架_spring框架下websocket的搭建
weixin_42557768的博客
02-16 592
本文基于Apach Tomcat 8.0.3+MyEclipse+maven+JDK1.7spring4.0以后加入了对websocket技术的支持，撸主目前的项目用的是SSM(springMVC+spring+MyBatis)框架，所以肯定要首选spring自带的websocket1 在maven的pom.xml中加入websocket所依赖的jar包com.fasterxml.jackson....
SpringMVC使用websocket做消息推送
wqh8522的博客
12-27 1万+
WebSocket WebSocket协议支持（在受控环境中运行不受信任的代码的）客户端与（选择加入该代码的通信的）远程主机之间进行全双工通信。用于此的安全模型是Web浏览器常用的基于原始的安全模式。 协议包括一个开放的握手以及随后的TCP层上的消息帧。 该技术的目标是为基于浏览器的、需要和服务器进行双向通信的（服务器不能依赖于打开多个HTTP连接（例如，使用XMLHttpRequest或<if
springws:基于SpringMVC实现的WebSocket工程实例
05-10
Spring-ws基于SpringMVC实现的支持SockJS的WebSocket工程实例说明本项目为maven项目，使用SpringMVC实现，用于展示如果使用 SockJS。项目启动后直接打开对应的端口在首页就可以看到展示的功能。后端在"/echo"上添加...
基于springmvc的websocket及时聊天
12-21
基于springmvc框架搭建的websocket及时聊天，配置了登陆拦截，代码简单易懂，代码基本运行环境是jdk1.7+tomcat，无需配置其他即可使用
SpringMVC使用WebSocket
04-01
使用SpringMVC结合WebSocket实现服务器与客户端双向沟通,程序很简单,只是为了演示配置(hello world),IntelliJ Maven项目,部署好以后测试地址 http://localhost:8080/test
用IDEA工具实现springmvc+websocket长链接
08-01
springmvc+websocket实现简单的聊天功能 spring版本：4.2.5.RELEASE tomcat版本：8.5.8 IDEA：2017
SpringMVC整合WebSocket实现即时通讯
跟心爱的人一起浪迹天涯
07-27 6879
1. pom中添加socket支持: &lt;dependency&gt; &lt;groupId&gt;org.springframework&lt;/groupId&gt; &lt;artifactId&gt;spring-websocket&lt;/artifactId&gt; &lt;version...
spring整合websocket完整代码
08-15
spring整合websocket完整代码，资源转载至网络
SpringMVC入门 - webSocket
weixin_44115360的博客
09-22 574
由于传统HTTP协议主要是拉取消息，因此一些需要服务器主动推送消息的功能就难以实现，传统上是采用AJAX轮询、长轮询等方法；现在则可以采用webSocket来优雅地实现浏览器和服务器间的双向通信机制。 本demo主要实现了一个简单的聊天室，加入网页的游客可以一起聊天（消息广播）。服务端主要利用了spring的websocket模块，浏览器可以直接利用JS，两端都尽量采用较新的版本。 1、pom.xml依赖 <dependency> <groupId>org
基于springMvc整合websocket
癸酉金鸡的博客
07-03 1万+
eclipse下，项目接口图：
SpringMVC整合WebSocket
徐小骥的博客
09-12 732
SpringMVC整合WebSocket javax.websocket-api
spring mvc 4.0 websocket 开发
天才
06-27 2611
websocket 是html5的新特性。 websocket采用了一种双工信道，底层应该采用了epoll,并发性特别好。 tomcat从7.45以后就开始支持了websocket技术，接下来，我会使用spring4.0自带的websocket开发工具。 HandshakeInterceptor用于拦截，websocket请求 package com.front.handler;
tomcat 7下spring 4.x mvc集成websocket以及sockjs完全参考指南（含nginx/https支持）
weixin_34206899的博客
11-10 260
之所以sockjs会存在，说得不好听点，就是因为微软是个流氓，现在使用windows 7的系统仍然有近半，而windows 7默认自带的是ie 8，有些会自动更新到ie 9，但是大部分非IT用户其实都不愿意或者不会升级（通常我们做IT的认为很简单的事情，在其他行业的人来看，那就是天书，不要觉得不可能，现实已如此）。 现在言归正传，这里完整的讲下在spring 4.x集成sockjs，以及运行在t...
在SpringMVC中使用WebSocket
山鹰的专栏
02-09 4477
SpringMvc项目的搭建在这里就不做多解释，要在Spring中实现 WebSocket 必须加上 spring-websocket和 spring-messaging两个包，同样，完整的pom.xml给出如下: 1 2 3 4 5 6 7 8 9 10 11 12 13 14
最全面的SpringMVC教程（六）——WebSocket
小新要变强的博客
12-02 5119
本文为【SpringMVC教程】WebSocket相关知识介绍，具体将对WebSocket进行简介，并通过实战案例对WebSocket的使用进行详尽介绍~
WebSocket与Java
热门推荐
张龙（风中叶）的专栏
12-23 3万+
本文来源于我在InfoQ中文站原创的文章，原文地址是：http://www.infoq.com/cn/news/2013/12/websocket-and-javaBozhidar Bozhanov是Ontotext AD的高级软件工程师，拥有多年的从业经验，也是stackoverflow上的活跃用户。他精通于Java与Java技术栈，如Spring、JPA、JavaEE等，同时还是http://
springmvc整合websocket
最新发布
06-28
### 回答1： SpringMVC整合WebSocket可以通过以下步骤实现： 1. 添加WebSocket依赖 在pom.xml文件中添加以下依赖： ``` <dependency> <groupId>org.springframework</groupId> <artifactId>spring-websocket</artifactId> <version>5.3.9</version> </dependency> ``` 2. 配置WebSocket 在SpringMVC配置文件中添加以下配置： ``` @Configuration @EnableWebSocket public class WebSocketConfig implements WebSocketConfigurer { @Override public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(new MyWebSocketHandler(), "/my-websocket"); } } ``` 其中，MyWebSocketHandler是自定义的WebSocket处理器，"/my-websocket"是WebSocket的访问路径。 3. 编写WebSocket处理器 自定义的WebSocket处理器需要实现WebSocketHandler接口，例如： ``` public class MyWebSocketHandler implements WebSocketHandler { @Override public void afterConnectionEstablished(WebSocketSession session) throws Exception { // 连接建立后的处理逻辑 } @Override public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception { // 处理收到的消息 } @Override public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception { // 处理传输错误 } @Override public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception { // 连接关闭后的处理逻辑 } @Override public boolean supportsPartialMessages() { return false; } } ``` 4. 编写WebSocket客户端 可以使用JavaScript或其他语言编写WebSocket客户端，例如： ``` var socket = new WebSocket("ws://localhost:8080/my-websocket"); socket.onopen = function() { // 连接建立后的处理逻辑 }; socket.onmessage = function(event) { // 处理收到的消息 }; socket.onclose = function(event) { // 连接关闭后的处理逻辑 }; ``` 以上就是SpringMVC整合WebSocket的基本步骤。 ### 回答2： Spring MVC 是一个基于 Java 的 Web 框架，可以将 WebSocket 整合到 Spring MVC 中，实现实时通信的功能。下面详细介绍 Spring MVC 整合 WebSocket 的步骤： 1. 配置 Maven 依赖：在 pom.xml 文件中添加以下依赖： ``` <dependency> <groupId>org.springframework</groupId> <artifactId>spring-websocket</artifactId> <version>4.3.13.RELEASE</version> </dependency> ``` 2. 配置 WebSocket 消息处理器：创建一个类来处理 WebSocket 消息。该类需要实现 `WebSocketHandler` 接口，实现处理 WebSocket 消息的方法。 ``` public class MyWebSocketHandler implements WebSocketHandler { @Override public void afterConnectionEstablished(WebSocketSession session) throws Exception { // WebSocket 连接建立时执行的操作 } @Override public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception { // 处理收到的 WebSocket 消息 } @Override public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception { // 处理 WebSocket 消息传输过程中出现的异常 } @Override public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception { // WebSocket 连接关闭时执行的操作 } @Override public boolean supportsPartialMessages() { return false; } } ``` 3. 配置 Spring MVC WebSocket 拦截器：创建一个类，实现 `HandshakeInterceptor` 接口。该拦截器可在 WebSocket 握手阶段执行特定的操作，例如在 WebSocket 握手时将用户信息添加到 session 中。 ``` public class MyWebSocketInterceptor implements HandshakeInterceptor { @Override public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception { // 在 WebSocket 握手之前执行的操作 return true; } @Override public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, @Nullable Exception exception) { // 当 WebSocket 握手成功时执行的操作 } } ``` 4. 配置 Spring MVC WebSocket：在 Spring MVC 配置文件中配置 WebSocket 服务。可以使用 `WebSocketHandlerRegistry` 注册 WebSocket 消息处理器，也可以使用 `HandshakeInterceptorRegistry` 注册 WebSocket 拦截器。 ``` @Configuration @EnableWebSocket public class WebSocketConfig implements WebSocketConfigurer { @Autowired private MyWebSocketHandler myWebSocketHandler; @Autowired private MyWebSocketInterceptor myWebSocketInterceptor; @Override public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(myWebSocketHandler, "/myWebSocket") .addInterceptors(myWebSocketInterceptor) .setAllowedOrigins("*"); } } ``` 5. 创建 WebSocket 客户端：在客户端中可以使用 JavaScript 代码调用 WebSocket 服务。使用 `var ws = new WebSocket("ws://localhost:8080/myWebSocket");` 创建 WebSocket 连接，然后可以监听 `ws.onopen`、`ws.onerror`、`ws.onmessage` 和 `ws.onclose` 等事件，并在这些事件发生时执行相应的操作。 总结来说，Spring MVC 整合 WebSocket 的步骤包括配置 Maven 依赖、配置 WebSocket 消息处理器、配置 WebSocket 拦截器、配置 Spring MVC WebSocket 和创建 WebSocket 客户端等。使用 Spring MVC 整合 WebSocket 可以使得在 Web 应用中实现实时通信变得更加简单和方便。 ### 回答3： Spring MVC 是一个基于 MVC(Model-View-Controller) 模式的 WEB 应用程序开发框架，而 WebSocket 是 HTML5 提出的基于 TCP 协议的全双工通讯技术，它可以让浏览器与服务器进行实时的双向数据传输。为了实现 Websocket 和 Spring MVC 的整合，我们需要通过以下步骤： 1. 添加 Spring WebSocket 依赖 首先在 Maven 或 Gradle 项目的 `pom.xml` 或 `build.gradle` 文件中添加 Spring WebSocket 的依赖，如果是手动添加 jar 包，则需要添加 `spring-websocket.jar` 和 `javax-websocket-client-api.jar` ，并且需要确保其版本和 Spring 的版本匹配。 2. 配置 WebSocket 处理器 接下来我们需要为 WebSocket 客户端和服务端分别配置其处理器。 在服务端，我们需要创建一个类来处理 WebSocket 连接请求，该类需要继承 `WebSocketHandler` 接口并实现其中的 `handleMessage`、`handleTransportError` 和 `afterConnectionClosed` 方法。 然后将这个类注册到 `WebSocketHandlerRegistry` 中，代码如下： ``` @Configuration @EnableWebSocket public class WebSocketConfig implements WebSocketConfigurer { @Override public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(new MyWebSocketHandler(), "/myHandler").setAllowedOrigins("*"); } } public class MyWebSocketHandler extends TextWebSocketHandler { @Override public void handleTextMessage(WebSocketSession session, TextMessage message) throws IOException { // 处理收到的消息 } @Override public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception { // 处理传输错误 } @Override public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception { // 处理关闭连接事件 } } ``` 在上述代码中，我们创建了一个 `WebSocketConfig` 配置类，并使用 `@EnableWebSocket` 注解开启 WebSocket 支持。 然后在 `registerWebSocketHandlers` 方法中，我们注册了一个 `MyWebSocketHandler` 处理器，并为其指定了路径 `"/myHandler"`。需要注意的是，我们使用 `setAllowedOrigins("*")` 方法指定了跨域访问的规则。 3. 在客户端发起连接 客户端连接 WebSocket 时需要通过标准的 WebSocket API 建立连接。这里我们以 JavaScript 代码为例： ``` var ws = new WebSocket("ws://localhost:8080/myHandler"); ws.onopen = function() { console.log("连接成功"); }; ws.onmessage = function(event) { console.log("收到消息：" + event.data); } ws.onclose = function() { console.log("连接关闭"); } ``` 在上述代码中，我们首先创建了一个 WebSocket 对象，并指定连接的 URL 为 `ws://localhost:8080/myHandler`。然后通过 `onopen`、`onmessage` 和 `onclose` 等事件监听器来处理连接成功、接收消息和连接关闭事件。 通过以上步骤，我们就完成了 WebSocket 和 Spring MVC 的整合。在实际的应用中，我们可以根据自己的需要来进一步扩展和优化代码，以达到更好的性能和用户体验。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值