Netty入门示例（一）

以下演示的是一个时间服务器。

依次启动Server，Client；Client从服务器上读取得时间后打印的控制台上。

ChannelInitializer，ChannelInboundHandlerAdapter

Server

提供时间服务。
监听8080端口，子类TimeServerHandlerAdapter是ChannelInboundHandlerAdapter的一个实现。
通过实现方法channelActive，在新请求进入时输入本机的时间。
通过实现方法exceptionCaught捕获异常。

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class Server {

   public static void main(String[] args) {
       new Server().bind(8080);
   }

   private void bind(int port) {
       EventLoopGroup boosGroup = new NioEventLoopGroup();
       EventLoopGroup workerGroup = new NioEventLoopGroup();
       ServerBootstrap bootstrap = new ServerBootstrap();
       bootstrap.group(boosGroup, workerGroup);
       bootstrap.channel(NioServerSocketChannel.class);
       bootstrap.option(ChannelOption.SO_BACKLOG, 2014);

       // init
       bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
           @Override
           protected void initChannel(SocketChannel socketChannel) throws Exception {

               // bind
               socketChannel.pipeline().addLast(new TimeServerHandlerAdapter());
           }
       });
       try {
           ChannelFuture future = bootstrap.bind(port).sync();
           future.channel().closeFuture().sync();
       } catch (InterruptedException e) {
           e.printStackTrace();
       } finally {
           boosGroup.shutdownGracefully();
           workerGroup.shutdownGracefully();
       }
   }

   // adapter
   class TimeServerHandlerAdapter extends ChannelInboundHandlerAdapter {
       @Override
       public void channelActive(final ChannelHandlerContext ctx) {
           final ByteBuf time = ctx.alloc().buffer(4);
           time.writeLong(System.currentTimeMillis());

           // write data
           final ChannelFuture f = ctx.writeAndFlush(time);
           f.addListener(new ChannelFutureListener() {
               public void operationComplete(ChannelFuture future) {
                   assert f == future;
                   ctx.close();
               }
           });
       }

       @Override
       public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
           cause.printStackTrace();
           ctx.close();
       }
   }
}

Client

调用服务器时间，打印在控制台上。

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

import java.util.Date;

public class Client {

   public static void main(String[] args) throws Exception {
       new Client().connect("127.0.0.1", 8080);
   }

   private void connect(String host, int port) throws InterruptedException {
       EventLoopGroup workerGroup = new NioEventLoopGroup();
       Bootstrap bs = new Bootstrap();
       bs.group(workerGroup);
       bs.channel(NioSocketChannel.class);
       bs.option(ChannelOption.SO_KEEPALIVE, true);

       // init
       bs.handler(new ChannelInitializer<SocketChannel>() {
           @Override
           public void initChannel(SocketChannel ch) throws Exception {
               ch.pipeline().addLast(new TimeClientHandlerAdapter());
           }
       });
       try {
           ChannelFuture f = bs.connect(host, port).sync();
           f.channel().closeFuture().sync();
       } finally {
           workerGroup.shutdownGracefully();
       }
   }

   // adapter
   class TimeClientHandlerAdapter extends ChannelInboundHandlerAdapter {
       @Override
       public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
           ByteBuf buf = (ByteBuf) msg;
           try {

               // read data
               System.out.println(new Date(buf.readLong()));
               ctx.close();
           } finally {
               buf.release();
           }
       }

       @Override
       public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
           cause.printStackTrace();
           ctx.close();
       }
   }
}