关于即时通讯:跟着源码一起学手把手教你用WebSocket打造Web端IM聊天

本文作者芋艿，原题“芋道 Spring Boot WebSocket 入门”，本次有订正和改变。

WebSocket 现在在 Web 端即时通讯技术利用里应用宽泛，不仅用于传统 PC 端的网页里，也被很多挪动端开发者用于基于 HTML5 的混合 APP 里。对于想要在基于 Web 的利用里增加 IM、推送等实时通信性能，WebSocket 简直是必须要把握的技术。

本文将基于 Tomcat 和 Spring 框架实现一个逻辑简略的入门级 IM 利用，对于即时通讯初学者来说，能找到一个简略间接且能顺利跑通的实例代码，显然意义更大，本文正是如此。心愿能给你的 IM 开发和学习带来启发。

注：源码在本文第四、五节结尾的附件处可下载。

学习交换：

即时通讯 / 推送技术开发交换 5 群：215477170 [举荐]

挪动端 IM 开发入门文章：《新手入门一篇就够：从零开发挪动端 IM》

开源 IM 框架源码：https://github.com/JackJiang2011/MobileIMSDK

（本文同步公布于：http://www.52im.net/thread-3483-1-1.html）

如果你对 Web 端即时通讯常识一头雾水，务必先读：《新手入门贴：史上最全 Web 端即时通讯技术原理详解》、《Web 端即时通讯技术盘点：短轮询、Comet、Websocket、SSE》。

限于篇幅，本文不会深究 WebSocket 技术实践，如有趣味请从根底学习：

《老手疾速入门：WebSocket 扼要教程》
《WebSocket 从入门到精通，半小时就够！》
《八问 WebSocket 协定：为你疾速解答 WebSocket 热门疑难》
《WebSocket 详解（一）：初步意识 WebSocket 技术》
《WebSocket 详解（二）：技术原理、代码演示和利用案例》
《WebSocket 详解（三）：深刻 WebSocket 通信协议细节》
《WebSocket 详解（四）：刨根问底 HTTP 与 WebSocket 的关系 (上篇)》
《WebSocket 详解（五）：刨根问底 HTTP 与 WebSocket 的关系 (下篇)》
《WebSocket 详解（六）：刨根问底 WebSocket 与 Socket 的关系》

如果想要更硬核一点的，能够读读上面这几篇：

《WebSocket 硬核入门：200 行代码，教你徒手撸一个 WebSocket 服务器》
《Web 端即时通讯实际干货：如何让你的 WebSocket 断网重连更疾速？》
《实践联系实际：从零了解 WebSocket 的通信原理、协定格局、安全性》

相比 HTTP 协定来说，WebSocket 协定对大多数后端开发者是比拟生疏的。

相对而言：WebSocket 协定重点是提供了服务端被动向客户端发送数据的能力，这样咱们就能够实现实时性较高的需要。例如：聊天 IM 即便通信性能、音讯订阅服务、网页游戏等等。

同时： 因为 WebSocket 应用 TCP 通信，能够防止反复创立连贯，晋升通信品质和效率。例如：美团的长连贯服务，具体能够看看《美团点评的挪动端网络优化实际：大幅晋升连贯成功率、速度等》。

情谊提醒：

这里有个误区，WebSocket 相比一般的 Socket 来说，仅仅是借助 HTTP 协定实现握手，创立连贯。后续的所有通信，都和 HTTP 协定无关。

看到这里，大家肯定认为又要开始哔哔 WebSocket 的概念。哈哈，我偏不~ 如果对这块不了的敌人，能够浏览本文“2、常识筹备”这一章。

要想应用 WebSocket，个别有如下几种解决方案可选：

1）计划一：Spring WebSocket；
2）计划二：Tomcat WebSocket；
3）计划三：Netty WebSocket。

目前笔者手头有个波及到 IM 即便通信的我的项目，采纳的是计划三。

次要起因是： 咱们对 Netty 框架的实战、原理与源码，都绝对相熟一些，所以就思考了它。并且，除了须要反对 WebSocket 协定，咱们还想提供原生的 Socket 协定。

如果仅仅是仅仅提供 WebSocket 协定的反对，能够思考采纳计划一或者计划二，在应用上，两个计划是比拟靠近的。相比来说，计划一 Spring WebSocket 内置了对 STOMP 协定的反对。

不过： 本文还是采纳计划二“Tomcat WebSocket”来作为入门示例。咳咳咳，没有非凡的起因，次要是开始写本文之前，曾经花了 2 小时应用它写了一个示例。切实是有点懒，不想改。如果能重来，我要选李白，哈哈哈哈~

当然，不要慌，计划一和计划二的实现代码，真心没啥差异。

在开始搭建 Tomcat WebSocket 入门示例之前，咱们先来理解下 JSR-356 标准，定义了 Java 针对 WebSocket 的 API：即 Javax WebSocket。标准是大哥，打死不会提供实现，所以 JSR-356 也是如此。目前，支流的 Web 容器都曾经提供了 JSR-356 的实现，例如说 Tomcat、Jetty、Undertow 等等。

