Netty学习--第一讲：IO模型

最新推荐文章于 2024-11-02 23:14:30 发布

rain_Man2018

最新推荐文章于 2024-11-02 23:14:30 发布

阅读量269

点赞数

分类专栏： netty 文章标签： netty

本文链接：https://blog.csdn.net/weixin_44038165/article/details/108616360

版权

netty 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一：netty的介绍

官网：https://netty.io/
Netty是由JBOSS提供的一个java开源框架，现在为github上的独立项目
Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序
Netty是基于NIO的，它封装了jdk的nio

TCP/IP -> 原生的JDK IO -> NIO -> Netty

需要理解同步与异步，阻塞与非阻塞

IDEA解决按两下shift弹出 search everywhere

二：netty的应用场景

在分布式系统中，各个节点之间需要远程服务调用，高性能的RPC框架必不可少，netty作为异步高性能的通信框架，往往作为基础通信组件被这些RPC框架所使用。
阿里分布式服务框架 Dubbo，默认使用 Netty 作为基础通信组件，还有 RocketMQ 也是使用 Netty 作为通讯的基础。

使用netty作为底层的相关项目：
https://netty.io/wiki/related-projects.html

大数据领域中的spark, flink

三：I/O模型

I/O 模型简单的理解：就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能

Java共支持3种网络编程模型IO模式：BIO、NIO、AIO

BIO:阻塞IO模型
同步并阻塞(传统阻塞型)，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销
Java NIO ：同步非阻塞
服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求就进行处理
Java AIO(NIO.2) ：异步非阻塞
AIO 引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用

四：BIO,NIO,AIO应用场景

BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序简单易理解。
NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器间通讯等。编程比较复杂，JDK1.4开始支持。
AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。

五：BIO 应用实例

1：使用BIO模型编写一个服务器端，监听6666端口，当有客户端连接时，就启动一个线程与之通讯。
2：要求使用线程池机制改善，可以连接多个客户端.:
3：服务器端可以接收客户端发送的数据(通过cmd的telnet 方式即可)。

