6.高性能NIO框架netty

1.Netty简介：

　　Netty是基于Java NIO的网络应用框架

　　Netty是一个NIO client-server(客户端服务器)框架，使用Netty可以快速开发网络应用，例如服务器和客户端协议。Netty

提供了一种新的方式来开发网络应用程序，这种新的方式使得它很容易使用和有很强的扩展性。Netty的内部实现是很复杂的

但是Netty提供了简单易用的api从网络处理代码中解耦业务逻辑。Netty是完全基于NIO实现的，所以整个Netty都是异步的，

网络应用程序通常需要有较高的可扩展性，无论是Netty还是其他的基于Java NIO的框架，都会提供可扩展性的解决方案。

Netty中一个关键组成部分是它的异步特性.

2.Netty通信的步骤：　

　　①创建两个NIO线程组，一个专门用于网络事件处理（接受客户端的连接），另一个则进行网络通信的读写。

　　②创建一个ServerBootstrap对象，配置Netty的一系列参数，例如接受传出数据的缓存大小等。

　　③创建一个用于实际处理数据的类ChannelInitializer，进行初始化的准备工作，比如设置接受传出数据的字符集、格式

以及实际处理数据的接口。

　　④绑定端口，执行同步阻塞方法等待服务器端启动即可

参考：Netty官方翻译文档

3.Netty代码示例1：　

1.客户端及其处理类

import io.netty.bootstrap.Bootstrap;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.EventLoopGroup;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.SocketChannel;

import io.netty.channel.socket.nio.NioSocketChannel;

import java.net.InetSocketAddress;

import cn.itcast_03_netty.sendobject.coder.PersonEncoder;

/**

 * • 连接服务器 • 写数据到服务器 • 等待接受服务器返回相同的数据 • 关闭连接

 * @author wilson

 */

public class EchoClient {

    private final String host;

    private final int port;

    public EchoClient(String host, int port) {

        this.host = host;

        this.port = port;

    }

    public void start() throws Exception {

        //NioEventLoopGroup 是用来处理I/O操作的多线程事件循环器

        EventLoopGroup nioEventLoopGroup = null;

        try {

            // 客户端引导类

            Bootstrap bootstrap = new Bootstrap();

            // EventLoopGroup可以理解为是一个线程池，这个线程池用来处理连接、接受数据、发送数据

            nioEventLoopGroup = new NioEventLoopGroup();

            //注册线程组

            bootstrap.group(nioEventLoopGroup)//多线程处理

                    .channel(NioSocketChannel.class)//指定通道类型为NioServerSocketChannel，一种异步模式，OIO阻塞模式为OioServerSocketChannel

                    .remoteAddress(new InetSocketAddress(host, port))//注册远程地址

                    .handler(new ChannelInitializer<SocketChannel>() {//业务处理类：Netty框架嵌入业务逻辑的地方

                                @Override

                                protected void initChannel(SocketChannel ch)

                                        throws Exception {

                                    ch.pipeline().addLast(new EchoClientHandler());//注册handler处理类：EchoClientHandler

                                }

                            });

            // 链接服务器，一直等待连接成功

            ChannelFuture channelFuture = bootstrap.connect().sync();

            //等待获取数据，最后关闭EventLoopGroup来释放资源

            channelFuture.channel().closeFuture().sync();

        } finally {

            nioEventLoopGroup.shutdownGracefully().sync();

        }

    }

    public static void main(String[] args) throws Exception {

        new EchoClient("localhost", 20000).start();

    }

}

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.SimpleChannelInboundHandler;

//业务处理类

