文章大纲
一、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方法会被会回调，我们在这个方法中打印出响应的时间信息。
创建后项目结构如下：
5. 项目运行与访问
5.1 运行服务端
5.2 运行客户端
三、项目源码下载
链接：https://pan.baidu.com/s/1v7QuR0ycWSCkDpaAd-tZhQ
提取码：0nyf
网友评论