HTML5的诞生，WebSocket协议被提出，它实现了浏览器与服务器的全双工通信，扩展了浏览器与服务端的通信功能，使服务端也能主动向客户端发送数据。

    1. package com.programb.jwt;
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5. import org.springframework.scheduling.annotation.EnableScheduling;
    7. @EnableScheduling
    8. @SpringBootApplication
    9. public class Application {
    10.     public static void main(String[] args) {
    11.         SpringApplication.run(Application.class, args);
    12.     }
    14. }
    1. package com.programb.jwt.commons;
    3. import com.fasterxml.jackson.core.JsonProcessingException;
    4. import com.fasterxml.jackson.core.type.TypeReference;
    5. import com.fasterxml.jackson.databind.ObjectMapper;
    7. import java.io.IOException;
    9. public class JacksonUtil {
    10.     private static ObjectMapper mapper = new ObjectMapper();
    12.     public static String bean2Json(Object obj) {
    13.         try {
    14.             return mapper.writeValueAsString(obj);
    15.         } catch (JsonProcessingException e) {
    16.             e.printStackTrace();
    17.             return "";
    18.         }
    19.     }
    23.     public static <T> T json2Bean(String jsonStr, TypeReference<T> typeReference) {
    24.         try {
    25.             return mapper.readValue(jsonStr, typeReference);
    26.         } catch (IOException e) {
    27.             e.printStackTrace();
    28.             return null;
    29.         }
    30.     }
    31. }
    2. package com.programb.jwt.config;
    4. import org.springframework.context.annotation.Configuration;
    5. import org.springframework.web.socket.config.annotation.EnableWebSocket;
    6. import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
    7. import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
    9. import com.programb.jwt.handler.SocketHandler;
    10. import com.programb.jwt.interceptor.WebSocketInterceptor;
    13. @Configuration
    14. @EnableWebSocket
    15. public class WebSocketConfig implements WebSocketConfigurer {
    16.     public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
    17.         registry.addHandler(new SocketHandler(), "/app")
    18.                 .addInterceptors(new WebSocketInterceptor())
    19.                 .setAllowedOrigins("*");
    20.     }
    21. }
    1. package com.programb.jwt.config;
    3. import org.springframework.context.annotation.Configuration;
    4. import org.springframework.messaging.simp.config.MessageBrokerRegistry;
    5. import org.springframework.web.socket.config.annotation.AbstractWebSocketMessageBrokerConfigurer;
    6. import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
    7. import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
    10. @Configuration
    11. @EnableWebSocketMessageBroker
    12. public class WebSocketStompConfig extends AbstractWebSocketMessageBrokerConfigurer {
    14.     @Override
    15.     public void registerStompEndpoints(StompEndpointRegistry stompEndpointRegistry) {
    16.         stompEndpointRegistry.addEndpoint("/simple")
    17.                 .setAllowedOrigins("*") //解决跨域问题
    18.                 .withSockJS();
    19.     }
    21.     @Override
    22.     public void configureMessageBroker(MessageBrokerRegistry registry) {
    23.         registry.enableSimpleBroker("/topic");
    24.     }
    25. }
    1. package com.programb.jwt.controller;
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.messaging.handler.annotation.MessageMapping;
    5. import org.springframework.messaging.handler.annotation.SendTo;
    6. import org.springframework.messaging.simp.SimpMessagingTemplate;
    7. import org.springframework.scheduling.annotation.Scheduled;
    8. import org.springframework.stereotype.Controller;
    10. import com.programb.jwt.model.RequestMessage;
    11. import com.programb.jwt.model.ResponseMessage;
    13. import java.text.DateFormat;
    14. import java.text.SimpleDateFormat;
    15. import java.util.Date;
    18. @Controller
    19. public class WsController {
    21.     private final SimpMessagingTemplate messagingTemplate;
    23.     @Autowired
    24.     public WsController(SimpMessagingTemplate messagingTemplate) {
    25.         this.messagingTemplate = messagingTemplate;
    26.     }
    28.     @MessageMapping("/welcome")
    29.     @SendTo("/topic/say")
    30.     public ResponseMessage say(RequestMessage message) {
    31.         System.out.println(message.getName());
    32.         return new ResponseMessage("welcome," + message.getName() + " !");
    33.     }
    36.     @Scheduled(fixedRate = 1000)
    37.     public void callback() {
    38.         // 发现消息
    39.         DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    40.         messagingTemplate.convertAndSend("/topic/callback", "定时推送消息时间: " + df.format(new Date()));
    41.     }
    42. }
    1. package com.programb.jwt.handler;
    3. import com.fasterxml.jackson.core.type.TypeReference;
    4. import com.programb.jwt.commons.JacksonUtil;
    5. import com.programb.jwt.model.WsParam;
    6. import com.programb.jwt.model.WsResponse;
    8. import org.slf4j.Logger;
    9. import org.slf4j.LoggerFactory;
    10. import org.springframework.stereotype.Component;
    11. import org.springframework.web.socket.CloseStatus;
    12. import org.springframework.web.socket.TextMessage;
    13. import org.springframework.web.socket.WebSocketSession;
    14. import org.springframework.web.socket.handler.TextWebSocketHandler;
    16. import java.io.IOException;
    17. import java.util.List;
    18. import java.util.Map;
    19. import java.util.concurrent.CopyOnWriteArrayList;
    22. @Component
    23. public class SocketHandler extends TextWebSocketHandler {
    25.     private Logger logger = LoggerFactory.getLogger(this.getClass());
    27.     List<WebSocketSession> sessions = new CopyOnWriteArrayList<>();
    29.     @Override
    30.     public void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
    31.         logger.info("handleTextMessage start");
    33.         String msg = message.getPayload();
    34.         logger.info("msg = " + msg);
    35.         WsParam<String> wsParam = JacksonUtil.json2Bean(msg, new TypeReference<WsParam<String>>(){});
    36.         if ("list".equals(wsParam.getMethod())) {
    37.             logger.info("call list method...");
    38.             WsResponse<String> response = new WsResponse<>();
    39.             response.setResult("hello list");
    40.             sendMessageToUser(session, new TextMessage(JacksonUtil.bean2Json(response)));
    41.         }
    42.         logger.info("handleTextMessage end");
    44.     }
    48.     @Override
    49.     public void afterConnectionEstablished(WebSocketSession session) throws Exception {
    50.         logger.info("Connected ... " + session.getId());
    51.         sessions.add(session);
    52.     }
    54.     @Override
    55.     public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
    56.         if (session.isOpen()) {
    57.             session.close();
    58.         }
    59.         sessions.remove(session);
    60.         logger.info(String.format("Session %s closed because of %s", session.getId(), status.getReason()));
    61.     }
    63.     @Override
    64.     public void handleTransportError(WebSocketSession session, Throwable throwable) throws Exception {
    65.         logger.error("error occured at sender " + session, throwable);
    66.     }
    68.     public void sendMessagesToUsers(TextMessage message) {
    69.         for (WebSocketSession user : sessions) {
    70.             try {
    72.                 if (user.isOpen()) {
    73.                     user.sendMessage(message);
    74.                 }
    75.             } catch (IOException e) {
    76.                 e.printStackTrace();
    77.             }
    78.         }
    79.     }
    82.     private void sendMessageToUser(WebSocketSession user, TextMessage message) {
    83.         try {
    84.             if (user.isOpen()) {
    85.                 user.sendMessage(message);
    86.             }
    87.         } catch (IOException e) {
    88.            logger.error("发送消息给指定的用户出错", e);
    89.         }
    90.     }
    91. }
    1. package com.programb.jwt.interceptor;
    3. import javax.servlet.http.HttpServletRequest;
    5. import org.slf4j.Logger;
    6. import org.slf4j.LoggerFactory;
    7. import org.springframework.http.server.ServerHttpRequest;
    8. import org.springframework.http.server.ServerHttpResponse;
    9. import org.springframework.http.server.ServletServerHttpRequest;
    10. import org.springframework.web.socket.WebSocketHandler;
    11. import org.springframework.web.socket.server.HandshakeInterceptor;
    13. import java.util.Map;
    16. public class WebSocketInterceptor implements HandshakeInterceptor {
    17.     private Logger logger = LoggerFactory.getLogger(this.getClass());
    18.     @Override
    19.     public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse arg1,
    20.                                    WebSocketHandler arg2, Map<String, Object> arg3) throws Exception {
    21.         if (request instanceof ServletServerHttpRequest) {
    22.             ServletServerHttpRequest servletRequest = (ServletServerHttpRequest) request;
    23.             HttpServletRequest httpRequest = servletRequest.getServletRequest();
    24.         }
    25.         logger.info("programb");
    26.         return true;
    27.     }
    29.     @Override
    30.     public void afterHandshake(ServerHttpRequest arg0, ServerHttpResponse arg1, WebSocketHandler arg2, Exception arg3) {
    31.         logger.info("programb");
    32.     }
    33. }
    1. package com.programb.jwt.model;
    4. public class RequestMessage {
    5.     private String name;
    7.     public String getName() {
    8.         return name;
    9.     }
    10. }
    1. package com.programb.jwt.model;
    4. public class ResponseMessage {
    5.     private String responseMessage;
    7.     public ResponseMessage(String responseMessage) {
    8.         this.responseMessage = responseMessage;
    9.     }
    11.     public String getResponseMessage() {
    12.         return responseMessage;
    13.     }
    14. }
    1. package com.programb.jwt.model;
    4. public class WsParam<T> {
    5.     private String method;
    6.     private T param;
    8.     public String getMethod() {
    9.         return method;
    10.     }
    12.     public void setMethod(String method) {
    13.         this.method = method;
    14.     }
    16.     public T getParam() {
    17.         return param;
    18.     }
    20.     public void setParam(T param) {
    21.         this.param = param;
    22.     }
    23. }
    1. package com.programb.jwt.model;
    4. public class WsResponse<T> {
    5.     private T result;
    7.     public T getResult() {
    8.         return result;
    9.     }
    11.     public void setResult(T result) {
    12.         this.result = result;
    13.     }
    14. }
    1. spring:
    2.   profiles:
    3.     active: dev
    5. server:
    6.   port: 8092
    9. spring:
    10.   profiles: dev
    12. logging:
    13.   level:
    14.     ROOT: INFO
    15.     com:
    16.       xncoding: DEBUG
    17.   file: D:/programb/logs/app.log
    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0</modelVersion>
    7.     <groupId>com.programb</groupId>
    8.     <artifactId>springboot-websocket</artifactId>
    9.     <version>1.0.0-SNAPSHOT</version>
    10.     <packaging>jar</packaging>
    12.     <name>springboot-websocket</name>
    13.     <description>WebScoket</description>
    15.     <parent>
    16.         <groupId>org.springframework.boot</groupId>
    17.         <artifactId>spring-boot-starter-parent</artifactId>
    18.         <version>2.0.4.RELEASE</version>
    19.     </parent>
    21.     <properties>
    22.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    23.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    24.         <java.version>1.8</java.version>
    25.         <netty.version>4.1.19.Final</netty.version>
    26.     </properties>
    28.     <dependencies>
    29.         <dependency>
    30.             <groupId>org.springframework.boot</groupId>
    31.             <artifactId>spring-boot-starter-websocket</artifactId>
    32.             <exclusions>
    33.                 <exclusion>
    34.                     <groupId>org.springframework.boot</groupId>
    35.                     <artifactId>spring-boot-starter-tomcat</artifactId>
    36.                 </exclusion>
    37.             </exclusions>
    38.         </dependency>
    39.         <dependency>
    40.             <groupId>org.springframework.boot</groupId>
    41.             <artifactId>spring-boot-starter-jetty</artifactId>
    42.         </dependency>
    43.     </dependencies>
    45.     <build>
    46.         <plugins>
    47.             <plugin>
    48.                 <groupId>org.apache.maven.plugins</groupId>
    49.                 <artifactId>maven-compiler-plugin</artifactId>
    50.                 <version>3.6.1</version>
    51.                 <configuration>
    52.                     <source>1.8</source>
    53.                     <target>1.8</target>
    54.                 </configuration>
    55.             </plugin>
    56.             <plugin>
    57.                 <groupId>org.apache.maven.plugins</groupId>
    58.                 <artifactId>maven-surefire-plugin</artifactId>
    59.                 <version>2.20</version>
    60.                 <configuration>
    61.                     <systemPropertyVariables>
    62.                         <swaggerOutputDir>${project.basedir}/src/main/resources/swagger</swaggerOutputDir>
    63.                         <asciiDocOutputDir>${project.basedir}/src/main/resources/swagger/swagger</asciiDocOutputDir>
    64.                     </systemPropertyVariables>
    65.                     <skip>true</skip>
    66.                 </configuration>
    67.             </plugin>
    68.             <plugin>
    69.                 <groupId>org.springframework.boot</groupId>
    70.                 <artifactId>spring-boot-maven-plugin</artifactId>
    71.                 <executions>
    72.                 </executions>
    73.             </plugin>
    74.         </plugins>
    76.         <resources>
    77.             <resource>
    78.                 <directory>src/main/resources</directory>
    79.             </resource>
    80.             <resource>
    81.                 <directory>src/main/java</directory>
    82.                 <includes>
    83.                     <include>**/*.xml</include>
    84.                 </includes>
    85.             </resource>
    86.         </resources>
    87.     </build>
    89. </project>