public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    // 客户端连接服务器后被调用

    @Override

    public void channelActive(ChannelHandlerContext ctx) throws Exception {

        System.out.println("客户端连接服务器，开始发送数据……");

        byte[] req = "QUERY TIME ORDER".getBytes();//消息

        //使用io.netty.buffer工具类将数据写入buffer

        ByteBuf firstMessage = Unpooled.buffer(req.length);//发送类

        firstMessage.writeBytes(req);//发送

        ctx.writeAndFlush(firstMessage);//flush

    }

    // 从服务器接收到数据后调用

    @Override

    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg)

            throws Exception {

        System.out.println("client 读取server数据..");

        // 服务端返回消息后

        ByteBuf buf = (ByteBuf) msg;

        byte[] req = new byte[buf.readableBytes()];

        buf.readBytes(req);

        String body = new String(req, "UTF-8");

        System.out.println("服务端数据为 :" + body);

    }

    // 发生异常时被调用

    @Override

    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)

            throws Exception {

        System.out.println("client exceptionCaught..");

        // 释放资源

        ctx.close();

    }

}

2.服务端及其处理类

package cn.itcast_03_netty.sendstring.server;

import io.netty.bootstrap.ServerBootstrap;

import io.netty.channel.Channel;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.EventLoopGroup;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.nio.NioServerSocketChannel;

/**

 * • 配置服务器功能，如线程、端口 • 实现服务器处理程序，它包含业务逻辑，决定当有一个请求连接或接收数据时该做什么

 * @author wilson

 */

public class EchoServer {

    private final int port;

    public EchoServer(int port) {

        this.port = port;

    }

    public void start() throws Exception {

        EventLoopGroup eventLoopGroup = null;

        try {

            //server端引导类

            ServerBootstrap serverBootstrap = new ServerBootstrap();

            //连接池处理数据

            eventLoopGroup = new NioEventLoopGroup();

            //装配Bootstrap

            serverBootstrap.group(eventLoopGroup)

            .channel(NioServerSocketChannel.class)//指定通道类型为NioServerSocketChannel，一种异步模式，OIO阻塞模式为OioServerSocketChannel

            .localAddress("localhost",port)//设置InetSocketAddress让服务器监听某个端口已等待客户端连接。

            .childHandler(new ChannelInitializer<Channel>() {//设置childHandler执行所有的连接请求

                @Override

                protected void initChannel(Channel ch) throws Exception {

                    ch.pipeline().addLast(new EchoServerHandler());//注册handler

                }

                    });

            // 最后绑定服务器等待直到绑定完成，调用sync()方法会阻塞直到服务器完成绑定,然后服务器等待通道关闭，因为使用sync()，所以关闭操作也会被阻塞。

            ChannelFuture channelFuture = serverBootstrap.bind().sync();

            System.out.println("开始监听，端口为：" + channelFuture.channel().localAddress());

            //获取数据

            channelFuture.channel().closeFuture().sync();

        } finally {

            eventLoopGroup.shutdownGracefully().sync();

        }

    }

    public static void main(String[] args) throws Exception {

        new EchoServer(20000).start();

    }

}

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.ChannelInboundHandlerAdapter;

import java.util.Date;

public class EchoServerHandler extends ChannelInboundHandlerAdapter {

    @Override

    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

        System.out.println("server 读取数据……");

        //读取客户端数据

        ByteBuf buf = (ByteBuf) msg;

        byte[] req = new byte[buf.readableBytes()];

        buf.readBytes(req);

        String body = new String(req, "UTF-8");

        System.out.println("接收客户端数据:" + body);

        //向客户端写数据

        System.out.println("server向client发送数据");

        String currentTime = new Date(System.currentTimeMillis()).toString();

        ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());

        ctx.write(resp);

    }

    @Override

    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

        System.out.println("server 读取数据完毕..");

        ctx.flush();//刷新后才将数据发出到SocketChannel

    }

    @Override

    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)

            throws Exception {

        cause.printStackTrace();

        ctx.close();

    }

}

客户端调用服务端运行结果：

客户端：

客户端连接服务器，开始发送数据……

client 读取server数据..

服务端数据为 :Wed Jun 13 09:54:20 CST 2018

服务端：

开始监听，端口为：/127.0.0.1:20000

server 读取数据……

接收客户端数据:QUERY TIME ORDER

server向client发送数据

server 读取数据完毕..