示例代码下载：

（因附件无奈上传到此处，请从同步链接处下载：http://www.52im.net/thread-3483-1-1.html）

代码目录内容是这样：

在本大节中，咱们会应用 Tomcat WebSocket 搭建一个 WebSocket 的示例。

提供如下音讯的性能反对：

1）身份认证申请；
2）私聊音讯；
3）群聊音讯。

思考到让示例更加易懂，咱们先做成全局有且仅有一个大的聊天室，即建设上 WebSocket 的连贯，都主动动进入该聊天室。

上面，开始漫游 WebSocket 这个鱼塘 …

在 pom.xml 文件中，引入相干依赖。

<?xml version=”1.0″encoding=”UTF-8″?>
<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 [url=http://maven.apache.org/xsd/m…”>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.10.RELEASE</version>
        <relativePath/> <!– lookup parent from repository –>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>lab-25-01</artifactId>
    <dependencies>
        <!– 实现对 WebSocket 相干依赖的引入，不便~ –>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <!– 引入 Fastjson，实现对 JSON 的序列化，因为后续咱们会应用它解析音讯 –>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>
    </dependencies>
</project>
具体每个依赖的作用，本人认真看下正文。

在 cn.iocoder.springboot.lab25.springwebsocket.websocket 包门路下，创立 WebsocketServerEndpoint 类，定义 Websocket 服务的端点（EndPoint）。

代码如下：

// WebsocketServerEndpoint.java
@Controller
@ServerEndpoint(“/”)
public class WebsocketServerEndpoint {
    private Logger logger = LoggerFactory.getLogger(getClass());
    @OnOpen
    public void onOpen(Session session, EndpointConfig config) {
        logger.info(“onOpen”, session);
    }
    @OnMessage
    public void onMessage(Session session, String message) {
        logger.info(“onOpen”, session, message); // 生产环境下，请设置成 debug 级别
    }
    @OnClose
    public void onClose(Session session, CloseReason closeReason) {
        logger.info(“onClose”, session, closeReason);
    }
    @OnError
    public void onError(Session session, Throwable throwable) {
        logger.info(“onClose”, session, throwable);
    }
}

如代码所示：

1）在类上，增加 @Controller 注解，保障创立一个 WebsocketServerEndpoint Bean；
2）在类上，增加 JSR-356 定义的 @ServerEndpoint 注解，标记这是一个 WebSocket EndPoint，门路为 /；
3）WebSocket 一共有四个事件，别离对应应用 JSR-356 定义的 @OnOpen、@OnMessage、@OnClose、@OnError 注解。

这是最简版的 WebsocketServerEndpoint 的代码。在下文，咱们会缓缓把代码补全。

在 cn.iocoder.springboot.lab24.springwebsocket.config 包门路下，创立 WebsocketServerEndpoint 配置类。

代码如下：

// WebSocketConfiguration.java
@Configuration
// @EnableWebSocket // 无需增加该注解，因为咱们并不是应用 Spring WebSocket
public class WebSocketConfiguration {
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

PS： 在 #serverEndpointExporter() 办法中，创立 ServerEndpointExporter Bean。该 Bean 的作用，是扫描增加有 @ServerEndpoint 注解的 Bean。

创立 Application.java 类，配置 @SpringBootApplication 注解即可。

代码如下：

// Application.java
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

执行 Application 启动该示例我的项目。

思考到大家可能不会或者不违心写前端代码，所以咱们间接应用 WebSocket 在线测试工具，测试 WebSocket 连贯。

如下图：

至此，最简略的一个 WebSocket 我的项目的骨架，咱们曾经搭建实现。上面，咱们开始革新，把相应的逻辑补全。

在 HTTP 协定中，是基于 Request/Response 申请响应的同步模型，进行交互。在 Websocket 协定中，是基于 Message 音讯的异步模型，进行交互。这一点，是很大的不同的，等会看到具体的音讯类，感触会更显著。

因为 WebSocket 协定，不像 HTTP 协定有 URI 能够辨别不同的 API 申请操作，所以咱们须要在 WebSocket 的 Message 里，减少可能标识音讯类型，这里咱们采纳 type 字段。

所以在这个示例中，咱们采纳的 Message 采纳 JSON 格局编码。

格局如下：

{
type: “”, // 音讯类型
body: {} // 音讯体
}

解释一下：

1）type 字段，音讯类型。通过该字段，咱们晓得应用哪个 MessageHandler 音讯处理器（对于 MessageHandler，咱们在下一节中，具体解析）；
2）body 字段，音讯体。不同的音讯类型，会有不同的音讯体；
3）Message 采纳 JSON 格局编码，次要思考便捷性，理论我的项目下，也能够思考 Protobuf 等更加高效且节俭流量的编码格局。

实际上： 咱们在该示例中，body 字段对应的 Message 相干的接口和类，切实想不到名字了。所有的 Message 们，咱们都放在 cn.iocoder.springboot.lab25.springwebsocket.message 包门路下。

4.6.1 Message

创立 Message 接口，根底音讯体，所有音讯体都要实现该接口。

代码如下：

// Message.java
publicinterfaceMessage {
}

目前作为一个标记接口，未定义任何操作。

4.6.2 认证相干 Message

创立 AuthRequest 类，用户认证申请。

代码如下：

// AuthRequest.java
public class AuthRequest implements Message {
    public static final String TYPE = “AUTH_REQUEST”;
    /**
     * 认证 Token
     */
    private String accessToken;
    // … 省略 set/get 办法
}

解释一下：

1）TYPE 动态属性，音讯类型为 AUTH_REQUEST。
2）accessToken 属性，认证 Token。

对于第 2）点，在 WebSocket 协定中，咱们也须要认证以后连贯，用户身份是什么。个别状况下，咱们采纳用户调用 HTTP 登录接口，登录胜利后返回的拜访令牌 accessToken。这里，咱们先不拓展开讲，预先能够看看《基于 Token 认证的 WebSocket 连贯》文章。

尽管说，WebSocket 协定是基于 Message 模型，进行交互。然而，这并不意味着它的操作，不须要响应后果。例如说，用户认证申请，是须要用户认证响应的。所以，咱们创立 AuthResponse 类，作为用户认证响应。

代码如下：

// AuthResponse.java
public class AuthResponse implements Message {
    public static final String TYPE = “AUTH_RESPONSE”;
    /**
     * 响应状态码
     */
    private Integer code;
    /**
     * 响应提醒
     */
    private String message;
    // … 省略 set/get 办法
}

解释一下：

1）TYPE 动态属性，音讯类型为 AUTH_REQUEST；
2）code 属性，响应状态码；
3）message 属性，响应提醒。

对于第 1）点，实际上，咱们在每个 Message 实现类上，都减少了 TYPE 动态属性，作为音讯类型。上面，咱们就不反复赘述了。

在本示例中，用户胜利认证之后，会播送用户退出群聊的告诉 Message，应用 UserJoinNoticeRequest。

代码如下：

// UserJoinNoticeRequest.java
public class UserJoinNoticeRequest implements Message {
    public static final String TYPE = “USER_JOIN_NOTICE_REQUEST”;
    /**
     * 昵称
     */
    private String nickname;
    // … 省略 set/get 办法
}

实际上，咱们能够在须要应用到 Request/Response 模型的中央，将 Message 进行拓展：

1）Request 抽象类，减少 requestId 字段，示意申请编号；
2）Response 抽象类，减少 requestId 字段，和每一个 Request 申请映射上（同时，外面对立定义 code 和 message 属性，示意响应状态码和响应提醒）。

这样，在应用到同步模型的业务场景下，Message 实现类应用 Request/Reponse 作为后缀。例如说，用户认证申请、删除一个好友申请等等。

而在应用到异步模型能的业务场景下，Message 实现类还是持续 Message 作为后缀。例如说，发送一条音讯，用户操作完后，无需阻塞期待后果

4.6.3 发送音讯相干 Message

创立 SendToOneRequest 类，发送给指定人的私聊音讯的 Message。

代码如下：

// SendToOneRequest.java
public class SendToOneRequest implements Message {
    public static final String TYPE = “SEND_TO_ONE_REQUEST”;
    /**
     * 发送给的用户
     */
    private String toUser;
    /**
     * 音讯编号
     */
    private String msgId;
    /**
     * 内容
     */
    private String content;
    // … 省略 set/get 办法
}

每个字段，本人看正文噢。

创立 SendToAllRequest 类，发送给所有人的群聊音讯的 Message。

代码如下：

// SendToAllRequest.java
public class SendToAllRequest implements Message {
    public static final String TYPE = “SEND_TO_ALL_REQUEST”;
    /**
     * 音讯编号
     */
    private String msgId;
    /**
     * 内容
     */
    private String content;
    // … 省略 set/get 办法
}

每个字段，本人看正文噢。

在服务端接管到发送音讯的申请，须要异步响应发送是否胜利。所以，创立 SendResponse 类，发送音讯响应后果的 Message。

代码如下：

// SendResponse.java
public class SendResponse implements Message {
    public static final String TYPE = “SEND_RESPONSE”;
    /**
     * 音讯编号
     */
    private String msgId;
    /**
     * 响应状态码
     */
    private Integer code;
    /**
     * 响应提醒
     */
    private String message;
    // … 省略 set/get 办法
}

重点看 msgId 字段：即音讯编号。客户端在发送音讯，通过应用 UUID 算法，生成全局惟一音讯编号（惟一 ID 的生成技术见：《从老手到专家：如何设计一套亿级音讯量的分布式 IM 零碎》的“_5、惟一 ID 的技术计划_”章节）。这样，服务端通过 SendResponse 音讯响应，通过 msgId 做映射。

在服务端接管到发送音讯的申请，须要转发音讯给对应的人。所以，创立 SendToUserRequest 类，发送音讯给一个用户的 Message。

代码如下：

// SendResponse.java
public class SendToUserRequest implements Message {
    public static final String TYPE = “SEND_TO_USER_REQUEST”;
    /**
     * 音讯编号
     */
    private String msgId;
    /**
     * 内容
     */
    private String content;
    // … 省略 set/get 办法
}

相比 SendToOneRequest 来说，少一个 toUser 字段。因为，咱们能够通过 WebSocket 连贯，曾经晓得发送给谁了。

每个客户端发动的 Message 音讯类型，咱们会申明对应的 MessageHandler 音讯处理器。这个就相似在 SpringMVC 中，每个 API 接口对应一个 Controller 的 Method 办法。

所有的 MessageHandler 们，咱们都放在 cn.iocoder.springboot.lab25.springwebsocket.handler 包门路下。

4.7.1 MessageHandler

创立 MessageHandler 接口，音讯处理器接口。

代码如下：

// MessageHandler.java
public interface MessageHandler<T extends Message> {
    /**
     * 执行解决音讯
     *
     * @param session 会话
     * @param message 音讯
     */
    void execute(Session session, T message);
    /**
     * @return 音讯类型，即每个 Message 实现类上的 TYPE 动态字段
     */
    String getType();
}

解释一下：

1）定义了泛型 <T>，须要是 Message 的实现类；
2）定义的两个接口办法，本人看下正文哈。

4.7.2 AuthMessageHandler

创立 AuthMessageHandler 类，解决 AuthRequest 音讯。

代码如下：

// AuthMessageHandler.java
@Component
public class AuthMessageHandler implements MessageHandler<AuthRequest> {
    @Override
    public void execute(Session session, AuthRequest message) {
        // 如果未传递 accessToken
        if(StringUtils.isEmpty(message.getAccessToken())) {
            WebSocketUtil.send(session, AuthResponse.TYPE,
                    new AuthResponse().setCode(1).setMessage(“ 认证 accessToken 未传入 ”));
            return;
        }
        // 增加到 WebSocketUtil 中
        WebSocketUtil.addSession(session, message.getAccessToken()); // 思考到代码简化，咱们先间接应用 accessToken 作为 User
        // 判断是否认证胜利。这里，伪装间接胜利
        WebSocketUtil.send(session, AuthResponse.TYPE,newAuthResponse().setCode(0));
        // 告诉所有人，某个人退出了。这个是可选逻辑，仅仅是为了演示
        WebSocketUtil.broadcast(UserJoinNoticeRequest.TYPE,
                newUserJoinNoticeRequest().setNickname(message.getAccessToken())); // 思考到代码简化，咱们先间接应用 accessToken 作为 User
    }
    @Override
    public String getType() {
        return AuthRequest.TYPE;
    }
}

代码比较简单，跟着代码读读即可。

对于 WebSocketUtil 类，咱们在「5.8、WebSocketUtil」一节中再来具体看看。

4.7.3 SendToOneRequest

创立 SendToOneHandler 类，解决 SendToOneRequest 音讯。

代码如下：

// SendToOneRequest.java
@Component
public class SendToOneHandler implements MessageHandler<SendToOneRequest> {
    @Override
    public void execute(Session session, SendToOneRequest message) {
        // 这里，伪装间接胜利
        SendResponse sendResponse = newSendResponse().setMsgId(message.getMsgId()).setCode(0);
        WebSocketUtil.send(session, SendResponse.TYPE, sendResponse);
        // 创立转发的音讯
        SendToUserRequest sendToUserRequest = newSendToUserRequest().setMsgId(message.getMsgId())
                .setContent(message.getContent());
        // 播送发送
        WebSocketUtil.send(message.getToUser(), SendToUserRequest.TYPE, sendToUserRequest);
    }
    @Override
    public String getType() {
        return SendToOneRequest.TYPE;
    }
}

代码比较简单，跟着代码读读即可。

4.7.4 SendToAllHandler

创立 SendToAllHandler 类，解决 SendToAllRequest 音讯。

代码如下：

// SendToAllRequest.java
@Component
public class SendToAllHandler implements MessageHandler<SendToAllRequest> {
    @Override
    public void execute(Session session, SendToAllRequest message) {
        // 这里，伪装间接胜利
        SendResponse sendResponse = newSendResponse().setMsgId(message.getMsgId()).setCode(0);
        WebSocketUtil.send(session, SendResponse.TYPE, sendResponse);
        // 创立转发的音讯
        SendToUserRequest sendToUserRequest = newSendToUserRequest().setMsgId(message.getMsgId())
                .setContent(message.getContent());
        // 播送发送
        WebSocketUtil.broadcast(SendToUserRequest.TYPE, sendToUserRequest);
    }
    @Override
    public String getType() {
        return SendToAllRequest.TYPE;
    }
}

代码比较简单，跟着代码读读即可。

代码在 cn.iocoder.springboot.lab25.springwebsocket.util 包门路下。

创立 WebSocketUtil 工具类，次要提供两方面的性能：

1）Session 会话的治理；
2）多种发送音讯的形式。

整体代码比较简单，本人瞅瞅哟。

代码在目录中的如下地位：

在本大节，咱们会批改 WebsocketServerEndpoint 的代码，欠缺其性能。

4.9.1 初始化 MessageHandler 汇合

实现 InitializingBean 接口，在 #afterPropertiesSet() 办法中，扫描所有 MessageHandler Bean，增加到 MessageHandler 汇合中。

代码如下：

// WebsocketServerEndpoint.java
/**
* 音讯类型与 MessageHandler 的映射
*
* 留神，这里设置成动态变量。尽管说 WebsocketServerEndpoint 是单例，然而 Spring Boot 还是会为每个 WebSocket 创立一个 WebsocketServerEndpoint Bean。
*/
private static final Map<String, MessageHandler> HANDLERS = newHashMap<>();
@Autowired
private ApplicationContext applicationContext;
@Override
public void afterPropertiesSet() throws Exception {
    // 通过 ApplicationContext 取得所有 MessageHandler Bean
    applicationContext.getBeansOfType(MessageHandler.class).values() // 取得所有 MessageHandler Bean.forEach(messageHandler -> HANDLERS.put(messageHandler.getType(), messageHandler)); // 增加到 handlers 中
    logger.info(“afterPropertiesSet”, HANDLERS.size());
}

通过这样的形式，能够防止手动配置 MessageHandler 与音讯类型的映射。

4.9.2 onOpen

从新实现 #onOpen(Session session, EndpointConfig config) 办法，实现连贯时，应用 accessToken 参数进行用户认证。

代码如下：

// WebsocketServerEndpoint.java
@OnOpen
public void onOpen(Session session, EndpointConfig config) {
    logger.info(“onOpen”, session);
    // <1> 解析 accessToken
    List<String> accessTokenValues = session.getRequestParameterMap().get(“accessToken”);
    String accessToken = !CollectionUtils.isEmpty(accessTokenValues) ? accessTokenValues.get(0) : null;
    // <2> 创立 AuthRequest 音讯类型
    AuthRequest authRequest = newAuthRequest().setAccessToken(accessToken);
    // <3> 取得音讯处理器
    MessageHandler<AuthRequest> messageHandler = HANDLERS.get(AuthRequest.TYPE);
    if(messageHandler == null) {
        logger.error(“onOpen”);
        return;
    }
    messageHandler.execute(session, authRequest);
}

如代码所示：

<1> 处：解析 ws:// 地址上的 accessToken 的申请参。例如说：ws://127.0.0.1:8080?accessToken=999999；
<2> 处：创立 AuthRequest 音讯类型，并设置 accessToken 属性；
<3> 处：取得 AuthRequest 音讯类型对应的 MessageHandler 音讯处理器，而后调用 MessageHandler#execute(session, message) 办法，执行解决用户认证申请。

关上三个浏览器创立，别离设置服务地址如下：

1）ws://127.0.0.1:8080/?accessToken= 芋艿；
2）ws://127.0.0.1:8080/?accessToken= 番茄；
3）ws://127.0.0.1:8080/?accessToken= 土豆。

而后，一一点击「开启连贯」按钮，进行 WebSocket 连贯。

最终成果如下图：

如上图所示：

1）在红圈中，能够看到 AuthResponse 的音讯；
2）在黄圈中，能够看到 UserJoinNoticeRequest 的音讯。

4.9.3 onMessage

从新实现 _#onMessage(Session session, String message)_ 办法，实现不同的音讯，转发给不同的 MessageHandler 音讯处理器。

代码如下：

// WebsocketServerEndpoint.java
@OnMessage
public void onMessage(Session session, String message) {
    logger.info(“onOpen”, session, message); // 生产环境下，请设置成 debug 级别
    try{
        // <1> 取得音讯类型
        JSONObject jsonMessage = JSON.parseObject(message);
        String messageType = jsonMessage.getString(“type”);
        // <2> 取得音讯处理器
        MessageHandler messageHandler = HANDLERS.get(messageType);
        if(messageHandler == null) {
            logger.error(“onMessage”, messageType);
            return;
        }
        // <3> 解析音讯
        Class<? extendsMessage> messageClass = this.getMessageClass(messageHandler);
        // <4> 解决音讯
        Message messageObj = JSON.parseObject(jsonMessage.getString(“body”), messageClass);
        messageHandler.execute(session, messageObj);
    } catch(Throwable throwable) {
        logger.info(“onMessage”, session, throwable);
    }
}

代码中：

<1> 处，取得音讯类型，从 “type” 字段中；
<2> 处，取得音讯类型对应的 MessageHandler 音讯处理器；
<3> 处，调用 #getMessageClass(MessageHandler handler) 办法，通过 MessageHandler 中，通过解析其类上的泛型，取得音讯类型对应的 Class 类。

代码如下：

// WebsocketServerEndpoint.java
private Class<? extends Message> getMessageClass(MessageHandler handler) {
    // 取得 Bean 对应的 Class 类名。因为有可能被 AOP 代理过。
    Class<?> targetClass = AopProxyUtils.ultimateTargetClass(handler);
    // 取得接口的 Type 数组
    Type[] interfaces = targetClass.getGenericInterfaces();
    Class<?> superclass = targetClass.getSuperclass();
    while((Objects.isNull(interfaces) || 0== interfaces.length) && Objects.nonNull(superclass)) {// 此处，是以父类的接口为准
        interfaces = superclass.getGenericInterfaces();
        superclass = targetClass.getSuperclass();
    }
    if(Objects.nonNull(interfaces)) {
        // 遍历 interfaces 数组
        for(Type type : interfaces) {
            // 要求 type 是泛型参数
            if(type instanceof ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) type;
                // 要求是 MessageHandler 接口
                if(Objects.equals(parameterizedType.getRawType(), MessageHandler.class)) {
                    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                    // 取首个元素
                    if(Objects.nonNull(actualTypeArguments) && actualTypeArguments.length > 0) {
                        return(Class<Message>) actualTypeArguments[0];
                    } else{
                        thrownewIllegalStateException(String.format(“ 类型 (%s) 取得不到音讯类型 ”, handler));
                    }
                }
            }
        }
    }
    throw new IllegalStateException(String.format(“ 类型 (%s) 取得不到音讯类型 ”, handler));
}

这是参考 rocketmq-spring 我的项目的 DefaultRocketMQListenerContainer#getMessageType() 办法，进行稍微批改。

如果大家对 Java 的泛型机制没有做过一点理解，可能稍微有点硬核。能够先临时跳过，晓得用意即可。

<4> 处，调用 MessageHandler#execute(session, message) 办法，执行解决申请。

另外： 这里减少了 try-catch 代码，防止整个执行的过程中，产生异样。如果在 onMessage 事件的解决中，产生异样，该音讯对应的 Session 会话会被主动敞开。显然，这个不合乎咱们的要求。例如说，在 MessageHandler 解决音讯的过程中，产生一些异样是无奈防止的。

持续基于上述创立的三个浏览器，咱们先点击「清空音讯」按钮，清空下音讯，清扫下上次测试展现进去的接管失去的 Message。当然，WebSocket 的连贯，不须要去断开。

在第一个浏览器中，别离发送两种聊天音讯。

一条 SendToOneRequest 私聊音讯：

{
    type: “SEND_TO_ONE_REQUEST”,
    body: {
        toUser: “ 番茄 ”,
        msgId: “eaef4a3c-35dd-46ee-b548-f9c4eb6396fe”,
        content: “ 我是一条单聊音讯 ”
    }
}

一条 SendToAllHandler 群聊音讯：

{
    type: “SEND_TO_ALL_REQUEST”,
    body: {
        msgId: “838e97e1-6ae9-40f9-99c3-f7127ed64747”,
        content: “ 我是一条群聊音讯 ”
    }
}

最终后果如下图：

如上图所示：

1）在红圈中，能够看到一条 SendToUserRequest 的音讯，仅有第二个浏览器（番茄）收到；
2）在黄圈中，能够看到三条 SendToUserRequest 的音讯，所有浏览器都收到。

4.9.4 onClose

从新实现 _#onClose(Session session, CloseReason closeReason)_ 办法，实现移除敞开的 Session。

代码如下：

// WebsocketServerEndpoint.java
@OnClose
public void onClose(Session session, CloseReason closeReason) {
logger.info(“onClose”, session, closeReason);
WebSocketUtil.removeSession(session);
}

4.9.5 onError

#onError(Session session, Throwable throwable) 办法，放弃不变。

代码如下：

// WebsocketServerEndpoint.java
@OnError
public void onError(Session session, Throwable throwable) {
logger.info(“onClose”, session, throwable);
}

示例代码下载：

（因附件无奈上传到此处，请从同步链接处下载：http://www.52im.net/thread-3483-1-1.html）

认真一个捉摸，虎躯一震，还是提供一个 Spring WebSocket 疾速入门的示例。

在上章「Tomcat WebSocket 实战入门」的 _lab-websocket-25-01_ 示例的根底上，咱们复制出 lab-websocket-25-02 我的项目，进行革新。

革新的代码目录内容是这样：

因为 Tomcat WebSocket 应用的是 Session 作为会话，而 Spring WebSocket 应用的是 WebSocketSession 作为会话，导致咱们须要稍微批改下 WebSocketUtil 工具类。改变十分稍微，点击 WebSocketUtil.java 查看下，秒懂的噢。

次要有两点：

1）将所有应用 Session 类的中央，调整成 WebSocketSession 类；
2）将发送音讯，从 Session 批改成 WebSocketSession。

将 _cn.iocoder.springboot.lab25.springwebsocket.handler_ 包门路下的音讯处理器们，应用到 Session 类的中央，调整成 WebSocketSession 类。

在 _cn.iocoder.springboot.lab25.springwebsocket.websocket_ 包门路下，创立 DemoWebSocketShakeInterceptor 拦截器。因为 WebSocketSession 无奈取得 ws 地址上的申请参数，所以只好通过该拦截器，取得 accessToken 申请参数，设置到 attributes 中。

代码如下：

// DemoWebSocketShakeInterceptor.java
public class DemoWebSocketShakeInterceptor extends HttpSessionHandshakeInterceptor {
    @Override// 拦挡 Handshake 事件
    public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response,WebSocketHandler wsHandler, Map<String, Object> attributes) throwsException {
        // 取得 accessToken
        if(request instanceof ServletServerHttpRequest) {
            ServletServerHttpRequest serverRequest = (ServletServerHttpRequest) request;
            attributes.put(“accessToken”, serverRequest.getServletRequest().getParameter(“accessToken”));
        }
        // 调用父办法，继续执行逻辑
        return super.beforeHandshake(request, response, wsHandler, attributes);
    }
}

