听说微信搜索《Java鱼仔》会变更强哦！

本文收录于JavaStarter ，里面有我完整的Java系列文章，学习或面试都可以看看哦

（一）什么是netty

Netty是一个异步的，基于事件驱动的网络应用框架，用于快速开发可维护、高性能的网络服务器和客户端。Netty的应用十分广泛，可以说主流的框架中，如果有网络方面的需求，一般用的都是netty框架。比如Dubbo、ES、Zookeeper中都用到了Netty。因此即使在平常工作中没有Netty的使用场景，Netty还是十分值得我们去学习的。

Netty底层基于NIO开发，其实大部分的Java程序员对于网络方面的开发能力是比较弱的，因此如果有网络相关的开发业务，如果自己通过BIO或者NIO实现，会产生很多问题。而通过Netty可以快速开发网络应用，因此也有人把Netty称为网络开发框架中的Spring。

关于NIO和BIO的区别，我之前在博客中也讲到过，BIO每次通信都要新建一个线程去处理，NIO通过多路复用的方式去处理请求。下图就是NIO的处理流程。

网络异常，图片无法展示

（二）第一个netty入门程序

既然基于NIO开发，netty的入门程序和我们当时写的nio入门程序比较像，首先开发一个服务器端，netty的开发流程可以遵循一套规范：

1、通过ServerBootstrap启动，组装netty组件

2、组装eventLoopGroup

3、组装Channel

4、通过handler处理连接、读写请求

publicclassFirstServer {
publicstaticvoidmain(String[] args) {
// 1、服务器端的启动器，组装netty组件newServerBootstrap()
//2、组装eventLoop组                .group(newNioEventLoopGroup())
//3、选择服务器的ServerSocketChannel实现                .channel(NioServerSocketChannel.class)
//4、负责处理连接和读写                .childHandler(newChannelInitializer<NioSocketChannel>() {
@OverrideprotectedvoidinitChannel(NioSocketChannelnioSocketChannel) throwsException {
//将bytebuffer转换为字符串nioSocketChannel.pipeline().addLast(newStringDecoder());
//自定义handler，这里接收读事件后展示数据nioSocketChannel.pipeline().addLast(newChannelInboundHandlerAdapter(){
@OverridepublicvoidchannelRead(ChannelHandlerContextctx, Objectmsg) throwsException {
System.out.println(msg);
                            }
                        });
                    }
                })
//5、监听端口                .bind(8080);
    }
}

接着开发一个客户端，客户端的整体流程和服务器端十分类似：

1、通过Bootstrap启动，组装netty组件

2、组装eventLoopGroup

3、组装Channel

4、添加handler处理器

5、建立连接

6、发送数据到服务端

publicclassFirstClient {
publicstaticvoidmain(String[] args) throwsInterruptedException {
//1、启动类newBootstrap()
//2、添加EventLoop组                .group(newNioEventLoopGroup())
//3、添加channel                .channel(NioSocketChannel.class)
//4、添加处理器                .handler(newChannelInitializer<NioSocketChannel>() {
@OverrideprotectedvoidinitChannel(NioSocketChannelnioSocketChannel) throwsException {
//将发送的内容encode编码nioSocketChannel.pipeline().addLast(newStringEncoder());
                    }
                })
//5、连接到服务器                .connect(newInetSocketAddress("localhost",8080))
                .sync()
                .channel()
//6、发送数据                .writeAndFlush("hello");
    }
}

启动服务器端后再启动客户端，可以发现服务端接受到了客户端发过来的信息。看到这里觉得还是有点蒙没关系，下面会对每个组件进行讲解。

（三）理解Netty中的组件

3.1 EventLoop

EventLoop其实是一个单线程的执行器，同时维护了一个Selector，EventLoop的作用是处理Channel上的io事件。

3.2 EventLoopGroup

EventLoopGroup是一组EventLoop，Channel通常会调用EventLoopGroup中的register方法绑定其中的一个EventLoop，后续这个channel中的io事件则都由这个EventLoop处理。

3.3 channel

channel是一个数据的传输流，channel可以理解为是通讯的载体。

3.4 ChannelHandler

ChannelHandler是用来处理Channel上的各种事件的，所有的ChannelHandler连起来就是pipeline。简单来讲，channel是数据的传输通道，而ChannelHandler用来处理通道中的数据。

3.5 ByteBuf

ByteBuf是netty中数据的传输载体，网络数据的基本单位总是字节，ByteBuf用来传输这些网络上的字节。

（四）EventLoop

EventLoop可以处理多种任务，单独使用EventLoop可以通过下面几个步骤实现：

1、创建一个EventLoopGroup

2、从EventLoopGroup中获取EventLoop

3、通过EventLoop执行任务

通过代码这样表示：

