Netty简单介绍(非原创)

文章大纲

一、Netty基础介绍
二、Netty代码实战
三、项目源码下载
四、参考文章

一、Netty基础介绍

1. 简介

官方定义为：”Netty 是一款异步的事件驱动的网络应用程序框架，支持快速地开发可维护的高性能的面向协议的服务器和客户端”

2. 主要特性

Netty有很多重要的特性，主要特性如下：
（1）优雅的设计
（2）统一的API接口，支持多种传输类型，例如OIO,NIO
（3）简单而强大的线程模型
（4）丰富的文档
（5）卓越的性能
（6）拥有比原生Java API 更高的性能与更低的延迟
（7）基于池化和复用技术，使资源消耗更低
（8）安全性
（9）完整的SSL/TLS以及StartTLS支持
（10）可用于受限环境，如Applet以及OSGI
Netty的以上特性，比较适合客户端数据较大的请求/处理场景，例如web服务器等，要想知道有哪些系统使用了Netty,可以参考：http://netty.io/wiki/adopters.html

3. 主要名词介绍

3.1 BIO(Blocking IO)：阻塞IO
早期的Java API(java.net)提供了由本地系统套接字库提供的所谓的阻塞函数，样例代码如下：

ServerSocket serverSocket = new ServerSocket(portNumber);
Socket clientSocket = serverSocket.accept();
BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
PrintWriter out =new PrintWriter(clientSocket.getOutputStream(), true);
String request, response;
while ((request = in.readLine()) != null) {
    if ("Done".equals(request)) {
        break;
}
response = processRequest(request);
out.println(response);
}

这段代码片段将只能同时处理一个连接，要管理多个并发客户端，需要为每个新的客户端 Socket 创建一个新的 Thread,线程模型如下图所示：

该种模型存在以下两个问题：
（1）在任何时候都可能有大量的线程处于休眠状态，只是等待输入或者输出数据就绪，这可能算是一种资源浪费
（2）需要为每个线程的调用栈都分配内存
（3）即使 Java 虚拟机（JVM）在物理上可以支持非常大数量的线程，但是远在到达该极限之前，上下文切换所带来的开销就会带来麻烦

3.2 NIO(Non Blocking IO):非阻塞IO
Java的NIO特性在JDK 1.4中引入，其结构如下：

从该图可以看出Selector 是Java 的非阻塞 I/O 实现的关键。它使用了事件通知 API以确定在一组非阻塞套接字中有哪些已经就绪能够进行 I/O 相关的操作。因为可以在任何的时间检查任意的读操作或者写操作的完成状态。该种模型下，一个单一的线程便可以处理多个并发的连接。与BIO相比，该模型有以下特点：
（1）使用较少的线程便可以处理许多连接，因此也减少了内存管理和上下文切换所带来开销
（2）当没有 I/O 操作需要处理的时候，线程也可以被用于其他任务

虽然Java 的NIO在性能上比BIO已经相当的优秀，但是要做到如此正确和安全并
不容易。特别是，在高负载下可靠和高效地处理和调度 I/O 操作是一项繁琐而且容易出错的任务，此时就是Netty上场的时间了

4. Netty好处

（1）使用多路复用技术，提高处理连接的并发性
（2）零拷贝：
a. Netty的接收和发送数据采用DIRECT BUFFERS，使用堆外直接内存进行Socket读写，不需要进行字节缓冲区的二次拷贝
b. Netty提供了组合Buffer对象，可以聚合多个ByteBuffer对象进行一次操作
c. Netty的文件传输采用了transferTo方法，它可以直接将文件缓冲区的数据发送到目标Channel，避免了传统通过循环write方式导致的内存拷贝问题
d. 内存池：为了减少堆外直接内存的分配和回收产生的资源损耗问题，Netty提供了基于内存池的缓冲区重用机制
e. 使用主从Reactor多线程模型，提高并发性
f. 采用了串行无锁化设计，在IO线程内部进行串行操作，避免多线程竞争导致的性能下降
g. 默认使用Protobuf的序列化框架
h. 灵活的TCP参数配置
详细说明，可参考： http://www.infoq.com/cn/articles/netty-high-performance#anch111813

