Netty框架介绍
一、netty(通讯框架)介紹
1、什么是netty
Netty是一个基于Java NIO类库的异步通讯框架,他的架构特点是:异步非阻塞、基于事件驱动、高性能、高可靠和高定制行。
2、netty应用场景
rpc远程调用框架dubbo底层就是通过netty来实现,netty的底层又是NIO。
1)、分布式开源框架中dubbo、Zookeeper,RocketMQ底层rpc通讯使用就是netty
2)、游戏开发中,底层使用netty通讯。
3、netty好处
1)、 NIO的类库和API繁杂,使用麻烦,你需要熟练掌握Selector、ServerSocketChannel、SocketChannel、ByteBuffer等;(解决NIO代码复杂问题)
2)、需要具备其它的额外技能做铺垫,例如熟悉Java多线程编程,因为NIO编程涉及到Reactor模式,你必须对多线程和网路编程非常熟悉,才能编写出高质量的NIO程序;
3)、可靠性能力补齐,工作量和难度都非常大。例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常码流的处理等等,NIO编程的特点是功能开发相对容易,但是可靠性能力补齐工作量和难度都非常大;
4)、JDK NIO的BUG,例如臭名昭著的epoll bug,它会导致Selector空轮询,最终导致CPU 100%。官方声称在JDK1.6版本的update18修复了该问题,但是直到JDK1.7版本该问题仍旧存在,只不过该bug发生概率降低了一些而已,它并没有被根本解决。(容错机制比NIO高)
二、Netty服务端(基于Netty3.0)
代码:
package com.yuyou;
import java.net.InetSocketAddress;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.ChannelStateEvent;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelHandler;
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
import org.jboss.netty.handler.codec.string.StringDecoder;
import org.jboss.netty.handler.codec.string.StringEncoder;
class ServerHanlder extends SimpleChannelHandler{
// 通道被关闭的时候会触发
@Override
public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
super.channelClosed(ctx, e);
System.out.println("channelClosed");
}
// 必须要建立连接,关闭通道的时候才会触发
@Override
public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
super.channelDisconnected(ctx, e);
System.out.println("channelDisconnected");
}
// 接受出现异常
@Override
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
super.exceptionCaught(ctx, e);
System.out.println("exceptionCaught");
}
// 接受客户端数据
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
super.messageReceived(ctx, e);
System.out.println("messageReceived");
System.out.println("服务器获取客户端发来的参数:"+e.getMessage());
ctx.getChannel().write("你好啊");
}
}
public class NettyServer {
public static void main(String[] args) {
// 1、创建服务对象
ServerBootstrap serverBootstrap = new ServerBootstrap();
// 2、创建两个线程池 一个监听端口号,一个监听nio
ExecutorService boos = Executors.newCachedThreadPool();
ExecutorService wook = Executors.newCachedThreadPool();
// 3、将线程池放入工程
serverBootstrap.setFactory(new NioServerSocketChannelFactory(boos, wook));
// 4、设置管道工程
serverBootstrap.setPipelineFactory(new ChannelPipelineFactory() {
public ChannelPipeline getPipeline() throws Exception {
ChannelPipeline pipeline = org.jboss.netty.channel.Channels.pipeline();
// 传输数据的时候直接为String
pipeline.addLast("decoder", new StringDecoder());
pipeline.addLast("encoder", new StringEncoder());
// 设置事件监听类
pipeline.addLast("serverHanlder", new ServerHanlder());
return pipeline;
}
});
// 绑定端口号
serverBootstrap.bind(new InetSocketAddress(8080));
System.out.println("服务器已经被启动.....");
}
}
三、Netty客户端(基于Netty3.0)
代码:
package com.yuyou;
import java.net.InetSocketAddress;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.jboss.netty.bootstrap.ClientBootstrap;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelFuture;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.ChannelStateEvent;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelHandler;
import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;
import org.jboss.netty.handler.codec.string.StringDecoder;
import org.jboss.netty.handler.codec.string.StringEncoder;
class ClientHandler extends SimpleChannelHandler{
// 通道被关闭的时候出发
@Override
public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
super.channelClosed(ctx, e);
System.out.println("channelClosed");
}
// 必须要建立连接,关闭通道的时候才会触发
@Override
public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
super.channelDisconnected(ctx, e);
System.out.println("channelDisconnected");
}
// 接受时出现异常
@Override
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
super.exceptionCaught(ctx, e);
System.out.println("exceptionCaught");
}
// 接受客户端数据
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
super.messageReceived(ctx, e);
System.out.println("messageReceived");
System.out.println("服务器向客户端回复的内容:"+e.getMessage());
}
}
public class NettyClient {
public static void main(String[] args) {
// 1、首先建立连接
ClientBootstrap clientBootstrap = new ClientBootstrap();
// 2、创建两个线程池
ExecutorService boos = Executors.newCachedThreadPool();
ExecutorService wook = Executors.newCachedThreadPool();
// 3、将线程池放入工程
clientBootstrap.setFactory(new NioClientSocketChannelFactory(boos, wook));
// 4、设置管道工程
clientBootstrap.setPipelineFactory(new ChannelPipelineFactory() {
public ChannelPipeline getPipeline() throws Exception {
ChannelPipeline pipeline = org.jboss.netty.channel.Channels.pipeline();
// 传输数据的时候直接为string类型
pipeline.addLast("decoder", new StringDecoder());
pipeline.addLast("encoder", new StringEncoder());
// 设置事件监听类
pipeline.addLast("clientHandler", new ClientHandler());
return pipeline;
}
});
// 绑定端口号
ChannelFuture connect = clientBootstrap.connect(new InetSocketAddress("10.110.1.34", 8080));
Channel channel = connect.getChannel();
System.out.println("客户端已经开始启动...");
Scanner scanner = new Scanner(System.in);
while(true) {
System.out.println("请输入内容:");
channel.write(scanner.next());
}
}
}
Netty服务端和客户端运行结果:
四、长连接和短连接、基于Netty4.0的客户和服务端
1、长连接:
服务端和客户端一直保持着通信连接。比如,移动端消息推送、MQ
2、短连接:
HTTP协议。
3、基于Netty4.0的服务端
代码:
package com.itmayideu;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.FixedLengthFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
class ServerHandler extends ChannelHandlerAdapter{
// 当通道被调用,执行方法(拿到数据)
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
super.channelRead(ctx, msg);
String value = (String) msg;
System.out.println("服务器端收到客户端msg:"+value);
// 回复客户端
ctx.writeAndFlush("over");
}
}
public class NettyServer {
public static void main(String[] args) {
try {
System.out.println("服务器端启动....");
// 1、创建两个线程池,一个负责接受客户端,一个进行传输
NioEventLoopGroup pGroup = new NioEventLoopGroup();
NioEventLoopGroup cGroup = new NioEventLoopGroup();
// 2、创建辅助类
ServerBootstrap b = new ServerBootstrap();
b.group(pGroup, cGroup).channel(NioServerSocketChannel.class).option(ChannelOption.SO_BACKLOG, 1024)
// 3.设置缓冲区与发送区大小
.option(ChannelOption.SO_SNDBUF, 32 * 1024).option(ChannelOption.SO_RCVBUF, 32 * 1024)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel sc) throws Exception {
sc.pipeline().addLast(new StringDecoder());
sc.pipeline().addLast(new ServerHandler());
}
});
// 启动
ChannelFuture cf = b.bind(8080).sync();
// 关闭
cf.channel().closeFuture().sync();
pGroup.shutdownGracefully();
cGroup.shutdownGracefully();
}catch (Exception e) {
e.printStackTrace();
}
}
}
4、基于Netty4.0的客户端
代码:
package com.itmayideu;
import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.FixedLengthFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
class ClientHandler extends ChannelHandlerAdapter{
// 当通道被调用执行该方法
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
// 接受数据
super.channelRead(ctx, msg);
String value = (String)msg;
System.out.println("客户端接受消息:"+value);
}
}
public class NettyClient {
public static void main(String[] args) throws InterruptedException {
System.out.println("客户端已经启动...");
// 创建负责接受客户端连接
NioEventLoopGroup pGroup = new NioEventLoopGroup();
Bootstrap b = new Bootstrap();
b.group(pGroup).channel(NioSocketChannel.class).handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel sc) throws Exception {
sc.pipeline().addLast(new StringDecoder());
sc.pipeline().addLast(new ClientHandler());
}
});
// 端口
ChannelFuture cf = b.connect("10.110.1.34",8080).sync();
cf.channel().writeAndFlush(Unpooled.wrappedBuffer("woyaoliangwan".getBytes()));
cf.channel().writeAndFlush(Unpooled.wrappedBuffer("woyaosanwan".getBytes()));
cf.channel().writeAndFlush(Unpooled.wrappedBuffer("woyaowuwan".getBytes()));
//等待客户端端口号关闭
cf.channel().closeFuture().sync();
pGroup.shutdownGracefully();
}
}
运行结果:
5、错误:远程主机强迫关闭一个现有的连接
原因:客户端没有正常四次挥手关闭连接,服务端报错。
五、粘包和拆包
1、介绍:
一个完整的业务可能会被TCP拆分成多个包进行发送,也有可能把多个小的包封装成一个大的数据包发送,这个就是TCP的拆包和封包问题。
下面可以看一张图,是客户端向服务端发送包:
图示介绍:
1. 第一种情况,Data1和Data2都分开发送到了Server端,没有产生粘包和拆包的情况。
2. 第二种情况,Data1和Data2数据粘在了一起,打成了一个大的包发送到Server端,这个情况就是粘包。
3. 第三种情况,Data2被分离成Data2_1和Data2_2,并且Data2_1在Data1之前到达了服务端,这种情况就产生了拆包。
由于网络的复杂性,可能数据会被分离成N多个复杂的拆包/粘包的情况,所以在做TCP服务器的时候就需要首先解决拆包/
2、粘包:
cf.channel().writeAndFlush(Unpooled.wrappedBuffer("woyaoliangwan".getBytes()));
Thread.sleep(1000);
cf.channel().writeAndFlush(Unpooled.wrappedBuffer("woyaosanwan".getBytes()));
Thread.sleep(1000);
cf.channel().writeAndFlush(Unpooled.wrappedBuffer("woyaowuwan".getBytes()));
//以上服务端会三次接受消息
cf.channel().writeAndFlush(Unpooled.wrappedBuffer("woyaoliangwan".getBytes()));
cf.channel().writeAndFlush(Unpooled.wrappedBuffer("woyaosanwan".getBytes()));
cf.channel().writeAndFlush(Unpooled.wrappedBuffer("woyaowuwan".getBytes()));
//以上服务端会一次接受客户端发送的消息
3、拆包
1)消息定长,报文大小固定长度,不够空格补全,发送和接收方遵循相同的约定,这样即使粘包了通过接收方编程实现获取定长报文也能区分。
2)包尾添加特殊分隔符,例如每条报文结束都添加回车换行符(例如FTP协议)或者指定特殊字符作为报文分隔符,接收方通过特殊分隔符切分报文区分。
3)将消息分为消息头和消息体,消息头中包含表示信息的总长度(或者消息体长度)的字段
六、序列化与自定义序列化协议
1、序列化和反序列化
序列化(serialization)就是将对象序列化为二进制形式(字节数组),一般也将序列化称为编码(Encode),主要用于网络传输、数据持久化等;
反序列化(deserialization)则是将从网络、磁盘等读取的字节数组还原成原始对象,以便后续业务的进行,一般也将反序列化称为解码(Decode),主要用于网络传输对象的解码,以便完成远程调用。
2、自定义序列化协议
XML
(1)定义:
XML(Extensible Markup Language)是一种常用的序列化和反序列化协议, 它历史悠久,从1998年的1.0版本被广泛使用至今。
(2)优点
人机可读性好
可指定元素或特性的名称
(3)缺点
序列化数据只包含数据本身以及类的结构,不包括类型标识和程序集信息。
类必须有一个将由 XmlSerializer 序列化的默认构造函数。
只能序列化公共属性和字段
不能序列化方法
文件庞大,文件格式复杂,传输占带宽
(4)使用场景
当做配置文件存储数据
实时数据转换
JSON
(1)定义:
JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。它基于 ECMAScript (w3c制定的js规范)的一个子集, JSON采用与编程语言无关的文本格式,但是也使用了类C语言(包括C, C++, C#, Java, JavaScript, Perl, Python等)的习惯,简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。
(2)优点
前后兼容性高
数据格式比较简单,易于读写
序列化后数据较小,可扩展性好,兼容性好
与XML相比,其协议比较简单,解析速度比较快
(3)缺点
数据的描述性比XML差
不适合性能要求为ms级别的情况
额外空间开销比较大
(4)适用场景(可替代XML)
跨防火墙访问
可调式性要求高的情况
基于Web browser的Ajax请求
传输数据量相对小,实时性要求相对低(例如秒级别)的服务
Fastjson
(1)定义
Fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法,把JSON Parse的性能提升到极致。
(2)优点
接口简单易用
目前java语言中最快的json库
(3)缺点
过于注重快,而偏离了“标准”及功能性
代码质量不高,文档不全
(4)适用场景
协议交互
Web输出
Android客户端
Thrift
(1)定义:
Thrift并不仅仅是序列化协议,而是一个RPC框架。它可以让你选择客户端与服务端之间传输通信协议的类别,即文本(text)和二进制(binary)传输协议, 为节约带宽,提供传输效率,一般情况下使用二进制类型的传输协议。
(2)优点
序列化后的体积小, 速度快
支持多种语言和丰富的数据类型
对于数据字段的增删具有较强的兼容性
支持二进制压缩编码
(3)缺点
使用者较少
跨防火墙访问时,不安全
不具有可读性,调试代码时相对困难
不能与其他传输层协议共同使用(例如HTTP)
无法支持向持久层直接读写数据,即不适合做数据持久化序列化协议
(4)适用场景
分布式系统的RPC解决方案
Avro
(1)定义:
Avro属于Apache Hadoop的一个子项目。 Avro提供两种序列化格式:JSON格式或者Binary格式。Binary格式在空间开销和解析性能方面可以和Protobuf媲美,Avro的产生解决了JSON的冗长和没有IDL的问题
(2)优点
支持丰富的数据类型
简单的动态语言结合功能
具有自我描述属性
提高了数据解析速度
快速可压缩的二进制数据形式
可以实现远程过程调用RPC
支持跨编程语言实现
(3)缺点
对于习惯于静态类型语言的用户不直观
(4)适用场景
在Hadoop中做Hive、Pig和MapReduce的持久化数据格式
Protobuf
(1)定义
protocol buffers 由谷歌开源而来,在谷歌内部久经考验。它将数据结构以.proto文件进行描述,通过代码生成工具可以生成对应数据结构的POJO对象和Protobuf相关的方法和属性。
(2)优点
序列化后码流小,性能高
结构化数据存储格式(XML JSON等)
通过标识字段的顺序,可以实现协议的前向兼容
结构化的文档更容易管理和维护
(3)缺点
需要依赖于工具生成代码
支持的语言相对较少,官方只支持Java 、C++ 、Python
(4)适用场景
对性能要求高的RPC调用
具有良好的跨防火墙的访问属性
适合应用层对象的持久化
其它
protostuff 基于protobuf协议,但不需要配置proto文件,直接导包即
Jboss marshaling 可以直接序列化java类, 无须实java.io.Serializable接口
Message pack 一个高效的二进制序列化格式
Hessian 采用二进制协议的轻量级remoting onhttp工具
kryo 基于protobuf协议,只支持java语言,需要注册(Registration),然后序列化(Output),反序列化(Input)