记一次netty的使用

我不是女神ヾ 2021-09-21 15:50 449阅读 0赞

前言：笔者在项目中使用的netty的场景是这样的，（物联网公司）所有机柜使用长连接连接到服务器，而服务器使用的正好是netty，所以不得已笔者需要学习netty的一些知识，这里只是浅浅的使用笔记，更深入的知识需要后期学习。这里是一个简单使用的笔记

准备：集成netty项目，需要准备好一个能访问使用的项目（略）

1：pom.xml文件（笔者认为所有项目第一步）导入netty的jar包

  1. <!--netty start-->
  2. <dependency>
  3.     <groupId>io.netty</groupId>
  4.     <artifactId>netty-all</artifactId>
  5.     <version>4.1.6.Final</version>
  6.     <scope>compile</scope>
  7. </dependency>
  8. <!--netty end-->

因为业务需要有一些json的使用，所以还需要json的jar包，如果没有json需求可以不使用用其它代替也可

  1. <!--fastjson start-->
  2. <dependency>
  3.     <groupId>com.alibaba</groupId>
  4.     <artifactId>fastjson</artifactId>
  5.     <version>1.2.3</version>
  6. </dependency>
  7. <!--fastjson end-->

2：开发netty的主要几个文件，这里分别是ServerHandler，ServerMain，NettyProperties，NettyConfig，业务类的主要几个文件ReturnInfo，ExecuteService和其它业务类等

netty部分代码

ServerHandler类

  1. package com.xiaomage.crm.netty;
  3. import com.xiaomage.crm.taskQueue.SpringContextUtil;
  4. import io.netty.channel.Channel;
  5. import io.netty.channel.ChannelHandlerContext;
  6. import io.netty.channel.ChannelInboundHandlerAdapter;
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  10. /**
  11.  * @version V1.0
  12.  * @Title: netty服务器处理消息的类
  13.  * @date: 2019/3/18 15:53
  14.  */
  15. public class ServerHandler extends ChannelInboundHandlerAdapter{
  17.     //日志
  18.     protected static Logger logger = LoggerFactory.getLogger(ServerHandler.class);
  21.     /**
  22.      * 客户端与服务端创建连接的时候调用
  23.      * 只发生在第一次连接,后续发送消息不再连接
  24.      */
  25.     @Override
  26.     public void channelActive(ChannelHandlerContext ctx){
  27.         logger.info("client connection start ..." + ctx);
  28.         //自己的业务处理保存通道信息
  29.         NettyConfig.addTemporary_Channel(ctx.channel());
  30.     }
  32.     /**
  33.      * 客户端与服务端断开连接时调用
  34.      */
  35.     @Override
  36.     public void channelInactive(ChannelHandlerContext ctx){
  37.         logger.info("client close ..." + ctx);
  38.         //自己的业务处理清除通道信息
  39.         NettyConfig.removeClient(ctx.channel());
  40.     }
  43.     /**
  44.      * 工程出现异常的时候调用
  45.      * 异常处理逻辑
  46.      */
  47.     @Override
  48.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause){
  49.         String line="server exceptionCaught method run:"+cause.getMessage();
  50.         if (NettyProperties.loggerDebugger) {
  51.             logger.info("exceptionCaught:"+line);
  52.         }
  53.         NettyConfig.removeClient(ctx.channel());
  54.         //连接已经断开
  55.         ctx.close();
  56.     }
  58.     /**
  59.      * 服务端处理客户端socket请求的核心方法，这里接收了客户端发来完整信息
  60.      * 业务处理逻辑放在这里 == 格式自己和客户端进行协商，笔者这里是
  61.      */
  62.     @Override
  63.     public void channelRead(ChannelHandlerContext ctx, Object info){
  64.             String message = info.toString();
  65.             if (NettyProperties.loggerDebugger) {
  66.                 logger.info("read:"+message);
  67.             }
  68.             //截取制定字符串，判断类型
  69.             int T_index = -1;
  70.             if((T_index=message.indexOf("\"T\""))!=-1){
  71.                 int VCode_index = T_index + 4;
  72.                 String vCode = message.substring(VCode_index, VCode_index+4);
  73.                 vCode = vCode.replaceAll("\"", "");
  74.                 vCode = vCode.replaceAll("'", "");
  75.                 vCode = vCode.trim();
  76.                 if(!vCode.equalsIgnoreCase("vv") && !vCode.equalsIgnoreCase("vc")){
  77.                     vCode = vCode.replace("V","v");
  78.                 }
  79.                 if(!NettyConfig.VcStart || vCode.equalsIgnoreCase("vc")){
  80.                     Object res= null;
  81.                     try {
  82.                         //动态调用方法  ==BeansUtils spring调用bean对象方法
  83.                         ExecuteService execute = SpringContextUtil.getBean(vCode,ExecuteService.class);
  85. //                        用反射获取
  86. //                        Object [] params = new Object[2];
  87. //                        params[0]=ctx.channel();
  88. //                        params[1]=message;
  89. //                        res = execute.getClass().getDeclaredMethod("handler", NioSocketChannel.class,String.class).invoke(execute,params);
  91.                         //直接获取
  92.                         res = execute.handler(ctx.channel(),message);
  94.                     }catch (Exception e) {
  95.                         System.out.println("解析异常跑错"+e.getMessage());
  96.                         LogErrorMessage(ctx.channel(),e.getMessage(),message,ReturnInfo.ERROR_UNKNOWN);
  97.                     }
  98.                     if(res!=null){
  99.                         String line = res.toString();
  101.                         ReturnInfo.sendMsg(ctx.channel(),line);
  102.                     }
  103.                 }else{
  104.                     ReturnInfo.sendMsg(ctx.channel(),NettyConfig.VcContent);
  105.                     ctx.close();
  106.                 }
  107.             }else{
  108.                 String errorInfo=ReturnInfo.DownStatePackage(ReturnInfo.ERROR_T_IS_NOT_FOUND);
  109.                 ReturnInfo.sendMsg(ctx.channel(),errorInfo);
  110.             }
  111.     }
  113.     /**
  114.      * @param ctx 通道
  115.      * @param errMessage 异常信息
  116.      * @param channelContent 通道数据
  117.      * @param ErrorCode 异常代码
  118.      * @Title: 处理异常数据
  119.      * @date: 2020/1/9 11:14
  120.      * @version V1.0
  121.      */
  122.     private void LogErrorMessage(Channel ctx, String errMessage, String channelContent, int ErrorCode) {
  123.         logger.error("unknown error:"+errMessage+",当前数据:"+channelContent);
  124.         String res= ReturnInfo.DownStatePackage(ErrorCode);
  125.         ReturnInfo.sendMsg(ctx,res);
  126.     }
  129. }