在 _cn.iocoder.springboot.lab25.springwebsocket.websocket_ 包门路下，创立 DemoWebSocketHandler 处理器。该处理器参考「5.9、欠缺 WebsocketServerEndpoint」大节，编写它的代码。

DemoWebSocketHandler.java 代码位于如下目录处，具体内容就不贴出来了，自已去读一读：

代码极其类似，简略撸下即可。

批改 WebSocketConfiguration 配置类，代码如下：

// WebSocketConfiguration.java
@Configuration
@EnableWebSocket// 开启 Spring WebSocket
public class WebSocketConfiguration implements WebSocketConfigurer {
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(this.webSocketHandler(), “/”) // 配置处理器
                .addInterceptors(newDemoWebSocketShakeInterceptor()) // 配置拦截器
                .setAllowedOrigins(“*”); // 解决跨域问题
    }
    @Bean
    public DemoWebSocketHandler webSocketHandler() {
        return new DemoWebSocketHandler();
    }
    @Bean
    public DemoWebSocketShakeInterceptor webSocketShakeInterceptor() {
        return new DemoWebSocketShakeInterceptor();
    }
}

解释一下：

1）在类上，增加 @EnableWebSocket 注解，开启 Spring WebSocket 性能；
2）实现 WebSocketConfigurer 接口，自定义 WebSocket 的配置（具体能够看看 #registerWebSocketHandlers(registry) 办法，配置 WebSocket 处理器、拦截器，以及容许跨域）。

