Netty的WebSocket协议实现服务端与客户端即时通信及问题总结

一、介绍

技术栈：
Java：1.8
SpringBoot：2.2.2.RELEASE
Netty：4.1.32.Final

基础了解可参考文章：https://blog.csdn.net/DreamsArchitects/article/details/120177336

当前时间：2021年12月31日17:02:38
作为2021年的最后一年博客。

二、问题

2.1 启动服务端方式

之前是直接使用main方法的方式启动服务端：

结合SpringBoot项目后应在主启动类的main方法内启动：

这样启动没问题，但是由于这个类是new出来的，无法被Spring容器托管。
在后续的业务逻辑处理中，

1. 无法使用@Value注解获取配置文件的值、
2. 使用@Autowired注入的对象会报空指针异常，比如使用RestTemplate对象进行调用时会空指针异常。

解决方法：使用ConfigurableListableBeanFactory （Spring应用上下文环境）获取对象（前提该类需要加上@Component注解被Spring托管）。

（SpringUtils工具类贴在附录）

另外还需注意之前的写法：

改进：

2.2 客户端连接对象存储问题

每当客户端连接，都会生成一个ChannelHandlerContext对象存储连接信息，
客户端与服务端之间进行即时通信就要使用这个对象。所以需要把每次连接的ChannelHandlerContext对象存储起来。
解决方法：

使用Map方式进行存储：

public  static Map<String, ChannelHandlerContext> map = new HashMap<String, ChannelHandlerContext>();


//可以通过ctx.channel().id()方法获取每次连接的socket ID作为Map的Key
String id = ctx.channel().id().toString();

客户端连接时，把ChannelHandlerContext对象存储起来：

客户端断开连接时，移除map中的ChannelHandlerContext对象：

2.3 服务端主动与客户端通信

前提：客户端与服务端已经建立socket连接。

服务端可以通过ChannelHandlerContext对象与客户端进行通信。

 ctx.channel().write(new TextWebSocketFrame("客户端消息：你好！"));
 ctx.flush();

2.4 @Sharable 注解

netty客户端重连时遇到的问题: 客户端每次connect都会重新建立一个channel。

@Sharable 用来说明ChannelHandler是否可以在多个channel直接共享使用，被注解的ChannelHandler对应的同一个实例可以被加入到一个或者多个ChannelPipelines一次或者多次，而不会存在竞争条件。

三、实现

channelActive（）连接建立
channelInactive（） 连接断开
channelRead0（） 方法接收客户端消息，并进行业务处理
exceptionCaught（）发生异常

 /**
     * 客户端与服务端创建链接的时候调用
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        String id = ctx.channel().id().toString();
        WebSocketServer.map.put(id,ctx);
        log.info("客户端已连接---》id:{}",id);
    }

 /**
     * 客户端与服务端断开连接的时候调用
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        //移除map socket 连接  id
        String socketId = ctx.channel().id().toString();
        WebSocketServer.map.remove(socketId);
        log.info("客户端连接断开，socket ID ：{} ",socketId);

    }

 /**
     * 接收客户端消息
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        String id = ctx.channel().id().toString();
        log.info("客户端发送消息---》id:{}",id);

        if (WebSocketServer.map.get(id) != null && WebSocketServer.map.get(id).equals(ctx)) {

        } else {
            //如果map中没有此ctx 将连接存入map中
            WebSocketServer.map.put(id, ctx);
        }
        //传统http接入：第一次握手消息有HTTP协议承载，所以它是一个HTTP消息，，执行handleHTTPRequest方法来处理WebSocket握手请求
        if (msg instanceof FullHttpRequest){
            log.info("处理WebSocket握手请求");
            handleHttpRequest(ctx,(FullHttpRequest) msg);
        }else if (msg instanceof WebSocketFrame){
            //WebSocket接入：链路建立成功后的操作
            log.info("WebSocket接入,链路建立成功后的操作");
            handleWebSocketFrame(ctx,(WebSocketFrame) msg);
        }

    }

四、附录

4.1 pom文件

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.haobai</groupId>
    <artifactId>besttone-newmsg-5g</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        <!--fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.73</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--JPA 持久层框架-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.32.Final</version>
        </dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.9</version>
        </dependency>

        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!--跳过测试-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <skip>true</skip>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

4.2 SpringUtils

package com.haobai.utils;

import org.springframework.aop.framework.AopContext;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

/**
 * spring工具类 方便在非spring管理环境中获取bean
 * 
 * @author ruoyi
 */
@Component
public final class SpringUtils implements BeanFactoryPostProcessor
{
    /** Spring应用上下文环境 */
    private static ConfigurableListableBeanFactory beanFactory;

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        SpringUtils.beanFactory = beanFactory;
    }

    /**
     * 获取对象
     *
     * @param name
     * @return Object 一个以所给名字注册的bean的实例
     * @throws org.springframework.beans.BeansException
     *
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException {
        return (T) beanFactory.getBean(name);
    }

    /**
     * 获取类型为requiredType的对象
     *
     * @param clz
     * @return
     * @throws org.springframework.beans.BeansException
     *
     */
    public static <T> T getBean(Class<T> clz) throws BeansException {
        T result = (T) beanFactory.getBean(clz);
        return result;
    }

    /**
     * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
     *
     * @param name
     * @return boolean
     */
    public static boolean containsBean(String name) {
        return beanFactory.containsBean(name);
    }

    /**
     * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
     *
     * @param name
     * @return boolean
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     *
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
        return beanFactory.isSingleton(name);
    }

    /**
     * @param name
     * @return Class 注册对象的类型
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     *
     */
    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException {
        return beanFactory.getType(name);
    }

    /**
     * 如果给定的bean名字在bean定义中有别名，则返回这些别名
     *
     * @param name
     * @return
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     *
     */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
        return beanFactory.getAliases(name);
    }

    /**
     * 获取aop代理对象
     * 
     * @param invoker
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T getAopProxy(T invoker) {
        return (T) AopContext.currentProxy();
    }
}