首先声明, 本文是为 Netty 新手准备的, 所以事无巨细的会把步骤列出来, 老手们就不用在我这篇文章上浪费时间了, 要不然你会嫌我墨迹的.
一, 前言
Netty 是一个开源的异步事件驱动的网络应用程序框架, 用于快速开发可维护的高性能协议服务器和客户端.
Netty 的创始人是韩国人 trustin lee, 他现在韩国 line 公司工作, 早前应用较多的 Mina 也是这牛人的作品.
Netty 目前的项目 leader 是德国人 Norman maurer(之前在 RedHat, 全职开发 Netty), 也是《Netty in action》的作者, 目前是苹果公司高级工程师, 同时也经常参加 netty 相关的技术会议, 这两大牛长下面这样:
Netty 的优点, 简单一句话: 使用简单, 功能强大, 性能强悍.
Netty 的特点:
高并发: Netty 是一款基于 NIO(Nonblocking IO, 非阻塞 IO)开发的网络通信框架, 对比于 BIO(Blocking I/O, 阻塞 IO), 他的并发性能得到了很大提高.
传输快: Netty 的传输依赖于零拷贝特性, 尽量减少不必要的内存拷贝, 实现了更高效率的传输.
封装好: Netty 封装了 NIO 操作的很多细节, 提供了易于使用调用接口.
Netty 的优势:
使用简单: 封装了 NIO 的很多细节, 使用更简单.
功能强大: 预置了多种编解码功能, 支持多种主流协议.
定制能力强: 可以通过 ChannelHandler 对通信框架进行灵活地扩展.
性能高: 通过与其他业界主流的 NIO 框架对比, Netty 的综合性能最优.
稳定: Netty 修复了已经发现的所有 NIO 的 bug, 让开发人员可以专注于业务本身.
社区活跃: Netty 是活跃的开源项目, 版本迭代周期短, bug 修复速度快.
Netty 高性能表现在哪些方面?
IO 线程模型: 同步非阻塞, 用最少的资源做更多的事.
内存零拷贝: 尽量减少不必要的内存拷贝, 实现了更高效率的传输.
内存池设计: 申请的内存可以重用, 主要指直接内存. 内部实现是用一颗二叉查找树管理内存分配情况.
串形化处理读写: 避免使用锁带来的性能开销.
高性能序列化协议: 支持 protobuf 等高性能序列化协议.
BIO,NIO 和 AIO 的区别是什么?
这三个概念分别对应三种通讯模型: 阻塞, 非阻塞, 非阻塞异步, 概念这里就不写了, 大家可以度娘搜一下, 网上好多博客说 Netty 对应 NIO, 准确来说, 应该是既可以是 NIO, 也可以是 AIO, 就看你怎么实现, 这三个的区别如下:
BIO: 一个连接一个线程, 客户端有连接请求时服务器端就需要启动一个线程进行处理, 线程开销大. 伪异步 IO: 将请求连接放入线程池, 一对多, 但线程还是很宝贵的资源.
NIO: 一个请求一个线程, 但客户端发送的连接请求都会注册到多路复用器上, 多路复用器轮询到连接有 I/O 请求时才启动一个线程进行处理.
AIO: 一个有效请求一个线程, 客户端的 I/O 请求都是由 OS 先完成了再通知服务器应用去启动线程进行处理.
BIO 是面向流的, NIO 是面向缓冲区的; BIO 的各种流是阻塞的. 而 NIO 是非阻塞的; BIO 的 Stream 是单向的, 而 NIO 的 channel 是双向的.
NIO 的特点: 事件驱动模型, 单线程处理多任务, 非阻塞 I/O,I/O 读写不再阻塞, 而是返回 0, 基于 block 的传输比基于流的传输更高效, 更高级的 IO 函数 zero-copy,IO 多路复用大大提高了 Java 网络应用的可伸缩性和实用性. 基于 Reactor 线程模型.
二, Netty 能做什么?
学技能都是为了能够应用到实际工作中去, 谁也不是为了学而学, 弄着玩不是, 那么 Netty 能做什么呢? 主要是在两个方面:
现在物联网的应用无处不在, 大量的项目都牵涉到应用传感器和服务器端的数据通信, Netty 作为基础通信组件, 能够轻松解决之前有较高门槛的通信系统开发, 你不用再为如何解析各类简单, 或复杂的通讯协议而薅头发了, 有过这方面开发经验的程序员会有更深刻, 或者说刻骨铭心的体会.
现在互联网系统讲究的都是高并发, 分布式, 微服务, 各类消息满天飞, Netty 在这类架构里面的应用可谓是如鱼得水, 如果你对当前的各种应用服务器不爽, 那么完全可以基于 Netty 来实现自己的 HTTP 服务器, FTP 服务器, UDP 服务器, RPC 服务器, webSocket 服务器, Redis 的 Proxy 服务器, MySQL 的 Proxy 服务器等等.
三, 掌握 Netty 有什么好处呢?
直接的好处是: 能够有进大厂, 拿高薪的机会, 业内好多著名的公司在招聘 ** 高级 / 资深 Java 工程师时基本上都要求熟练掌握, 或熟悉 Netty.
这个名单还可以很长很长...
作为一个学 Java 的, 如果没有研究过 Netty, 那么你对 Java 语言的使用和理解仅仅停留在表面水平, 会点 SSH, 写几个 MVC, 访问数据库和缓存, 这些只是初, 中等 Java 程序员干的事. 如果你要进阶, 想了解 Java 服务器的深层高阶知识, Netty 绝对是一个必须要过的门槛.
间接地好处是: 多款开源框架中应用了 Netty, 掌握了 Netty, 就具有分析这些开源框架的基础了, 也就是有了成为技术大牛的基础.
这些开源框架有哪些呢? 简单罗列一些典型的, 如下:
阿里分布式服务框架 Dubbo 的 RPC 框架;
淘宝的消息中间件 RocketMQ;
Hadoop 的高性能通信和序列化组件 Avro 的 RPC 框架;
开源集群运算框架 Spark;
分布式计算框架 Storm;
并发应用和分布式应用 Akka;
名单依然很长很长....
四, 动手开干, 实现一个传输字符串的简单实例
在开始动手之前, 必要的基础概念还是要知道的, 要不然代码敲下来, 功能倒是实现了, 但对 Netty 还是一头雾水, 这就不是本文要达到的目的了.
本示例需要用到的基础知识主要有以下几方面的东东, 这些知识点最好有一个大概的了解, 要不然, 看实例会有一定的困难.
掌握 Java 基础
掌握 Maven 基础
熟悉 IntelliJ IDEA 集成开发工具的使用, 这个工具简称 IDEA
知道 TCP,Socket 的基本概念
1,Netty 的组件
I/O: 各种各样的流 (文件, 数组, 缓冲, 管道...) 的处理(输入输出).
Channel: 通道, 代表一个连接, 每个 Client 请对会对应到具体的一个 Channel.
ChannelPipeline: 责任链, 每个 Channel 都有且仅有一个 ChannelPipeline 与之对应, 里面是各种各样的 Handler.
handler: 用于处理出入站消息及相应的事件, 实现我们自己要的业务逻辑.
EventLoopGroup:I/O 线程池, 负责处理 Channel 对应的 I/O 事件.
ServerBootstrap: 服务器端启动辅助对象.
Bootstrap: 客户端启动辅助对象.
ChannelInitializer:Channel 初始化器.
ChannelFuture: 代表 I/O 操作的执行结果, 通过事件机制, 获取执行结果, 通过添加监听器, 执行我们想要的操作.
ByteBuf: 字节序列, 通过 ByteBuf 操作基础的字节数组和缓冲区.
2, 基础环境准备
基础环境准备主要有三个方面: JDK 安装及环境变量设置, Maven 安装及环境变量设置, IDEA 安装及基本设置.
2.1,JDK 安装及环境变量设置
JDK 下载, 可以从官方现在, 也可以度娘上随便搜下载链接, 最新版是 JDK14, 我这里下载的是 JDK8, 用 8 还是 14 哪个版本无所谓, 都可以, 但要注意一点的是, 现在从 JDK 的官网 Oracle 下载需要账号了, 没账号的可下不了啦, 不知道在搞什么东东.
官网下载地址: https://www.oracle.com/ , 截图如下:
下载完, 一路 Next 安装完, 在创建 Java 环境变量设置,[此电脑]右键 -->[属性]-->[高级系统设置]-->[环境变量]-->[系统变量], 截图如下:
Java 环境变量创建完毕后, 在 DOS 窗口执行命令: java -version, 测试一下是否正常
2.2,Maven 安装及环境变量设置
Maven 功能很强大, 但大家不用担心, 本实例中仅仅是利用其便利的 jar 包依赖, jar 包依赖传递, 基本上没有任何学习成本.
jar 包依赖, jar 包依赖传递的概念如下图, 清楚明了, 都不用多做解释:
Maven 是下载, 解压缩后, 配置环境变量后就能用, 不用安装的.
下载地址
安装: 下载压缩包, 解压, 文件夹拷贝到所想存储的位置(如 C 盘根目录)
配置环境变量, 和 Java 的环境变量配置一样的, 创建 MAVEN_HOME, 指向 Maven 文件夹, 再在 path 中添加进去就行, 如下图:
由于直接冲 Maven 的中央仓库中自动下载 jar 包较慢, 一般在 Maven 的配置文件中, 增加阿里云的公共仓库配置, 这样会显著加快 jar 包的下载速度, 如下:
上面的环境变量设置完后, 通过 DOS 窗口中输入命令: mvn -version 进行验证是否成功, 如下:
2.3,IDEA 安装及基本设置
IDEA 的下载和安装就不多说了, 其版本分旗舰版和社区版, 旗舰版收费, 社区版免费, 社区版不支持 html,JS,CSS 等, 但对于本实例, 社区版就够用了, 但如果你不在乎那点银子, 可以考虑旗舰版, 一步到位, 万一后面我们还要做 Web 系统开发可以免得折腾.
其安装不用多说, 一路 Next 就行, 安装完后, 在其配置里面指定一下 JDK,Maven 的位置就行了, 如下图:
Maven 指定:[File]-->[setting]-->[Build,Excution,Deployment]-->[Build Tools]-->[Maven]
JDK 指定:[File]-->[Project Structure]-->[Project Setting]-->[Project]
3, 在 IDEA 中创建 Maven 工程
新建工程
填写包名及工程名称
Maven 配置
生成工程, 自动创建 Maven 的依赖文件
在 pom.xml 中配置 Netty 依赖
经过上面的步骤, 我们的 Maven 工程就已经创建完毕, 现在可以编写 Netty 的第一个程序, 这个程序很简单, 传输一个字符串, 虽然程序很简单, 但是已经能够大体上反映 Netty 开发通信程序的一个整体流程了.
4,Netty 开发的基本流程
Netty 开发的基本流程很简洁, 服务器端和客户端都是这个套路, 如下:
Netty 开发的实际过程, 这是一个简化的过程, 但已经把大概流程表达出来了, 绿色的代表客户端流程, 蓝色的代表服务器端流程, 注意标红的部分, 见下图:
4.1 创建客户端类
创建 Handler
首先创建 Handler 类, 该类用于接收服务器端发送的数据, 这是一个简化的类, 只重写了消息读取方法 channelRead0, 捕捉异常方法 exceptionCaught.
客户端的 Handler 一般继承的是 SimpleChannelInboundHandler, 该类有丰富的方法, 心跳, 超时检测, 连接状态等等.
代码如下:
- package com.jcj.helloworld;
- import io.netty.buffer.ByteBuf;
- import io.netty.channel.ChannelHandler;
- import io.netty.channel.ChannelHandlerContext;
- import io.netty.channel.SimpleChannelInboundHandler;
- import io.netty.util.CharsetUtil;
- /**
- * @Auther: 江成军
- * @Date: 2020/6/1 11:12
- * @Description: 通用 handler, 处理 I/O 事件
- */
- @ChannelHandler.Sharable
- public class HandlerClientHello extends SimpleChannelInboundHandler<ByteBuf>
- {
- @Override
- protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception
- {
- /**
- * @Author 江成军
- * @Date 2020/6/1 11:17
- * @Description 处理接收到的消息
- **/
- System.out.println("接收到的消息:"+byteBuf.toString(CharsetUtil.UTF_8));
- }
- @Override
- public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception
- {
- /**
- * @Author 江成军
- * @Date 2020/6/1 11:20
- * @Description 处理 I/O 事件的异常
- **/
- cause.printStackTrace();
- ctx.close();
- }
- }
代码说明:
@ChannelHandler.Sharable, 这个注解是为了线程安全, 如果你不在乎是否线程安全, 不加也可以.
SimpleChannelInboundHandler, 这里的类型可以是 ByteBuf, 也可以是 String, 还可以是对象, 根据实际情况来.
channelRead0, 消息读取方法, 注意名称中有个 0.
ChannelHandlerContext, 通道上下文, 代指 Channel.
ByteBuf, 字节序列, 通过 ByteBuf 操作基础的字节数组和缓冲区, 因为 JDK 原生操作字节麻烦, 效率低, 所以 Netty 对字节的操作进行了封装, 实现了指数级的性能提升, 同时使用更加便利.
CharsetUtil.UTF_8, 这个是 JDK 原生的方法, 用于指定字节数组转换为字符串时的编码格式.
创建客户端启动类
客户端启动类根据服务器端的 IP 和端口, 建立连接, 连接建立后, 实现消息的双向传输.
代码较简洁, 如下:
- package com.jcj.helloworld;
- import com.sun.org.apache.bcel.internal.generic.ATHROW;
- import io.netty.Bootstrap.Bootstrap;
- import io.netty.buffer.Unpooled;
- 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.NioSocketChannel;
- import io.netty.util.CharsetUtil;
- import java.NET.InetSocketAddress;
- /**
- * @Auther: 江成军
- * @Date: 2020/6/1 11:24
- * @Description: 客户端启动类
- */
- public class AppClientHello
- {
- private final String host;
- private final int port;
- public AppClientHello(String host, int port)
- {
- this.host = host;
- this.port = port;
- }
- public void run() throws Exception
- {
- /**
- * @Author 江成军
- * @Date 2020/6/1 11:28
- * @Description 配置相应的参数, 提供连接到远端的方法
- **/
- EventLoopGroup group = new NioEventLoopGroup();//I/O 线程池
- try {
- Bootstrap bs = new Bootstrap();// 客户端辅助启动类
- bs.group(group)
- .channel(NioSocketChannel.class)// 实例化一个 Channel
- .remoteAddress(new InetSocketAddress(host,port))
- .handler(new ChannelInitializer<SocketChannel>()// 进行通道初始化配置
- {
- @Override
- protected void initChannel(SocketChannel socketChannel) throws Exception
- {
- socketChannel.pipeline().addLast(new HandlerClientHello());// 添加我们自定义的 Handler
- }
- });
- // 连接到远程节点; 等待连接完成
- ChannelFuture future=bs.connect().sync();
- // 发送消息到服务器端, 编码格式是 utf-8
- future.channel().writeAndFlush(Unpooled.copiedBuffer("Hello World", CharsetUtil.UTF_8));
- // 阻塞操作, closeFuture()开启了一个 channel 的监听器(这期间 channel 在进行各项工作), 直到链路断开
- future.channel().closeFuture().sync();
- } finally {
- group.shutdownGracefully().sync();
- }
- }
- public static void main(String[] args) throws Exception
- {
- new AppClientHello("127.0.0.1",18080).run();
- }
- }
由于代码中已经添加了详尽的注释, 这里只对极个别的进行说明:
ChannelInitializer, 通道 Channel 的初始化工作, 如加入多个 handler, 都在这里进行.
bs.connect().sync(), 这里的 sync()表示采用的同步方法, 这样连接建立成功后, 才继续往下执行.
pipeline(), 连接建立后, 都会自动创建一个管道 pipeline, 这个管道也被称为责任链, 保证顺序执行, 同时又可以灵活的配置各类 Handler, 这是一个很精妙的设计, 既减少了线程切换带来的资源开销, 避免好多麻烦事, 同时性能又得到了极大增强.
4.2 创建服务器端类
创建 Handler
和客户端, 只重写了消息读取方法 channelRead(注意这里不是 channelRead0), 捕捉异常方法 exceptionCaught.
另外服务器端 Handler 继承的是 ChannelInboundHandlerAdapter, 而不是 SimpleChannelInboundHandler, 至于这两者的区别, 这里赘述, 大家自行百度吧.
代码如下:
- package com.jcj.helloworld;
- import io.netty.buffer.ByteBuf;
- import io.netty.buffer.Unpooled;
- import io.netty.channel.ChannelHandler;
- import io.netty.channel.ChannelHandlerContext;
- import io.netty.channel.ChannelInboundHandlerAdapter;
- import io.netty.util.CharsetUtil;
- /**
- * @Auther: 江成军
- * @Date: 2020/6/1 11:47
- * @Description: 服务器端 I/O 处理类
- */
- @ChannelHandler.Sharable
- public class HandlerServerHello extends ChannelInboundHandlerAdapter
- {
- @Override
- public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception
- {
- // 处理收到的数据, 并反馈消息到到客户端
- ByteBuf in = (ByteBuf) msg;
- System.out.println("收到客户端发过来的消息:" + in.toString(CharsetUtil.UTF_8));
- // 写入并发送信息到远端(客户端)
- ctx.writeAndFlush(Unpooled.copiedBuffer("你好, 我是服务端, 我已经收到你发送的消息", CharsetUtil.UTF_8));
- }
- @Override
- public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception
- {
- // 出现异常的时候执行的动作(打印并关闭通道)
- cause.printStackTrace();
- ctx.close();
- }
- }
以上代码很简洁, 大家注意和客户端 Handler 类进行比较.
创建服务器端启动类
服务器端启动类比客户端启动类稍显复杂一点, 先贴出代码如下:
- package com.jcj.helloworld;
- 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 java.NET.InetSocketAddress;
- /**
- * @Auther: 江成军
- * @Date: 2020/6/1 11:51
- * @Description: 服务器端启动类
- */
- public class AppServerHello
- {
- private int port;
- public AppServerHello(int port)
- {
- this.port = port;
- }
- public void run() throws Exception
- {
- EventLoopGroup group = new NioEventLoopGroup();//Netty 的 Reactor 线程池, 初始化了一个 NioEventLoop 数组, 用来处理 I/O 操作, 如接受新的连接和读 / 写数据
- try {
- ServerBootstrap b = new ServerBootstrap();// 用于启动 NIO 服务
- b.group(group)
- .channel(NioServerSocketChannel.class) // 通过工厂方法设计模式实例化一个 channel
- .localAddress(new InetSocketAddress(port))// 设置监听端口
- .childHandler(new ChannelInitializer<SocketChannel>() {
- //ChannelInitializer 是一个特殊的处理类, 他的目的是帮助使用者配置一个新的 Channel, 用于把许多自定义的处理类增加到 pipline 上来
- @Override
- public void initChannel(SocketChannel ch) throws Exception {//ChannelInitializer 是一个特殊的处理类, 他的目的是帮助使用者配置一个新的 Channel.
- ch.pipeline().addLast(new HandlerServerHello());// 配置 childHandler 来通知一个关于消息处理的 InfoServerHandler 实例
- }
- });
- // 绑定服务器, 该实例将提供有关 IO 操作的结果或状态的信息
- ChannelFuture channelFuture= b.bind().sync();
- System.out.println("在" + channelFuture.channel().localAddress()+"上开启监听");
- // 阻塞操作, closeFuture()开启了一个 channel 的监听器(这期间 channel 在进行各项工作), 直到链路断开
- channelFuture.channel().closeFuture().sync();
- } finally {
- group.shutdownGracefully().sync();// 关闭 EventLoopGroup 并释放所有资源, 包括所有创建的线程
- }
- }
- public static void main(String[] args) throws Exception
- {
- new AppServerHello(18080).run();
- }
- }
代码说明:
EventLoopGroup, 实际项目中, 这里创建两个 EventLoopGroup 的实例, 一个负责接收客户端的连接, 另一个负责处理消息 I/O, 这里为了简单展示流程, 让一个实例把这两方面的活都干了.
NioServerSocketChannel, 通过工厂通过工厂方法设计模式实例化一个 channel, 这个在大家还没有能够熟练使用 Netty 进行项目开发的情况下, 不用去深究.
到这里, 我们就把服务器端和客户端都写完了 , 如何运行呢, 先在服务器端启动类上右键, 点 Run 'AppServerHello.main()'菜单运行, 见下图:
然后, 再同样的操作, 运行客户端启动类, 就能看见效果了.
5, 尾声
本文的内容就到这里结束了, 希望本文能够让大家对 Netty 有一个整体的认识, 并大概了解其开发流程.
Netty 的功能很多, 本文只是一个入门的介绍, 如果大家对于 Netty 开发有兴趣, 可以关注我并给我留言, 我会根据关注和留言情况, 陆续再撰写 Netty 实战开发的文章.
得到肯定和正向反馈, 才有继续写下去的愿望和动力, 毕竟写这种事无巨细的文章, 还是挺费精力的.
来源: https://www.cnblogs.com/chamu/p/13217490.html