先分享一下自己的经历。
去年7月进入新公司没多久,部门领导就给我分配了一个任务:给公司的一个户外设备写一个采集数据程序,将数据入库,然后做一个web端。因为领导是做.NET的,当时在来之前有和领导沟通过,领导的意思是希望来一个会网络编程和多线程,部门急需一个可以来做采集程序的java,我当时有点心虚,是这样回复领导:自己也只是有1年多java的工作,不会网络编程,自己搭一个简单的web项目架构还是可以应付的,我只能尽自己的最大的可能做好这件事。
后来进入公司后,做采集程序是一头雾水,自己之前只是做web的,对web项目的架构以及业务还是比较熟悉,但是关于和硬件之间的通讯还真的是从来都没有接触过。It is the first step that is troublesome。问过一些朋友,也百度过看过一些技术博客,有用socket 连接,多线程后加while死循环来接受做采集,后来慢慢发现用netty这种NIO网络应用框架比较合适。
接受就是熟悉一下具体的业务,户外设备会主动连接服务器IP,定时向服务器的指定端口发送报文。所以当前的采集程序结合netty的情况就是需要写一个netty的server端,来监听服务器本机的该指定端口,接受户外设备发送过来的报文即可,而不需要再写一个netty的client端。
首先说明一下,本项目应用的框架:springboot+netty+rabbitMq+mybatis+lombok+logback,数据库选用的是MYSQL。
开发环境:idea2018+jdk1.8+mysql5.6.35+maven3.5.3
接下来就是搭建项目:
1.idea快速创建springboot项目,在pom.xml文件中配置依赖包
<dependencies> <!--web模块starter依赖--> <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> <!-- netty依赖 springboot2.0自动导入版本--> <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> </dependency> <!--rabbitmq依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> <!--mybatis依赖--> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.3.2</version> </dependency> <!--mysql依赖--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency> <!--pagehelper 分页插件--> <dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper-spring-boot-starter</artifactId> <version>1.2.5</version> </dependency> <!--lombok 插件--> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.16.6</version> </dependency> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>RELEASE</version> <scope>compile</scope> </dependency> <!--编写更少量的代码:使用apache commons工具类库: https://www.cnblogs.com/ITtangtang/p/3966955.html--> <!--apache.commons.lang3--> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> </dependency> <!--你可以把这个工具看成是java.util的扩展--> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-collections4</artifactId> <version>${commons-collections4.version}</version> </dependency> <!--apache.codec:编码方法的工具类包 https://blog.csdn.net/u012881904/article/details/52767853--> <dependency> <groupId>commons-codec</groupId> <artifactId>commons-codec</artifactId> </dependency> </dependencies>
2.自定义netty的server端BootNettyServer类
package com.rtstjkx.jkxlistener.netty; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.AdaptiveRecvByteBufAllocator; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.nio.NioServerSocketChannel; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; /** * netty的server */ @Component @Slf4j public class BootNettyServer { @Autowired BootNettyInitializer bootNettyInitializer; public void run(int port) throws Exception { /** * 配置服务端的NIO线程组 * NioEventLoopGroup 是用来处理I/O操作的Reactor线程组 * bossGroup:用来接收进来的连接,workerGroup:用来处理已经被接收的连接,进行socketChannel的网络读写, * bossGroup接收到连接后就会把连接信息注册到workerGroup * workerGroup的EventLoopGroup默认的线程数是CPU核数的二倍 */ EventLoopGroup bossGroup = new NioEventLoopGroup(1); EventLoopGroup workerGroup = new NioEventLoopGroup(); try { /** * ServerBootstrap 是一个启动NIO服务的辅助启动类 */ ServerBootstrap serverBootstrap = new ServerBootstrap(); /** * 设置group,将bossGroup, workerGroup线程组传递到ServerBootstrap */ serverBootstrap = serverBootstrap.group(bossGroup, workerGroup); /** * ServerSocketChannel是以NIO的selector为基础进行实现的,用来接收新的连接,这里告诉Channel通过NioServerSocketChannel获取新的连接 */ serverBootstrap = serverBootstrap.channel(NioServerSocketChannel.class); /** * option是设置 bossGroup,childOption是设置workerGroup * netty 默认数据包传输大小为1024字节, 设置它可以自动调整下一次缓冲区建立时分配的空间大小,避免内存的浪费 最小 初始化 最大 (根据生产环境实际情况来定) * 使用对象池,重用缓冲区 */ serverBootstrap = serverBootstrap.option(ChannelOption.RCVBUF_ALLOCATOR, new AdaptiveRecvByteBufAllocator(64, 10496, 1048576)); serverBootstrap = serverBootstrap.childOption(ChannelOption.RCVBUF_ALLOCATOR, new AdaptiveRecvByteBufAllocator(64, 10496, 1048576)); System.out.println("正在监听8234端口中...."); /** * 设置 I/O处理类,主要用于网络I/O事件,记录日志,编码、解码消息 */ serverBootstrap = serverBootstrap.childHandler(bootNettyInitializer); /** * 绑定端口,同步等待成功 */ ChannelFuture f = serverBootstrap.bind(port).sync(); /** * 等待服务器监听端口关闭 */ f.channel().closeFuture().sync(); } catch (InterruptedException e) { } finally { /** * 退出,释放线程池资源 */ bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } } }
3.自定义初始化类BootNettyInitializer类
继承ChannelInitializer,实现initChannel方法,初始化信道时可以配置心跳、编码器、解码器、以及业务处理ChannelHandler类。
package com.rtstjkx.jkxlistener.netty; import com.rtstjkx.jkxlistener.netty.coder.MyDecoder; import io.netty.channel.Channel; import io.netty.channel.ChannelInitializer; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; /** * 通道初始化 * @param <SocketChannel> */ @Component public class BootNettyInitializer<SocketChannel> extends ChannelInitializer<Channel> { @Autowired BootNettyHandler bootNettyHandler; @Autowired MyDecoder myDecoder; @Override protected void initChannel(Channel ch) throws Exception { // ChannelOutboundHandler,依照逆序执行 ch.pipeline().addLast("decoder", myDecoder); ch.pipeline().addLast(bootNettyHandler); System.out.println("信道初始化中...."); } }
4.自定义业务处理类BootNettyHandler
package com.rtstjkx.jkxlistener.netty; import com.rtstjkx.jkxlistener.controller.OrderController; import com.rtstjkx.jkxlistener.entity.Order; import com.rtstjkx.jkxlistener.rabbitmq.RabbitProducer; import com.rtstjkx.jkxlistener.service.serviceImpl.OrderServiceImpl; import com.rtstjkx.jkxlistener.util.StringUtil; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.*; import io.netty.channel.socket.SocketChannel; import io.netty.handler.timeout.IdleStateEvent; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import java.io.IOException; import java.net.InetSocketAddress; import java.text.SimpleDateFormat; import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; import java.util.Date; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; /** * I/O数据读写处理类 */ @Component @ChannelHandler.Sharable @Slf4j public class BootNettyHandler extends ChannelInboundHandlerAdapter { // 将当前客户端连接 存入map 实现控制设备下发 参数 public static Map<String, Channel> ctxMap = new LinkedHashMap<String, Channel>(); /** * 从客户端收到新的数据时,这个方法会在收到消息时被调用 * * @param ctx * @param msg */ @Override public void channelRead(ChannelHandlerContext ctx, Object msg) { SocketChannel channel = (SocketChannel) ctx.channel(); ByteBuf buff = Unpooled.buffer();//netty需要用ByteBuf传输 //将字符串转成每两个字符加空格形式的字符串 7D 7D 21 3C C5 3B 0D 0D 7D 7D 25 3C String regex = "(.{2})"; String input = msg.toString().replaceAll(regex, "$1 ");
//将报文信息记录到日志中 log.info(channel.remoteAddress().getHostString() + ": " + input); System.out.println("服务端接受信息为: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + " 接收到消息:" + input); //具体的处理业务逻辑,解析报文帧结构,将数据入库 ...... } /** * 从客户端收到新的数据、读取完成时调用 * * @param ctx */ @Override public void channelReadComplete(ChannelHandlerContext ctx) { ctx.flush(); } /** * 当出现 Throwable 对象才会被调用,即当 Netty 由于 IO 错误或者处理器在处理事件时抛出的异常时 * * @param ctx * @param cause */ @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { System.out.println("程序异常,断开客户端连接"); //获取客户端的请求地址 取到的值为客户端的 ip+端口号 InetSocketAddress insocket = (InetSocketAddress) ctx.channel().remoteAddress(); String clientIp = insocket.getAddress().getHostAddress();//设备IP地址(个人将设备的IP地址当作 map 的key,channel对象做value) if(ctxMap.get(clientIp)!=null){//如果不为空就剔除 ctxMap.remove(clientIp, ctx.channel()); }else{//否则就将当前的设备ip+端口存进map 当做下发设备的标识的key } cause.printStackTrace(); ctx.close();//抛出异常,断开与客户端的连接 log.info(clientIp+"连接断开"); } /** * 客户端与服务端第一次建立连接时 执行 * * @param ctx * @throws Exception */ @Override public void channelActive(ChannelHandlerContext ctx) { InetSocketAddress insocket = (InetSocketAddress) ctx.channel().remoteAddress(); String clientIp = insocket.getAddress().getHostAddress(); if(ctxMap.get(clientIp)!=null){//如果不为空就不存 }else{//否则就将当前的设备ip+端口存进map 当做下发设备的标识的key ctxMap.put(clientIp, ctx.channel()); } log.info(clientIp+"连接"); } /** * 客户端与服务端 断连时 执行 * * @param ctx * @throws Exception */ @Override public void channelInactive(ChannelHandlerContext ctx) throws Exception { super.channelInactive(ctx); InetSocketAddress insocket = (InetSocketAddress) ctx.channel().remoteAddress(); String clientIp = insocket.getAddress().getHostAddress(); if(ctxMap.get(clientIp)!=null){//如果不为空就剔除 ctxMap.remove(clientIp, ctx.channel()); }else{//否则就将当前的设备ip+端口存进map 当做下发设备的标识的key } ctx.close(); //断开连接时,必须关闭,否则造成资源浪费,并发量很大情况下可能造成宕机 log.info(clientIp+"断开"); } /** * 服务端当read超时, 会调用这个方法 * * @param ctx * @param evt * @throws Exception */ @Override public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception, IOException { if (evt instanceof IdleStateEvent) { IdleStateEvent event = (IdleStateEvent) evt; String eventType = null; switch (event.state()) { case READER_IDLE: eventType = "读空闲"; break; case WRITER_IDLE: eventType = "些空闲"; break; case ALL_IDLE: eventType = "读写空闲"; break; default: } String date = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")); log.info(date + " " + ctx.channel().remoteAddress() + " " + eventType); } } }
回到开始位置,自定义netty的server端BootNettyServer类该如何启动?
我的方案是在application启动类中来启动。
application类实现CommandLineRunner,来启动nettyserver服务
package com.rtstjkx.jkxlistener; import com.rtstjkx.jkxlistener.netty.BootNettyServer; import org.mybatis.spring.annotation.MapperScan; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.CommandLineRunner; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @MapperScan("com.rtstjkx.jkxlistener.repository") @SpringBootApplication public class KjxApplication implements CommandLineRunner { @Value("${netty.port}") private Integer port; @Autowired BootNettyServer bootNettyServer; public static void main(String[] args) throws Exception { SpringApplication.run(KjxApplication.class, args); } @Override public void run(String... args) throws Exception { /** * 启动netty服务端服务 */ bootNettyServer.run(port); } }
至此,采集程序完成。
此程序仅个人学习理解后完成,如有不足的地方,还请进一步多多给出指导,thank you !!!