netty-学习笔记

零、socket：

http://haohaoxuexi.iteye.com/blog/1979837

一、NIO（1.0）非阻塞

• NIO的特点：
  1. Buffer，缓冲区
  2. Channel，管道
  3. Selector，多路复用选择器
• NIO的步骤：

二、AIO（NIO2.0）异步非阻塞

　　使用了异步的channel，调用jdk底层的回掉函数，异步处理。

三、什么是netty（基于NIO2.0）

　　 Netty is an asynchronous event-driven network application framework  for rapid development of maintainable high performance protocol servers & clients.

　　  Netty is a NIO client server framework which enables quick and easy development of network applications such as protocol servers and clients. It greatly simplifies and streamlines network programming such as TCP and UDP socket server.

四、为什么使用netty

　　远古：使用的是io，近代是nio，现在是netty（已经封装好了的，相对与nio，API更加的简单）

• netty的特点：

1. 责任链，和tomcat中的fitter类似（最后结果交给servlet）避免请求的发送者和接受者直接的耦合关系。
2. 异步

Netty的异步事件驱动模型主要涉及到下面几个核心的概念：

1. Channel：表示一个与socket关联的通道
2. ChannelPipeline： 管道，一个Channel拥有一个ChannelPipeline，ChannelPipeline维护着一个处理链（严格的说是两 个：upstream、downstream），处理链是由很多处理句柄ChannelHandler所构成，每个ChannelHandler处理完以 后会传递给链中的下一个处理句柄继续处理。
3. ChannelHandler：处理句柄，用户可以定义自己的处理句柄来处理每个请求，或发出请求前进行预处理，典型的有编码/解码器：decoder、encoder。
4. ChannelEvent：事件，是整个模型的处理对象，当产生或触发（fire）一个事件时，该事件会沿着ChannelPipeline处理链依次被处理。
5. ChannelFuture： 异步结果，这个是异步事件处理的关键，当一个事件被处理时，可以直接以ChannelFuture的形式直接返回，不用在当前操作中被阻塞。可以通过 ChannelFuture得到最终的执行结果，具体的做法是在ChannelFuture添加监听器listener，当操作最终被执行完 后，listener会被触发，我们可以在listener的回调函数中预定义我们的业务代码。

五、如何使用netty，netty的demo

1. 建立连接池
2. 继承netty父类实现方法

TimeServer

 package com.wanghongye.Netty;

 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.channel.ChannelFuture;
 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;

 /**
  * @Description ：netty服务端
  * @author ：王红叶
  * @date(创建日期)：2015年9月22日 下午5:15:22
  * @company(公司)：深圳市彩讯科技有限公司
  *
  * @History(修改历史):
  */
 public class TimeServer
 {

     public void bind(int port) throws Exception
     {
         EventLoopGroup bossGroup = new NioEventLoopGroup();
         EventLoopGroup workGroup = new NioEventLoopGroup();

         try
         {
             ServerBootstrap b = new ServerBootstrap();
             b.group(bossGroup, workGroup).channel(NioServerSocketChannel.class)
                 .option(ChannelOption.SO_BACKLOG, 1024).childHandler(new ChildChannelHandler());

             ChannelFuture f = b.bind(port).sync();

             f.channel().closeFuture().sync();
         }
         finally
         {
             bossGroup.shutdownGracefully();
             workGroup.shutdownGracefully();
         }
     }

     private class ChildChannelHandler extends ChannelInitializer<SocketChannel>{

         @Override
         protected void initChannel(SocketChannel arg0) throws Exception
         {
             arg0.pipeline().addLast(new TimeChannelHandler());
         }
     }

     public static void main(String[] args) throws Exception
     {
         int port = 8080;
         if(args != null && args.length>0){
             port = Integer.valueOf(args[0]);
         }
         new TimeServer().bind(port);
     }
 }

