技术成就梦想

Netty入门




一、NIO

  Netty框架底层是对NIO的高度封装,所以想要更好的学习Netty之前,应先了解下什么是NIO – NIO是non-blocking的简称,
在jdk1.4 里提供的新api,他的他的特性如下:
  * 为所有的原始类型提供(Buffer)缓存支持,字符集编码解码解决方案。
  * Channel :一个新的原始I/O 抽象。支持锁和内存映射文件的文件访问接口。提供多路(non-bloking)非阻塞式的高伸缩
性网络I/O 。
  NIO是一个非阻塞式的I/O,它由一个专门的线程来处理所有的IO事件,并负责分发,并且它只有在事件到达的时候才会触发,
而不是去同步的监视事件;线程之间通过wait,notify 等方式通讯。保证每次上下文切换都是有意义的。减少无谓的线程切换。
  NIO和IO最大的区别是数据打包和传输方式。IO是以流的方式处理数据,而NIO是以块的方式处理数据。NIO的核心部分由
Channels、Buffers、Selectors三部分组成。

(一)Channel和Buffer

  正常的情况下,所有的IO在NIO中都从一个Channel 开始。Channel有点像流。数据可以从Channel读到Buffer中,也可以从
Buffer写到Channel中。JAVA NIO中的一些主要Channel的实现:FileChannel、DatagramChannel、SocketChannel、
ServerSocketChannel。这些实现类覆盖了UDP和TCP网络IO,以及文件IO。
  而Buffer的一些实现类:ByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer、ShortBuffer,则覆盖
了能通过IO发送的基本数据类型:byte,short,int,long,float,double和char。

(二)Selector

  Selector允许单线程处理多个Channel。如果你的应用打开了多个连接(通道),但每个连接的流量都很低,使用Selector
就会很方便。而要使用Selector,就得向Selector注册Channel,然后调用它的select()方法。这个方法会一直阻塞到某个注册的
通道有事件就绪。一旦这个方法返回,线程就可以处理这些事件,事件的例子有如新连接进来,数据接收等。

二、Netty

(一)Netty入门

  大数据,高访问场景的互联网项目或者多系统的协同工作,使用一个服务器根本不能胜任。就需要把系统拆分成了多个服务,
根据需要部署在多个机器上,这些服务非常灵活,可以随着访问量弹性扩展。但是多个模块的跨服务通信,时间和资源都是极大
地浪费。传统的Blocking IO不能解决,因为会有线程阻塞的问题,而使用非阻塞IO(NIO),则需要耗费太多的精力。而Netty框架
(RPC框架)则很好的解决了这个问题。
  Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具,用以快速开发高性能、
高可靠性的网络服务器和客户端程序。他就是一个程序,是封装java socket noi的,我们直接拿来用就好了。
  Netty通信服务端的步骤:
    1、创建两个NIO线程组,一个专门用于网络事件处理(接受客户端的连接),另一个则进行网络通信的读写。
    2、创建一个ServerBootstrap对象,配置Netty的一系列参数,例如接受传出数据的缓存大小等。
    3、创建一个用于实际处理数据的类ChannelInitializer,进行初始化的准备工作,比如设置接受传出数据的字符集、
格式以及实际处理数据的接口。
    4、绑定端口,执行同步阻塞方法等待服务器端启动即可。
    5、关闭相应的资源。

服务端栗子:
  服务端的管理者:

/**
* 服务端处理通道.这里只是打印一下请求的内容,并不对请求进行任何的响应
* 继承自ChannelHandlerAdapter, 这个类实现了ChannelHandler接口,
* ChannelHandler提供了许多事件处理的接口方法,然后你可以覆盖这些方法。
* @author lcy
*
*/
public class DiscartServiceHandler extends ChannelHandlerAdapter {
/**
* 客户端收到新消息时,这个方法会被调用
* 
* @param ctx
* 通道处理的上下文信息
* @param msg
* 接受的消息
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
try {
// 将接收到的信息转换为缓冲区
ByteBuf str = (ByteBuf) msg;
// 打印传输过来的信息
System.out.print(str.toString(CharsetUtil.UTF_8));
} finally {
// 释放ByteBuf对象
ReferenceCountUtil.release(msg);
}
}

/**
* 在异常时触发
*/
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
//输出错误信息
cause.printStackTrace();
ctx.close();
}
}

  服务端:

