Netty权威指南之Netty入门应用-蒲公英云

本章节需要学习的内容如下：

1、Netty开发环境搭建

2、服务端程序开发NettyServer

3、客户端程序开发NettyClient

第一节：Netty开发环境搭建

（1）、访问Netty的官网http://netty.io,从【Download】标签页下载netty-5.0.0.Alpha2.tar.bz2安装包，安装包不大，14.6M左右。下载完成后，如下截图:

Center

(2)、通过解压缩工具打开压缩工具，如以下截图：

Center 1

（3）、搭建Netty 应用工程，使用MyEclipse 10 创建普通的Java工程，同时创建Java源文件的package。

Center 2

（4）、创建第三方类库存放文件夹lib,同时将netty-all-5.0.0.Alpha2.jar文件复制到lib目录下。

Center 3

到此，Netty应用程序的开发环境已经搭建完毕。

第二节：Netty服务端开发

温故知新：在开始使用Netty开发服务端之前，先回顾一下使用NIO进行服务端开发步骤：

1、创建ServerSocketChannle,并配置它为非阻塞模式。

2、绑定监听，配置TCP参数。比如blocklog大小。

3、创建一个独立的IO线程，用于轮训多路复用器Selector。

4、创建Selector,将之前创建的ServerSocketChannle注册到Selector上，监听SelectKey.Accept.

5、启动IO线程，在循环体中执行Selector.select()方法，轮训就绪的Channle.

6、当轮训到就绪状态的Channle,需要对其判断，如果是SelectorKey.Accept状态，说明是新客户端接入，则调用ServerSocketChannle.accept()的方法接受新的客户端。

7、设置新接入的客户端的链路SocketChannle为非阻塞模式，配置其他的TCP参数。

8、将SocketChannle注册到Selector,监听OP_READ操作位。

9、如果轮训的Channle为OP_READ,则说明SocketChannle中有新的就绪的数据包需要读取，构造ByteBuff对象，读取数据包。

10、如果轮训的Channle的状态为OP_WRITE,说明还有数据没有发送完成，需要继续发送。

分析：一个简单的Java NIO服务端程序，如果我们选择使用Java JDK 的NIO库开发，竟然需要进过繁琐的十几步操作才能完成最基本的信息发送与接受，这也是我们选择Java NIO 开源框架的原因(Netty).

NettyServer.java

package com.nio.server;
import com.nio.handler.NettyServerHandler;
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;
/**
 * Created by vixuan-008 on 2015/6/19.
 */
public class NettyServer {
    public static void main(String[] args)throws Exception{
        int port=17666;
        new NettyServer().bind(port);
    }
    public void bind(int port)throws Exception{
        //配置服务端的NIO线程池
        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 NettyServerHandler());
            //绑定端口，等待同步成功
            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 socketChannel) throws Exception {
            socketChannel.pipeline().addLast(new NettyServerHandler());
        }
    }
}

NettyServerHandler.java

package com.nio.handler;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
/**
 * Created by vixuan-008 on 2015/6/19.
 */
public class NettyServerHandler extends ChannelHandlerAdapter {
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            ctx.close();
    }
    @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("the server receiver data is:"+body);
        String currentTime="time".equalsIgnoreCase(body) ? new java.util.Date(System.currentTimeMillis()).toString():"no zuo no die";
        ByteBuf resp= Unpooled.copiedBuffer(currentTime.getBytes());
        ctx.write(resp);
    }
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        super.channelReadComplete(ctx);
        ctx.flush();
    }
}

第三节：Netty客户端开发

NettyClient.java

package com.nio.client;
import com.nio.handler.NettyClientHandler;
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;
/**
 * Created by vixuan-008 on 2015/6/19.
 */
public class NettyClient {
    public static void main(String[] args)throws  Exception{
        int port=17666;
        new NettyClient().connect(port,"127.0.0.1");
    }
    public void connect(int port,String host)throws Exception{
        //配置客户端NIO线程池
        EventLoopGroup workGroup=new NioEventLoopGroup();
        try{
            io.netty.bootstrap.Bootstrap b=new io.netty.bootstrap.Bootstrap();
            b.group(workGroup).channel(NioSocketChannel.class).option(ChannelOption.TCP_NODELAY,true).handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    socketChannel.pipeline().addLast(new NettyClientHandler());
                }
            });
            //发起异步连接操作
            ChannelFuture f=b.connect(host,port).sync();
            //等待客户端链路关闭
            f.channel().closeFuture().sync();
        }finally {
            //释放NIO 线程组
            workGroup.shutdownGracefully();
        }
    }
}

NettyClientHandler.java

package com.nio.handler;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
/**
 * Created by vixuan-008 on 2015/6/19.
 */
public class NettyClientHandler extends ChannelHandlerAdapter {
    private final ByteBuf message;
    public NettyClientHandler() {
        byte[] req="time".getBytes();
        message= Unpooled.buffer(req.length);
        message.writeBytes(req);
    }
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(message);
    }
    @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("this client receiver data is:"+body);
    }
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
    }
}