TimeChannelHandler

 package com.wanghongye.Netty;

 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelHandlerAdapter;
 import io.netty.channel.ChannelHandlerContext;

 /**
  * Netty处理类
  * @Description ：
  * @author ：王红叶
  * @date(创建日期)：2015年9月22日 下午4:54:06
  * @company(公司)：深圳市彩讯科技有限公司
  *
  * @History(修改历史):
  */
 public class TimeChannelHandler extends ChannelHandlerAdapter
 {
     public void channelRead(ChannelHandlerContext ctx, Object msg)
         throws Exception
     {
         ByteBuf byteBuf = (ByteBuf) msg;
         byte[] req = new byte[byteBuf.readableBytes()];
         byteBuf.readBytes(req);

         String body = new String(req, "UTF-8");
         System.out.println("*********" + body);
         String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new java.util.Date(
             System.currentTimeMillis()).toString() : "BAD　ORDER";
         ByteBuf byteBufReps = Unpooled.copiedBuffer(currentTime.getBytes());
         ctx.write(byteBufReps);

     }

     public void channelReadComplete(ChannelHandlerContext ctx)
     {
         ctx.close();
     }

     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
         throws Exception
     {
         ctx.close();
     }

 }

TimeClient

 package com.wanghongye.Netty;

 import io.netty.bootstrap.Bootstrap;
 import io.netty.channel.ChannelFuture;
 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.NioSocketChannel;

 /**
  * @Description ：netty的客户端
  * @author ：王红叶
  * @date(创建日期)：2015年9月22日 下午5:09:54
  * @company(公司)：深圳市彩讯科技有限公司
  *
  * @History(修改历史):
  */
 public class TimeClient
 {
     public void connet(int port, String host) throws Exception
     {
         EventLoopGroup group = new NioEventLoopGroup();
         try
         {
             Bootstrap bootstrap = new Bootstrap();
             bootstrap.group(group).channel(NioSocketChannel.class)
                 .option(ChannelOption.TCP_NODELAY, true)
                 .handler(new ChildChannelHandler());

             ChannelFuture f = bootstrap.connect(host, port).sync();
             f.channel().closeFuture().sync();
         }
         finally
         {
             group.shutdownGracefully();
         }
     }

     private class ChildChannelHandler extends ChannelInitializer<SocketChannel>
     {

         @Override
         protected void initChannel(SocketChannel arg0) throws Exception
         {
             arg0.pipeline().addLast(new TimeChannelClientHandler());
         }
     }

     public static void main(String[] args) throws Exception
     {
         int port = 8080;
         if (args != null && args.length > 0)
         {
             port = Integer.valueOf(args[0]);
         }
         new TimeClient().connet(port, "127.0.0.1");
     }
 }

TimeChannelClientHandler

 package com.wanghongye.Netty;

 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelHandlerAdapter;
 import io.netty.channel.ChannelHandlerContext;

 public class TimeChannelClientHandler extends ChannelHandlerAdapter
 {
     private final ByteBuf buf;

     public TimeChannelClientHandler()
     {
         byte[] req = "QUERY TIME ORDER".getBytes();
         buf = Unpooled.buffer(req.length);
         buf.writeBytes(req);
     }

     public void channelActive(ChannelHandlerContext ctx)
     {
         ctx.writeAndFlush(buf);
     }

     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception
     {
         ByteBuf byteBuf = (ByteBuf) msg;
         byte[] req = new byte[byteBuf.readableBytes()];
         byteBuf.readBytes(req);

         String body = new String(req, "UTF-8");
         System.out.println("###########" + body);
     }

     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
         throws Exception
     {
         ctx.close();
     }
 }

　　(NO RUN SUCCESS)

六、项目中如何使用netty

　　在pns（TCP是同步的）和统一配置中使用netty，主要使用了netty的异步和socket。

七、关于netty的资料

1. 《netty权威指南》
2. http://www.cnblogs.com/java-my-life/archive/2012/05/28/2516865.html
3. http://www.cnblogs.com/NanguoCoffee/archive/2010/12/10/1902491.html

八、netty的相关讨论

1. 为什么说netty是异步的？允许客户端最大的同时连接数：服务器有开放那么多文件句柄数 支持那么多长连接 只要服务器资源够就行，另外tomcat自己也会限制连接数。netty的异步体现在：1、服务端不持有连接，使用的是轮询的方法2、channel通道是异步的3、使用了channel future回调
2. netty如何编码解码，TCP自带了拆包粘包的功能，netty把他们封装好了，然后处理内容我们需要自己实现