美文网首页即时通讯技术研究Netty学习
史上最通俗Netty入门长文:基本介绍、环境搭建、动手实战

史上最通俗Netty入门长文:基本介绍、环境搭建、动手实战

作者: JackJiang2011 | 来源:发表于2020-11-18 13:37 被阅读0次

    原作者江成军,原题“还在被Java NIO虐?该试试Netty了”,收录时有修订和改动。

    1、阅读对象

    本文适合对Netty一无所知的Java NIO网络编程新手阅读,为了做到这一点,内容从最基本介绍到开发环境的配置,再到第一个Demo代码的编写,事无巨细都用详细的图文进行了说明。

    所以本文这对于新手来说帮助很大,但对于老司机来说,就没有必要了。老司机请绕道哦。

    PS:是的,用Java写IM、消息推送的话,基本上都是用的Netty,所以如果你想用Java做即时通讯这类系统,学习Netty肯定没错。

    学习交流:

    - 即时通讯/推送技术开发交流5群:215477170[推荐]

    - 移动端IM开发入门文章:《新手入门一篇就够:从零开发移动端IM

    - 开源IM框架源码:https://github.com/JackJiang2011/MobileIMSDK

    (本文同步发布于:http://www.52im.net/thread-3207-1-1.html

    2、本文作者

    江成军:工信部信息系统项目管理师,全栈工程师,多年丰富的JavaWEB平台、PC端软件、移动端APP开发及培训经验,擅长把复杂的事情搞简单。

    3、基本常识

    在了解Netty之前,我们非常有必要简要了解一下Java网络编程模型的基本常识,具体说也就是BIO、NIO和AIO这3个技术概念。

    BIO、NIO和AIO这三个概念分别对应三种通讯模型:阻塞、非阻塞、非阻塞异步,具体这里就不详细写了。网上好多博客说Netty对应NIO,准确来说,应该是既可以是NIO,也可以是AIO,就看你怎么实现。

    这三个概念的区别如下:

    1)BIO:一个连接一个线程,客户端有连接请求时服务器端就需要启动一个线程进行处理,线程开销大。

    2)NIO:一个请求一个线程,客户端发送的连接请求会注册到多路复用器上,多路复用器轮询到该连接有I/O请求时才启动一个线程进行处理;

    3)AIO:一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

    通俗地概括一下就是:

    1)BIO是面向流的,NIO是面向缓冲区的;

    2)BIO的各种流是阻塞的,而NIO是非阻塞的;

    3)BIO的Stream是单向的,而NIO的channel是双向的。

    NIO的的显著特点:事件驱动模型、单线程处理多任务、非阻塞I/O,I/O读写不再阻塞,而是返回0、基于block的传输比基于流的传输更高效、更高级的IO函数zero-copy、IO多路复用大大提高了Java网络应用的可伸缩性和实用性。基于Reactor线程模型。

    限于篇幅原因,这里没办法深入展开话题,想深入了解的,可以继续阅读这几篇:

    1)《Java的BIO和NIO很难懂?用代码实践给你看,再不懂我转行!》;

    2)《少啰嗦!一分钟带你读懂Java的NIO和经典IO的区别》;

    3)《史上最强Java NIO入门:担心从入门到放弃的,请读这篇!》(* 推荐必读)。

    4、认识Netty

    4.1 基本介绍

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

    往通俗了讲,可以将Netty理解为:一个将Java NIO进行了大量封装,并大大降低Java NIO使用难度和上手门槛的超牛逼框架。

    PS:Netty的官网是 https://netty.io/,可以随时下载到最新的Netty源码,以及各种API文档和开发指南。

    4.2 技术特征

    Netty的优点,概括一下就是:

    1)使用简单;

    2)功能强大;

    3)性能强悍。

    Netty的特点:

    1)高并发:基于 NIO(Nonblocking IO,非阻塞IO)开发,对比于 BIO(Blocking I/O,阻塞IO),他的并发性能得到了很大提高;

    2)传输快:传输依赖于零拷贝特性,尽量减少不必要的内存拷贝,实现了更高效率的传输;

    3)封装好:封装了 NIO 操作的很多细节,提供了易于使用调用接口。

    Netty的优势:

    1)使用简单:封装了 NIO 的很多细节,使用更简单;

    2)功能强大:预置了多种编解码功能,支持多种主流协议;

    3)扩展性强:可以通过 ChannelHandler 对通信框架进行灵活地扩展;

    4)性能优异:通过与其他业界主流的 NIO 框架对比,Netty 的综合性能最优;

    5)运行稳定:Netty 修复了已经发现的所有 NIO 的 bug,让开发人员可以专注于业务本身;

    6)社区活跃:Netty 是活跃的开源项目,版本迭代周期短,bug 修复速度快。

    Netty高性能表现在哪些方面?

    1)IO 线程模型:同步非阻塞,用最少的资源做更多的事;

    2)内存零拷贝:尽量减少不必要的内存拷贝,实现了更高效率的传输;

    3)内存池设计:申请的内存可以重用,主要指直接内存。内部实现是用一颗二叉查找树管理内存分配情况;

    4)串形化处理读写:避免使用锁带来的性能开销;

    5)高性能序列化协议:支持 protobuf 等高性能序列化协议。

    限于篇幅,Netty的详细特征就不展开了,有兴趣的可以读一读《新手入门:目前为止最透彻的的Netty高性能原理和框架架构解析》。

    5、Netty的作者

    个人而言,了解一项技术,比较喜欢扒一下它的作者情况,不是八卦,只是个人习惯,希望对所使用的技术了解地更多更全面而已。

    5.1 Netty的创始人

    Netty的创始人是韩国人Trustin Lee,80年出生,8岁起在MSX迷你计算机上编写BASIC程序,爱好游戏编程以及使用汇编、C和C++解决编程问题,1998年获得韩国信息奥林匹克竞赛铜牌。

    就读于韩国Yonsei大学计算机系期间,曾为多家公司编写高性能网络应用以及少量的web程序,毕业后,就职于Arreo通讯公司,该公司为韩国最大的移动短信提供商之一。

    他现在韩国line公司工作(据他个人博客显示,他以于2020年8月底从Line离职了,具体博文 点这里),早前应用较多的Mina也是这牛人的作品。

    ▲ Trustin Lee 本尊

    Trustin Lee大神的其它信息:

    他的个人博客:https://t.motd.kr/

    他的Github:https://github.com/trustin

    5.2 Netty现任Leader

    Netty目前的项目leader是德国人Norman Maurer(之前在Redhat,全职开发Netty),也是《Netty in Action》的作者,目前是苹果公司高级工程师。

    ▲ Norman maurer 本尊

    Norman maurer大神的其它信息:

    他的个人博客:http://normanmaurer.me/

    他的Github:https://github.com/normanmaurer

    最后,附上两位大神的同框图:

    6、Netty能做什么?

    学技能都是为了能够应用到实际工作中去,谁也不是为了学而学、弄着玩不是,那么Netty能做什么呢?

    主要是在两个方面。

    一方面:现在物联网的应用无处不在,大量的项目都牵涉到应用传感器和服务器端的数据通信,Netty作为基础通信组件、能够轻松解决之前有较高门槛的通信系统开发,你不用再为如何解析各类简单、或复杂的通讯协议而薅头发了,有过这方面开发经验的程序员会有更深刻、或者说刻骨铭心的体会。

    另一方面:现在互联网系统讲究的都是高并发、分布式、微服务,各类消息满天飞(是的,IM系统、消息推送系统就是其中的典型),Netty在这类架构里面的应用可谓是如鱼得水,如果你对当前的各种应用服务器不爽,那么完全可以基于Netty来实现自己的HTTP服务器、FTP服务器、UDP服务器、RPC服务器、WebSocket服务器、Redis的Proxy服务器、MySQL的Proxy服务器等等。

    7、掌握Netty有什么好处?

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

    这个名单还可以很长很长。。。

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

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

    这些开源框架有哪些呢?

    简单罗列一些典型的,如下:

    1)阿里分布式服务框架 Dubbo 的 RPC 框架;

    2)淘宝的消息中间件 RocketMQ

    3)Hadoop 的高性能通信和序列化组件 Avro 的 RPC 框架;

    4)开源集群运算框架 Spark

    5)分布式计算框架 Storm

    6)并发应用和分布式应用 Akka

    7)名单依然很长很长。。。。

    8、理论知识准备

    本文的下半部分,将手翅手,带你动手实现一个传输字符串的简单实例。

    在开始动手之前,必要的基础概念还是要知道的,要不然代码敲下来,功能倒是实现了,但对Netty还是一头雾水,这就不是本文要达到的目的了。

    本示例需要用到的基础知识主要有以下几方面的东东,这些知识点最好有一个大概的了解,要不然,看实例会有一定的困难。

    1)掌握Java基础;

    2)掌握Maven基础;

    3)熟悉IntelliJ IDEA集成开发工具的使用,这个工具简称IDEA;

    4)知道TCP、Socket的基本概念。

    尤其提一下,TCP、Socket没概念的,下面这几篇一定要读一下:

    1)《网络编程懒人入门(一):快速理解网络通信协议(上篇)

    2)《网络编程懒人入门(二):快速理解网络通信协议(下篇)

    3)《网络编程懒人入门(三):快速理解TCP协议一篇就够

    4)《脑残式网络编程入门(二):我们在读写Socket时,究竟在读写什么?

    大致了解一下Netty的主要组件及概念:

    1)I/O:各种各样的流(文件、数组、缓冲、管道。。。)的处理(输入输出);

    2)Channel:通道,代表一个连接,每个Client请对会对应到具体的一个Channel;

    3)ChannelPipeline:责任链,每个Channel都有且仅有一个ChannelPipeline与之对应,里面是各种各样的Handler;

    4)handler:用于处理出入站消息及相应的事件,实现我们自己要的业务逻辑;

    5)EventLoopGroup:I/O线程池,负责处理Channel对应的I/O事件;

    6)ServerBootstrap:服务器端启动辅助对象;

    7)Bootstrap:客户端启动辅助对象;

    8)ChannelInitializer:Channel初始化器;

    9)ChannelFuture:代表I/O操作的执行结果,通过事件机制,获取执行结果,通过添加监听器,执行我们想要的操作;

    10)ByteBuf:字节序列,通过ByteBuf操作基础的字节数组和缓冲区。

    关于深入理解Netty的这些概念,建议有必要的话,务必详读:《新手入门:目前为止最透彻的的Netty高性能原理和框架架构解析》。

    对于Netty开发,API文档和源码是最常用的资料,以下是我整理的在线阅读链接:

    1)Netty-4.1.x 源码地址:http://docs.52im.net/extend/docs/src/netty4_1/ (可在线阅读)

    2)Netty-4.1.x API 文档:http://docs.52im.net/extend/docs/api/netty4_1/ (可在线阅读)

    9、开发环境准备

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

    下面请逐个跟着我来傻瓜式配置和操做即可。

    9.1 JDK安装及环境变量设置

    JDK下载,可以从官方现在,也可以度娘上随便搜下载链接,我这里下载的是JDK8,要注意一点的是,现在从JDK的官网Oracle下载需要账号了,没账号的可下不了啦,不知道在搞什么东东。

    官网下载地址:https://www.oracle.com ,截图依次如下:

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

    截图如下:

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

    9.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 进行验证是否成功,如下:

    9.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]

    9.4 在IDEA中创建Maven工程

    新建工程:

    填写包名及工程名称:

    Maven配置:

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

    在pom.xml中配置Netty依赖:

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

    10、开始动手代码实战

    10.1 Netty开发的基本套路

    Netty开发的基本套路很简洁,服务器端和客户端都是这样。

    大致的套路基本如下:

    Netty开发的实际代码过程,也确实并不复杂,就像下图这样,绿色的代表客户端流程、蓝色的代表服务器端流程,注意标红的部分。

    实际代码过程就像下图这样:

    10.2 创建客户端类

    10.2.1)创建Handler:

    首先创建Handler类,该类用于接收服务器端发送的数据,这是一个简化的类,只重写了消息读取方法channelRead0、捕捉异常方法exceptionCaught。

    客户端的Handler一般继承的是SimpleChannelInboundHandler,该类有丰富的方法,心跳、超时检测、连接状态等等。

    代码如下:

    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;

    /**

     * @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

        {

            /**

            * @Description  处理接收到的消息

            **/

            System.out.println("接收到的消息:"+byteBuf.toString(CharsetUtil.UTF_8));

        }

        @Override

        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throwsException

        {

            /**

            * @Description  处理I/O事件的异常

            **/

            cause.printStackTrace();

            ctx.close();

        }

    }

    代码说明:

    1)@ChannelHandler.Sharable:这个注解是为了线程安全,如果你不在乎是否线程安全,不加也可以;

    2)SimpleChannelInboundHandler:这里的类型可以是ByteBuf,也可以是String,还可以是对象,根据实际情况来;

    3)channelRead0:消息读取方法,注意名称中有个0;

    4)ChannelHandlerContext:通道上下文,代指Channel;

    5)ByteBuf:字节序列,通过ByteBuf操作基础的字节数组和缓冲区,因为JDK原生操作字节麻烦、效率低,所以Netty对字节的操作进行了封装,实现了指数级的性能提升,同时使用更加便利;

    6)CharsetUtil.UTF_8:这个是JDK原生的方法,用于指定字节数组转换为字符串时的编码格式。

    10.2.2)创建客户端启动类:

    客户端启动类根据服务器端的IP和端口,建立连接,连接建立后,实现消息的双向传输。

    代码较简洁,如下:

    import com.sun.org.apache.bcel.internal.generic.ATHROW;

    import io.netty.*;

    import java.net.InetSocketAddress;

    /**

     * @Date: 2020/6/1 11:24

     * @Description: 客户端启动类

     */

    public class AppClientHello

    {

        private final String host;

        private fina lint port;

        public AppClientHello(String host, int port)

        {

            this.host = host;

            this.port = port;

        }

        public void run() throws Exception

        {

            /**

            * @Description  配置相应的参数,提供连接到远端的方法

            **/

            EventLoopGroup group = newNioEventLoopGroup();//I/O线程池

            try{

                Bootstrap bs = newBootstrap();//客户端辅助启动类

                bs.group(group)

                        .channel(NioSocketChannel.class)//实例化一个Channel

                        .remoteAddress(newInetSocketAddress(host,port))

                        .handler(newChannelInitializer<SocketChannel>()//进行通道初始化配置

                        {

                            @Override

                            protected void initChannel(SocketChannel socketChannel) throws Exception

                            {

                                socketChannel.pipeline().addLast(newHandlerClientHello());//添加我们自定义的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();

        }

    }

    由于代码中已经添加了详尽的注释,这里只对极个别的进行说明:

    1)ChannelInitializer:通道Channel的初始化工作,如加入多个handler,都在这里进行;

    2)bs.connect().sync():这里的sync()表示采用的同步方法,这样连接建立成功后,才继续往下执行;

    3)pipeline():连接建立后,都会自动创建一个管道pipeline,这个管道也被称为责任链,保证顺序执行,同时又可以灵活的配置各类Handler,这是一个很精妙的设计,既减少了线程切换带来的资源开销、避免好多麻烦事,同时性能又得到了极大增强。

    10.3 创建服务器端类

    10.3.1)创建Handler:

    和客户端一样,只重写了消息读取方法channelRead(注意这里不是channelRead0)、捕捉异常方法exceptionCaught。

    另外服务器端Handler继承的是ChannelInboundHandlerAdapter,而不是SimpleChannelInboundHandler,至于这两者的区别,这里不赘述,大家自行百度吧。

    代码如下:

    import io.netty.*;

    /**

     * @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类进行比较。

    10.3.2)创建服务器端启动类:

    服务器端启动类比客户端启动类稍显复杂一点,先贴出代码如下:

    import io.netty.*;

    import java.net.InetSocketAddress;

    /**

     * @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 = newNioEventLoopGroup();//Netty的Reactor线程池,初始化了一个NioEventLoop数组,用来处理I/O操作,如接受新的连接和读/写数据

            try{

                ServerBootstrap b = newServerBootstrap();//用于启动NIO服务

                b.group(group)

                        .channel(NioServerSocketChannel.class) //通过工厂方法设计模式实例化一个channel

                        .localAddress(newInetSocketAddress(port))//设置监听端口

                        .childHandler(newChannelInitializer<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();

        }

    }

    代码说明:

    1)EventLoopGroup:实际项目中,这里创建两个EventLoopGroup的实例,一个负责接收客户端的连接,另一个负责处理消息I/O,这里为了简单展示流程,让一个实例把这两方面的活都干了;

    2)NioServerSocketChannel:通过工厂通过工厂方法设计模式实例化一个channel,这个在大家还没有能够熟练使用Netty进行项目开发的情况下,不用去深究。

    到这里,我们就把服务器端和客户端都写完了 ,如何运行呢,先在服务器端启动类上右键,点Run 'AppServerHello.main()'菜单运行,见下图。

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

    11、写在最后

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

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

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

    附录:更多NIO异步网络编程资料

    Java新一代网络编程模型AIO原理及Linux系统AIO介绍

    有关“为何选择Netty”的11个疑问及解答

    开源NIO框架八卦——到底是先有MINA还是先有Netty?

    选Netty还是Mina:深入研究与对比(一)

    选Netty还是Mina:深入研究与对比(二)

    NIO框架入门(一):服务端基于Netty4的UDP双向通信Demo演示

    NIO框架入门(二):服务端基于MINA2的UDP双向通信Demo演示

    NIO框架入门(三):iOS与MINA2、Netty4的跨平台UDP双向通信实战

    NIO框架入门(四):Android与MINA2、Netty4的跨平台UDP双向通信实战

    Netty 4.x学习(一):ByteBuf详解

    Netty 4.x学习(二):Channel和Pipeline详解

    Netty 4.x学习(三):线程模型详解

    Apache Mina框架高级篇(一):IoFilter详解

    Apache Mina框架高级篇(二):IoHandler详解

    MINA2 线程原理总结(含简单测试实例)

    Apache MINA2.0 开发指南(中文版)[附件下载]

    MINA、Netty的源代码(在线阅读版)已整理发布

    解决MINA数据传输中TCP的粘包、缺包问题(有源码)

    解决Mina中多个同类型Filter实例共存的问题

    实践总结:Netty3.x升级Netty4.x遇到的那些坑(线程篇)

    实践总结:Netty3.x VS Netty4.x的线程模型

    详解Netty的安全性:原理介绍、代码演示(上篇)

    详解Netty的安全性:原理介绍、代码演示(下篇)

    详解Netty的优雅退出机制和原理

    NIO框架详解:Netty的高性能之道

    Twitter:如何使用Netty 4来减少JVM的GC开销(译文)

    绝对干货:基于Netty实现海量接入的推送服务技术要点

    Netty干货分享:京东京麦的生产级TCP网关技术实践总结

    新手入门:目前为止最透彻的的Netty高性能原理和框架架构解析

    写给初学者:Java高性能NIO框架Netty的学习方法和进阶策略

    少啰嗦!一分钟带你读懂Java的NIO和经典IO的区别

    史上最强Java NIO入门:担心从入门到放弃的,请读这篇!

    手把手教你用Netty实现网络通信程序的心跳机制、断线重连机制

    Java的BIO和NIO很难懂?用代码实践给你看,再不懂我转行!

    >> 更多同类文章 ……

    本文已同步发布于“即时通讯技术圈”公众号。

    ▲ 本文在公众号上的链接是:点此进入,原文链接是:http://www.52im.net/thread-3207-1-1.html

    相关文章

      网友评论

        本文标题:史上最通俗Netty入门长文:基本介绍、环境搭建、动手实战

        本文链接:https://www.haomeiwen.com/subject/yufciktx.html