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;
/**
 * @FileName TimeClient.java
 * @Description: 
 *
 * @Date 2016年3月2日 
 * @author Administroter
 * @version 1.0
 * 
 */
public class TimeClient {
 public void connect(int port, String host) throws Exception {
  // 配置客户端NIO线程组
  EventLoopGroup group = new NioEventLoopGroup();
  try {
   //客户端辅助启动类
      Bootstrap b = new Bootstrap();
      b.group(group).channel(NioSocketChannel.class)
       .option(ChannelOption.TCP_NODELAY, true)
       .handler(new ChannelInitializer<SocketChannel>() {
    public void initChannel(SocketChannel ch)
     throws Exception {
        ch.pipeline().addLast(new TimeClientHandler());
    }
       });
      // 发起异步连接操作
      ChannelFuture f = b.connect(host, port).sync();
      // 当代客户端链路关闭
      f.channel().closeFuture().sync();
  } finally {
      // 优雅退出，释放NIO线程组
      group.shutdownGracefully();
  }
     }
     /**
      * @param args
      * @throws Exception
      */
     public static void main(String[] args) throws Exception {
  int port = 8080;
  if (args != null && args.length > 0) {
      try {
   port = Integer.valueOf(args[0]);
      } catch (NumberFormatException e) {
   // 采用默认值
      }
  }
  new TimeClient().connect(port, "127.0.0.1");
     }
}

import java.util.logging.Logger;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
/**
 * @FileName TimeClientHandler.java
 * @Description:
 *
 * @Date 2016年3月2日
 * @author Administroter
 * @version 1.0
 * 
 */
public class TimeClientHandler extends ChannelHandlerAdapter {
 private static final Logger logger = Logger.getLogger(TimeClientHandler.class.getName());
 private final ByteBuf firstMessage;
 /**
  * Creates a client-side handler.
  */
 public TimeClientHandler() {
  byte[] req = "QUERY TIME ORDER".getBytes();
  firstMessage = Unpooled.buffer(req.length);
  firstMessage.writeBytes(req);
 }
 /**
  * TCP链路建立成功后，调用这个方法发送查询指令给服务器
  */
 @Override
 public void channelActive(ChannelHandlerContext ctx) {
  ctx.writeAndFlush(firstMessage);
 }
 /**
  * 服务器你响应结果后调用这个方法，获取服务器响应的结果
  */
 @Override
 public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  ByteBuf buf = (ByteBuf) msg;
  byte[] req = new byte[buf.readableBytes()];
  buf.readBytes(req);
  String body = new String(req, "UTF-8");
  System.out.println("Now is : " + body);
 }
 /**
  * 链路建立失败，释放资源
  */
 @Override
 public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
  // 释放资源
  logger.warning("Unexpected exception from downstream : " + cause.getMessage());
  ctx.close();
 }
}

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;
/**
 * @FileName TimeServer.java
 * @Description: 
 *
 * @Date 2016年3月2日 
 * @author Administroter
 * @version 1.0
 * 
 */
public class TimeServer {
  public void bind(int port) throws Exception {
   // 配置服务端的NIO线程组
   EventLoopGroup bossGroup = new NioEventLoopGroup();
   EventLoopGroup workerGroup = new NioEventLoopGroup();
   try {
    /**
     * 创建ServerBootstrap,它是Netty用于启动NIO服务端的辅助启动类
     */
       ServerBootstrap b = new ServerBootstrap();
       /**
        * 创建管道NioServerSocketChannel,也就是NIO中的ServerSocketChannel，然后设置TCP的参数，设置为1024，最后
        * 创建ChildChannelHandler，也就是Reactor模式中的handler类，用于处理网络IO时间，比如对消息的编解码。
        */
       b.group(bossGroup, workerGroup)
        .channel(NioServerSocketChannel.class)
        .option(ChannelOption.SO_BACKLOG, 1024)
        .childHandler(new ChildChannelHandler());
       /**
        * 绑定端口，同步等待成功
        * 绑定完成之后会返回一个ChannelFuture,这里类似于JDK的java.util.concurrent.Future。
        * 用于异步操作的通知回调
        */
       ChannelFuture f = b.bind(port).sync();
       // 等待服务端监听端口关闭
       f.channel().closeFuture().sync();
   } finally {
       // 优雅退出，释放线程池资源
       bossGroup.shutdownGracefully();
       workerGroup.shutdownGracefully();
   }
      }
      private class ChildChannelHandler extends ChannelInitializer<SocketChannel> {
   @Override
   protected void initChannel(SocketChannel arg0) throws Exception {
       arg0.pipeline().addLast(new TimeServerHandler());
   }
      }
      /**
       * @param args
       * @throws Exception
       */
      public static void main(String[] args) throws Exception {
   int port = 8080;
   if (args != null && args.length > 0) {
       try {
    port = Integer.valueOf(args[0]);
       } catch (NumberFormatException e) {
    // 采用默认值
       }
   }
   new TimeServer().bind(port);
      }
}

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
/**
 * @FileName TimeServerHandler.java
 * @Description:用于对网络事件读写操作
 *
 * @Date 2016年3月2日
 * @author Administroter
 * @version 1.0
 * 
 */
public class TimeServerHandler extends ChannelHandlerAdapter {
 
 @Override
 public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  //msg客户端发送的请求参数,转成ByteBuf,这里的ByteBuf相当于jdk中的ByteBuffer
  ByteBuf buf = (ByteBuf) msg;
  //获取缓冲区客户端的请求参数，其中的readableBytes()方法可以返回缓冲区可读的字节数
  byte[] req = new byte[buf.readableBytes()];
  //将缓冲区的字节数组复制到byte数组中
  buf.readBytes(req);
  String body = new String(req, "UTF-8");
  System.out.println("The time server receive order : " + body);
  String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new java.util.Date(System.currentTimeMillis()).toString()
    : "BAD ORDER";
  ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
  ctx.write(resp);
 }
 @Override
 public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
  //将消息写入到SocketChannel
  ctx.flush();
 }
 @Override
 public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
  ctx.close();
 }
}