Netty4学习笔记(一) 基础篇
在开始学习Netty之前，我们先对Unix系统常用的I/O模型进行介绍，然后对Java的I/O历史演进历史进行简单的说明。
Linux 网络I/O模型简介
Linux内核将所有外部设备都看做一个文件来操作，对一个文件的读写操作会调用内核提供的系统命令，返回一个 file descriptor（fd，文件描述符）。而对一个socket的读写也会有相应的描述符，称为 socket fd（socket描述符），描述符就是一个数字，它指向内核中的一个结构体（文件路径，数据区等一些属性）。
根据Unix 网络编程对I/O模型的分类，Unix提供了5种I/O模型，分别如下。
（1）阻塞I/O模型：最常用的I/O模型就是阻塞I/O模型，缺省情形下，所有文件操作都是阻塞的。我们以套接字接口为例来讲解此模型：在进程空间中调用recvfrom，其系统调用直到数据包到达且被复制到应用的缓冲区中或者发生错误时才返回，在此期间一直会等待，进程从调用recvfrom开始到它返回的整段时间内都是被阻塞的，因此被称为阻塞I/O模型，如下图所示
（2）非阻塞I/O模型：recvfrom从应用层到内核的时候，如果该缓冲区没有数据的话，就直接返回一个EWOULDBLOCK错误，一般都对非阻塞I/O模型进行轮询检查这个状态，看看内核是不是有数据到来，如下图所示
（3）I/O复用模型：Linux提供select/poll，进程将一个或者多个fd传递给select或poll系统调用，阻塞在select操作上，这样select/poll可以帮助我们检测多个fd是否处于就绪状态。select/poll是顺序扫描fd是否就绪，而且支持的fd数量有限，因此它的使用受到了一些制约。Linux还提供了epoll系统调用，epoll使用基于事件驱动方式代替顺序扫描，因此性能更高。当有fd就绪时，立刻回调函数rollback，如下图所示
（4）信号驱动I/O模型：首先开启套接口信号驱动I/O功能，并通过系统调用sigaction来执行一个信号处理函数（此系统调用立即返回，进程继续工作，它是非阻塞的）。当数据准备就绪时，就为该进程生成一个SIGIO信号，通过信号回调通知应用程序调用recvfrom来读取数据，并通知主循环函数处理数据，如下图所示：
（5）异步I/O模型：告知内核启动某个操作，并让内核在整个操作完成后（包括将数据从内核复制到用户自己的缓冲区）通知我们。这种模型与信号驱动模型的主要区别是：信号驱动IO由内核通知我们何时可以开始下一个IO操作：异步I/O模型由内核通知我们I/O操作何时完成，如下图所示：
I/O多路复用技术
在I/O编程过程中，当需要同时处理多个客户端接入请求时，可以利用多线程或者I/O多路复用技术进行处理。I/O多路复用技术通过把多个I/O的阻塞复用到同一个select的阻塞上，从而使得系统在单线程的情况下可以同时处理多个客户端请求。与传统的多线程/多进程模型相比，I/O多路复用技术的最大优势是系统开销小，系统不需要创建新的额外进程或线程，也不需要维护这些进程和线程的运行，降低了系统的维护工作量，节省了系统资源，I/O多路复用的主要应用场景如下：
- 服务器需要同时处理多个处于监听状态或者多个连接状态的套接字；
- 服务器需要同时处理多种网络协议的套接字；
目前支持I/O多路复用的系统调用有select、pselect、 poll、epoll，在Linux网络编程过程中，很长一段时间都使用select做轮询和网络事件通知，然而select的一些固有缺陷导致了它的应用受到了很大的限制，最终Linux不得不在新的内核版本中寻找select的替代方案，最终选择了epoll。epoll与select的原理比较类似，为了克服select的缺点，epoll做了很多重大改进，总结如下：
- 支持一个进程打开的socket描述符（FD）不受限制（仅受限于操作系统的最大文件句柄数）。
- I/O效率不会随着FD数量的增加而线性下降。
传统select/poll的另一个致命弱点，就是当你拥有一个很大的socket集合时，由于网络延时或者链路空闲，任意时刻只有少部分的socket是“活跃”的，但是select/poll每次调用都会线性扫描全部的集合，导致效率呈线性下降。epoll不存在这个问题，它只会对“活跃”的socket进行操作——这是因为在内核的实现中，epoll是根据每个fd上面的callback函数实现的。那么只有“活跃”的socket才会去主动调用callback函数，其他
idle状态的socket则不会。在这点上，epoll实现了一个伪AIO。 - 使用mmap加速内核与用户空间的消息传递。
- epoll的API更加简单。
Java I/O演进之路
从JDK1.0到JDK1.3，Java I/O类库都非常原始，很多UNIX网络编程中的概念或者接口在I/O类库中都没有体现，例如Pipe、Channel、Buffer和Selector等。在2002年发布JDK1.4时，NIO以JSR-51的身份正式随JDK发布。它新增了java.nio包，提供了很多进行异步I/O开发的API和类库，主要的类和接口如下：
- 进行异步I/O操作的缓冲区ByteBuffer等；
- 进行异步I/O操作的管道Pipe；
- 进行各种I/O操作的（同步或异步）的Chanel，包括ServerSocketChanel和SocketChanel；
- 多种字符集的编码能力和解码能力；
- 实现非阻塞I/O操作的多路复用器Selector；
- 文件通道FileChanel；
新的NIO类库的提供，极大的促进了基于Java的异步非阻塞编程的应用和发展，但是，它依然有不完善的地方，特别是对文件系统的处理能力仍显不足，主要问题如下：
- 没有统一的文件属性（例如读写权限）；
- API能力较弱，例如目录的级联创建和递归遍历，往往需要自己实现；
- 底层存储系统的一些高级API无法使用；
- 所有的文件操作都是同步阻塞调用，不支持异步文件读写操作。
2011年7月28日，JDK7正式发布。它的一个比较大的亮点就是将原来的NIO类库进行了升级，被称为NIO 2.0。NIO 2.0由JSR-203演进而来，它主要提供了如下三个方面的改进：
- 提供能够批量获取文件属性的API，这些API具有平台无关性，不与特定的文件系统相耦合。另外，它还提供了标准文件的SPI，供各个服务提供商扩展实现；
- 提供AIO功能，支持基于文件的异步I/O操作和针对网络套接字的异步操作；
- 完成JSR-51定义的通道功能，包括对配置和多播的数据报的支持等。
Netty4 入门应用
开发环境
- IDEA 15
- JDK 1.7
- Maven 3.3
1、添加maven依赖
<dependency>
<groupId>io.nettygroupId>
<artifactId>netty-allartifactId>
<version>4.1.6.Finalversion>
dependency>2、Netty服务端开发
package com.bytebeats.netty4.sample.ch1;
import com.bytebeats.netty4.sample.util.Constants;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Hello world Server.
* @author Ricky
*
*/
public class EchoServer {
private Logger logger = LoggerFactory.getLogger(getClass());
private int port;
public EchoServer(int port) {
this.port = port;
}
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)
.option(ChannelOption.SO_BACKLOG, 1024)
.childHandler(new ChannelInitializer() { // (4)
@Override
public void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
p.addLast(new EchoServerHandler());
}
});
// Bind and start to accept incoming connections.
ChannelFuture f = b.bind(port).sync(); // (7)
logger.info("server bind port:{}", port);
// Wait until the server socket is closed.
f.channel().closeFuture().sync();
} finally {
// Shut down all event loops to terminate all threads.
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
public static void main(String[] args) throws Exception {
new EchoServer(Constants.PORT).run();
}
}
package com.bytebeats.netty4.sample.ch1;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Handles a server-side channel.
*/
public class EchoServerHandler extends ChannelInboundHandlerAdapter { // (1)
private Logger logger = LoggerFactory.getLogger(getClass());
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) { // (2)
logger.info("server channel read...");
ByteBuf buf = (ByteBuf) msg;
byte[] req = new byte[buf.readableBytes()];
buf.readBytes(req);
try {
String body = new String(req, "UTF-8");
logger.info("server channel read msg:{}", body);
}catch (Exception e){
e.printStackTrace();
}
String response = "hello from server";
ByteBuf resp = Unpooled.copiedBuffer(response.getBytes());
ctx.write(resp);
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
logger.info("server channel read complete");
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { // (4)
// Close the connection when an exception is raised.
logger.error("server caught exception", cause);
ctx.close();
}
}3、Netty客户端开发
package com.bytebeats.netty4.sample.ch1;
import com.bytebeats.netty4.sample.util.Constants;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Hello world Client.
* @author Ricky
*
*/
public class EchoClient {
private Logger logger = LoggerFactory.getLogger(getClass());
private String host;
private int port;
public EchoClient(String host, int port) {
this.host = host;
this.port = port;
}
public void send() throws InterruptedException {
EventLoopGroup group = new NioEventLoopGroup();
try {
Bootstrap b = new Bootstrap();
b.group(group)
.channel(NioSocketChannel.class)
.option(ChannelOption.TCP_NODELAY, true)
.handler(new ChannelInitializer() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
p.addLast(new EchoClientHandler());
}
});
// Start the client.
ChannelFuture f = b.connect(host, port).sync();
logger.info("client connect to host:{}, port:{}", host, port);
// Wait until the connection is closed.
f.channel().closeFuture().sync();
} finally {
// Shut down the event loop to terminate all threads.
group.shutdownGracefully();
}
}
public static void main(String[] args) throws Exception {
new EchoClient(Constants.HOST, Constants.PORT).send();
}
}
package com.bytebeats.netty4.sample.ch1;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Handles a client-side channel.
*/
public class EchoClientHandler extends ChannelInboundHandlerAdapter { // (1)
private Logger logger = LoggerFactory.getLogger(getClass());
private final ByteBuf firstMessage;
public EchoClientHandler(){
byte[] req = "Hello from client".getBytes();
firstMessage = Unpooled.buffer(req.length);
firstMessage.writeBytes(req);
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
logger.info("client channel active");
// Send the message to Server
logger.info("client send req...");
ctx.writeAndFlush(firstMessage);
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) { // (2)
ByteBuf buf = (ByteBuf) msg;
byte[] req = new byte[buf.readableBytes()];
buf.readBytes(req);
try {
String body = new String(req, "UTF-8");
logger.info("client channel read msg:{}", body);
}catch (Exception e){
e.printStackTrace();
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { // (4)
// Close the connection when an exception is raised.
logger.error("client caught exception", cause);
ctx.close();
}
}源码均已上传至Github：https://github.com/TiFG/netty4-samples