搞懂Netty（1）一个基本入门案例（使用Springboot整合）

写了很久的java并发包里面的文章，今天换一个口味。很早之前学的Netty，由于最近项目经常使用到，遇到了很多坑，因此想通过一个体系教程说一下这个高性能异步通信框架Netty，这也是netty的第一篇文章。主要是通过Springboot来整合Netty实现一个最基本的案例。

一、Netty是什么

想认识Netty最好的方式就是直接去官网看文档，由于文档是英文，因此直接在这里翻译过来了。

Netty是一个高性能、异步事件驱动的NIO框架，支持如TCP、UDP协议和传输文件。“高性能”并不意味着程序会出现各种性能或其他问题。它是一种精心设计的框架，其灵活性、稳定性依然能够得到保证。

官网说这个Netty特别好，毕竟是自家的产品，不过好不好还是用户说了才可以，通过实践证明，目前Netty是我们业界最流行的NIO框架，无数个商业项目也已经验证了。毕竟java的NIO框架开发起来太恶心，而且还有各种bug没有解决。

为什么我们要首选Netty呢？之前看的书列举了很多条，不过最根本的我觉得还是这几个：使用简单、功能强大、性能高、开发无烦恼。无烦恼是因为bug较少，而且也比较成熟。

相信你看这篇文章，可能是项目中要用到，也可能只是想学习一个新技能。不管是出于什么目的，通过上面的分析，你就会发现这个Netty真的是很有必要了解学习。下面我们就直接上手写个最基本的案例吧。

二、案例实现

这个是一个客户端服务端简单通信的案例，假设服务端是个女孩，客户端男孩向其表白。

男孩：I love you

女孩：no

男孩：不灰心不丧气，继续爱你

1、前提准备

如果你是Springboot直接在maven中添加依赖即可

1<!--添加netty依赖-->
2<dependency>
3       <groupId>io.netty</groupId>
4       <artifactId>netty-all</artifactId>
5       <version>5.0.0.Alpha1</version>
6</dependency>

如果你没有使用maven那么直接去官网或者是百度下载一个netty-all-5.0.0.Alpha1的jar包导入即可。

2、服务端（女孩）开发

我们直接看代码，再来分析其流程。

1@Component
 2public class NettyServer {
 3    EventLoopGroup boss = new NioEventLoopGroup();
 4    EventLoopGroup work = new NioEventLoopGroup();
 5    @PostConstruct
 6    public void start() throws InterruptedException {
 7            ServerBootstrap bootstrap = new ServerBootstrap();
 8            bootstrap.group(boss, work)
 9                    .channel(NioServerSocketChannel.class)
10                    .option(ChannelOption.SO_BACKLOG, 1024)
11                    .childOption(ChannelOption.SO_KEEPALIVE, true)
12                    .handler(new LoggingHandler(LogLevel.INFO))
13                    .childHandler(new ChannelInitializer<SocketChannel>() {
14                        public void initChannel(SocketChannel sc) throws Exception {
<
8000
span style="margin:0px;padding:0px 20px 0px 0px;max-width:100%;font-size:inherit;line-height:inherit;color:rgb(174,135,250);">15                            sc.pipeline().addLast(new ServerUAVHandler());
16                        }
17                     });
18            ChannelFuture cf = bootstrap.bind(8888).sync();
19            if (cf.isSuccess()){
20                System.out.println("启动成功");
21            }
22    }
23    @PreDestroy
24    private void destory() throws Exception{
25        boss.shutdownGracefully();
26        work.shutdownGracefully();
27        System.out.println("关闭server");
28    }
29}

基本流程最好对照着代码来看，这样理解的会更加深刻。

（1）new了两个NioEventLoopGroup，一个是boss，一个是work。NioEventLoopGroup是一个线程组，boss线程组用于接收客户端的连接工作，work线程组用于处理数据。

（2）在start方法中，首先new了一个ServerBootstrap，，名字叫bootstrap。它是netty用于启动NIO服务端的辅助启动类。目的是降低服务端的开发复杂度。

（3）.group(boss, work)目的是将两个线程组传入，让其工作。

（4）.channel(NioServerSocketChannel.class)就类比与NIO中的ServerSocketChannel。

（5）.option(ChannelOption.SO_BACKLOG, 1024)配置TCP参数，将其中一个参数backlog设置为1024，表明临时存放已完成三次握手的请求的队列的最大长度。

（6）.childOption(ChannelOption.SO_KEEPALIVE, true)设置TCP长连接,一般如果两个小时内没有数据的通信时,TCP会自动发送一个活动探测数据报文。

（7）.handler(new LoggingHandler(LogLevel.INFO))处理Log日志。

（8）.childHandler，用于处理客户端的IO事件，比如有一个客户端发起请求，要读取数据，就可以使用这里面的类来处理这个事件。这是整个处理的核心。也是我们自己主要关注的类。