至此，咱们曾经实现 Spring WebSocket 的示例。

前面，咱们执行 Application 来启动我的项目。具体的测试，这里就不反复了，能够本人应用 WebSocket 在线测试工具来测试下。

尽管说，WebSocket 协定曾经在支流的浏览器上，失去十分好的反对，然而总有一些“异类”，是不兼容的。所以就诞生了 SockJS、Socket.io 这类库。对于它们的介绍与应用，能够看看《SockJS 简略介绍》、《Web 端即时通讯技术的倒退与 WebSocket、Socket.io 的技术实际》文章。

理论场景下，咱们在应用 WebSocket 还是原生 Socket 也好，都须要思考“如何保障音讯肯定送达给用户？”

大家必定可能想到的是：如果用户不处于在线的时候，音讯长久化到 MySQL、MongoDB 等等数据库中。这个是正确，且是必须要做的。

咱们在一起思考下边界场景：客户端网络环境较差，特地是在挪动端场景下，呈现网络闪断，可能会呈现连贯理论曾经断开，而服务端认为客户端处于在线的状况。此时，服务端会将音讯发给客户端，那么音讯理论就发送到“空气”中，产生失落的状况。

要解决这种状况下的问题，须要引入客户端的 ACK 音讯机制。

目前，支流的有两种做法。