ServerMain类

  1. package com.xiaomage.crm.netty;
  3. import io.netty.bootstrap.ServerBootstrap;
  4. import io.netty.buffer.ByteBuf;
  5. import io.netty.buffer.Unpooled;
  6. import io.netty.channel.ChannelFuture;
  7. import io.netty.channel.ChannelInitializer;
  8. import io.netty.channel.ChannelOption;
  9. import io.netty.channel.EventLoopGroup;
  10. import io.netty.channel.nio.NioEventLoopGroup;
  11. import io.netty.channel.socket.SocketChannel;
  12. import io.netty.channel.socket.nio.NioServerSocketChannel;
  13. import io.netty.handler.codec.DelimiterBasedFrameDecoder;
  14. import io.netty.handler.codec.string.StringDecoder;
  15. import io.netty.handler.timeout.ReadTimeoutHandler;
  16. import org.slf4j.Logger;
  17. import org.slf4j.LoggerFactory;
  18. import org.springframework.stereotype.Component;
  20. import javax.annotation.PostConstruct;
  21. import java.nio.charset.Charset;
  22. import java.util.concurrent.TimeUnit;
  24. /**
  25.  * 1. 双线程组
  26.  * 2. Bootstrap配置启动信息
  27.  * 3. 注册业务处理Handler
  28.  * 4. 绑定服务监听端口并启动服务
  29.  */
  30. @Component
  31. public class ServerMain {
  33.     //日志
  34.     protected static Logger logger = LoggerFactory.getLogger(ServerMain.class);
  36.     // 监听线程组，监听客户端请求
  37.     private EventLoopGroup acceptorGroup = null;
  39.     // 处理客户端相关操作线程组，负责处理与客户端的数据通讯
  40.     private EventLoopGroup clientGroup = null;
  42.     // 服务启动相关配置信息
  43.     private ServerBootstrap bootstrap = null;
  45.     public ServerMain(){
  46.         init();
  47.     }
  49.     //初始化设置 netty相关模式
  50.     private void init(){
  51.         acceptorGroup = new NioEventLoopGroup();
  52.         clientGroup = new NioEventLoopGroup();
  53.         bootstrap = new ServerBootstrap();
  54.         // 绑定线程组
  55.         bootstrap.group(acceptorGroup, clientGroup);
  56.         // 设定通讯模式为NIO
  57.         bootstrap.channel(NioServerSocketChannel.class);
  58.         // 设定缓冲区大小
  59.         bootstrap.option(ChannelOption.SO_BACKLOG, NettyProperties.so_backlog);
  60.         // SO_SNDBUF发送缓冲区，SO_RCVBUF接收缓冲区，SO_KEEPALIVE开启心跳监测（保证连接有效）
  61.         bootstrap.option(ChannelOption.SO_SNDBUF, NettyProperties.so_sndbuf)
  62.             .option(ChannelOption.SO_RCVBUF, NettyProperties.so_rcvbuf)
  63.             .option(ChannelOption.SO_KEEPALIVE, true);
  64.     }
  67.     //netty服务启动的主要方法
  68.     public ChannelFuture doAccept(int port) throws InterruptedException{
  70.         bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
  72.             //tcp连接入口 默认重新initChannel方法
  73.             @Override
  74.             protected void initChannel(SocketChannel socketChannel) throws Exception {
  75.                 // 数据分隔符, 定义的数据分隔符一定是一个ByteBuf类型的数据对象。
  76.                 ByteBuf [] delimiters = new ByteBuf [2];
  77.                 delimiters[0] = Unpooled.copiedBuffer("\\r\\n".getBytes());
  78.                 delimiters[1] = Unpooled.copiedBuffer(NettyProperties.CARRIAGE_RETURN.getBytes());
  80.                 // 处理固定结束标记符号的Handler。这个Handler没有@Sharable注解修饰，
  81.                 // 必须每次初始化通道时创建一个新对象
  82.                 // 使用特殊符号分隔处理数据粘包问题，也要定义每个数据包最大长度。netty建议数据有最大长度。
  83.                 socketChannel.pipeline().addLast(new DelimiterBasedFrameDecoder(NettyProperties.maxFrameLength, true,true,delimiters));
  85.                 //字符串解码器Handler，会自动处理channelRead方法的msg参数，将ByteBuf类型的数据转换为字符串对象
  86.                 socketChannel.pipeline().addLast(new StringDecoder(Charset.forName("UTF-8")));
  88.                 // 定义一个定时断线处理器，当多长时间内，没有任何的可读取数据，自动断开连接。
  89.                 // 构造参数，就是间隔时长。 默认的单位是秒。
  90.                 // 自定义间隔时长单位。 new ReadTimeoutHandler(long times, TimeUnit unit);
  91.                 socketChannel.pipeline().addLast(new ReadTimeoutHandler(NettyProperties.readTimeout, TimeUnit.SECONDS));
  93.                 //ServerHandler 自定义的处理 netty服务器处理消息类 -- 注册，发送消息，接收消息都在这个类
  94.                 socketChannel.pipeline().addLast(new ServerHandler());
  95.             }
  96.         });
  97.         ChannelFuture future = bootstrap.bind(port).sync();
  98.         return future;
  99.     }
  101.     //线程组关闭方法
  102.     public void release(){
  103.         this.acceptorGroup.shutdownGracefully();
  104.         this.clientGroup.shutdownGracefully();
  105.     }
  108.     @PostConstruct
  109.     public void start(){
  111.         //加载参数
  112.         NettyProperties.init();
  114.         //使用1个线程启动netty服务
  115.         Thread thread = new Thread(new Runnable() {
  116.             @Override
  117.             public void run() {
  118.                 ChannelFuture future = null;
  119.                 ServerMain server = null;
  120.                 try{
  121.                     server = new ServerMain();
  123.                     future = server.doAccept(NettyProperties.port);
  124.                     logger.info("server started...");
  125.                     logger.info("启动成功");
  126.                     future.channel().closeFuture().sync();
  127.                 }catch(InterruptedException e){
  128.                     e.printStackTrace();
  129.                 }finally{
  130.                     if(null != future){
  131.                         try {
  132.                             future.channel().closeFuture().sync();
  133.                         } catch (InterruptedException e) {
  134.                             e.printStackTrace();
  135.                         }
  136.                     }
  137.                     //关闭启动类
  138.                     if(null != server){
  139.                         server.release();
  140.                     }
  141.                 }
  142.             }
  143.         });
  144.         thread.start();
  145.     }
  147. }