二、Netty代码实战

在本节中，我们将前面讲解NIO编程时的时间服务案例，改成用Netty来实现。TimeClient发送“QUERY TIME ORDER”请求，TimeServer接受到这个请求后，返回当前时间。

1. 新建maven项目

创建后项目结构如下：

2. pom.xml文件添加依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wxc</groupId>
    <artifactId>netty-test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.0.28.Final</version>
            <scope>compile</scope>
        </dependency>


    </dependencies>

</project>

3. 编写服务端代码

3.1 创建TimeServer.java
时间服务器TimeServer在8080端口监听客户端请求，如下

package server;

import io.netty.bootstrap.ServerBootstrap;
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.NioServerSocketChannel;
import io.netty.handler.codec.LineBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;

public class TimeServer {
    private int port=8080;
    public void run() throws Exception {
        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 LineBasedFrameDecoder(1024));
                            ch.pipeline().addLast(new StringDecoder());
                            ch.pipeline().addLast(new TimeServerHandler());
                        }
                    });

            ChannelFuture f = b.bind(port).sync(); // (5)
            System.out.println("TimeServer Started on 8080...");
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
    public static void main(String[] args) throws Exception {
        new TimeServer().run();
    }
}

说明：

1、首先我们创建了两个EventLoopGroup实例：bossGroup和workerGroup，目前可以将bossGroup和workerGroup理解为两个线程池。其中bossGroup用于接受客户端连接，bossGroup在接受到客户端连接之后，将连接交给workerGroup来进行处理。

2、接着，我们创建了一个ServerBootstrap实例，从名字上就可以看出来这是一个服务端启动类，我们需要给设置一些参数，包括第1步创建的bossGroup和workerGroup。

3、我们通过channel方法指定了NioServerSocketChannel，这是netty中表示服务端的类，用于接受客户端连接，对应于java.nio包中的ServerSocketChannel。

4、我们通过childHandler方法，设置了一个匿名内部类ChannelInitializer实例，用于初始化客户端连接SocketChannel实例。在第3步中，我们提到NioServerSocketChannel是用于接受客户端连接，在接收到客户端连接之后，netty会回调ChannelInitializer的initChannel方法需要对这个连接进行一些初始化工作，主要是告诉netty之后如何处理和响应这个客户端的请求。在这里，主要是添加了3个ChannelHandler实例：LineBasedFrameDecoder、StringDecoder、TimeServerHandler。其中LineBasedFrameDecoder、StringDecoder是netty本身提供的，用于解决TCP粘包、解包的工具类。

LineBasedFrameDecoder在解析客户端请求时，遇到字符”\n”或”\r\n”时则认为是一个完整的请求报文，然后将这个请求报文的二进制字节流交给StringDecoder处理。

StringDecoder将字节流转换成一个字符串，交给TimeServerHandler来进行处理。

TimeServerHandler是我们自己要编写的类，在这个类中，我们要根据用户请求返回当前时间。

5、在所有的配置都设置好之后，我们调用了ServerBootstrap的bind(port)方法，开启真正的监听在8080端口，接受客户端请求。

3.2 创建TimeServerHandler.java
TimeServerHandler用户处理客户端的请求，每当接收到"QUERY TIME ORDER”请求时，就返回当前时间，否则返回"BAD REQUEST”。

package server;

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 TimeServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { // 1
        String request = (String) msg; //2
        String response = null;
        if ("QUERY TIME ORDER".equals(request)) { // 3
            response = new Date(System.currentTimeMillis()).toString();
        } else {
            response = "BAD REQUEST";
        }
        response = response + System.getProperty("line.separator"); // 4
        ByteBuf resp = Unpooled.copiedBuffer(response.getBytes()); // 5
        ctx.writeAndFlush(resp); // 6
    }
}