第一种： 基于每一条音讯编号 ACK

整体流程如下：

1）无论客户端是否在线，服务端都先把接管到的音讯长久化到数据库中。如果客户端此时在线，服务端将残缺音讯推送给客户端；
2）客户端在接管到音讯之后，发送 ACK 音讯编号给服务端，告知曾经收到该音讯。服务端在收到 ACK 音讯编号的时候，标记该音讯曾经发送胜利；
3）服务端定时轮询，在线的客户端，是否有超过 N 秒未 ACK 的音讯。如果有，则从新发送音讯给对应的客户端。

这种计划，因为客户端逐条 ACK 音讯编号，所以会导致客户端和服务端交互次数过多。当然，客户端能够异步批量 ACK 多条音讯，从而缩小次数。

不过因为服务端依然须要定时轮询，也会导致服务端压力较大。所以，这种计划根本曾经不采纳了。

第二种： 基于滑动窗口 ACK

整体流程如下：

1）无论客户端是否在线，服务端都先把接管到的音讯长久化到数据库中。如果客户端此时在线，服务端将音讯编号推送给客户端；
2）客户端在接管到音讯编号之后，和本地的音讯编号进行比对。如果比本地的小，阐明该音讯曾经收到，疏忽不解决；如果比本地的大，应用本地的音讯编号，向服务端拉取大于本地的音讯编号的音讯列表，即增量音讯列表。拉取实现后，更新音讯列表中最大的音讯编号为新的本地的音讯编号；
3）服务端在收到客户端拉取增量的音讯列表时，将申请的编号记录到数据库中，用于晓得客户端此时本地的最新消息编号；
4）思考到服务端将音讯编号推送给客户端，也会存在失落的状况，所以客户端会每 N 秒定时向服务端拉取大于本地的音讯编号的音讯列表。

