java架构之路-（netty专题）netty的基本使用和netty聊天室

上次回顾：

　　上次博客，我们主要说了我们的IO模型，BIO同步阻塞，NIO同步非阻塞，AIO基于NIO二次封装的异步非阻塞，最重要的就是我们的NIO，脑海中应该有NIO的模型图。

Netty概念：

　　Netty是由JBOSS提供的一个java开源框架，现为 Github上的独立项目。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。 也就是说，Netty 是一个基于NIO的客户、服务器端的编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应用的编程开发过程，例如：基于TCP和UDP的socket服务开发。 “快速”和“简单”并不用产生维护性或性能上的问题。Netty 是一个吸收了多种协议（包括FTP、SMTP、HTTP等各种二进制文本协议）的实现经验，并经过相当精心设计的项目。最终，Netty 成功的找到了一种方式，在保证易于开发的同时还保证了其应用的性能，稳定性和伸缩性。---摘自百度百科。

基本使用：

　　我们来看一下代码吧

　　服务端：

package com.xiaocai.netty;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class NettyServer {

    public static void main(String[] args) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);//新建线程组,用于处理请求
        EventLoopGroup workerGroup = new NioEventLoopGroup();//真正工作的线程组
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();//创建一个server,相当于NIO的server
            bootstrap.group(bossGroup, workerGroup) //采用链式编程,将两个线程组加入到server中
                    .channel(NioServerSocketChannel.class) //设置一个信道,相当于NIO中的ServerSocketChannel
                    .option(ChannelOption.SO_BACKLOG, 1024) //对服务端给予一些设置
                    .childHandler(new ChannelInitializer<SocketChannel>() {//给予初始化,并加入回调函数
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new NettyServerHandler());
                        }
                    });
            System.out.println("netty server start。。");
            ChannelFuture cf = bootstrap.bind(9000).sync();//绑定端口,sync方法是等待异步操作执行完毕
            cf.channel().closeFuture().sync();//对通道关闭进行监听，closeFuture是异步操作，监听通道关闭
                                        // 通过sync方法同步等待通道关闭处理完毕，这里会阻塞等待通道关闭完成
        } finally {
            bossGroup.shutdownGracefully(); //关闭处理请求的线程组
            workerGroup.shutdownGracefully();//关闭真正工作的线程组
        }
    }
}

　　服务端的代码看起来还是比较乱的，但不要担心，基本都是固定写法的，大致就开线程，设置server，设置通道，初始化，给予回调函数，我们来看一下回调函数。

package com.xiaocai.netty;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    //当客户端连接服务器完成就会触发该方法
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ByteBuf buf = Unpooled.copiedBuffer("HelloServer".getBytes(CharsetUtil.UTF_8));
        ctx.writeAndFlush(buf);
    }

    //当通道有读取事件时会触发，即服务端发送数据给客户端
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("收到客户端的消息:" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("客户端的地址： " + ctx.channel().remoteAddress());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("我收到了异常");
        cause.printStackTrace();
        ctx.close();
    }
}

　　这个回调函数也基本是固定的，继承ChannelInboundHandlerAdapter 类，然后我们写在里面就可以了，几乎需要我们做的主要是这个回调函数。

　　客户端：

package com.xiaocai.netty;

import io.netty.bootstrap.Bootstrap;
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;

public class NettyClient {
    public static void main(String[] args) throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();// 开启工作线程组
        try {
            Bootstrap bootstrap = new Bootstrap(); //创建一个和服务端相对应的server
            bootstrap.group(group) //设置线程组
                    .channel(NioSocketChannel.class) //使用NioSocketChannel作为客户端的通道实现
                    .handler(new ChannelInitializer<SocketChannel>() {//设置回调函数
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ch.pipeline().addLast(new NettyClientHandler());
                        }
                    });
            System.out.println("netty client start。。");
            ChannelFuture cf = bootstrap.connect("127.0.0.1", 9000).sync();//启动客户端去连接服务器端
            //对通道关闭进行监听
            cf.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();//关闭线程组
        }
    }
}

　　客户端和服务端差不多，开启线程设置一个对应的server，设置信道，设置回调函数，我们还是看一下客户端的回调函数做了什么事情。

package com.xiaocai.netty;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

public class NettyClientHandler extends ChannelInboundHandlerAdapter {