NettyProperties类

  1. package com.xiaomage.crm.netty;
  4. import java.util.function.Function;
  6. /**
  7.  * @version V1.0
  8.  * @Title: netty 配置信息
  9.  * @Description: //netty 配置信息
  10.  * @date: 2019/9/24 14:31
  11.  */
  13. public class NettyProperties {
  15.     public static int port=9999;            // 监听端口
  16.     public static int so_backlog=1024;      // 设定缓冲区大小/可链接数
  17.     public static int so_sndbuf=16*1024;    // SO_SNDBUF发送缓冲区
  18.     public static int so_rcvbuf=16*1024;    // SO_RCVBUF接收缓冲区
  19.     public static int maxFrameLength=1024;  // 每个数据包最大长度
  20.     public static int readTimeout=60;       // 定义一个定时断线处理器，当多长时间内，没有任何的可读取数据，自动断开连接(单位秒)
  21.     public static String CARRIAGE_RETURN="\r\n";       // 结束符
  22.     public static boolean loggerDebugger=false;
  24.     /**
  25.      * 初始化配置文件的参数
  26.      */
  27.     public static void init(){
  28.         Function<String, Integer> function = Integer::parseInt;
  30. //        读配置文件赋值
  31. //        port= function.apply(Global.getConfig("port"));
  32. //        so_backlog= function.apply(Global.getConfig("so_backlog"));
  33. //        so_sndbuf= function.apply(Global.getConfig("so_sndbuf"));
  34. //        so_rcvbuf= function.apply(Global.getConfig("so_rcvbuf"));
  35. //        maxFrameLength= function.apply(Global.getConfig("maxFrameLength"));
  36. //        readTimeout= function.apply(Global.getConfig("readTimeout"));
  37. //        CARRIAGE_RETURN= Global.getConfig("CARRIAGE_RETURN");
  38.     }
  41. }

