NIO编程

最新推荐文章于 2023-04-26 17:08:59 发布
最新推荐文章于 2023-04-26 17:08:59 发布
阅读量113 收藏
点赞数
分类专栏： java后端 计算机 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43489232/article/details/115441320
版权

NIO编程

1、流

1.1、 java.io下的字符流和字节流

在这里插入图片描述

1.1.1、字符流

字符流更加的方便我们使用，一般字符都是由多个字节来形成的，若我们使用字节流传输，则还需要我们自己将其转换为字符，若我们直接使用字符流的话，这样就能直接读取与输出字符。

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

1.1.2、字节流

字节流则是对一个个字节进行读取
在这里插入图片描述
在这里插入图片描述

1.2、装饰器模式

在这里插入图片描述

在字符流中BufferedReader、InputStreamReader和FilterReader，字节流中的BufferedInputStream、DataInputStreamReader与DataOutputStream都运用到了装饰器模式，因为它们本身不能进行实例化，都需要传入基本的Reader或InputStream来进行升级，这里便体现的是装饰器模式。

2、Socket

Socket认为是网络传输的端点，它也是一种数据源，将特定的ip地址与端口号与其进行绑定，这样它就能够实现通信的功能，如下图中，服务器中的socket绑定了对应的ip与端口号，与客户端间进行通信。

2.1、通过Socket发送数据

在这里插入图片描述

  1. 创建Socket，绑定特定的ip地址与端口号
  2. 将Socket与网卡驱动程序绑定
  3. 通过Socket我们就能够发送数据了
  4. 网卡驱动程序对Socket数据进行读取

2.2、通过Socket读取数据

在这里插入图片描述

  1. 我们还是要先创建Socket
  2. 将Socket与网卡驱动程序进行绑定
  3. Socket接收来自网卡驱动程序的数据
  4. 从Socket中读取数据

3、BIO模型

在这里插入图片描述
简述BIO模型中服务端与客户端的响应过程

  1. 服务器serverSocket先要和端口进行绑定
  2. 绑定完成后，执行accept方法，等待客户端的连接，这个方法是阻塞式调用，也就是说，要一直等待客户端的连接响应，不做其他事情，一直等，（被阻塞的还有InputStream.read()、OutputStream.write()，这两个也会一直等待客户端的响应）
  3. 客户端创建Socket对象，绑定服务器的ip地址与端口号，与服务器进行连接
  4. 服务器接收到客户端的连接请求，accept方法获取到客户端的socket信息，连接成功
  5. 服务器与客户端创建各自的io流，实现全双工通信
  6. 之后便可以随时结束连接

在这里插入图片描述

4、NIO模型

NIO：非阻塞IO
NIO和BIO有以下的区别：

  1. 使用Channel代替Stream
  2. 使用Selector监控多条Channel
  3. 在一个线程里处理多个Channel I/O

Channel是双向的，即可以读又可以写，相比于Stream，它并不区分出输入流和输出流，而且Channel可以完成非阻塞的读写，也可以完成阻塞的读写。
在这里插入图片描述

Channel间的数据交换，都需要依赖Buffer，Buffer实际上内存上一块用来读写的区域。

NIO模型分析：

  1. 在服务器端创建一个Selector，将ServerSocketChannel注册到Selector上，被Selector监听的事件为Accept。
  2. Client1请求与服务器建立连接，Selector接收到Accept事件，服务器端对其进行处理（handles），服务器与客户端连接成功。
  3. 建立连接过程中，服务器通道（ServerSocketChannel）调用accept方法，获取到与客户端进行连接的通道（SocketChannel），也将其注册到Selector上，监听READ事件，这样，客户端向服务器发送消息，就能触发该READ事件进行响应，读取该消息。
  4. 同样，两个客户连接过来也是一个线程在起作用，将Client2的SocketChannel注册到服务器的Selector，并监听READ事件，随时响应随时处理。即一个客户端有一个SocketChannel，两个客户端就有两个SocketChannel，这个就是我们使用nio编程模型来用一个selector对象在一个线程里边监听以及处理多个通道的io的操作。

5、NIO多人聊天室

服务端：

package chatroom.nio.server;

import java.io.Closeable;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.Charset;
import java.util.Set;

public class ChatServer {

    //默认监听端口
    private final int DEFAULT_SERVER_PORT = 8888;
    private final String QUIT = "quit";
    private static final int BUFFER = 1024;

    //服务端的channel和selector
    private ServerSocketChannel serverSocketChannel;
    private Selector selector;
    private ByteBuffer rBuffer = ByteBuffer.allocate(BUFFER);
    private ByteBuffer wBuffer = ByteBuffer.allocate(BUFFER);
    private Charset charset = Charset.forName("UTF-8");