    /**
     * 当客户端连接服务器完成就会触发该方法
     *
     * @param ctx 设置好的信道,相当于上下文
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        ByteBuf buf = Unpooled.copiedBuffer("HelloServer".getBytes(CharsetUtil.UTF_8));
        ctx.writeAndFlush(buf);
    }

    //当通道有读取事件时会触发，即服务端发送数据给客户端
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("收到服务端的消息:" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("服务端的地址： " + ctx.channel().remoteAddress());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

　　两侧的代码都是差不多的，回调函数，建立连接以后我们做什么，接收到数据以后我们做什么，差不多就是这个意思。这里为什么是给予两个线程呢？简单来说就是为了能承受更高的并发，一个线程专门来负责接收连接，不至于让有的请求卡死或延迟很高的状态，后面说底层源码的时候，这个还会再说的。

Netty模块组件 

　　Bootstrap、ServerBootstrap：

　　Bootstrap意思是引导，一个 Netty 应用通常由一个Bootstrap 开始，主要作用是配置整个 Netty 程序，串联各个组件，Netty 中 Bootstrap 类是客户端程序的启动引导类，ServerBootstrap 是服务端启动引导类。

　　Future、ChannelFuture：

　　正如前面介绍，在 Netty 中所有的 IO 操作都是异步的，不能立刻得知消息是否被正确处理。 但是可以过一会等它执行完成或者直接注册一个监听，具体的实现就是通过 Future 和  ChannelFutures，他们可以注册一个监听，当操作执行成功或失败时监听会自动触发注册的监听事 件。

　　Channel：

　　Netty 网络通信的组件，能够用于执行网络 I/O 操作。Channel 为用户提供：

　　1）当前网络连接的通道的状态（例如是否打开？是否已连接？）

　　2）网络连接的配置参数 （例如接收缓冲区大小）

　　3）提供异步的网络 I/O 操作(如建立连接，读写，绑定端口)，异步调用意味着任何 I/O 调用都将立即 返回，并且不保证在调用结束时所请求的 I/O 操作已完成。

　　4）调用立即返回一个 ChannelFuture 实例，通过注册监听器到 ChannelFuture 上，可以 I/O 操作成功、失败或取消时回调通知调用方。

　　5）支持关联 I/O 操作与对应的处理程序。 不同协议、不同的阻塞类型的连接都有不同的 Channel 类型与之对应。

NioSocketChannel;//异步的客户端 TCPSocket 连接。
NioServerSocketChannel;//异步的服务器端 TCP Socket 连接。
NioDatagramChannel;//异步的 UDP 连接。
NioSctpChannel;//异步的客户端 Sctp 连接。
NioSctpServerChannel;//异步的 Sctp 服务器端连接，这些通道涵盖了UDP和TCP网络IO以及文件IO。 

　　Selector：

　　Netty 基于 Selector 对象实现 I/O 多路复用，通过 Selector 一个线程可以监听多个连接的 Channel  事件。 当向一个 Selector 中注册 Channel 后，Selector 内部的机制就可以自动不断地查询(Select) 这些注册 的 Channel 是否有已就绪的 I/O 事件（例如可读，可写，网络连接完成等），这样程序就可以很简单地使用一个线程高效地管理多个Channel 。

　　NioEventLoop：

　　NioEventLoop 中维护了一个线程和任务队列，支持异步提交执行任务，线程启动时会调用 NioEventLoop 的 run 方法，执行 I/O 任务和非 I/O 任务： I/O 任务，即selectionKey中ready 的事件，如 accept、connect、read、write 等，由  processSelectedKeys方法触发。非 IO 任务，添加到 taskQueue 中的任务，如 register0、bind0 等任务，由 runAllTasks 方法触发。

　　NioEventLoopGroup：

　　NioEventLoopGroup，主要管理 eventLoop 的生命周期，可以理解为一个线程池，内部维护了一组线程，每个线程(NioEventLoop)负责处理多个 Channel 上的事件，而一个 Channel 只对应于一个线程。

　　ChannelHandler：

　　ChannelHandler 是一个接口，处理 I/O 事件或拦截 I/O 操作，并将其转发到其 ChannelPipeline(业务处理链)中的下一个处理程序。 ChannelInboundHandler 用于处理入站 I/O 事件，ChannelOutboundHandler用于处理出站 I/O事件。

　　ChannelHandlerContext：

　　保存 Channel 相关的所有上下文信息，同时关联一个 ChannelHandler 对象。

　　ChannelPipline：

　　保存 ChannelHandler 的List，用于处理或拦截 Channel 的入站事件和出站操作。内部是一个双向链表，记住tail和head，后面说编解码会详细去说。

netty聊天室：

　　互联网行业：在分布式系统中，各个节点之间需要远程服务调用，高性能的 RPC 框架必不可少， Netty 作为异步高性能的通信框架，往往作为基础通信组件被这些 RPC 框架使用。典型的应用有：阿里分布式服务框架 Dubbo 的 RPC 框架使用 Dubbo 协议进行节点间通信，Dubbo 协议默认使用  Netty 作为基础通信组件，用于实现。各进程节点之间的内部通信。Rocketmq底层也是用的Netty作为基础通信组件。 游戏行业：无论是手游服务端还是大型的网络游戏，Java 语言得到了越来越广泛的应用。Netty 作为高性能的基础通信组件，它本身提供了 TCP/UDP 和 HTTP 协议栈。我们来实现一个简单的聊天室。一步步的我们拿着刚才的代码改造一下。

　　服务端：

package com.xiaocai.chat;

import com.xiaocai.netty.NettyServerHandler;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
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 io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class ChatRoomServer {

    public static void main(String[] args) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new StringEncoder());
                            ch.pipeline().addLast(new StringDecoder());
                            ch.pipeline().addLast(new ChatRoomServerHandler());
                        }
                    });
            System.out.println("聊天室开启了！！！");
            ChannelFuture cf = bootstrap.bind(9000).sync();
            cf.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

　　程序还是和原来的程序差不多的，这里都是一些固定的写法，只有两行代码我们刚才没说，加入了两个拦截器，一个是编码一个是解码，下次博客会重点说这个，我们来看一下我们的回调函数。

package com.xiaocai.chat;

import io.netty.channel.*;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;

import java.text.SimpleDateFormat;
import java.util.Date;

public class ChatRoomServerHandler extends SimpleChannelInboundHandler<String> {

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

    //当客户端连接服务器完成就会触发该方法
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        String nowTime = sdf.format(new Date());
        String userName = channel.id() + "";
        String msg = nowTime + " " + userName + " 上线了!";
        channelGroup.writeAndFlush(msg);
        channelGroup.add(channel);
        System.out.println("[服务端]: " + msg);
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        //获取到当前 channel
        Channel channel = ctx.channel();
        //这时我们遍历 channelGroup, 根据不同的情况， 回送不同的消息
        channelGroup.forEach(ch -> {
            if (channel != ch) { //不是当前的 channel,转发消息
                ch.writeAndFlush(channel.id() + " 发送了消息：" + msg);
            } else {//回显自己发送的消息给自己
                ch.writeAndFlush("[ 自己 ]发送了消息：" + msg);
            }
        });
    }

    //表示 channel 处于不活动状态, 提示离线了
    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        Channel channel = ctx.channel();
        //将客户离开信息推送给当前在线的客户
        channelGroup.writeAndFlush("[ 客户端 ]" + channel.id() + " 下线了");
        System.out.println(channel.id() + " 下线了");
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        //关闭通道
        ctx.close();
    }
}

　　这次我们继承的是SimpleChannelInboundHandler这个类，他是对于ChannelInboundHandlerAdapter的再次封装，然后我们的是通过信道组来发送消息的，先来看channelActive方法，就是当有客户端连接的时候，我们应该自己有所感知，并且将某某上线的消息广播出去。channelRead0方法就是当有数据传输过来时的一些处理，我们用channelGroup来判断是否是自己发送的消息，是自己发送的消息我们给予自己说了什么什么，别的消息就是某某某说了什么什么。

　　客户端：

package com.xiaocai.chat;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
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.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.util.Scanner;

public class ChatRoomClient {
    public static void main(String[] args) throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group) //设置线程组
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {//设置回调函数
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ch.pipeline().addLast(new StringEncoder());
                            ch.pipeline().addLast(new StringDecoder());
                            ch.pipeline().addLast(new ChatRoomClientHandler());
                        }
                    });
            ChannelFuture cf = bootstrap.connect("127.0.0.1", 9000).sync();
            //得到 channel
            Channel channel = cf.channel();

            System.out.println("我" + channel.id() + "进入了聊天室");
            //客户端需要输入信息， 创建一个扫描器
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNextLine()) {
                String msg = scanner.nextLine();
                //通过 channel 发送到服务器端
                channel.writeAndFlush(msg);
            }
            cf.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }
}

　　客户端的代码和原来的也是差不多了，还是多两个拦截器，进行编码解码，然后下面就是我们的扫描器，来扫描控制台输入的，一会我们要用控制台来完成这个聊天室，所以我们要扫描控制台的输入，我们来看一下我们的拦截器。

package com.xiaocai.chat;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class ChatRoomClientHandler extends SimpleChannelInboundHandler<String> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println(msg);
    }
}

　　就是当有消息发过来时，我们打印出来就可以了，我们来看看我们的效果。

 

　　大概就是这样的，就是我们的客户端发送消息，由服务端接收，然后由服务端再次转发出去。

总结：

　　今天我们主要说了Netty的基本使用，需要记住那几行固定代码都是什么意思，为什么要开启两个线程来共同处理，然后就是我们的一个小例子，聊天室程序，下次我们来说一下我们的编码解码，还有粘包拆包。

最进弄了一个公众号，小菜技术，欢迎大家的加入