NettyConfig类

  1. package com.xiaomage.crm.netty;
  4. import io.netty.channel.Channel;
  5. import io.netty.channel.ChannelId;
  6. import io.netty.channel.group.ChannelGroup;
  7. import io.netty.channel.group.DefaultChannelGroup;
  8. import io.netty.util.concurrent.GlobalEventExecutor;
  9. import org.springframework.util.StringUtils;
  11. import java.util.Map;
  12. import java.util.concurrent.ConcurrentHashMap;
  14. /**
  15.  * @version V1.0
  16.  * @Title: 存储整个工程的全局配置
  17.  */
  18. public class NettyConfig {
  21.     /**
  22.      * 存储每一个客户端接入进来时的channel对象
  23.      */
  24.     private static ChannelGroup group = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
  26.     public static boolean VcStart = false;
  28.     public static String VcContent = "sorry,is close!";
  29.     /**
  30.      * 认证通道,存储channel和相应客户端编号
  31.      * key:设备编号
  32.      * val:通道
  33.      */
  34.     private static Map<String, ChannelId> clientMap = new ConcurrentHashMap<>();
  36.     /**
  37.      * 未认证的通道
  38.      * key:Channel:通道
  39.      * val：链接时间
  40.      */
  41.     private static Map<Integer,Long> temporary_Channel = new ConcurrentHashMap<>();
  44.     /**
  45.      * 添加临时通道
  46.      * 自己的业务处理临时通道目的（将通道与自己的业务信息绑定）
  47.      */
  48.     public static void addTemporary_Channel(Channel channel){
  49.         temporary_Channel.put(channel.id().hashCode(),System.currentTimeMillis());
  50.         group.add(channel);
  51.     }
  52.     /**
  53.      * 判断当前通道是否未注册
  54.      */
  55.     public static boolean ChannelRegister(Channel channel){
  56.         return temporary_Channel.containsKey(channel.id().hashCode());
  57.     }
  58.     /**
  59.      * 添加删除临时通道
  60.      */
  61.     public static void removeTemporary_Channel(Channel channel){
  62.         temporary_Channel.remove(channel.id().hashCode());
  63.     }
  65.     /**
  66.      * 保存设备的编号和连接通道的关系
  67.      * @param channel
  68.      * @param ap
  69.      */
  70.     public static void addClient(Channel channel,String ap){
  71.         //已认证设备清除临时通道
  72.         removeTemporary_Channel(channel);
  73.         //存储已认证设备
  74.         clientMap.put(ap,channel.id());
  75.     }
  77.     /**
  78.      * 获取通道Channel
  79.      * @param ap 设备编号
  80.      * @return
  81.      */
  82.     public static Channel getClient(String ap){
  83.         ChannelId channelId=clientMap.get(ap);
  84.         if(channelId==null)
  85.             return null;
  86.         Channel Channel=group.find(channelId);
  87.         return Channel;
  88.     }
  89.     /**
  90.      * 获取所有通道ChannelAll
  91.      * @return
  92.      */
  93.     public static Map<String, ChannelId> getClientAll(){
  94.         return clientMap;
  95.     }
  98.     /**
  99.      * 清除通道
  100.      * @param channel 通道Channel
  101.      * @return
  102.      */
  103.     public static void removeClient(Channel channel){
  104.         ChannelId cur_channelId=channel.id();
  105.         String key=getChannelAp(cur_channelId);
  106.         if(!StringUtils.isEmpty(key)){
  107.             clientMap.remove(key);
  108.         }
  109.         group.remove(channel);
  110.     }
  112.     /**
  113.      * 根据通道信息获取设备编号
  114.      * @param channelid 通道
  115.      * @return
  116.      */
  117.     public static String getChannelAp(ChannelId channelid){
  118.         for (String key : clientMap.keySet()) {
  119.             ChannelId channelId=clientMap.get(key);
  120.             if(channelid.asLongText().equalsIgnoreCase(channelId.asLongText())){
  121.                 return key;
  122.             }
  123.         }
  124.         return null;
  125.     }
  130. }

