Netty学习--基础组件

使用netty的开源框架

Dubbo：阿里开源的高性能rpc通讯框架

RocketMQ：阿里出品的高性能消息队列

Spark：为大规模数据处理设计的一款计算引擎

Elasticsearch,Cassandra,Flink,Netty-SocketIO,Spring5,Play,Grpc...

Netty是什么

异步事件驱动框架，用户快速开发高性能服务端和客户端
封装了JDK底层BIO和NIO模型，提供高可用的API
自带编解码器解决拆包粘包问题，用户只用关心业务逻辑
精心设计的reactor线程模型支持高并发海量连接
自带各种协议栈可以在处理任何一种通用协议都不用亲自动手

Netty基本组件

在没有netty的情况下，客户端和服务端的通信


public class ServerBoot {

    private static final int PORT = 8000;

    public static void main(String[] args) {
   　　　// 启动一个server
        Server server = new Server(PORT);
        server.start();
    }
}

Server端的代码如下：

public class Server {

    private ServerSocket serverSocket;

    public Server(int port) {
        try {
　　　　　　　// 根据端口号绑定端口
            this.serverSocket = new ServerSocket(port);
            System.out.println("服务端启动成功，端口:" + port);
        } catch (IOException exception) {
            System.out.println("服务端启动失败");
        }
    }

    // 避免创建server的程序阻塞ServerBoot的主线程，所以把端口监听放到一个独立的线程中
    public void start() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                doStart();
            }
        }).start();
    }
    
    // 接收客户端的连接
    private void doStart() {
        while (true) {
            try {
　　　　　　　　　 // 接收到客户端连接，accept是个阻塞方法,当一个客户端过来后才创建socket
                Socket client = serverSocket.accept();
  　　　　　　　　// 避免socket读写阻塞serverSocket.accept，所以ClientHandler需要新建一个线程
                new ClientHandler(client).start();
            } catch (IOException e) {
                System.out.println("服务端异常");
            }
        }
    }
}

ClientHandler代码如下：

public class ClientHandler {

    public static final int MAX_DATA_LEN = 1024;
    // 保存客户端socket
    private final Socket socket;

    public ClientHandler(Socket socket) {
        this.socket = socket;
    }

    public void start() {
        System.out.println("新客户端接入");
        new Thread(new Runnable() {
            @Override
            public void run() {
                doStart();
            }
        }).start();
    }

    private void doStart() {
        try {
            InputStream inputStream = socket.getInputStream();
　　　　　　　// 客户端与服务端通信
            while (true) {
                byte[] data = new byte[MAX_DATA_LEN];
                int len;
                while ((len = inputStream.read(data)) != -1) {
                    String message = new String(data, 0, len);
                    System.out.println("客户端传来消息: " + message);
                    socket.getOutputStream().write(data);
                }

            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端Client的代码如下：

public class Client {
    private static final String HOST = "127.0.0.1";
    private static final int PORT = 9010;
    private static final int SLEEP_TIME = 5000;

    public static void main(String[] args) throws IOException {
        final Socket socket = new Socket(HOST, PORT);

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("客户端启动成功!");
                while (true) {
                    try {
                        String message = "hello world";
                        System.out.println("客户端发送数据: " + message);
                        socket.getOutputStream().write(message.getBytes());
                    } catch (Exception e) {
                        System.out.println("写数据出错!");
                    }
                    sleep();
                }


            }
        }).start();

    }

    private static void sleep() {
        try {
            Thread.sleep(SLEEP_TIME);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

客户端与服务端通信的逻辑：

服务端视角：

服务端首先监听端口
通过while(true)不断accept链接，如果客户端创建新的连接，服务端拿到连接,然后由处理器去处理客户端连接
服务端接收数据
服务端做业务逻辑处理
服务端发送数据给客户端

以上过程跟netty组件对应起来的关系如下：

1.监听端口，有两层含义：server在某一个端口监听新用户连接，新用户连接建立完成之后在端口不断监听新连接的数据

对应Server类中的doStart方法的while循环，以阻塞的方式接受新用户连接。

ClientHandler方法的doStart方法中的while循环，不断监听连接上是否有读写

对应netty中的NioEventLoop,字面意思就是nio的事件循环，主要包括：新连接的接入，当前连接上的数据流的读写

2.新用户的连接在java的底层是当做一个socket，在netty中对应的组件为Channel，是对socket的一个抽象。

3.服务端接收客户端数据流的载体都是基于ByteBuf，ByteBuf封装了一些好用的api，可以跟底层连接的数据流进行通信

4.数据流到服务端之后，服务端要处理业务逻辑，对应ClientHnadler中的doStart方法中的处理。客户端与服务端通信一般会定义一个二进制协议，要对二进制协议的数据包进行拆分，拆分之后对于每个不同类型的协议数据包都有不同的java对象，首先要把字节里面的字段读取出来转换成自定义的一个java对象。netty把每一个处理过程都当做一个ChannelHander，比如对数据包进行拆分，对数据包进行java对象的转换。

5.发送数据：服务端处理业务逻辑之后，将结果返回给客户端。整个执行流程与接收数据流程基本一致。

这个线程包括两部分，服务端接收客户端连接，及每个连接的读写（与上面socket通信对应）。而NioEventLoop同时做这两件事情

while(true)对应NioEventLoop的run方法

Server中的accept对应NioEventLoop中的Select操作，client中的getOutputStream，也对应select操作。

processSelectedKeys处理对应的连接。

一个channel对应一个socket。

在NioEventLoop类中的processSelectedKey方法中

if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
                unsafe.read();
                if (!ch.isOpen()) {
                    // Connection already closed - no need to handle write.
                    return;
                }
            }

其中unsafe.read() 有两个实现类 NioByteUnsafe和NioMessageUnsafe，前者对应客户端的channel的数据流读写，后者对应是否有新连接进入。

在NioServerSocketChannel类中的doReadMessages方法中是对新连接建立的处理

@Override
    protected int doReadMessages(List<Object> buf) throws Exception {
        SocketChannel ch = javaChannel().accept();

        try {
            if (ch != null) {
                buf.add(new NioSocketChannel(this, ch));
                return 1;
            }
           ...

javaChannel对应一个ServerSocketChannel，对应底层nio模型中的socketchannel，也是对应了demo中的ServerSocket

protected AbstractChannel(Channel parent) {
        this.parent = parent;
        id = newId();
        unsafe = newUnsafe();
        pipeline = newChannelPipeline();
    }

　在每个channel中都有一个默认的pipeline(DefaultChannelPipeline)

在DefaultChannelPipeline中的addAfter方法对逻辑链进行动态增加

@Override
    public final ChannelPipeline addAfter(
            EventExecutorGroup group, String baseName, String name, ChannelHandler handler)

小结

最重要的就是NioEventLoop，起了两种类型的线程，一个是监听客户端连接，另一个是处理客户端读写

channel就是对一条连接的封装,在channel封装的api中可以进行数据读写

对数据的读写可以看做是逻辑处理的链（Pipeline），每一个的逻辑处理都是一个ChannelHandler

在一条channel中的数据读写都是基于ByteBuffer来操作的。

posted @ 2020-04-05 23:41 liekkas01 阅读(199) 评论(0) 编辑收藏举报

刷新页面返回顶部

Netty学习--基础组件

公告