（9）ChannelFuture cf = bootstrap.bind(8888).sync();绑定监听端口。使用sync方法阻塞一直到绑定成功。

（10）下面通过一个if语句表明，如果绑定成功那就输出“服务端启动成功”。

（11）最后将boss和work使用finally代码块优雅的退出。何为优雅今后再说。

其实上面的这些代码都是固定模式的，也就是说你使用的时候直接就可以用了，最核心的就是如何处理客户端的各种事件，比如说有客户端连接、读、写数据等等相关事件。看看ServerUAVHandler类是如何实现的，

1public class ServerUAVHandler extends ChannelHandlerAdapter {
 2    @Override
 3    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
 4        ByteBuf buf = (ByteBuf) msg;
 5        byte[] req = new byte[buf.readableBytes()];
 6        buf.readBytes(req);
 7        String body = new String(req,"UTF-8");
 8        System.out.println("客户端信息是："+body);
 9        ByteBuf resp = Unpooled.copiedBuffer("no".getBytes());
10        ctx.writeAndFlush(resp).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
11    }
12}

基本流程如下：

（1）ServerUAVHandler继承了ChannelHandlerAdapter主要是用于处理网络的读写事件。

（2）重写了channelRead读方法，在这个方法内部可以读取客户端的请求信息。其中一个参数msg就是封装的信息对象。我们可以在内部通过ByteBuf这个工具类进行读取。内部实现的细节就不再多描述了。

3、客户端（男孩）开发

1@Component
 2public class NettyClient {
 3    private SocketChannel socketChannel;
 4    EventLoopGroup group = new NioEventLoopGroup();
 5    @PostConstruct
 6    public void start() throws Exception {
 7        //boss 线程组用于处理连接工作
 8        try{
 9            Bootstrap b = new Bootstrap();
10            b.group(group).channel(NioSocketChannel.class)
11                    .option(ChannelOption.TCP_NODELAY, true)
12                    .option(ChannelOption.SO_KEEPALIVE,true)
13                    .handler(new ChannelInitializer<SocketChannel>() {
14                        public void initChannel(SocketChannel ch) throws Exception {
15
16                            ch.pipeline().addLast(new ClientHandler());
17                        }
18                    });
19            //绑定端口
20            ChannelFuture cf = b.connect("127.0.0.1",8888).sync();
21            if(cf.isSuccess()){
22                System.out.println("链接服务器成功");
23            }
24            cf.channel().closeFuture().sync();
25        }finally{
26           group.shutdownGracefully();
27        }
28    }
29}

从上面的代码我们会发现，和服务器端的类似，我们在这里主要关注于和服务器有什么不一样，可能是年龄越来越大，你在对比的时候一定要返回去看看，不仅可以加深印象，还可能突然就恍然大悟了。

（1）首先，只new了一个NioEventLoopGroup，因为不需要处理连接，所以客户端只关注于读写数据的操作。

（2）在start方法内部创建了一个Bootstrap，名字是b，意思是客户端的启动类。

（3）接着使用option配置一些参数。

（4）使用handler方法传递一个类，在内部有一个ClientHandler类，同样也是客户端的核心。

（5）接下来链接服务器，指定地址和端口。最终关闭链接优雅的推出线程组。

上面的代码都是模板代码，你可以直接拿来用，在后期越来越深入的时候再来修改。在这里我们还是主要关注一下这个ClientHandler类吧。

1public class ClientHandler extends ChannelHandlerAdapter {
 2    @Override
 3    public void channelActive(ChannelHandlerContext ctx) throws Exception {
 4        byte[] req = "I love you".getBytes();
 5        ByteBuf first = Unpooled.buffer(req.length);
 6        first.writeBytes(req);
 7        ctx.writeAndFlush(first).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
 8    }
 9    @Override
10    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
11        ByteBuf buf = (ByteBuf) msg;
12        byte[] req = new byte[buf.readableBytes()];
13        buf.readBytes(req);
14        String body = new String(req,"UTF-8");
15        if("no".equals(body)){
16            ByteBuf resp = Unpooled.copiedBuffer("不灰心不丧气，继续我爱你".getBytes());
17            ctx.writeAndFlush(resp).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
18        }
19    }
20}

在这里客户端，首先给服务端发送一个消息“I Love you ”。然后如果收到的是no回复，再说一次“不灰心不丧气，继续我爱你”。这里重写了两个方法channelActive和channelRead方法，第一个是连接到服务端的时候调用，一个是读取服务端的信息调用。

三、总结

通过以上的分析，不知道你能否体会到Netty带来的方便，其实NettyServer类和NettyClient都是模板类，我们只需要关注于这个handler处理类即可，而且相关的处理方法，我们可以直接通过重写就可以实现。再回想一下NIO编程客户端和服务端通信的时候，代码写的都想XX。

OK，今天的文章就先说到这里吧，对了学习最好的方式就是动手敲一遍，有时候看着很简单，但是真实的操作一遍就会遇见很多坑。