package com.atguigu.bio;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class BIOServer {
    public static void main(String[] args) throws IOException {
        //1、创建一个线程池
        //2、如果有客户端连接，就创建一个线程，与之通讯（单独写一个方法）
        ExecutorService executorService = Executors.newCachedThreadPool();

        //创建ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
        System.out.println("服务器启动了");

        while (true) {
            System.out.println("线程信息：id= "+ Thread.currentThread().getId() + "; 线程名字：" + Thread.currentThread().getName());
            //监听，等待客户端连接
            System.out.println("等待连接");
            final Socket socket = serverSocket.accept();
            System.out.println("连接到一个客户端");

            //创建一个线程，与之通讯
            executorService.execute(() -> {
                //重写Runnable方法，与客户端进行通讯
                handler(socket);
            });
        }
    }

    //编写一个Handler方法，和客户端通讯
    public static void handler(Socket socket) {
        try {
            System.out.println("线程信息：id= "+ Thread.currentThread().getId() + "; 线程名字：" + Thread.currentThread().getName());
            byte[] bytes = new byte[1024];
            //通过socket获取输入流
            InputStream inputStream = socket.getInputStream();
            //循环的读取客户端发送的数据
            while (true){
                System.out.println("线程信息：id= "+ Thread.currentThread().getId() + "; 线程名字：" + Thread.currentThread().getName());
                System.out.println("read....");
                int read = inputStream.read(bytes);
                if (read != -1){
                    System.out.println(new String(bytes, 0, read));//输出客户端发送的数据
                } else {
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            System.out.println("关闭和client的连接");
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

六：NIO详解

NIO 有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector(选择器)
在这里插入图片描述
参考：https://blog.csdn.net/qq_35751014/category_9722459.html

七：编程

在这里插入图片描述
通过Buffer数组来完成读写操作，即Scattering（写入Buffer数组）和Gathering（读取）

/**
         * Scatting：将数据写入到buffer时，可以使用buffer数组，依次写入
         * Gathering：从buffer读取数据时，可以采用buffer数组，依次读取
         */
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        InetSocketAddress socketAddress = new InetSocketAddress(7000);
        serverSocketChannel.socket().bind(socketAddress);

        // 创建buffer数组
        ByteBuffer[] buffers = new ByteBuffer[2];
        buffers[0] = ByteBuffer.allocate(5);
        buffers[1] = ByteBuffer.allocate(8);
        int messageLength = 10;
        // 等待连接
        SocketChannel socketChannel = serverSocketChannel.accept();
        // 循环读取
        while (true) {
            int byteRead = 0;
            while (byteRead < messageLength){
                long l = socketChannel.read(buffers);
                byteRead += l;
                System.out.println("byteRead = "+byteRead);
                Arrays.asList(buffers).stream().map(buffer -> "position = "+buffer.position() +",limit = "+buffer.limit()).forEach(System.out::println);
            }

            Arrays.asList(buffers).forEach(byteBuffer -> byteBuffer.flip());
            int byteWrite = 0;
            while (byteWrite < messageLength){
                long l = socketChannel.write(buffers);
                byteWrite += l;
            }
            Arrays.asList(buffers).forEach(byteBuffer -> byteBuffer.clear());
            System.out.println("byteRead = "+byteRead + ",byteWrite = "+byteWrite +",messageLength = "+messageLength);

在这里插入图片描述

服务端代码：

package com.atguigu.nio;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

//网络服务器端程序
public class NIOServer {
    public static void main(String[] args) throws  Exception{
        //1. 得到一个ServerSocketChannel对象
        ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
        //2. 得到一个Selector对象
        Selector selector=Selector.open();
        //3. 绑定一个端口号, 在服务器的6666监听
        //serverSocketChannel.bind(new InetSocketAddress(6666));
        serverSocketChannel.socket().bind(new InetSocketAddress(6666));
        //4. 设置非阻塞方式
        serverSocketChannel.configureBlocking(false);
        //5. 把ServerSocketChannel对象注册给Selector对象
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        //6. 干活
        while(true){
            //6.1 监控客户端
            //如果使用 selector.select() 就会阻塞在这里的
            if(selector.select(1000)==0){  //nio非阻塞式的优势
                System.out.println("Server:等待了1秒，无客户端连接");
                continue;
            }
            //6.2 得到SelectionKey,判断通道里的事件
            Iterator<SelectionKey> keyIterator=selector.selectedKeys().iterator();
            while(keyIterator.hasNext()){
                SelectionKey key=keyIterator.next();
                if(key.isAcceptable()){  //客户端连接请求事件

                    SocketChannel socketChannel=serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector,SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                }
                if(key.isReadable()){  //读取客户端数据事件
                    SocketChannel channel=(SocketChannel) key.channel();
                    ByteBuffer buffer=(ByteBuffer) key.attachment();
                    channel.read(buffer);
                    System.out.println("接收到客户端数据："+new String(buffer.array()));
                }
                // 6.3 手动从集合中移除当前key,防止重复处理
                keyIterator.remove();
            }
        }
    }
}

客户端编程：

package com.atguigu.nio;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

//网络客户端程序
public class NIOClient {
    public static void main(String[] args) throws  Exception{
        //1. 得到一个网络通道
        SocketChannel channel=SocketChannel.open();
        //2. 设置非阻塞方式
        channel.configureBlocking(false);
        //3. 提供服务器端的IP地址和端口号
        InetSocketAddress address=new InetSocketAddress("127.0.0.1",6666);
        //4. 连接服务器端
        if(!channel.connect(address)){
            while(!channel.finishConnect()){  //nio非阻塞式
                System.out.println("客户端: 因为连接需要时间，客户端不会阻塞，可以做个计算工作...");
            }
        }
        //连接成功了..
        //5. 得到一个缓冲区并存入数据
        String msg="hello,尚硅谷";
        ByteBuffer writeBuf = ByteBuffer.wrap(msg.getBytes());
        //6. 发送数据
        channel.write(writeBuf);
        System.in.read();
    }
}