    private int port;

    public ChatServer(int port) {
        this.port = port;
    }

    /*
    检查用户是否准备退出
     */
    public boolean readyToQuit(String msg) {
        return QUIT.equals(msg);
    }

    public void close(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


    private void start() {
        try {
            //创建ServerSocketChannel通道
            serverSocketChannel = ServerSocketChannel.open();
           //默认是阻塞模式，需要改为非阻塞  *** 重点 ***
            serverSocketChannel.configureBlocking(false);
           //绑定监听端口
            serverSocketChannel.socket().bind(new InetSocketAddress(port));

            //创建selector
            selector = Selector.open();
            //将accept事件注册到selector上   SelectionKey对象可以取出监听事件的相关信息。
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("服务器启动成功，监听端口号：" + port + "...");

            //不断的监听响应
            while(true) {
                //阻塞式调用，需要不停的调用select，故放入while循环中
                selector.select();

                //获取监听到触发的所有事件的SelectionKey
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                for(SelectionKey selectionKey : selectionKeys) {
                    //处理事件
                    handlers(selectionKey);
                }
                //注意要清空事件，否则会重复响应
                selectionKeys.clear();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            close(selector);
        }

    }


    //处理事件
    private void handlers(SelectionKey selectionKey) throws IOException {
        // ACCEPT事件 - 和客户端建立了连接
        if(selectionKey.isAcceptable()) {
            //处理accpet事件
            //先获取ServerSocketChannel
            ServerSocketChannel serverSocketChannel = (ServerSocketChannel)selectionKey.channel();

            //获取对应的客户端通道
            SocketChannel clientSocketChannel = serverSocketChannel.accept();
            //默认是阻塞模式，需要改为非阻塞
            clientSocketChannel.configureBlocking(false);

            //将客户端通道绑定到selector上,监听read事件
            clientSocketChannel.register(selector, SelectionKey.OP_READ);

            System.out.println(getClientName(clientSocketChannel) + "已连接");

        }
        //READ事件 - 客户端发送了消息给服务端就会触发read事件
         else if(selectionKey.isReadable()) {
            //处理read事件
            //通过selection获取对应的客户端通道
            SocketChannel clientSocketChannel = (SocketChannel)selectionKey.channel();
            //获取通道中的消息
            String fwdMsg = receive(clientSocketChannel);

            if(fwdMsg.isEmpty()) {
                //接受不到消息，那么把该通道移除
                selectionKey.channel();
                //通知selector有注册的通道被移除了，更新状态
                selector.wakeup();

            } else {
                //转发消息
                forwardMessage(clientSocketChannel, fwdMsg);
                System.out.println(getClientName(clientSocketChannel) + ":" + fwdMsg);

                if(readyToQuit(fwdMsg)) {
                    selectionKey.channel();
                    selector.wakeup();
                    System.out.println(getClientName(clientSocketChannel) + "已断开");
                }
            }
        }

    }

    private String getClientName(SocketChannel client) {
        return "客户端[" + client.socket().getPort() + "]";
    }


    /**
     * 接收方法
     */
    private String receive(SocketChannel clientSocketChannel) throws IOException {
        rBuffer.clear();

        //一直读数据
        while(clientSocketChannel.read(rBuffer) > 0);
        //flip将buffer的读模式转换为写模式
        rBuffer.flip();
        return String.valueOf(charset.decode(rBuffer));

    }

    /**
     * 转发消息
     */
    private void forwardMessage(SocketChannel clientSocketChannel, String fwdMsg) throws IOException {
        //keys()方法区别于selectedKeys()，selectedKeys()返回的是接下来需要被处理的通道key
        //而keys()返回的是与selector绑定的所有通道key
        for (SelectionKey selectionKey : selector.keys()) {
            Channel connectedClient = selectionKey.channel();
            if (selectionKey.channel() instanceof ServerSocketChannel) {
                continue;
            }
            //有效且不是发送者
            if (selectionKey.isValid() && !clientSocketChannel.equals(connectedClient)) {
                wBuffer.clear();
                //写入消息
                wBuffer.put(charset.encode(getClientName(clientSocketChannel) + ":" + fwdMsg));
                //wBuffer由写状态转换为读状态
                wBuffer.flip();
                //有数据有一直读
                while (wBuffer.hasRemaining()) {
                    ((SocketChannel)connectedClient).write(wBuffer);
                }
            }
        }
    }

    public static void main(String[] args) {
        ChatServer chatServer = new ChatServer(7777);
        chatServer.start();
    }
}

客户端：

package chatroom.nio.client;

import java.io.Closeable;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedSelectorException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Set;

public class ChatClient {

    //默认主机地址
    private static final String DEFAULT_SERVER_HOST = "127.0.0.1";
    //默认监听端口
    private static final int DEFAULT_SERVER_PORT = 8888;
    private static  final String QUIT = "quit";
    private static final int BUFFER_SIZE = 1024;

    private String host;
    private int port;
    private SocketChannel clientSocketChannel;
    private ByteBuffer rBuffer = ByteBuffer.allocate(BUFFER_SIZE);
    private ByteBuffer wBuffer = ByteBuffer.allocate(BUFFER_SIZE);
    private Selector selector;
    private Charset charset = Charset.forName("UTF-8");

    public ChatClient() {
        this.host = DEFAULT_SERVER_HOST;
        this.port = DEFAULT_SERVER_PORT;
    }

    public ChatClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    /*
    检查用户是否准备退出
     */
    public boolean readyToQuit(String msg) {
        return QUIT.equals(msg);
    }

    public void close(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


    private void start() {
        try {
            // 创建用户通道
            clientSocketChannel = SocketChannel.open();
            clientSocketChannel.configureBlocking(false);

            //创建selector，并且将用户通道的connect请求注册上去
            selector = Selector.open();
            clientSocketChannel.register(selector, SelectionKey.OP_CONNECT);

            //尝试与服务器建立连接
            clientSocketChannel.connect(new InetSocketAddress(host, port));

            while(selector.isOpen()) {
                selector.select();
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                for (SelectionKey selectionKey : selectionKeys) {
                    //响应请求
                    handler(selectionKey);
                }
                selectionKeys.clear();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClosedSelectorException e) {
            // 用户正常退出
        } finally {
            close(selector);
        }

    }

    private void handler(SelectionKey key) throws IOException {
        // connect事件 - 连接就绪事件
        if (key.isConnectable()) {
            SocketChannel client = (SocketChannel) key.channel();
            // 如果能够与服务器响应
            if(client.isConnectionPending()) {
                // 正式建立连接
                client.finishConnect();

                // 处理用户输入的信息，由于该线程会被用户输入所阻塞，故需要新建一个线程
                new Thread(new UserInputHandler(this)).start();
            }
            client.register(selector, SelectionKey.OP_READ);
        }
        // read事件 - 服务器转发消息
        else if (key.isReadable()) {
            SocketChannel client =  (SocketChannel) key.channel();
            String msg = receive(client);
            if (msg.isEmpty()) {
                // 服务端异常
                close(selector);
            } else {
                // TODO
                System.out.println(msg);
            }

        }
    }

    private String receive(SocketChannel client) throws IOException {
        rBuffer.clear();
        while (client.read(rBuffer) > 0);
        rBuffer.flip();
        return String.valueOf(charset.decode(rBuffer));
    }

    public void send(String msg) throws IOException {
        if (msg.isEmpty()) {
            return;
        }

        wBuffer.clear();
        // put方法写入缓冲区
        wBuffer.put(charset.encode(msg));
        // 转换为读模式
        wBuffer.flip();
        while (wBuffer.hasRemaining()) {
            clientSocketChannel.write(wBuffer);
        }

        // 检查用户是否退出
        if (readyToQuit(msg)) {
            close(selector);
        }
    }

    public static void main(String[] args) {
        ChatClient client = new ChatClient(DEFAULT_SERVER_HOST, 7777);
        client.start();
    }

}

客户端UserInputHandler：

package chatroom.nio.client;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class UserInputHandler implements Runnable{

    private ChatClient chatClient;

    public UserInputHandler(ChatClient chatClient) {
        this.chatClient = chatClient;
    }

    @Override
    public void run() {
        try {
            //等待用户输入消息
            BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
            while (true) {
                String input = consoleReader.readLine();
                // 向服务器发送消息
                chatClient.send(input);
                //检查用户是否准备退出
                if (chatClient.readyToQuit(input)) {
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
北冥有瑜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
NIO编程实现实例
02-21
4. **NIO编程流程**： - 打开通道：根据需求创建FileChannel、SocketChannel或ServerSocketChannel。 - 创建缓冲区：根据需要处理的数据类型创建对应的Buffer实例。 - 读写数据：使用通道与缓冲区交互，将数据从...
RPC框架设计(二)-NIO编程
路人贾的博客
05-07 240
2.NIO编程 2.1 NIO介绍 Java NIO全称java non-blocking IO，是指JDK提供的新API。从JDK1.4开始，Java提供了一系列改进的输入/输出的新特性，被统称为NIO（即 New IO），是同步非阻塞的。 1.NIO有三大核心部分：Channel(通道)、Buffer(缓冲区)、Selector(选择器) 2.NIO是面向缓冲区编程的。数据读取到一个缓冲区中，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞时的高伸缩性风格 3.Java N
NIO编程简介
weixin_42386438的博客
04-11 798
NIO(同步非阻塞)
java网络编程——NIO架构
tang_seven的博客
04-26 2060
简单叙述java NIO架构，并基于NIO架构下实现聊天系统的代码编写
Java NIO 编程指引
06-30
Java,NIO,教程 非堵塞IO编程
NIO编程技术指南_预览版
10-08
综上所述，NIO编程技术是Java中处理高性能并发I/O的重要工具，对于开发高可用、高并发的服务端应用具有重大意义。通过深入理解和熟练运用NIO，开发者能够构建出更高效、更灵活的系统。《NIO与Socket编程技术指南》_...
NIO网络编程
12-22
NIO网络编程 Selector选择器 进行监听，是新连接或已经连接，读写数据 常用方法 public static Selector Open(); 得到一个选择器对象 public int select(long timeout); 监听所有注册通道，存在IO流操作，将对应...
Java NIO 网络编程初探
12-22
Java NIO 网络编程初探 1. Java NIO Java 1.4 版本添加了一个新的IO API，称为NIO（New IO）。NIO拥有所有IO的功能，但是操作方法却完全不一样。NIO支持面向缓冲区的、基于通道的IO操作。能够更加高效的进行IO操作。...
Java高并发编程代码（Netty NIO 实例）
05-12
Java高并发编程代码（Netty NIO 实例）
JAVA-NIO程序设计完整实例
04-18
NULL 博文链接：https://shift-alt-ctrl.iteye.com/blog/1840554
NIO模型
车车的博客
10-20 471
NIO的介绍 NIO(New IO)同步非阻塞IO模型，采用了事件驱动的思想来实现一个复用器，来解决大并发的问题 NIO中，将读、写、可连接、可接受等操作在BIO中是阻塞处理，将操作设置为非阻塞，并将这些操作视为事件，当关注某个事件时，将其注册到复用器Selector(本质上使用底层操作系统提供的IO复用器：select、poll，epoll)。由系统来监听事件是否准备就绪， 当socket有读或者可写操作时，系统会通知相应的用户程序来处理，将流读取到缓冲区或者写入到系统中 一个复用器上是...
NIO与缓冲区
一枚野生程序员 —— Tim
02-08 664
Java NIO简介Java NIO (New IO/Non Blocking IO)，官方给的定义是New IO，但是我们也可以当作是Non Blocking IO，即非阻塞式IO，是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支 持面向缓冲区的、基于通道的...
java之NIO编程
敲代码的小小酥的博客
12-03 1511
java NIO详解
Java NIO编程实例之三Selector
LogicTeamLeader的专栏
04-08 2361
Java NIO主要包含三个概念，即缓冲区（Buffer）、通道（Channel）和选择器（Selector）。前面的文章已经介绍了缓冲区和通道，本文则讲述最复杂的选择器Selector。 本文是本系列的第三篇文章，关于缓冲区Buffer可以看第一篇： https://zhuanlan.zhihu.com/p/25701512 关于通道Channel可以看第二篇： https://zhuan
解锁网络编程之NIO的前世今生
喜欢历史的码农
11-27 527
NIO 内容概览： NIO 网络编程模型 NIO 网络编程详解 NIO 网络编程实战 NIO 网络编程缺陷 一、NIO网络编程模型 1、编程模型定义 NIO : 又叫Non-blocking I/O或New I/O;全新的输入输出标准库； 做为原始I/O的补充，为了高性能和高并发的场景使用。 模型：对事物共性的抽象； 编程模型...
redis优缺点总结
热门推荐
码农之道
04-29 4万+
优点： 1 读写性能优异 2 支持数据持久化，支持AOF和RDB两种持久化方式 3 支持主从复制，主机会自动将数据同步到从机，可以进行读写分离。 4 数据结构丰富：除了支持string类型的value外还支持string、hash、set、sortedset、list等数据结构。       缺点： 1 Redis不具备自动容错和恢复功能，主机从机的宕机都会导致前端部分
在NIO编程体系中，负责集中监控系统中所有事件的对象是：
最新发布
06-09
在NIO编程体系中，负责集中监控系统中所有事件的对象是选择器（Selector）。Selector是Java NIO中的一个组件，它可以同时监控多个通道上的事件，例如：连接请求、数据到达等。Selector可以让单线程处理多个通道，也...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值