publicclassTestEventLoop {
publicstaticvoidmain(String[] args) {
//1、创建事件循环组//NioEventLoopGroup可以处理IO事件、普通任务、定时任务EventLoopGroupgroup=newNioEventLoopGroup();
//2、获取下一个事件循环对象EventLoopeventLoop=group.next();
//3、执行普通任务eventLoop.execute(()->{
System.out.println("普通任务");
        });
//4、执行定时任务eventLoop.scheduleAtFixedRate(()->{
System.out.println("定时任务");
        },0,1, TimeUnit.SECONDS);
    }
}

EventLoop最常用的就是执行IO任务了，我们在入门程序中写的group(new NioEventLoopGroup())就是把EventLoop用来处理IO任务。

在netty中，我们还会在绑定group时指定boss和work，boss用来处理连接，work用来处理收到读写请求后续的操作，有的时候我们还可以自定义EventLoopGroup处理其他任务，因此前面的FirstServer 可以写成下面这样：

publicclassNioServer {
publicstaticvoidmain(String[] args) {
//boss用来处理连接NioEventLoopGroupbossGroup=newNioEventLoopGroup();
//work用来处理读写请求NioEventLoopGroupworkGroup=newNioEventLoopGroup();
//otherGroup处理普通任务，比如打印一段内容EventLoopGroupotherGroup=newDefaultEventLoop();
newServerBootstrap()
                .group(bossGroup,workGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(newChannelInitializer<NioSocketChannel>() {
@OverrideprotectedvoidinitChannel(NioSocketChannelnioSocketChannel) throwsException {
nioSocketChannel.pipeline().addLast(newChannelInboundHandlerAdapter(){
@OverridepublicvoidchannelRead(ChannelHandlerContextctx, Objectmsg) throwsException {
ByteBufbyteBuf= (ByteBuf) msg;
System.out.println(byteBuf.toString());
ctx.fireChannelRead(msg); //将msg传给下一个处理者                            }
                        })
                        .addLast(otherGroup,"handler",newChannelInboundHandlerAdapter(){
@OverridepublicvoidchannelRead(ChannelHandlerContextctx, Objectmsg) throwsException {
ByteBufbyteBuf= (ByteBuf) msg;
System.out.println(byteBuf.toString());
                            }
                        });
                    }
                }).bind(8080);
    }
}

（五）Channel

Channel中有几个常用的方法：

close() 关闭channelpipeline() 添加处理器write() 将数据写入到缓冲区flush() 将数据刷出，也就是发给服务端writeAndFlush() 将数据写入并刷出

我们通过入门案例的客户端代码讲解Channel

5.1 channel的连接

publicclassNioClient  {
publicstaticvoidmain(String[] args) throwsInterruptedException {
ChannelFuturechannelFuture=newBootstrap()
                .group(newNioEventLoopGroup())
                .channel(NioSocketChannel.class)
                .handler(newChannelInitializer<NioSocketChannel>() {
@OverrideprotectedvoidinitChannel(NioSocketChannelnioSocketChannel) throwsException {
nioSocketChannel.pipeline().addLast(newStringEncoder());
                    }
                })
//connect是一个异步调用的过程，因此必须要使用sync方法等待连接建立                .connect(newInetSocketAddress("localhost", 8080));
//1、使用sync方法阻塞线程直到连接建立channelFuture.sync();
channelFuture.channel().writeAndFlush("hello,world");
    }
}

整个流程这里就不介绍了，主要介绍里面的一个方法 channelFuture.sync(); 当调用connect方法建立连接时，这个connect方法其实是一个异步的方法，因此如果不加 channelFuture.sync()方法等待连接建立，是无法获取到连接后的channel的，更别提写入数据了。

除了使用sync等待连接，还可以采用设置监听器的方式获取channelFuture

publicstaticvoidmain(String[] args) throwsInterruptedException {
ChannelFuturechannelFuture=newBootstrap()
            .group(newNioEventLoopGroup())
            .channel(NioSocketChannel.class)
            .handler(newChannelInitializer<NioSocketChannel>() {
@OverrideprotectedvoidinitChannel(NioSocketChannelnioSocketChannel) throwsException {
nioSocketChannel.pipeline().addLast(newStringEncoder());
                }
            })
//connect是一个异步调用的过程，因此必须要使用sync方法等待连接建立            .connect(newInetSocketAddress("localhost", 8080));
//2、使用addListener方法异步处理结果channelFuture.addListener(newChannelFutureListener() {
//在nio连接建立完毕之后，调用operationComplete方法@OverridepublicvoidoperationComplete(ChannelFuturechannelFuture) throwsException {
Channelchannel=channelFuture.channel();
channel.writeAndFlush("hello,world");
        }
    });
}

