搭建SpringBoot+ Netty + WebSocket 通信协议框架

运用场景：与机器设备进行通讯或者其他场景；
pom文件就不上传了，直接上代码，网上都可以找的到 主要是 SpringBoot 和 Netty 的依赖

1.配置类

@Component
@ConfigurationProperties(prefix = "ws")
public class WebSocketConfig {

    private int port;
    private String host;
    private boolean ssl;
    private String cert;
    private String key;

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public boolean getSsl() {
        return ssl;
    }

    public void setSsl(boolean ssl) {
        this.ssl = ssl;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getCert() {
        return cert;
    }

    public void setCert(String cert) {
        this.cert = cert;
    }
}

2.properties 配置文件

ws.ssl=false
ws.port=8082
ws.host=localhost

3.Action

public class Action {

    private Object target;

    private Method method;


    /**
     * @param target
     * @param method
     */
    public Action(Object target, Method method) {
        this.target = target;
        this.method = method;
    }

    public Object call(Object... args) throws InvocationTargetException, IllegalAccessException {
        return method.invoke(target, args);
    }

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public Method getMethod() {
        return method;
    }

    public void setMethod(Method method) {
        this.method = method;
    }

    @Override
    public String toString() {
        return "ActionMethod{" +
                "target=" + target +
                ", method=" + method +
                '}';
    }
}

4.定义Command注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface Command {
    int value();
}

5.路由类

public class Router {

    private static Map routers = new ConcurrentHashMap();

    public static void add(int command, Action action) {

        if (routers.containsKey(command)) {
//            log.warn("Router: duplicate command " + command);
        }

        routers.put(command, action);
    }

    public static void dispatcher(Integer command, ChannelHandlerContext ctx, Object msg) throws Exception {
        Action action = routers.get(command);

        if (action == null) {
//            throw new Exception("Action Not Found: " + command);
//            log.warn("Router not found: " + command);
            return;
        }

        action.call(ctx, msg);
    }
}

6.Handler扫描器

@Component
public class Scaner implements BeanPostProcessor {

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

        Class clazz = bean.getClass();
        clazz.getAnnotation(Command.class);
        Command command = clazz.getAnnotation(Command.class);

        if (command != null) {
            Method[] methods = clazz.getMethods();
            for (Method method : methods) {
                if (method.getName().equals("handler")) {
                    Router.add(command.value(), new Action(bean, method));
                }
            }
        }

        return bean;
    }
}

7.Netty服务

@Component
public class Server {

    @Autowired
    WebSocket webSocket;
    /**
     * 创建bootstrap
     */
    private ServerBootstrap serverBootstrap;
    /**
     * BOSS
     */
    private EventLoopGroup bossGroup;
    /**
     * Worker
     */
    private EventLoopGroup workerGroup;
    /**
     * NETT服务器配置类
     */
    @Resource
    private WebSocketConfig webSocketConfig;

    /**
     * 关闭服务器方法
     */
    @PreDestroy
    public void close() {
        // 优雅退出
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }

    /**
     * 开启及服务线程
     */
    public void start() throws Exception {
        int port = webSocketConfig.getPort();

        serverBootstrap = new ServerBootstrap();
        bossGroup = new NioEventLoopGroup();
        workerGroup = new NioEventLoopGroup();

        serverBootstrap.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .handler(new LoggingHandler(LogLevel.INFO))
                .option(ChannelOption.SO_BACKLOG, 1024)
                .childOption(ChannelOption.SO_LINGER, 0)
                .childOption(ChannelOption.TCP_NODELAY, true)
                .childOption(ChannelOption.SO_KEEPALIVE, true);


        try {
            //设置事件处理
            serverBootstrap.childHandler(new ChannelInitializer() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ChannelPipeline pipeline = ch.pipeline();
                    
                    pipeline
                            .addLast(new IdleStateHandler(50, 50, 50, TimeUnit.SECONDS))
                            .addLast(new HttpServerCodec())
                            .addLast(new HttpObjectAggregator(65536))
                            .addLast(new ChunkedWriteHandler())
                            //设置websocket路径
                            .addLast(new WebSocketServerProtocolHandler("/sweeper", null, true))
                            .addLast(webSocket);
                }
            });
            
            ChannelFuture f = serverBootstrap.bind(port).sync();
            f.channel().closeFuture().sync();

        } catch (InterruptedException e) {

            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

8.websocket核心类

@Service()
@Scope("prototype")
@ChannelHandler.Sharable
public class WebSocket extends SimpleChannelInboundHandler