/**
* 服务端
* @author lcy
*
*/
public class DiscartServer {
private int port;

public DiscartServer(int port) {
super();
this.port = port;
}

public void run() throws Exception {
//(一)设置两个线程组
//用来接收进来的连接
NioEventLoopGroup bossGroup = new NioEventLoopGroup();
// 用来处理已经接受的连接
NioEventLoopGroup workGroup = new NioEventLoopGroup();
System.out.println("准备运行的端口" + port);
try {
//(二)辅助工具类,用于服务器通道的一系列配置
ServerBootstrap bootstrap = new ServerBootstrap();
//(三)绑定两个线程组
// 设置group,这一步是必须的,如果没有设置group将会报java.lang.IllegalStateException:group not set异常
bootstrap = bootstrap.group(bossGroup, workGroup);
//(四)指定NIO的模式
/***
* ServerSocketChannel以NIO的selector为基础进行实现的,用来接收新的连接
* 这里告诉Channel如何获取新的连接.
*/
bootstrap = bootstrap.channel(NioServerSocketChannel.class);
//(五)配置具体的数据处理方式,就是往里添加规则
bootstrap = bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {

@Override
protected void initChannel(SocketChannel arg0) throws Exception {
//与50秒内都没有与服务端进行通信的客户端断连
arg0.pipeline().addLast(new ReadTimeoutHandler(50));
arg0.pipeline().addLast(new HttpObjectAggregator(1048576));
// 添加实际处理数据的类
arg0.pipeline().addLast(new DiscartServiceHandler());
}
});
//(六)设置TCP缓冲区
bootstrap = bootstrap.option(ChannelOption.SO_BACKLOG, 128);
//保持连接
bootstrap = bootstrap.childOption(ChannelOption.SO_KEEPALIVE, true);
//(七)绑定端口,启动接收进来的连接
ChannelFuture sync = bootstrap.bind(port).sync();
//(八) 这里会一直等待,直到socket被关闭
sync.channel().closeFuture().sync();
} finally {
//(九)关闭资源
workGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
}
//服务开启
public static void main(String[] args) throws Exception {
int port;
if (args.length > 0) {
port = Integer.parseInt(args[0]);
} else {
port = 8080;
}
new DiscartServer(port).run();
System.out.println("server:run()");
}
}

客户端栗子:

  实际处理数据的类:

public class ChannelClient extends ChannelInitializer{

@Override
protected void initChannel(Channel arg0) throws Exception {
//与50秒内都没有与服务端进行通信的客户端断连
arg0.pipeline().addLast(new ReadTimeoutHandler(50));
arg0.pipeline().addLast(new HttpObjectAggregator(1048576));
//设置Channel
arg0.pipeline().addLast(new ChannelHandlerAdapter(){

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
try {
// 将接收到的信息转换为缓冲区
ByteBuf str = (ByteBuf) msg;
// 打印传输过来的信息
System.out.print(str.toString(CharsetUtil.UTF_8));
} finally {
// 释放ByteBuf对象
ReferenceCountUtil.release(msg);
}
}

@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
//输出错误信息
cause.printStackTrace();
ctx.close();
}
});

}
}

  客户端:

