概述

Netty是java 网络编程框架，一个NIO客户端/服务端框架，并发高，传输快，封装好。它大大简化和简化了网络编程，如TCP和UDP套接字服务器。
Netty是Reactor模式的实现： Reactor中的组件：
a) Reactor:是IO事件的派发者。将事件分发给绑定该事件的Handler处理；相当于有分发功能的Selector。
b) Acceptor:用于接受client连接，建立对应client的Handler，并向Reactor注册此Handler。相当于NIO中建立连接的那个判断分支。
c) Handler:事件处理器，绑定了某类事件。是和一个client通讯的实体，实现业务的处理。相当于消息读写处理等操作类。

Netty_8">1. 第一个Netty程序

官方推荐的demo，使用Netty实现一个Discard服务端(Discard协议是抛弃协议，服务端收到消息后不做任何处理。在此我们用它测试服务端和客户端是否连接成功。)
引入jar包：

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.32.Final</version>
</dependency>

1.1 服务端

消息处理器：

java">import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

public class DiscardHandler extends ChannelInboundHandlerAdapter {
    //读取客户端发送的信息
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Server received: " + in.toString(CharsetUtil.UTF_8));
        //读取完不处理，直接释放
        in.release();
    }

    //有异常的时候
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();//关闭连接
    }
}

ChannelHandler用来实现服务端的逻辑，ChannelInboundHandler接口用来定义入站事件的方法。ChannelInboundHandlerAdapter中提供了默认ChannelInboundHandler的实现。所以继承这个类，并重写几个方法即可。
启动类：

java">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;

public class NettyServer {
    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup(); // (1)
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap(); // (2)
            b.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class) // (3)
                    .childHandler(new ChannelInitializer<SocketChannel>() { // (4)
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new DiscardHandler());
                        }
                    })
                    .option(ChannelOption.SO_BACKLOG, 128)          // (5)
                    .childOption(ChannelOption.SO_KEEPALIVE, true); // (6)

            // 绑定端口
            ChannelFuture f = b.bind(8000).sync(); // (7)

            // 等待，直到服务端关闭
            // 在这个示例中这里不会运行到，但当需要关闭的时候，可以这样执行
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

(1) NioEventLoopGroup是一个处理I/O操作的多线程循环。Netty为不同种类的传输提供了多种EventLoopGroup。此处实现了一个服务端的应用程序。通常服务端需要两个NioEventLoopGroup,第一个称作boos,boos用来接收进来的连接。另一个是worker,worker用来处理已经被接收的连接，一旦boss接收到连接，就会把连接信息注册到worker上。使用多少线程以及如何将它们映射到创建的通道取决于EventLoopGroup实现，可以通过构造函数进行配置。
(2) ServerBootstrap是一个设置服务端的工具类。
(3) 指定使用NioServerSocketChannel实例化传入的连接。
(4) 当一个新的连接被接受，一个新的子Channel将被创建，ChannelInitializer会添加ChannelHandler的实例(自定义的DiscardHandler)到Channel的ChannelPipeline。ChannelHandler用于处理消息。如果有入站信息，这个Handler（处理器）将被通知。
(5) 可以设置Channel的参数，这里写的是TCP/IP服务器，所以可以设置套接字选项。SO_BACKLOG是服务端接受连接的队列长度，如果队列已满，客户端连接将被拒绝，windows默认值就是128。
(6) option()选项是提供给NioServerSocketChannel接收进来的连接，也就是boos线程。childOption()选项提供给由父管道接收来的连接，也就是worker线程。SO_KEEPALIVE默认是false，启用该功能，TCP会主动探测空闲连接的有效性，相当于心跳机制，默认心跳间隔是7200s。
(7) 绑定端口。

1.2 客户端

java">import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringEncoder;

import java.util.Date;

public class NettyClient {
    public static void main(String[] args) throws InterruptedException {
        Bootstrap bootstrap = new Bootstrap();
        NioEventLoopGroup group = new NioEventLoopGroup();

        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<Channel>() {
                    @Override
                    protected void initChannel(Channel ch) {
                        ch.pipeline().addLast(new StringEncoder());
                    }
                });

        Channel channel = bootstrap.connect("127.0.0.1", 8000).channel();

        while (true) {//每隔两秒发一条信息
            channel.writeAndFlush(new Date() + ": hello world!");
            Thread.sleep(2000);
        }
    }
}