netty之基础aio,bio,nio

已于 2024-09-30 09:24:43 修改
阅读量204 收藏 3
点赞数 4
分类专栏： 中间件 Netty 文章标签： nio android
于 2024-09-30 08:58:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_LiMingfly/article/details/142645549
版权

前言


在Java中，提供了一些关于使用IO的API，可以供开发者来读写外部数据和文件，我们称这些API为Java IO。IO是Java中比较重要知识点，且比较难学习的知识点。并且随着Java的发展为提供更好的数据传输性能，目前有三种IO共存；分别是BIO、NIO和AIO。
在这里插入图片描述
同步阻塞I/O模式
是一个比较传统的通信方式，模式简单，使用方便。但并发处理能力低，通信耗时，依赖网速。
同步非阻塞模式
NIO 与原来的 I/O 有同样的作用和目的, 他们之间最重要的区别是数据打包和传输的方式。原来的 I/O 以流的方式处理数据，而 NIO 以块的方式处理数据。
异步非阻塞I/O模型
是一种非阻塞异步的通信模式。在NIO的基础上引入了新的异步通道的概念，并提供了异步文件通道和异步套接字通道的实现。

aio


目录结构如下图
在这里插入图片描述

新建客服端启动类 AioClient

public class AioClient {
    public static void main(String[] args) throws Exception {
        AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();
        Future<Void> future = socketChannel.connect(new InetSocketAddress("192.168.108.89", 7397));
        System.out.println("com.lm.netty01.aio client start done. {码农明哥 | 欢迎关注&获取源码}");
        future.get();
        socketChannel.read(ByteBuffer.allocate(1024), null, new AioClientHandler(socketChannel, Charset.forName("GBK")));
        Thread.sleep(100000);
    }

}

客户端消息处理器类

