Java网络编程（9） - Netty怎么做数据通信？Netty的心跳检测怎么实现？Netty怎么用Http协议通信？

Netty实际案例的考虑 – 数据通信实现

      1、长链接：使用长链接通道不断开的形式进行通信，也就是Server和Client的通道一直处于开启状态，如果服务器性能足够好，并且我们的客户端数据也比较少的情况下，可以使用这种。

      2、一次性批量提交数据：这是采用短链接方式，也就是会把数据保存在本地临时缓冲区或者临时表里，当达到临界值时，进行一次性批量提交，又或者根据定时任务轮询提交，这种情况的弊端是做不到实时性传输，在对实时性不高的应用程序可以使用这种。

      3、特殊的长链接：在指定的某一时间内，服务器与某些客户端没有任何通信，则断开连接。下次连接则客户端向服务端发送数据的时候，再次建立连接，但这种需要考虑两个因素。

一是在超时时，服务端和客户端没有任何通信后关闭通道？关闭通道后又如何再次建立连接？

      二是客户端宕机时，无需考虑，下次客户端重启之后就可以与服务器建立连接，但是服务器宕机时，客户端如何与服务器进行链接？

import org.jboss.marshalling.MarshallerFactory; import org.jboss.marshalling.Marshalling; import org.jboss.marshalling.MarshallingConfiguration;   import io.netty.handler.codec.marshalling.DefaultMarshallerProvider; import io.netty.handler.codec.marshalling.DefaultUnmarshallerProvider; import io.netty.handler.codec.marshalling.MarshallerProvider; import io.netty.handler.codec.marshalling.MarshallingDecoder; import io.netty.handler.codec.marshalling.MarshallingEncoder;   /**  * 序列化编解码器：  * JBoss：Marshalling  * Google：Protobuf  * 基于Protobuf：Kyro  * MessagePack框架  */ public class N06MarshallingDecoderEncoderUtils {       public final static String TAG = "serial";         /**      * 解码器：将二进制序列化为java对象      */     public static MarshallingDecoder buildDecoder() {          //通过Marshalling工具类获取到实例对象，serial标识创建的是java的序列化工厂对象          MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory(TAG);                   //创建MarshallingConfiguration对象，并配置版本号          MarshallingConfiguration marshallingConfiguration = new MarshallingConfiguration();          marshallingConfiguration.setVersion(5);                   //创建Provider          DefaultUnmarshallerProvider provider = new DefaultUnmarshallerProvider(marshallerFactory, marshallingConfiguration);                   //构建Netty的解码对象，并配置provider和单个消息序列化的最大长度         return new MarshallingDecoder(provider, 1024 * 1024);     }         /**      * 编码器：将对象序列化为二进制数组      */     public static MarshallingEncoder buildEncoder() {          //序列化java工厂类          MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory(TAG);                   //创建配置类          MarshallingConfiguration marshallingConfiguration = new MarshallingConfiguration();          marshallingConfiguration.setVersion(5);                   //创建供应者          MarshallerProvider provider = new DefaultMarshallerProvider(marshallerFactory, marshallingConfiguration);                   //构建Netty的MarshallingEncoder对象          MarshallingEncoder marshallingEncoder = new MarshallingEncoder(provider);          return marshallingEncoder;     } }

import java.io.Serializable;   /**  * 请求数据  */ public class N06Request implements Serializable {       private static final long serialVersionUID = -7633763905125419996L;       private String data;       public String getData() {          return data;     }       public void setData(String data) {          this.data = data;     }

import java.io.Serializable;   /**  * 响应数据  */ public class N06Response implements Serializable {       private static final long serialVersionUID = -6704864849770619898L;       private String data;       public String getData() {          return data;     }       public void setData(String data) {          this.data = data;     } }

import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelFutureListener; import io.netty.channel.ChannelHandlerAdapter; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import io.netty.handler.logging.LogLevel; import io.netty.handler.logging.LoggingHandler; import io.netty.handler.timeout.ReadTimeoutHandler;   /**  * 案例：数据通信服务端  */ public class N06DataCommunicationServer {     public static void main(String[] args) throws Exception {          //连接和传输数据          EventLoopGroup connectEventLoopGroup = new NioEventLoopGroup();          EventLoopGroup dataEventLoopGroup = new NioEventLoopGroup();                   //启动类          ServerBootstrap serverBootstrap = new ServerBootstrap();          serverBootstrap.group(connectEventLoopGroup, dataEventLoopGroup) //绑定                           .channel(NioServerSocketChannel.class) //模式                           .option(ChannelOption.SO_BACKLOG, 1024) //TCP缓冲                           .handler(new LoggingHandler(LogLevel.INFO)) //日志                           .childHandler(new ChannelInitializer() { //初始化                                @Override                                protected void initChannel(SocketChannel ch) throws Exception {                                    //编解码器                                    ch.pipeline().addLast(N06MarshallingDecoderEncoderUtils.buildDecoder());                                    ch.pipeline().addLast(N06MarshallingDecoderEncoderUtils.buildEncoder());                                                                       //读取超时                                    ch.pipeline().addLast(new ReadTimeoutHandler(5));                                                                       //处理类                                    ch.pipeline().addLast(new DataCommunicationServerHandler());                                }                           });                   //通道          ChannelFuture channelFuture = serverBootstrap.bind(1111).sync();          channelFuture.channel().closeFuture().sync();                   //关闭          connectEventLoopGroup.shutdownGracefully();          dataEventLoopGroup.shutdownGracefully();              } } class DataCommunicationServerHandler extends ChannelHandlerAdapter {         @Override     public void channelActive(ChannelHandlerContext ctx) throws Exception {          System.out.println("Server Active");     }         @Override     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {          //已经设置了编解码器          N06Request request = (N06Request) msg;          System.out.println("Server：" + request.getData());                   //响应          N06Response response = new N06Response();          response.setData("Hi Client!");          ctx.writeAndFlush(response)              //模拟关闭链接，客户端重新链接              .addListener(ChannelFutureListener.CLOSE);     }         @Override     public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {          System.out.println("Server Read Complete");     }         @Override     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {          cause.printStackTrace();     } }

import io.netty.bootstrap.Bootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelHandlerAdapter; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInitializer; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioSocketChannel; import io.netty.handler.logging.LogLevel; import io.netty.handler.logging.LoggingHandler; import io.netty.handler.timeout.ReadTimeoutHandler; import io.netty.util.ReferenceCountUtil;   /**  * 案例：数据通信客户端  */ public class N06DataCommunicationClient {     public static void main(String[] args) throws InterruptedException {          //创建链接          DataCommunicationClient dataCommunicationClient = new DataCommunicationClient();          ChannelFuture channelFuture = dataCommunicationClient.getChannelFuture();                   //写出数据          N06Request request = new N06Request();          request.setData("Hi，Server!");          channelFuture.channel().writeAndFlush(request);                   channelFuture.channel().closeFuture().sync();                            //在服务端开启，写完数据就断开，模拟重连的过程          //获取连接          ChannelFuture channelFuture2 =     dataCommunicationClient.getChannelFuture();          System.out.println(channelFuture2.channel().isActive());          System.out.println(channelFuture2.channel().isOpen());                   //再次发送数据          request = new N06Request();          request.setData("Hi，Server2222222!");          channelFuture2.channel().writeAndFlush(request);          channelFuture2.channel().closeFuture().sync();                   System.out.println("结束");     } } class DataCommunicationClient {         private EventLoopGroup eventLoopGroup;     private Bootstrap bootstrap;     private ChannelFuture channelFuture;         /**      * 创建实例时，就初始化启动类      */     public DataCommunicationClient () {          //创建链接          this.eventLoopGroup = new NioEventLoopGroup();                   //启动类          this.bootstrap = new Bootstrap();          this.bootstrap.group(eventLoopGroup) //绑定                           .channel(NioSocketChannel.class) //模式                           .handler(new LoggingHandler(LogLevel.INFO)) //日志                           .handler(new ChannelInitializer() {                                @Override                                protected void initChannel(SocketChannel ch) throws Exception {                                    //编解码器                                    ch.pipeline().addLast(N06MarshallingDecoderEncoderUtils.buildDecoder());                                    ch.pipeline().addLast(N06MarshallingDecoderEncoderUtils.buildEncoder());                                                                       //超时                                    ch.pipeline().addLast(new ReadTimeoutHandler(5));                                                                       //数据处理类                                    ch.pipeline().addLast(new DataCommunicationClientHandler());                                }                           });     }         /**      * 建立链接      */     public void connect() {          try {              this.channelFuture = bootstrap.connect("127.0.0.1", 1111).sync();              System.out.println("链接建立成功！");          } catch (InterruptedException e) {              e.printStackTrace();          }     }         /**      * 获取连接      */     public ChannelFuture getChannelFuture() {          //为空就继续获取连接          if(null == this.channelFuture) {              this.connect();          }          //继续获取连接          if (!this.channelFuture.channel().isActive()) {              this.connect();          }          return channelFuture;     } } class DataCommunicationClientHandler extends ChannelHandlerAdapter {         @Override     public void channelActive(ChannelHandlerContext ctx) throws Exception {          System.out.println("Client Active");     }         @Override     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {          try {              N06Response response = (N06Response) msg;              System.out.println("Client：" + response);          } finally {              ReferenceCountUtil.release(msg);          }     }         @Override     public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {          System.out.println("Client Read Complete");     }         @Override     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {          cause.printStackTrace();     } }

 

Netty实际案例– 心跳检测实现

      使用Socket通信一般会处理多个服务器之间的心跳检测，一般来讲去维护一个服务器集群，肯定要有一台或几台服务器的Master，然后由多态Slave，那么Master肯定时时刻刻知道自己下面的Slave服务器的各种情况，然后进行实时监控的功能，在分布式框架里叫作心跳检测或心跳监控，最佳处理方案就是使用一些通信框架去实现。

import org.jboss.marshalling.MarshallerFactory; import org.jboss.marshalling.Marshalling; import org.jboss.marshalling.MarshallingConfiguration;   import io.netty.handler.codec.marshalling.DefaultMarshallerProvider; import io.netty.handler.codec.marshalling.DefaultUnmarshallerProvider; import io.netty.handler.codec.marshalling.MarshallerProvider; import io.netty.handler.codec.marshalling.MarshallingDecoder; import io.netty.handler.codec.marshalling.MarshallingEncoder;   /**  * 序列化编解码器：  * JBoss：Marshalling  * Google：Protobuf  * 基于Protobuf：Kyro  * MessagePack框架  */ public class N07MarshallingDecoderEncoderUtils {       public final static String TAG = "serial";         /**      * 解码器：将二进制序列化为java对象      */     public static MarshallingDecoder buildDecoder() {          //通过Marshalling工具类获取到实例对象，serial标识创建的是java的序列化工厂对象          MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory(TAG);                   //创建MarshallingConfiguration对象，并配置版本号          MarshallingConfiguration marshallingConfiguration = new MarshallingConfiguration();          marshallingConfiguration.setVersion(5);                   //创建Provider          DefaultUnmarshallerProvider provider = new DefaultUnmarshallerProvider(marshallerFactory, marshallingConfiguration);                   //构建Netty的解码对象，并配置provider和单个消息序列化的最大长度          return new MarshallingDecoder(provider, 1024 * 1024);     }         /**      * 编码器：将对象序列化为二进制数组      */     public static MarshallingEncoder buildEncoder() {          //序列化java工厂类          MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory(TAG);                   //创建配置类          MarshallingConfiguration marshallingConfiguration = new MarshallingConfiguration();          marshallingConfiguration.setVersion(5);                   //创建供应者          MarshallerProvider provider = new DefaultMarshallerProvider(marshallerFactory, marshallingConfiguration);                   //构建Netty的MarshallingEncoder对象          MarshallingEncoder marshallingEncoder = new MarshallingEncoder(provider);          return marshallingEncoder;     } }

import java.io.Serializable;   /**  * 请求数据  */ public class N07Request implements Serializable {       private static final long serialVersionUID = -7633763905125419996L;       private String data;       public String getData() {          return data;     }       public void setData(String data) {          this.data = data;     } }

import java.io.Serializable;   /**  * 响应数据  */ public class N07Response implements Serializable {       private static final long serialVersionUID = -6704864849770619898L;       private String data;       public String getData() {          return data;     }       public void setData(String data) {          this.data = data;     }       @Override     public String toString() {          return "Response [data=" + data + "]";     } }

import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelHandlerAdapter; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import io.netty.handler.logging.LogLevel; import io.netty.handler.logging.LoggingHandler;   /**  * 案例：心跳检测服务端  */ public class N07HeartbeatServer {     public static void main(String[] args) throws Exception {          //链接和传数据          EventLoopGroup connectEventLoopGroup = new NioEventLoopGroup();          EventLoopGroup dataEventLoopGroup = new NioEventLoopGroup();                   //启动类          ServerBootstrap serverBootstrap = new ServerBootstrap();          serverBootstrap.group(connectEventLoopGroup, dataEventLoopGroup) //绑定                           .channel(NioServerSocketChannel.class) //模式                           .option(ChannelOption.SO_BACKLOG, 1024) //TCP缓冲区                           .handler(new LoggingHandler(LogLevel.INFO)) //日志                            .childHandler(new ChannelInitializer() {                                @Override                                protected void initChannel(SocketChannel ch) throws Exception {                                    //编解码器                                    ch.pipeline().addLast(N07MarshallingDecoderEncoderUtils.buildDecoder());                                    ch.pipeline().addLast(N07MarshallingDecoderEncoderUtils.buildEncoder());                                                                       //处理类                                    ch.pipeline().addLast(new HeartbeatServerHandler());                                }                           });            System.out.println("服务端启动......");                   //绑定端口          ChannelFuture channelFuture = serverBootstrap.bind(1111).sync();          channelFuture.channel().closeFuture().sync();                   //关闭          connectEventLoopGroup.shutdownGracefully();          dataEventLoopGroup.shutdownGracefully();     } } class HeartbeatServerHandler extends ChannelHandlerAdapter {         private static final String KEY = "111111122222233333333";         /**      * 认证      */     private boolean auth(ChannelHandlerContext ctx, Object msg) throws Exception {          System.out.println("进入数据验证.......");          String data = (String)msg;          if (KEY.equals(data)) {              ctx.writeAndFlush("success");              return true;          }          ctx.writeAndFlush("failure"); //       ctx.writeAndFlush("failure").addListener(ChannelFutureListener.CLOSE);          return true;     }         @Override     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {          //认证          if (msg instanceof String) {              boolean auth = auth(ctx, msg);              System.out.println("验证结果：" + auth);          //心跳数据          } else if(msg instanceof N07Request) {              N07Request request = (N07Request) msg;              System.out.println("Server：" + request.getData());              ctx.writeAndFlush("收到状态数据"); //           ctx.writeAndFlush("收到状态数据").addListener(ChannelFutureListener.CLOSE);                   }else {              ctx.writeAndFlush("failure"); //           ctx.writeAndFlush("failure").addListener(ChannelFutureListener.CLOSE);          }     } }

import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit;   import io.netty.bootstrap.Bootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelHandlerAdapter; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInitializer; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioSocketChannel; import io.netty.util.ReferenceCountUtil;   /**  * 案例：心跳检测客户端  */ public class N07HeartbeatClient {     public static void main(String[] args) throws Exception {          //创建链接          EventLoopGroup eventLoopGroup = new NioEventLoopGroup();                   //启动          Bootstrap bootstrap = new Bootstrap();          bootstrap.group(eventLoopGroup) //绑定                       .channel(NioSocketChannel.class) //模式                       .handler(new ChannelInitializer() { //初始化                           @Override                           protected void initChannel(SocketChannel ch) throws Exception {                                //编解码器                               ch.pipeline().addLast(N07MarshallingDecoderEncoderUtils.buildDecoder());                               ch.pipeline().addLast(N07MarshallingDecoderEncoderUtils.buildEncoder());                                                               //处理器                                ch.pipeline().addLast(new HeartbeatClientHandler());                           }                       });                   //链接          ChannelFuture channelFuture = bootstrap.connect("127.0.0.1",1111).sync();          channelFuture.channel().closeFuture().sync();                   //关闭          eventLoopGroup.shutdownGracefully();     } } class HeartbeatClientHandler extends ChannelHandlerAdapter {         private ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);         private static final String KEY = "111111122222233333333";         @Override     public void channelActive(ChannelHandlerContext ctx) throws Exception {          System.out.println("客户端启动去验证...");          //通道启用时，就去链接          ctx.writeAndFlush(KEY);     }         @Override     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {          try {              System.out.println("客户端读取回传的数据...");              if (msg instanceof String) {                   //认证成功，发送心跳数据                   if("success".equals(msg)) {                       //延迟2秒发送，测试时，要注意，Server端设置了关闭（ChannelFutureListener.CLOSE）                       this.scheduledExecutorService.scheduleWithFixedDelay(new HeartbeatRun(ctx), 0, 2, TimeUnit.SECONDS);                   }                   System.out.println("Client：" + msg);              }else {                   System.out.println("Client：Other - " + msg);              }                       } finally {              ReferenceCountUtil.release(msg);          }     } } class HeartbeatRun implements Runnable {         private ChannelHandlerContext ctx;         public HeartbeatRun(ChannelHandlerContext ctx) {          super();          this.ctx = ctx;     }       @Override     public void run() {          //发送机器数据 //       Sigar sigar = new Sigar();          try { //           CpuPerc cpuPerc = sigar.getCpuPerc();              N07Request request = new N07Request(); //           request.setData("Cpu使用率：" + cpuPerc.getUser());              request.setData("Cpu使用率：88%");              ctx.writeAndFlush(request);          } catch (Exception e) {              e.printStackTrace();          }     } }

 

Netty使用Http协议通信案例，并实现文件服务器案例

      Http协议是超文本协议，是建立在TCP传输协议之上的应用层协议，目前主流是针对WEB开发，Http的应用非常广泛。其中Netty的Http协议也是一部非阻塞的。

 

Http特点

      简单：客户端请求服务器只需要携带指定的URL和携带必要的参数即可。

      灵活：Http协议允许传输任意类型的数据对象，传输内容由Http消息头中的Content-Type加以标记。

      无状态：协议对事务处理是没有记录能力的，如果后续处理需要之前的信息，必须重新获取，侧面显示出Http的轻量级、敏捷、负载轻。

      组成部分：请求头、请求行、请求正文。

      请求方式：Get（获取）、Post（附加新的提交数据）、Head（请求获取由请求URI标识的资源的响应消息头）、Put（新增）、Delete（删除）、Trace（测试和诊断）、Connect（保留未来）、Options（查询服务器性能）

      状态码：分类为1、2、3、4、5。

/**  * 案例 - Netty使用Http协议，也可基于SSL的链接访问  */ public class N08HttpRequestServer {       //SSL     static SslContext sslContext = null;         public static void main(String[] args) throws Exception {                   //SSL          boolean ssl = null != System.getProperty("ssl");                   //端口配置，SSL的端口不一样          int port = Integer.parseInt(System.getProperty("port",ssl? "8443" : "8080"));                   //SSL配置          if (ssl) {              SelfSignedCertificate selfSignedCertificate = new SelfSignedCertificate();              sslContext = SslContext.newServerContext(selfSignedCertificate.certificate(), selfSignedCertificate.privateKey());          }                   //配置链接和传输数据          EventLoopGroup connectEventLoopGroup = new NioEventLoopGroup();          EventLoopGroup dataEventLoopGroup = new NioEventLoopGroup();                   //启动类          ServerBootstrap serverBootstrap = new ServerBootstrap();          serverBootstrap.group(connectEventLoopGroup,dataEventLoopGroup) //绑定                           .option(ChannelOption.SO_BACKLOG, 1024)                           .channel(NioServerSocketChannel.class) //模式                           .handler(new LoggingHandler(LogLevel.INFO)) //日志                           .childHandler(new ChannelInitializer() {                                @Override                                protected void initChannel(SocketChannel ch) throws Exception {                                    //SSL配置                                    if(null != sslContext) {                                        ch.pipeline().addLast(sslContext.newHandler(ch.alloc()));                                    }                                                                       //编解码器                                    ch.pipeline().addLast(new HttpServerCodec());                                                                       //数据处理类                                    ch.pipeline().addLast(new HttpRequestServerHandler());                                }                           });              //启动          ChannelFuture channelFuture = serverBootstrap.bind(port).sync();          System.out.println("浏览器访问：http://127.0.0.1:8080/");          channelFuture.channel().closeFuture().sync();                   //关闭          connectEventLoopGroup.shutdownGracefully();          dataEventLoopGroup.shutdownGracefully();     } } class HttpRequestServerHandler extends ChannelHandlerAdapter {         /**      * 响应内容      */     private static final byte[] CONTENT = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'};         @Override     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {          //请求是Http的请求          if (msg instanceof HttpRequest) {              //编解码器已设置              HttpRequest httpRequest = (HttpRequest) msg;                           if(HttpHeaderUtil.is100ContinueExpected(httpRequest)) {                   ctx.writeAndFlush(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE));              }                           //响应数据              DefaultFullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK,Unpooled.wrappedBuffer(CONTENT));              response.headers().set(HttpHeaderNames.CONTENT_TYPE,"text/plain");              response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH,response.content().readableBytes());                           //是否活跃的响应              boolean keepAlive = HttpHeaderUtil.isKeepAlive(httpRequest);              if (!keepAlive) {                   ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);                           }else {                   response.headers().set(HttpHeaderNames.CONNECTION,HttpHeaderValues.KEEP_ALIVE);                   ctx.writeAndFlush(response);              }          }     } }

 

Http文件服务器案例

      Netty的Http协议栈从性能和可靠性都比较优异，非常适合Web容器场景下应用，相比于传统的Tomcat、Jetty等Web容器更加轻量级，灵活性和定制型也更好。

import java.io.File; import java.io.RandomAccessFile;   import javax.activation.MimetypesFileTypeMap;   import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelFutureListener; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelProgressiveFuture; import io.netty.channel.ChannelProgressiveFutureListener; import io.netty.channel.EventLoopGroup; import io.netty.channel.SimpleChannelInboundHandler; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import io.netty.handler.codec.http.DefaultHttpResponse; import io.netty.handler.codec.http.FullHttpRequest; import io.netty.handler.codec.http.HttpHeaderNames; import io.netty.handler.codec.http.HttpHeaderUtil; import io.netty.handler.codec.http.HttpHeaderValues; import io.netty.handler.codec.http.HttpObjectAggregator; import io.netty.handler.codec.http.HttpRequestDecoder; import io.netty.handler.codec.http.HttpResponseEncoder; import io.netty.handler.codec.http.HttpResponseStatus; import io.netty.handler.codec.http.HttpVersion; import io.netty.handler.codec.http.LastHttpContent; import io.netty.handler.stream.ChunkedFile; import io.netty.handler.stream.ChunkedWriteHandler;   /**  * 案例 - 文件服务器，Http下载文件，并实时监控  */ public class N09HttpDownloadFileServer {     public static void main(String[] args) throws Exception {                   String url = "/sources/";                   //链接和数据处理          EventLoopGroup connectEventLoopGroup = new NioEventLoopGroup();          EventLoopGroup dataEventLoopGroup = new NioEventLoopGroup();                   //启动类          ServerBootstrap serverBootstrap = new ServerBootstrap();          serverBootstrap.group(connectEventLoopGroup, dataEventLoopGroup) //绑定                           .channel(NioServerSocketChannel.class) //模式                           .childHandler(new ChannelInitializer() { //初始化                                @Override                                protected void initChannel(SocketChannel ch) throws Exception {                                    //编解码器，请求解码，响应编码                                    ch.pipeline().addLast("http-decoder", new HttpRequestDecoder());                                    ch.pipeline().addLast("http-encoder", new HttpResponseEncoder());                                                                       //多个消息转为单一的FullHttpRequest或FullHttpResponse                                    ch.pipeline().addLast("http-aggregator",new HttpObjectAggregator(65535));                                                                       //支持异步发送码流，用于支持大文件传输，但不占用过多的内存，防止java内存溢出                                     ch.pipeline().addLast("http-chunked",new ChunkedWriteHandler());                                                                       //自定义文件服务器业务处理                                    ch.pipeline().addLast("fileServerHandler",new HttpDownloadFileServerHandler(url));                                }                           });                   //绑定端口          ChannelFuture channelFuture = serverBootstrap.bind("127.0.0.1",1111).sync();          System.out.println("访问地址：http://127.0.0.1:1111" + url);          System.out.println("下载地址：http://127.0.0.1:1111" + url + "2.png");          channelFuture.channel().closeFuture().sync();                   //关闭          connectEventLoopGroup.shutdownGracefully();          dataEventLoopGroup.shutdownGracefully();     } } class HttpDownloadFileServerHandler extends SimpleChannelInboundHandler {         //访问地址     private String url;         public HttpDownloadFileServerHandler(String url) {          this.url = url;     }       @Override     protected void messageReceived(ChannelHandlerContext ctx, FullHttpRequest msg) throws Exception {          //获取请求的uri路径          String uri = msg.uri();                   //正常的话，要校验请求、校验uri、校验文件或文件夹等等                   //拼接文件地址          String path = System.getProperty("user.dir") + File.separator + uri;          System.out.println("请求的路径：" + path);                   //随机文件读写类，只读的方式          RandomAccessFile randomAccessFile = null;          try {              randomAccessFile = new RandomAccessFile(new File(path), "r");          } catch (Exception e) {              e.printStackTrace();          }                   //响应数据          DefaultHttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);          //响应信息          HttpHeaderUtil.setContentLength(response, randomAccessFile.length());          //响应头          response.headers().set(HttpHeaderNames.CONTENT_TYPE,new MimetypesFileTypeMap().getContentType(path));          //是否一直保持连接          if (HttpHeaderUtil.isKeepAlive(msg)) {              response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);          }          //写出          ctx.write(response);                   //构建文件发送线程，将文件写入到Chunked缓冲区          ChannelFuture channelFuture = ctx.write(new ChunkedFile(randomAccessFile,0,randomAccessFile.length(),8192),ctx.newProgressivePromise());          //监听传输文件          channelFuture.addListener(new ChannelProgressiveFutureListener() {              @Override              public void operationProgressed(ChannelProgressiveFuture future, long progress, long total) throws Exception {                   if (total < 0) {                       System.out.println("传输进展：" + progress);                   }else {                       System.out.println("传输进展：" + progress + " / " + total);                   }              }              @Override              public void operationComplete(ChannelProgressiveFuture future) throws Exception {                   System.out.println("传输结束！");              }          });          //如果使用Chunked编码，需要发送一个编码结束的看空消息体进行标记，表示所有消息体已经成功发送          ChannelFuture lastChannelFuture = ctx.write(LastHttpContent.EMPTY_LAST_CONTENT);          //刷出缓存          ctx.flush();          if (!HttpHeaderUtil.isKeepAlive(msg)) {              lastChannelFuture.addListener(ChannelFutureListener.CLOSE);          }                   System.out.println("处理完成");     } }