说明：
1、TimeServerHandler继承了ChannelInboundHandlerAdapter，并覆盖了channelRead方法，当客户端发送了请求之后，channelRead方法会被回调。参数ChannelHandlerContext包含了当前发送请求的客户端的一些上下文信息，msg表示客户端发送的请求信息。
2、我们直接msg强制转换成了String类型。这是因为我们在前面已经添加过了StringDecoder，其已经将二进制流转换成了一个字符串
3、构建响应。会判断请求是否合法，如果请求信息是"QUERY TIME ORDER”，则返回当前时间，否则返回"BAD REQUEST”
4、在响应内容中加上了System.getProperty("line.separator”)，也就是所谓的换行符。在linux操作系统中，就是”\n”，在windows操作系统是”\r\n”。加上换行符，主要是因为客户端也要对服务端的响应进行解码，当遇到一个换行符时，就认为是一个完整的响应。
5、调用了Unpooled.copiedBuffer方法创建了一个缓冲区对象ByteBuf。在java nio包中，使用ByteBuffer类来表示一个缓冲区对象。在netty中，使用ByteBuf表示一个缓冲区对象。在后面的章节中，我们会对ByteBuf进行详细讲解。
6、调用ChannelHandlerContext的writeAndFlush方法，将响应刷新到客户端

4. 编写客户端代码

4.1 创建TimeClient .java
TimeClient负责与服务端的8080端口建立连接

public class TimeClient {
    public static void main(String[] args) throws Exception {
        String host = "localhost";
        int port = 8080;
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap(); // (1)
            b.group(workerGroup); // (2)
            b.channel(NioSocketChannel.class); // (3)
            b.handler(new ChannelInitializer<SocketChannel>() {// (4)
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new LineBasedFrameDecoder(1024));
                    ch.pipeline().addLast(new StringDecoder());
                    ch.pipeline().addLast(new TimeClientHandler());
                }
            });
            // Start the client.
            ChannelFuture f = b.connect(host, port).sync(); // (5)
            // Wait until the connection is closed.
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
        }
    }
}

说明：
1、首先我们创建了一个Bootstrap实例，与ServerBootstrap相对应，这表示一个客户端的启动类
2、我们调用group方法给Bootstrap实例设置了一个EventLoopGroup实例。前面提到，EventLoopGroup的作用是线程池。前面在创建ServerBootstrap时，设置了一个bossGroup，一个wrokerGroup，这样做主要是为将接受连接和处理连接请求任务划分开，以提升效率。对于客户端而言，则没有这种需求，只需要设置一个EventLoopGroup实例即可。
3、通过channel方法指定了NioSocketChannel，这是netty在nio编程中用于表示客户端的对象实例。
4、类似server端，在连接创建完成，初始化的时候，我们也给SocketChannel添加了几个处理器类。其中TimeClientHandler是我们自己编写的给服务端发送请求，并接受服务端响应的处理器类。
5、所有参数设置完成之后，调用Bootstrap的connect(host, port)方法，与服务端建立连接。

4.2 创建TimeClientHandler.java
TimeClientHandler主要用于给Server端发送"QUERY TIME ORDER”请求，并接受服务端响应。

public class TimeClientHandler extends ChannelInboundHandlerAdapter {
    private byte[] req=("QUERY TIME ORDER" + System.getProperty("line.separator")).getBytes();
    @Override
    public void channelActive(ChannelHandlerContext ctx) {//1
        ByteBuf message = Unpooled.buffer(req.length);
        message.writeBytes(req);
        ctx.writeAndFlush(message);
    }
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        String body = (String) msg;
        System.out.println("Now is:" + body);
    }
}

说明：
1、TimeClientHandler继承了ChannelInboundHandlerAdapter，并同时覆盖了channelActive和channelRead方法。
2、当客户端与服务端连接建立成功后，channelActive方法会被回调，我们在这个方法中给服务端发送"QUERY TIME ORDER”请求。
3、当接受到服务端响应后，channelRead方法会被会回调，我们在这个方法中打印出响应的时间信息。

创建后项目结构如下：