这种形式，在业务被称为推拉联合的计划，在分布式音讯队列、配置核心、注册核心实现实时的数据同步，常常被采纳。

并且，采纳这种计划的状况下，客户端和服务端不肯定须要应用长连贯，也能够应用长轮询所代替。

做法比方，客户端发送带有音讯版本号的 HTTP 申请到服务端：

1）如果服务端已有比客户端新的音讯编号，则间接返回增量的音讯列表；
2）如果服务端没有比客户端新的音讯编号，则 HOLD 住申请，直到有新的音讯列表能够返回，或者 HTTP 申请超时；
3）客户端在收到 HTTP 申请超时时，立刻又从新发动带有音讯版本号的 HTTP 申请到服务端。如此重复循环，通过音讯编号作为增量标识，达到实时获取音讯的目标。

如果大家对音讯牢靠投递这块感兴趣，能够看看上面这几篇：

《零根底 IM 开发入门 (三)：什么是 IM 零碎的可靠性？》
《从客户端的角度来谈谈挪动端 IM 的音讯可靠性和送达机制》
《IM 音讯送达保障机制实现 (一)：保障在线实时音讯的牢靠投递》
《IM 音讯送达保障机制实现 (二)：保障离线音讯的牢靠投递》
《IM 群聊音讯如此简单，如何保障不丢不重？》
《IM 开发干货分享：如何优雅的实现大量离线音讯的牢靠投递》
《一套亿级用户的 IM 架构技术干货 (下篇)：可靠性、有序性、弱网优化等》

