springboot整合netty之简单使用

项目介绍

简单介绍：我在实际的工作之中做过的项目阐述这个项目。
netty client，netty server，other server主要围绕这三个服务之间的逻辑处理。
逻辑图：

设备工作流程.png
主要以netty server为例讲解
项目中主要解决了一下问题：

在netty server的核心业务处理类中处理无法注入bean的问题
提供netty连接通道channel在分布式下的共享服务思路·后续更新具体实现方案

netty和springboot的整合

pom.xml 文件

在SpringBoot项目里添加netty的依赖,注意不要用netty5的依赖,因为已经废弃了



    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.2.6.RELEASE
         
    
    com.netty.vr
    centre
    0.0.1-SNAPSHOT
    centre
    Demo project for Spring Boot

    
        1.8
    

    
        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.projectlombok
            lombok
            true
        
        
        
            io.netty
            netty-all
            4.1.42.Final
        
        
            com.alibaba
            fastjson
            1.2.61
        
        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
            2.1.1
        
        
            mysql
            mysql-connector-java
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
            
                
                    org.junit.vintage
                    junit-vintage-engine
                
            
        
        
            net.bytebuddy
            byte-buddy
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
            
                org.apache.maven.plugins
                maven-surefire-plugin
                2.20.1
                
                    
                    true

yml配置文件

将端口和IP写入application.yml文件里,本机测试,用127.0.0.1就ok。即使在服务器上部署也建议127.0.0.1，然后用nginx配置域名代理

netty:
  port: 8888
  url: 127.0.0.1

netty服务启动引导类

package com.daoyin.vr.centre.component;

import com.daoyin.vr.centre.netty.MyWebSocketChannelHandler;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import org.springframework.stereotype.Component;
import java.net.InetSocketAddress;
/**
 * netty程序的入口，负责启动应用
 * @author Mr培
 */
@Component
public class NettyServer {
    public void start(InetSocketAddress address){
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap server = new ServerBootstrap();
            server.group(bossGroup, workGroup);
            server.channel(NioServerSocketChannel.class);
            server.childHandler(new MyWebSocketChannelHandler());
            System.out.println("服务端开启等待客户端连接....");
            Channel ch = server.bind(address).sync().channel();
            ch.closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //优雅的退出程序
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
}

启动main方法，CommandLineRunner #run()
这里主要是通过CommandLineRunner 接口的run方法，实现在项目启动后执行的功能，SpringBoot提供的一种简单的实现方案就是添加一个model并实现CommandLineRunner接口，实现功能的代码放在实现的run方法中。
当然还有其他的启动方法，比如

利用 ApplicationListener 上下文监听器
注解@PostConstruct
利用监听器启动
这里以CommandLineRunner为例

package com.daoyin.vr.centre;

import com.daoyin.vr.centre.component.NettyServer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.net.InetSocketAddress;

/**
 * 实现 CommandLineRunner 执行额外任务
 * @author Mr培
 */
@SpringBootApplication
public class CentreApplication implements CommandLineRunner {

    @Value("${netty.port}")
    private int port;

    @Value("${netty.url}")
    private String url;

    /**
     * final修饰 + 构造器 ≌ @Autowired 注解
     * */
    private final NettyServer server;

    public CentreApplication(NettyServer server) {
        this.server = server;
    }
    public static void main(String[] args) {
        SpringApplication.run(CentreApplication.class, args);
    }
    /**
     * 服务开始则启动netty server
     * */
    @Override
    public void run(String... args){
        InetSocketAddress address = new InetSocketAddress(url,port);
        server.start(address);
    }
}

存储整个工程的全局配置

可根据个人的不同业务逻辑自行实现业务方法

package com.daoyin.vr.centre.netty;

import io.netty.channel.Channel;
import io.netty.channel.ChannelId;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.util.concurrent.GlobalEventExecutor;

import java.util.concurrent.ConcurrentHashMap;

/**
* 存储整个工程的全局配置
* @author rp
*
*/
public class NettyConfig {
   
   /**
    * 存储每一个客户端接入进来时的channel对象
    */
   public static ChannelGroup group = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
   /**
    * 储存每一个客户端接入进来时的channel键值对 对象
    * */
   public static ConcurrentHashMap cannelMap = new ConcurrentHashMap<>();
   /**
    * vr设备状态储存
    * 0 未占用  1 占用
    * */
   public static ConcurrentHashMap vrStatusMap = new ConcurrentHashMap<>();

   /**
    * 添加设备和状态
    * */
   public static void addStatus(String key,Integer status){
       vrStatusMap.put(key,status);
   }

   /**
    * 查询设备状态
    * */
   public static Integer findStatus(String key){
       return vrStatusMap.get(key);
   }

   /**
    * 储存netty客户端channel管道
    * */
   public static void addChannel(String key,Channel channel){
       group.add(channel);
       cannelMap.put(key,channel.id());
   }
   /**
   * 查询客户端channel管道
   * */
   public static Channel findChannel(String key){
       return group.find(cannelMap.get(key));
   }

   /**
    * 移除客户端channel管道
    * */
   public static void removeChannel(Channel channel){
       NettyConfig.group.remove(channel);
   }

   /**
    * 根据设备标识找到客户端channel并发送消息
    * */
   public static void send(String key,String value){
       findChannel(key).writeAndFlush(new TextWebSocketFrame(value));
   }

   /**
    * 根据客户端channel直接发送消息
    * */
   public static void send(Channel channel,String value){
       channel.writeAndFlush(new TextWebSocketFrame(value));
   }

   /**
    * 根据设备标识移除客户端channel
    * */
   public static void removeChannel(String key,Channel channel){
       group.remove(channel);
       cannelMap.remove(key);
   }

   /**
    * 群发消息
    * */
   public static void sendAll(String value){
       group.writeAndFlush(new TextWebSocketFrame(value));
   }
}

初始化连接时候的各个组件

package com.daoyin.vr.centre.netty;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.stream.ChunkedWriteHandler;

/**
 * 初始化连接时候的各个组件
 * @author Mr培
 *
 */
public class MyWebSocketChannelHandler extends ChannelInitializer {

    @Override
    protected void initChannel(SocketChannel channel){
        channel.pipeline().addLast("http-codec", new HttpServerCodec());
        channel.pipeline().addLast("aggregator", new HttpObjectAggregator(65536));
        channel.pipeline().addLast("http-chunked", new ChunkedWriteHandler());
        channel.pipeline().addLast("handler", new MyWebSocketHandler());
    }

}

接收/处理/响应客户端websocket请求的核心业务处理类
服务端业务处理handler

package com.daoyin.vr.centre.netty;

import com.daoyin.vr.centre.service.VrChannelService;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PingWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PongWebSocketFrame;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketServerHandshaker;
import io.netty.handler.codec.http.websocketx.WebSocketServerHandshakerFactory;
import io.netty.util.CharsetUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.concurrent.*;

/**
 * 接收/处理/响应客户端websocket请求的核心业务处理类
 * @author rp
 */
@Component
public class MyWebSocketHandler extends SimpleChannelInboundHandler

springboot整合netty之简单使用

项目介绍

netty和springboot的整合

netty连接通道channel在分布式下的共享服务思路

其他

你可能感兴趣的:(springboot整合netty之简单使用)