Netty教程

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

一、前言

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

Netty的创始人是韩国人trustin lee,他现在韩国line公司工作,早前应用较多的Mina也是这牛人的作品。

Netty目前的项目leader是德国人Norman maurer(之前在Redhat,全职开发Netty),也是《Netty in action》的作者,目前是苹果公司高级工程师,同时也经常参加netty相关的技术会议,这两大牛长下面这样:

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。

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 ,截图如下:

Netty教程 Netty教程 Netty教程

下载完,一路Next安装完,在创建Java环境变量设置,[此电脑]右键–>[属性]–>[高级系统设置]–>[环境变量]–>[系统变量],截图如下:

Netty教程

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

Netty教程

2.2、Maven安装及环境变量设置

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

jar包依赖、jar包依赖传递的概念如下图,清楚明了,都不用多做解释:

Netty教程

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

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

安装:下载压缩包,解压,文件夹拷贝到所想存储的位置(如C盘根目录

配置环境变量,和Java的环境变量配置一样的,创建MAVEN_HOME,指向Maven文件夹,再在path中添加进去就行,如下图:

Netty教程

由于直接冲Maven的中央仓库中自动下载jar包较慢,一般在Maven的配置文件中,增加阿里云的公共仓库配置,这样会显著加快jar包的下载速度,如下:

Netty教程
Netty教程
Netty教程

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

Netty教程

2.3、IDEA安装及基本设置

IDEA的下载和安装就不多说了,其版本分旗舰版和社区版,旗舰版收费,社区版免费,社区版不支持html、js、css等,但对于本实例,社区版就够用了,但如果你不在乎那点银子,可以考虑旗舰版,一步到位,万一后面我们还要做WEB系统开发可以免得折腾。

其安装不用多说,一路Next就行,安装完后,在其配置里面指定一下JDK、Maven的位置就行了,如下图:

Maven指定:[File]–>[setting]–>[Build,Excution,Deployment]–>[Build Tools]–>[Maven]

Netty教程

JDK指定:[File]–>[Project Structure]–>[Project Setting]–>[Project]

Netty教程

3、在IDEA中创建Maven工程

新建工程

Netty教程

填写包名及工程名称

Netty教程
Netty教程

Maven配置

Netty教程

生成工程,自动创建Maven的依赖文件

Netty教程

pom.xml中配置Netty依赖

Netty教程

经过上面的步骤,我们的Maven工程就已经创建完毕,现在可以编写Netty的第一个程序,这个程序很简单,传输一个字符串,虽然程序很简单,但是已经能够大体上反映Netty开发通信程序的一个整体流程了。

4、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教程

然后,再同样的操作,运行客户端启动类,就能看见效果了。

5、尾声

本文的内容就到这里结束了,希望本文能够让大家对Netty有一个整体的认识,并大概了解其开发流程。

Netty的功能很多,本文只是一个入门的介绍,如果大家对于Netty开发有兴趣,可以关注我并给我留言,我会根据关注和留言情况,陆续再撰写Netty实战开发的文章。

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

原文 

http://www.cnblogs.com/chamu/p/13217490.html

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » Netty教程

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址