思路是一样的，等连接建立之后再处理对应的方法。

5.2 channel的关闭

除了连接是异步方法之外，channel的关闭方法也是异步的，因此也需要通过

同步阻塞的方式等待关闭：Channelchannel=channelFuture.channel();
ChannelFuturecloseFuture=channel.closeFuture();
System.out.println("等待关闭中");
//当其他线程关闭了channel,sync同步等待closeFuture.sync();
System.out.println("连接已关闭");

同样也可以采用监听器回调的方式：

Channelchannel=channelFuture.channel();
ChannelFuturecloseFuture=channel.closeFuture();
closeFuture.addListener(newChannelFutureListener() {
@OverridepublicvoidoperationComplete(ChannelFuturechannelFuture) throwsException {
System.out.println("连接已关闭");
    }
});

（六）ChannelHandler

ChannelHandler是用来处理Channel上的各种事件的，handler分为inbound和outbount两种，所有的ChannelHandler连起来就是pipeline。

ChannelInboundHandlerAdapter的子类主要用来读取客户端数据，写回结果。

ChannelOutboundHandlerAdapter的字类主要对写回结果进行加工。

关于handler和pipeline的代码在前面的例子中都有写

publicstaticvoidmain(String[] args) {
newServerBootstrap()
            .group(newNioEventLoopGroup())
            .channel(NioServerSocketChannel.class)
            .childHandler(newChannelInitializer<NioSocketChannel>() {
@OverrideprotectedvoidinitChannel(NioSocketChannelnioSocketChannel) throwsException {
//1、从channel中获取到pipelineChannelPipelinepipeline=nioSocketChannel.pipeline();
//2、添加handler处理器到pipelinepipeline.addLast(newChannelInboundHandlerAdapter(){
@OverridepublicvoidchannelRead(ChannelHandlerContextctx, Objectmsg) throwsException {
ByteBufbyteBuf= (ByteBuf) msg;
System.out.println(byteBuf.toString());
ctx.fireChannelRead(msg); //将msg传给下一个处理者                        }
                    });
//3、添加多个表示依次执行pipeline.addLast(newChannelInboundHandlerAdapter(){
@OverridepublicvoidchannelRead(ChannelHandlerContextctx, Objectmsg) throwsException {
ByteBufbyteBuf= (ByteBuf) msg;
System.out.println(byteBuf.toString());
                        }
                    });
                }
            }).bind(8080);

（七）ByteBuf

netty中的ByteBuf比JDK自带的ByteBuffer对字节数据的操作更加友好，也更加强大。ByteBuf的主要优势有几下几点：

1、支持自动扩容

2、支持池化技术，可以重用实例，节约内存

3、读写指针分离

4、很多方法体现了零拷贝，比如slice、duplicate等

接下来通过一些操作带你来了解ByteBuf。

1、自动扩容

创建一个默认的ByteBuf，初始容量是256，写入一系列数据之后，这个容量会随着数据的增大自动扩容。

publicstaticvoidmain(String[] args) {
ByteBufbuf=ByteBufAllocator.DEFAULT.buffer();
System.out.println(buf);
StringBuilderstringBuilder=newStringBuilder();
for (inti=0; i<500; i++) {
stringBuilder.append("1");
    }
buf.writeBytes(stringBuilder.toString().getBytes());
System.out.println(buf);
}

结果：

PooledUnsafeDirectByteBuf(ridx: 0, widx: 0, cap: 256)
PooledUnsafeDirectByteBuf(ridx: 0, widx: 500, cap: 512)

ByteBuf的扩容规则如下：

如果数据大小没有超过512，每次扩容到16的整数倍

如果数据大小超过512，则扩容到下一个2^n次

扩容不能超过max capacity

2、直接内存和堆内存

ByteBuf支持创建基于直接内存的ByteBuf，也支持创建基于堆内存的ByteBuf。两者的差距在于：

堆内存的分配效率较高，但是读写性能相对比较低。

直接内存的分配效率比较低，但是读写性能较高（少一次内存复制）

netty默认使用直接内存作为创建ByteBuf的方式

ByteBufAllocator.DEFAULT.heapBuffer();
ByteBufAllocator.DEFAULT.directBuffer();

3、池化技术

ByteBuf支持池化技术，所谓池化指的是ByteBuf创建出来后可以重用，节约内存。通过JVM参数开启或关闭netty的池化，默认开启状态：

-Dio.netty.allocator.type={unpooled|pooled}

（八）总结

Netty是个很强大的框架，但是网络开发本就是一件比较复杂的事情，接下来我会用Netty做一些简单的应用出来，通过这些应用会让Netty更加容易理解一些。我是鱼仔，我们下期再见！

网络开发的最强大框架：Netty快速入门