毕竟，本篇这里写的有点简略哈 ~

最初： 如果你想零碎的学习 IM 开发方面方面的常识，举荐详读：《新手入门一篇就够：从零开发挪动端 IM》。如果你自认为曾经有点小牛 x 了，能够看看生产环境下的大用户量 IM 零碎架构设计方面的常识：《从老手到专家：如何设计一套亿级音讯量的分布式 IM 零碎》。

限于篇幅，这里就不再持续开展了。

《自已开发 IM 有那么难吗？手把手教你自撸一个 Andriod 版繁难 IM (有源码)》
《一种 Android 端 IM 智能心跳算法的设计与实现探讨（含样例代码）》
《手把手教你用 Netty 实现网络通信程序的心跳机制、断线重连机制》
《[轻量级即时通讯框架 MobileIMSDK 的 iOS 源码（开源版）[ 附件下载]](http://www.52im.net/thread-35…》
《[开源 IM 工程“蘑菇街 TeamTalk”2015 年 5 月前未删减版残缺代码 [ 附件下载]](http://www.52im.net/thread-77…》
《[NIO 框架入门 ( 一)：服务端基于 Netty4 的 UDP 双向通信 Demo 演示 [附件下载]](http://www.52im.net/thread-36…》
《[NIO 框架入门 ( 二)：服务端基于 MINA2 的 UDP 双向通信 Demo 演示 [附件下载]](http://www.52im.net/thread-37…》
《[NIO 框架入门 ( 三)：iOS 与 MINA2、Netty4 的跨平台 UDP 双向通信实战 [附件下载]](http://www.52im.net/thread-37…》
《[NIO 框架入门 ( 四)：Android 与 MINA2、Netty4 的跨平台 UDP 双向通信实战 [附件下载]](http://www.52im.net/thread-38…》
《[一个 WebSocket 实时聊天室 Demo：基于 node.js+socket.io [ 附件下载]](http://www.52im.net/thread-51…》
《适宜老手：从零开发一个 IM 服务端（基于 Netty，有残缺源码）》
《拿起键盘就是干：跟我一起徒手开发一套分布式 IM 零碎》
《正确理解 IM 长连贯的心跳及重连机制，并入手实现（有残缺 IM 源码）》
《适宜老手：手把手教你用 Go 疾速搭建高性能、可扩大的 IM 零碎 (有源码)》
《跟着源码一起学：手把手教你用 WebSocket 打造 Web 端 IM 聊天》

本文已同步公布于“即时通讯技术圈”公众号。

▲ 本文在公众号上的链接是：点此进入。同步公布链接是：http://www.52im.net/thread-3483-1-1.html

关于即时通讯:跟着源码一起学手把手教你用WebSocket打造Web端IM聊天

一、引言

二、常识筹备

三、内容概述

四、Tomcat WebSocket 实战入门

4.1、根本介绍

4.2、引入依赖

4.3、WebsocketServerEndpoint

4.4、WebSocketConfiguration

4.5、Application

4.6、音讯

4.7、音讯处理器

4.8、WebSocketUtil

4.9、欠缺 WebsocketServerEndpoint

五、Spring WebSocket 实战入门

5.0、根底介绍

5.1、WebSocketUtil

5.2、音讯处理器

5.3、DemoWebSocketShakeInterceptor

5.4、DemoWebSocketHandler

5.5、WebSocketConfiguration

七、写在最初

附录：更多 IM 开发入手实际文章