3业务类

ExecuteService类

  1. package com.xiaomage.crm.netty;
  3. import com.alibaba.fastjson.JSONObject;
  4. import io.netty.channel.Channel;
  5. import org.springframework.stereotype.Service;
  7. /**
  8.  * @version V1.0
  9.  * @Title: 业务处理接口
  10.  * @Description: //业务处理接口
  11.  * @date: 2019/9/24 16:32
  12.  */
  13. @Service
  14. public class ExecuteService {
  15.     /**
  16.      * 当前接受的数据转换为json之后的数据
  17.      */
  18.     protected JSONObject jsonObject;
  19.     /**
  20.      * 设备编号
  21.      */
  22.     protected String deviceID;
  23.     /**
  24.      * 功能码编号
  25.      */
  26.     protected String T;
  27.     /**
  28.      * 本次连接是否合法或者数据是否合法,默认为不合法
  29.      */
  30.     protected boolean success;
  32.     /**
  33.      * 相应的业务处理
  34.      * @param mes 接收到的数据
  35.      * @return
  36.      */
  37.     public String handler(Channel channel, String mes){
  38.         this.success = false;
  39.         this.jsonObject = veriData(mes);
  40.         if(jsonObject==null){
  41.             //解析失败
  42.             return ReturnInfo.DownStatePackage(ReturnInfo.ERROR_ANALYSIS);
  43.         }
  44.         this.T = this.jsonObject.getString("T");
  45.         if(!"VV".equals(T)){
  46.             if(NettyConfig.ChannelRegister(channel)){
  47.                 //未注册
  48.                 return ReturnInfo.DownStatePackage(ReturnInfo.ERROR_REGISTER);
  49.             }
  50.         }
  51.         this.success = true;
  52.         return ReturnInfo.DownStatePackage(ReturnInfo.ERROR_UNKNOWN);
  53.     }
  55.     /**
  56.      * 验证接收到的数据是否正确
  57.      * @param data 接收到的JSON数据
  58.      * @return 返回JSONObject
  59.      */
  60.     public static JSONObject veriData(String data) {
  61.         JSONObject jsonObject=null;
  62.         //剔除空的在占位
  63.         data=data.trim();
  64.         try {
  65.             String tempData = data;
  66.             jsonObject = ((JSONObject) JSONObject.parse(tempData));
  67.         } catch (Exception e) {
  68.             System.out.println("convert JSONObject error:"+e.getMessage());
  69.         }
  70.         return jsonObject;
  71.     }
  74. }
  76. ReturnInfo类
  78. package com.xiaomage.crm.netty;
  81. import com.alibaba.fastjson.JSONObject;
  82. import io.netty.buffer.Unpooled;
  83. import io.netty.channel.Channel;
  84. import io.netty.channel.ChannelFuture;
  85. import org.slf4j.Logger;
  86. import org.slf4j.LoggerFactory;
  87. import java.io.UnsupportedEncodingException;
  88. import java.util.LinkedHashMap;
  90. /**
  91.  * @version V1.0
  92.  * @Title: 返回信息控制类
  93.  * @Description: //返回信息,以及描述返回状态码的信息
  94.  * @date: 2019/9/24 17:57
  95.  */
  96. public class ReturnInfo {
  97.     /**
  98.      * 解析失败
  99.      */
  100.     public static final int ERROR_ANALYSIS=0;
  101.     /**
  102.      * 接收成功
  103.      */
  104.     public static final int sussecs=1;
  105.     /**
  106.      * 接收成功，有反馈数据（只有一条）
  107.      */
  108.     public static final int sussecs2=2;
  109.     /**
  110.      * 接收成功，有反馈数据（多条）
  111.      */
  112.     public static final int sussecs3=3;
  113.     /**
  114.      * 未知异常
  115.      */
  116.     public static final int ERROR_UNKNOWN=-1;
  117.     /**
  118.      * 超时未通信
  119.      */
  120.     public static final int ERROR_OVERTIME=-2;
  121.     /**
  122.      * T不存在(T表示功能编号,例如V1、V2)
  123.      */
  124.     public static final int ERROR_T_IS_NOT_FOUND=-3;
  125.     /**
  126.      * 未注册
  127.      */
  128.     public static final int ERROR_REGISTER=-4;
  129.     /**
  130.      * L数据出错
  131.      */
  132.     public static final int ERROR_L=-5;
  133.     /**
  134.      * 查询固件不存在
  135.      */
  136.     public static final int ERROR_PACKAGE=-6;
  137.     /**
  138.      * 命令数据转换json对象失败
  139.      */
  140.     public static final int ERROR_CONVERTJSON=-7;
  143.     // 日志
  144.     protected static  Logger logger = LoggerFactory.getLogger(ReturnInfo.class);
  147.     /**
  148.      * 下行-结果包
  149.      * @param t 0:json解析失败  1：接收成功(且无数据下发,表心跳)  -4：通道未注册   -1：未知异常
  150.      * @return String 封装的结果内容
  151.      */
  152.     public static String DownStatePackage(int t){
  153.         LinkedHashMap linkHashMap = new LinkedHashMap();
  154.         linkHashMap.put("S", t);
  155.         JSONObject jsonObject = new JSONObject(linkHashMap);
  156.         String resultInfo = jsonObject.toJSONString();
  157.         return resultInfo;
  158.     }
  161.     /**
  162.      * 指定通道下发数据
  163.      * @param channel 通道
  164.      * @param msg 发送消息内容
  165.      */
  166.     public static ChannelFuture sendMsg(Channel channel, String msg){
  168.         //判断是否需要日志
  169.         if (NettyProperties.loggerDebugger) {
  170.             logger.info("sendMsg:"+ msg);
  171.         }
  172.         //统一添加结束符
  173.         msg = msg + NettyProperties.CARRIAGE_RETURN;
  174.         //发送并返回
  175.         return channel.writeAndFlush(Unpooled.copiedBuffer(getBytesStr(msg)));
  176.     }
  178.     /**
  179.      * 转换字符串为byte[]
  180.      * @param str 要发送的字符串内容
  181.      * @return byte[] 子节数组，异常返回null
  182.      */
  183.     private static byte[] getBytesStr(String str){
  184.         try {
  185.             return str.getBytes("UTF-8");
  186.         } catch (UnsupportedEncodingException e) {
  187.             logger.error("getBytesStr error:"+e.getMessage());
  188.         }
  189.         return null;
  190.     }
  192. }

