还在被Java NIO虐？该试试Netty了！

时间 2021-04-14

标签 css html java 程序员数据库 apache bootstrap 设计模式数组缓存栏目 Java 繁體版

原文原文链接

首先声明，本文是为Netty新手准备的，因此事无巨细的会把步骤列出来，老手们就不用在我这篇文章上浪费时间了，要否则你会嫌我墨迹的。css

1、前言

Netty是一个开源的异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。html

Netty的创始人是韩国人trustin lee，他如今韩国line公司工做，早前应用较多的Mina也是这牛人的做品。java

Netty目前的项目leader是德国人Norman maurer（以前在Redhat，全职开发Netty）,也是《Netty in action》的做者，目前是苹果公司高级工程师，同时也常常参加netty相关的技术会议，这两大牛长下面这样：
程序员

Netty的优势，简单一句话：使用简单、功能强大、性能强悍。数据库

Netty的特色：apache

高并发：Netty 是一款基于 NIO（Nonblocking IO，非阻塞IO）开发的网络通讯框架，对比于 BIO（Blocking I/O，阻塞IO），他的并发性能获得了很大提升。bootstrap

传输快：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线程模型。

2、Netty能作什么？

学技能都是为了可以应用到实际工做中去，谁也不是为了学而学、弄着玩不是，那么Netty能作什么呢？主要是在两个方面：

如今物联网的应用无处不在，大量的项目都牵涉到应用传感器和服务器端的数据通讯，Netty做为基础通讯组件、可以轻松解决以前有较高门槛的通讯系统开发，你不用再为如何解析各种简单、或复杂的通信协议而薅头发了，有过这方面开发经验的程序员会有更深入、或者说刻骨铭心的体会。
如今互联网系统讲究的都是高并发、分布式、微服务，各种消息满天飞，Netty在这类架构里面的应用可谓是如鱼得水，若是你对当前的各类应用服务器不爽，那么彻底能够基于Netty来实现本身的HTTP服务器，FTP服务器，UDP服务器，RPC服务器，WebSocket服务器，Redis的Proxy服务器，MySQL的Proxy服务器等等。

3、掌握Netty有什么好处呢？

直接的好处是：可以有进大厂、拿高薪的机会，业内好多著名的公司在招聘高级/资深Java工程师时基本上都要求熟练掌握、或熟悉Netty。

这个名单还能够很长很长。。。

做为一个学Java的，若是没有研究过Netty，那么你对Java语言的使用和理解仅仅停留在表面水平，会点SSH，写几个MVC，访问数据库和缓存，这些只是初、中等Java程序员干的事。若是你要进阶，想了解Java服务器的深层高阶知识，Netty绝对是一个必需要过的门槛。

间接地好处是：多款开源框架中应用了Netty，掌握了Netty，就具备分析这些开源框架的基础了，也就是有了成为技术大牛的基础。

这些开源框架有哪些呢？简单罗列一些典型的，以下：

阿里分布式服务框架 Dubbo 的 RPC 框架；

淘宝的消息中间件 RocketMQ；

Hadoop 的高性能通讯和序列化组件 Avro 的 RPC 框架；

开源集群运算框架 Spark；

分布式计算框架 Storm；

并发应用和分布式应用 Akka；

名单依然很长很长。。。。

4、动手开干、实现一个传输字符串的简单实例

在开始动手以前，必要的基础概念仍是要知道的，要否则代码敲下来，功能却是实现了，但对Netty仍是一头雾水，这就不是本文要达到的目的了。

本示例须要用到的基础知识主要有如下几方面的东东，这些知识点最好有一个大概的了解，要否则，看实例会有必定的困难。

掌握Java基础

掌握Maven基础

熟悉IntelliJ IDEA集成开发工具的使用，这个工具简称IDEA

知道TCP、Socket的基本概念

一、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操做基础的字节数组和缓冲区。

二、基础环境准备

基础环境准备主要有三个方面：JDK安装及环境变量设置、Maven安装及环境变量设置、IDEA安装及基本设置。

2.一、JDK安装及环境变量设置

JDK下载，能够从官方如今，也能够度娘上随便搜下载连接，最新版是JDK14，我这里下载的是JDK8，用8仍是14哪一个版本无所谓，均可以，但要注意一点的是，如今从JDK的官网Oracle下载须要帐号了，没帐号的可下不了啦，不知道在搞什么东东。
官网下载地址：https://www.oracle.com ，截图以下：

下载完，一路Next安装完，在建立Java环境变量设置，[此电脑]右键-->[属性]-->[高级系统设置]-->[环境变量]-->[系统变量]，截图以下：

Java环境变量建立完毕后，在DOS窗口执行命令：java -version，测试一下是否正常

2.二、Maven安装及环境变量设置

Maven功能很强大，但你们不用担忧、本实例中仅仅是利用其便利的jar包依赖、jar包依赖传递，基本上没有任何学习成本。

jar包依赖、jar包依赖传递的概念以下图，清楚明了，都不用多作解释：

Maven是下载，解压缩后，配置环境变量后就能用，不用安装的。

下载地址https://downloads.apache.org/maven/maven-3/3.6.3/binaries/

安装：下载压缩包，解压，文件夹拷贝到所想存储的位置（如C盘根目录）

配置环境变量，和Java的环境变量配置同样的，建立MAVEN_HOME,指向Maven文件夹，再在path中添加进去就行，以下图：

因为直接冲Maven的中央仓库中自动下载jar包较慢，通常在Maven的配置文件中，增长阿里云的公共仓库配置，这样会显著加快jar包的下载速度，以下：

上面的环境变量设置完后，经过DOS窗口中输入命令：mvn -version 进行验证是否成功，以下：

2.三、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]

三、在IDEA中建立Maven工程

新建工程

填写包名及工程名称

Maven配置

生成工程，自动建立Maven的依赖文件

在pom.xml中配置Netty依赖

通过上面的步骤，咱们的Maven工程就已经建立完毕，如今能够编写Netty的第一个程序，这个程序很简单，传输一个字符串，虽然程序很简单，可是已经可以大致上反映Netty开发通讯程序的一个总体流程了。

四、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()'菜单运行，见下图：

而后，再一样的操做，运行客户端启动类，就能看见效果了。

五、尾声

本文的内容就到这里结束了，但愿本文可以让你们对Netty有一个总体的认识，并大概了解其开发流程。

Netty的功能不少，本文只是一个入门的介绍，若是你们对于Netty开发有兴趣，能够关注我并给我留言，我会根据关注和留言状况，陆续再撰写Netty实战开发的文章。

获得确定和正向反馈，才有继续写下去的愿望和动力，毕竟写这种事无巨细的文章，仍是挺费精力的。

若是对Netty很感兴趣，同时又等不及文章的龟速更新，能够参考一下视频
51CTO：Netty教程：十二个实例带你轻松掌握Netty
腾讯课堂：Netty教程：十二个实例带你轻松掌握Netty
CSDN学院：Netty教程：十二个实例带你轻松掌握Netty
网易云课堂：Netty教程：十二个实例带你轻松掌握Netty