public class AioClientHandler extends ChannelAdapter {
    public AioClientHandler(AsynchronousSocketChannel channel, Charset charset) {
        super(channel, charset);
    }
    @Override
    public void channelActive(ChannelHandler ctx) {
        try {
            System.out.println("程序员码农 | 链接报告信息:" + ctx.channel().getRemoteAddress());
            //通知客户端链接建立成功
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void channelInactive(ChannelHandler ctx) {
    }
    @Override
    public void channelRead(ChannelHandler ctx, Object msg) {
        System.out.println("码农明哥 | 服务端收到：" + new Date() + " " + msg + "\r\n");
        ctx.writeAndFlush("客户端信息处理Success！\r\n");
    }
}

服务端

public class AioServer extends Thread {
    private AsynchronousServerSocketChannel serverSocketChannel;

    @Override
    public void run() {
        try {
            serverSocketChannel = AsynchronousServerSocketChannel.open(AsynchronousChannelGroup.withCachedThreadPool(Executors.newCachedThreadPool(), 10));
            serverSocketChannel.bind(new InetSocketAddress(7397));
            System.out.println("com.lm.netty01 aio server start done.  欢迎关注&获取源码}");
            // 等待
            CountDownLatch latch = new CountDownLatch(1);
            serverSocketChannel.accept(this, new AioServerChannelInitializer());
            latch.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public AsynchronousServerSocketChannel serverSocketChannel() {
        return serverSocketChannel;
    }

    public static void main(String[] args) {
        new AioServer().start();
    }
}

初始化

public class AioServerChannelInitializer extends ChannelInitializer {
    @Override
    protected void initChannel(AsynchronousSocketChannel channel) throws Exception {
        channel.read(ByteBuffer.allocate(1024), 10, TimeUnit.SECONDS, null, new AioServerHandler(channel, Charset.forName("GBK")));
    }
}

处理消息

public class AioServerHandler extends ChannelAdapter {
    public AioServerHandler(AsynchronousSocketChannel channel, Charset charset) {
        super(channel, charset);
    }

    @Override
    public void channelActive(ChannelHandler ctx) {
        try {
            System.out.println("码农明哥| 链接报告信息:" + ctx.channel().getRemoteAddress());
            //通知客户端链接建立成功
            ctx.writeAndFlush("码农明哥 | 通知服务端链接建立成功" + " " + new Date() + " " + ctx.channel().getRemoteAddress() + "\r\n");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void channelInactive(ChannelHandler ctx) {
    }

    @Override
    public void channelRead(ChannelHandler ctx, Object msg) {
        System.out.println("码农明哥 | 服务端收到：" + new Date() + " " + msg + "\r\n");
        ctx.writeAndFlush("服务端信息处理Success！\r\n");
    }
}

Channle适配器模仿Netty

public abstract class ChannelAdapter implements CompletionHandler<Integer, Object> {

    private AsynchronousSocketChannel channel;
    private Charset charset;

    public ChannelAdapter(AsynchronousSocketChannel channel, Charset charset) {
        this.channel = channel;
        this.charset = charset;
        if (channel.isOpen()) {
            channelActive(new ChannelHandler(channel, charset));
        }
    }

    @Override
    public void completed(Integer result, Object attachment) {
        try {
            final ByteBuffer buffer = ByteBuffer.allocate(1024);
            final long timeout = 60 * 60L;
            channel.read(buffer, timeout, TimeUnit.SECONDS, null, new CompletionHandler<Integer, Object>() {
                @Override
                public void completed(Integer result, Object attachment) {
                    if (result == -1) {
                        try {
                            channelInactive(new ChannelHandler(channel, charset));
                            channel.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        return;
                    }
                    buffer.flip();
                    channelRead(new ChannelHandler(channel, charset), charset.decode(buffer));
                    buffer.clear();
                    channel.read(buffer, timeout, TimeUnit.SECONDS, null, this);
                }

                @Override
                public void failed(Throwable exc, Object attachment) {
                    exc.printStackTrace();
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Override
    public void failed(Throwable exc, Object attachment) {
        exc.getStackTrace();
    }

    public abstract void channelActive(ChannelHandler ctx);

    public abstract void channelInactive(ChannelHandler ctx);

    // 读取消息抽象类
    public abstract void channelRead(ChannelHandler ctx, Object msg);

}

服务端测试
启动服务端
在这里插入图片描述
在这里插入图片描述

BIO


目录结构如下
在这里插入图片描述

客户端


public class BioClient {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("192.168.2.178", 7397);
            System.out.println("itstack-demo-netty bio client start done. {关注公众号：bugstack虫洞栈 | 欢迎关注&获取源码}");
            BioClientHandler bioClientHandler = new BioClientHandler(socket, Charset.forName("utf-8"));
            bioClientHandler.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

消息处理器

public class BioClientHandler extends ChannelAdapter {
    public BioClientHandler(Socket socket, Charset charset) {
        super(socket, charset);
    }

    @Override
    public void channelActive(ChannelHandler ctx) {
        System.out.println("链接报告LocalAddress:" + ctx.socket().getLocalAddress());
        ctx.writeAndFlush("hi! 我是码农明哥 BioClient to msg for you \r\n");
    }

    @Override
    public void channelRead(ChannelHandler ctx, Object msg) {
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + " 接收到消息：" + msg);
        ctx.writeAndFlush("hi 我已经收到你的消息Success！\r\n");
    }
}

服务端

public class BioServer extends Thread {

    private ServerSocket serverSocket = null;

    public static void main(String[] args) {
        BioServer bioServer = new BioServer();
        bioServer.start();
    }

    @Override
    public void run() {
        try {
            serverSocket = new ServerSocket();
            serverSocket.bind(new InetSocketAddress(7397));
            System.out.println("com.lm.netty01.bio bio server start done. {关注码农明哥| 欢迎关注&获取源码}");
            while (true) {
                Socket socket = serverSocket.accept();
                BioServerHandler handler = new BioServerHandler(socket, Charset.forName("GBK"));
                handler.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

消息处理器


public class BioServerHandler extends ChannelAdapter {

    public BioServerHandler(Socket socket, Charset charset) {
        super(socket, charset);
    }

    @Override
    public void channelActive(ChannelHandler ctx) {
        System.out.println("链接报告LocalAddress:" + ctx.socket().getLocalAddress());
        ctx.writeAndFlush("hi! 我是码农明哥 BioServer to msg for you \r\n");
    }

    @Override
    public void channelRead(ChannelHandler ctx, Object msg) {
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + " 接收到消息：" + msg);
        ctx.writeAndFlush("hi 我已经收到你的消息Success！\r\n");
    }
}

适配器

public abstract class ChannelAdapter extends Thread {

    private Socket socket;
    private ChannelHandler channelHandler;
    private Charset charset;

    public ChannelAdapter(Socket socket, Charset charset) {
        this.socket = socket;
        this.charset = charset;
        while (!socket.isConnected()) {
            break;
        }
        channelHandler = new ChannelHandler(this.socket, charset);
        channelActive(channelHandler);
    }

    @Override
    public void run() {
        try {
            BufferedReader input = new BufferedReader(new InputStreamReader(this.socket.getInputStream(), charset));
            String str = null;
            while ((str = input.readLine()) != null) {
                channelRead(channelHandler, str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 链接通知抽象类
    public abstract void channelActive(ChannelHandler ctx);

    // 读取消息抽象类
    public abstract void channelRead(ChannelHandler ctx, Object msg);
}

BIO测试
启动服务端

在这里插入图片描述
在这里插入图片描述

NIO


目录结构如下
在这里插入图片描述
客户端 

public class NioClient {
    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);

        boolean isConnect = socketChannel.connect(new InetSocketAddress("192.168.2.178", 7397));
        if (isConnect) {
            socketChannel.register(selector, SelectionKey.OP_READ);
        } else {
            socketChannel.register(selector, SelectionKey.OP_CONNECT);
        }
        System.out.println("com.lm.netty01.nio nio client start done. {关注码农明哥 | 欢迎关注&获取源码}");
        new NioClientHandler(selector, Charset.forName("GBK")).start();
    }
}

消息处理器

public class NioClientHandler  extends ChannelAdapter {

    public NioClientHandler(Selector selector, Charset charset) {
        super(selector, charset);
    }

    @Override
    public void channelActive(ChannelHandler ctx) {
        try {
            System.out.println("链接报告LocalAddress:" + ctx.channel().getLocalAddress());
            ctx.writeAndFlush("hi! 我是，码农明哥 NioClient to msg for you \r\n");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void channelRead(ChannelHandler ctx, Object msg) {
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + " 接收到消息：" + msg);
        ctx.writeAndFlush("hi 我已经收到你的消息Success！\r\n");
    }
}

服务端

public class NioServer {
    private Selector selector;
    private ServerSocketChannel socketChannel;

    public static void main(String[] args) throws IOException {
        new NioServer().bind(7893);
    }

    public void bind(int port) {
        try {
            selector = Selector.open();
            socketChannel = ServerSocketChannel.open();
            socketChannel.configureBlocking(false);
            socketChannel.socket().bind(new InetSocketAddress(port), 1024);
            socketChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("com.lm.netty01.nio server start done. {关注码农明哥 | 欢迎关注&获取源码}");
            new NioServerHandler(selector, Charset.forName("GBK")).start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

消息处理器

public class NioServerHandler extends ChannelAdapter {

    public NioServerHandler(Selector selector, Charset charset) {
        super(selector, charset);
    }

    @Override
    public void channelActive(ChannelHandler ctx) {
        try {
            System.out.println("链接报告LocalAddress:" + ctx.channel().getLocalAddress());
            ctx.writeAndFlush("hi! 我是码农明哥 NioServer to msg for you \r\n");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void channelRead(ChannelHandler ctx, Object msg) {
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + " 接收到消息：" + msg);
        ctx.writeAndFlush("hi 我已经收到你的消息Success！\r\n");
    }

}

Nio测试
启动NioServer
在这里插入图片描述
在这里插入图片描述
好了到这里就结束了基础的netty学习，大家一定要跟着动手操作起来。需要的源码的 可私信我获取；
重要：
给大家构建了个资源群 欢迎圈友携朋友一起加入 大家需要的si我进。

编程、小哥哥
关注
专栏目录
Netty学习基础：BIO、NIO、AIO
04-17 680
其实我的重点呢，是来和大家一起学习接下来的Netty篇 然而嘞，这个Netty又不太合适直接讲，为啥呢，我们学习一门技术必须知道这门技术的由来的初衷是啥，对吧 先来给大家简单的介绍一下Netty是什么 Netty是一个提供异步事件驱动的网络应用程序框架，用以快速开发高性能、高可靠的网络服务器和客户端程序 Netty简化了网络程序的开发，属于BIO、NIO、AIO的演变中的产物，属于一种NIO框架 在我们平时使用的很多中间件中，很多底层通信都是采用的Netty，比如rocketmq、dubbo，这些我们最常见
BIO、NIO、AIO、Netty 、TCP全网最全解析！Netty中提供了哪些线程模型？
10-07
本文将深入探讨BIO（ Blocking I/O）、NIO（Non-blocking I/O）、AIO（Asynchronous I/O）以及Netty框架中的线程模型，并与TCP网络协议相结合，为您提供全网最全面的解析。 首先，让我们从基础开始，了解这些I/O...
【Netty】BIO，NIO，AIO 模型
记录各种Bug解决案例及日常学习内容
05-10 470
目录一、输入IO与输出IO原理二、同步和异步的区别三、阻塞与非阻塞的区别1. BIO客户端2. BIO服务端四、NIO(Non Blocking IO) 同步非阻塞1. 简单模拟NIO底层代码实现2. 选择器IO多路复用底层原理 一、输入IO与输出IO原理 内核态: CPU可以访问内存所有数据, 包括外围设备, 例如硬盘, 网卡； 用户态: (独立创建应用程序) 只能受限的访问内存, 且不允许访问外围设备. 占用CPU的能力被剥夺, CPU资源可以被其他程序获 1、BIO(Blocking I O) 同
【Netty系列】Netty/BIO/NIO/AIO
Love Peace
04-19 1094
Netty是一个开源的异步的事件驱动的网络应用框架，用于快速开发高性能的网络服务器和客户端。它主要用于构建可伸缩的网络应用程序，如协议服务器和客户端。Netty的设计目标是提供一个简单、快速、稳定的网络应用程序框架，同时保持灵活性和可扩展性。Netty基于NIO（非阻塞I/O）的事件驱动模型，使用了高效的线程池和优化的内存分配机制，使得它在处理大量并发连接时表现出色。Netty广泛用于构建各种类型的网络应用，包括Web服务器、游戏服务器、即时通讯系统等。
Netty（一）- Netty与BIO、NIO、AIO介绍
及时当勉励，岁月不待人
12-02 2366
Netty（一）- Netty与BIO、NIO、AIO介绍
Netty系列3-BIO、AIO、NIO
哼哼的博客
05-11 304
客户端和服务端通信本质上就是服务端监听端口，客户端发起连接请求，通过三次握手连接，如果连接成功建立，双方就可以通过套接字socket进行通信。 根据通信实现方式的不同又分为BIO、AIO、NIO三种。 1.BIO BIO是同步阻塞模型。通常由一个Acceptor线程监听客户端的连接，接收到连接请求后为每个客户端都创建一个新线程进行处理，最后将响应通过输出流返回给客户端，线程销毁。 BIO最大的缺点...
Netty架构基础之BIO NIO AIO网络编程模型
小糖豆
10-19 628
前言 公司业务需求，需要用到tcp数据传输，基于java自带的socket太low，而且编程复杂，市面上比较流行的netty比较适合。学习netty之前，先简单总结一下各种数据传输类型。 java支持的类型 Java 共支持 3 种网络编程模型/IO 模式：BIO、NIO、AIO Java BIO： 理解： 同步并阻塞(传统阻塞型)，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器 端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销 适用场景：BIO 方式适用于连接数目
我所知道Netty之初识BIO、NIO、AIO
我吃西红柿
12-29 2025
针对于Netty的基础BIO、NIO、AIO
Netty学习总结之BIO、NIO、AIO
My Blog
11-13 819
Netty学习总结之BIO、NIO、AIO
java aio nio bio_3. 彤哥说netty系列之Java BIO NIO AIO进化史
weixin_42131790的博客
02-15 92
你好，我是彤哥，本篇是netty系列的第三篇。欢迎来我的公从号彤哥读源码系统地学习源码&架构的知识。简介上一章我们介绍了IO的五种模型，实际上Java只支持其中的三种，即BIO/NIO/AIO。本文将介绍Java中这三种IO的进化史，并从使用的角度剖析它们背后的故事。Java BIOBIO概念解析BIO，Blocking IO，阻塞IO，它是Java的上古产品，自出生就有的东西(JDK 1...
BIO,NIO,AIO,Netty面试题.pdf
04-07
### BIO、NIO、AIO、Netty 面试题解析 #### 1. Java IO 基础概述 Java中的I/O操作是通过流（Stream）来实现的，所有的数据都通过流的方式被串行化处理。串行化的含义在于数据必须按顺序输入输出。Java中的IO操作...
2024年Java常见的-BIO,NIO,AIO,Netty面试题
04-20
### 2024年Java常见BIO、NIO、AIO、Netty面试题解析 #### 一、基础知识概述 1. **IO概念**： - Java中的I/O（Input/Output）指的是输入输出操作，它以流为基础进行数据的输入输出。所有的数据在Java中都是以流的...
java socket bio 改造为 netty nio
DavidSoCool的博客
09-29 324
近日公司接入一款健康监测设备，厂家提供的服务端server demo代码中使用的是java 原生socket，demo代码中在发现连接后使用独立线程处理后续通信，由于设备的特殊性，需要把端口暴露在公网，每当被恶意连接时创建了大量线程，占用系统资源造成了服务宕机，因此需要进行改造。经过改造后使用了4个worker线程进行读写，消除了原先恶意连接造成线程数无线扩大的问题。
MySQL | union all 和union(去重和不去重）
jingling555的博客
09-26 330
现在运营想要分别查看学校为山东大学或者性别为男性的用户的device_id、gender、age和gpa数据，请取出相应结果，。示例：user_profile。
Raspberry Pi3B+之Rpanion(gst)和ffmpeg验证
lida2003的专栏
09-30 665
以前ArduRover和ArduCopter上没有遇到过问题，帧速率30FPS是没问题的，当时还是设置的720P。但是在bulleye系统上，曾经使用该设置720P也能很好的运行在30FPS，怀疑是上述系统可能有硬件编码器的介入。其实，目前使用下来，Rpanion是非常容易上手使用的一个伴机软件，主要提供了：摄像头视频转发/电传报文转发。，以上是笔者的代理服务器，请根据自己的情况替换。若不安装该组件，测试代码会报错，无法执行。若不安装该组件，测试代码会报错，无法执行。获取软件包问题时，请使用代理服务。
mysql学习教程，从入门到精通，SQL UNION 运算符（27）
qq_45746668的博客
09-27 620
UNION` 运算符在 SQL 中用于合并两个或多个 `SELECT` 语句的结果集，并默认去除重复的行。如果你想要包含所有重复行，可以使用 `UNION ALL`。下面是一个使用 `UNION` 运算符的示例，假设我们有两个表：`employees_2020` 和 `employees_2021`，它们存储了不同年份的员工信息，每个表都有 `employee_id`（员工ID）和 `employee_name`（员工姓名）两个字段。
NIO基础
我的博客
09-28 1000
这样，一个单独的线程可以通过轮询 Selector 来判断一组 Channel 是否有就绪状态的事件，从而只需要少量的线程就能处理大量的客户端请求。，可以从 channel 将数据读入 buffer，也可以将 buffer 的数据写入 channel，而之前的 stream 要么是输入，要么是输出，channel 比 stream 更为底层。它与数组类似，但是提供了对数据的结构化访问，并且可以跟踪已经读写了多少数据。Buffer 是一块可以写入数据，然后可以从中读取数据的内存块。
【Android 14源码分析】WMS-窗口显示-流程概览与应用端流程分析
最新发布
隔壁小王的博客
09-30 615
WMS 负责管理设备上所有的 Window ，所以应用想显示一个 Window 则要通过 WMS 来完成。而 WMS 毕竟还是上层，窗口的内容要显示到屏幕上，还需要 SurfaceFlinger 来处理。应用端: 控制其内部的窗口的添加及 UI 绘制逻辑WMS 模块: 作为系统窗口管理模块，处理应用端的窗口显示逻辑应用端与 WMS 通信通过匿名 Binder -> Session 完成。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值