其它业务类

  1. package com.xiaomage.crm.netty;
  3. import com.alibaba.fastjson.JSONObject;
  4. import io.netty.channel.Channel;
  5. import org.springframework.stereotype.Service;
  7. /**
  8.  * @version V1.0
  9.  * @Title: 通道注册 业务类
  10.  * @Description: //上行--通道注册
  11.  * @date: 2019/9/24 16:34
  12.  */
  13. @Service
  14. public class VV extends ExecuteService{
  16.     @Override
  17.     public String handler(Channel channel, String mes) {
  18.         String superres=super.handler(channel,mes);
  19.         if(!this.success)
  20.             return superres;
  21.         JSONObject jsonObject=this.jsonObject;
  22.         this.deviceID=jsonObject.get("U").toString();
  23. //        //添加通道并注册
  24.         NettyConfig.addClient(channel,deviceID);
  25.         return ReturnInfo.DownStatePackage(ReturnInfo.sussecs);
  26.     }
  29. }

与spring集成获取spring中bean的工具类

  1. package com.xiaomage.crm.taskQueue;
  3. import org.springframework.beans.BeansException;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.ApplicationContextAware;
  6. import org.springframework.lang.Nullable;
  7. import org.springframework.stereotype.Component;
  9. /**
  10.  * 获取spring的bean
  11.  */
  12. @Component
  13. public class SpringContextUtil implements ApplicationContextAware {
  14.     private static ApplicationContext applicationContext = null;
  16.     @Override
  17.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  18.         if (SpringContextUtil.applicationContext == null) {
  19.             SpringContextUtil.applicationContext = applicationContext;
  20.             //System.out.println( "========ApplicationContext配置成功,在普通类可以通过调用ToolSpring.getAppContext()获取applicationContext对象,applicationContext="+ applicationContext + "========");
  21.         }
  22.     }
  24.     public static ApplicationContext getApplicationContext() {
  25.         return applicationContext;
  26.     }
  28.     public static Object getBean(String name) {
  29.         return getApplicationContext().getBean(name);
  30.     }
  32.     public static <T>T getBean(Class<T> clazz) {
  33.         // TODO Auto-generated method stub
  34.         return getApplicationContext().getBean(clazz);
  35.     }
  37.     public static <T> T getBean(String var1, @Nullable Class<T> var2){
  38.         return applicationContext.getBean(var1, var2);
  39.     }
  41. }

发表评论

表情：
评论列表 （有 0 条评论，449人围观）

还没有评论，来说两句吧...

相关阅读

    相关 记一次 pandas 的使用

    这周在做一个平台测试的活，东西不难，开发加上测试原本打算两天搞定，结果直接干到了周五下午才交了活。中间的“曲折”过程就不一一赘述了，有个很深的感悟是：设计真的很重要！开发的最终

    妖狐艹你老母妖狐艹你老母/ 0 赞/ 251 阅读

    相关 记一次面试

        2019.7.16日  天气：暴热暴晒，撑着伞都顶不住...   今天去面试前端实习生，到公司后就直接开始写笔试题目，然后写完后，与面试官进行交谈，发现自己的一些不足，

    心已赠人心已赠人/ 0 赞/ 521 阅读

    相关 记一次netty的使用

    前言：笔者在项目中使用的netty的场景是这样的，（物联网公司）所有机柜使用长连接连接到服务器，而服务器使用的正好是netty，所以不得已笔者需要学习netty的一些知识，这里

    我不是女神ヾ我不是女神ヾ/ 0 赞/ 450 阅读