/**
* 客户端
* @author lcy
*/
public class Client {
@SuppressWarnings("resource")
public static void main(String[] args) throws Exception {
//创建一个新的线程组
NioEventLoopGroup workGroup = new NioEventLoopGroup();
//初始化Netty
Bootstrap bootstrap = new Bootstrap();
//指定工作的线程组
bootstrap = bootstrap.group(workGroup);
//指定 Channel的类型。因为是客户端, 因此使用了 NioSocketChannel。
bootstrap.channel(NioSocketChannel.class);
/**
* 设置链接的一些属性
*/
//降低延迟,禁用了禁用nagle算法。nagle算法受TCP延迟确认影响,会导致相继两次向连接发送请求包。
bootstrap.option(ChannelOption.TCP_NODELAY, true);
//保持连接检测对方主机是否崩溃,避免(服务器)永远阻塞于TCP连接的输入
bootstrap.option(ChannelOption.SO_KEEPALIVE, true);
//使用netty默认的解码器会出现读取不完整,不会执行channelRead方法。设置这个属性可惜保证Netty读取的完整
bootstrap.option(ChannelOption.MAX_MESSAGES_PER_READ, Integer.MAX_VALUE);
//设置数据处理器
bootstrap.handler(new ChannelClient());
//同步的链接
Channel channel = bootstrap.connect("127.0.0.1", 8080).sync().channel();
channel.writeAndFlush(Unpooled.copiedBuffer("Hello Netty...".getBytes()));
channel.closeFuture().sync();
workGroup.shutdownGracefully();
}
}

(二)Netty的数据通讯:

  1、使用长连接通道不断开的形式进行通信,也就是服务器和客户端的通道一直处于开启状态,如果服务器性能足够好,
并且客户端数量也比较多的情况下,推荐这种方式。
  2、一次性批量提交数据,采用短连接方式。也就是说先把数据保存到本地临时缓存区或者临时表,当达到界值时进行一
次性批量提交,又或者根据定时任务轮询提交。
  3、使用一种特殊的长连接,在某一指定时间段内,服务器与某台客户端没有任何通信,则断开连接。下次连接则是客户
端向服务器发送请求的时候,再次建立连接。

(三)Netty的编解码器:  

    1. Decoder 解码器    负责将消息从字节或其他序列形式转成指定的消息对象。
  2. Encoder 编码器    将消息对象转成字节或其他序列形式在网络上传输。
  入站”ByteBuf读取bytes后由 ToIntegerDecoder 进行解码,然后将解码后的消息存入List集合中,然后传递到ChannelPipeline
中的下一个ChannelInboundHandler。
  解码器:
    1)ByteToMessageDecoder,需自己判断ByteBuf读取前是否有足够的字节,否则会出现沾包的现象。
    2)ReplayingDecoder,无需自己检查字节长度,但是使用起来具有局限性:
      * 不是所有的操作都被ByteBuf支持,如果调用一个不支持的操作会抛出DecoderException。
      * ByteBuf.readableBytes()大部分时间不会返回期望值。
    3)MessageToMessageDecoder(message-to-message)
  解码器是用来处理入站数据,Netty提供了很多解码器的实现,可以根据需求详细了解。
  编码器:
    1)MessageToByteEncoder
    2)MessageToMessageEncoder 需要将消息编码成其他的消息时可以使用Netty提供的MessageToMessageEncoder抽象类
来实现。例如将Integer编码成String。

(四)Netty中解决TCP粘包/拆包问题

  想要解决TCP的粘包/拆包问题,首先要知道什么是TCP粘包、拆包:
    TCP是一个“流”协议,所谓流就是没有界限的遗传数据。大家可以想象一下,如果河水就好比数据,他们是连成一片的,没有
分界线,TCP底层并不了解上层业务数据的具体含义,它会根据TCP缓冲区的具体情况进行包的划分,也就是说,在业务上一个完整的
包可能会被TCP分成多个包进行发送,也可能把多个小包封装成一个大的数据包发送出去,这就是所谓的粘包/拆包问题。
  解决方案:
  1、消息定长,例如每个报文的大小固定为200个字节,如果不够,空位补空格。
  2、在包尾部增加特殊字符进行分割,例如加回车等。
  3、将消息分为消息头和消息体,在消息头中包含表示消息总长度的字段,然后进行业务逻辑的处理。
  Netty中解决TCP粘包/拆包的方法:
    1、分隔符类:DelimiterBasedFrameDecoder(自定义分隔符)
    2、定长:FixedLengthFrameDecoder