Java NIO实现双向读写Server与Client

最新推荐文章于 2022-01-29 17:26:58 发布
最新推荐文章于 2022-01-29 17:26:58 发布
阅读量661 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cin_ie/article/details/102622895
版权

正在复习Java基础知识，依葫芦画瓢写了个NIO服务的demo，又改进了下，做成了双向读写。分享给需要的朋友

废话少说，代码如下：

B_Server
package nio_demo_01;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

/**
 * @Author: yesiming
 * @Platform: Mac
 * @Date: 10:31 AM 2019/10/16
 *
 * NIO Demo
 */
public class B_Server implements Runnable {

    private Selector selector;

    private ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
    private ByteBuffer writeBuffer = ByteBuffer.allocate(1024);

    public B_Server(int port) {

        try {
            // 1. 打开多路复用
            this.selector = Selector.open();

            // 2. 打开服务器通道
            ServerSocketChannel ssc = ServerSocketChannel.open();

            // 3. 设置服务器通道为阻塞模式
            ssc.configureBlocking(false);

            // 4. 绑定端口
            ssc.bind(new InetSocketAddress(port));

            // 5. 把服务器channel注册到选择器中，监听阻塞时间
            ssc.register(this.selector, SelectionKey.OP_ACCEPT);
            System.out.println("注册服务端channel");

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

    @Override
    public void run() {

        while(true) {
            try {
                System.out.println("进入while了");
                // 1. 让选择器开始监听
                this.selector.select();
                System.out.println("选择器已经打开");

                // 2. 返回选择器结果集
                Iterator<SelectionKey> keys = this.selector.selectedKeys().iterator();

                System.out.println("这里做了什么");

                // 3. 遍历
                while(keys.hasNext()) {
                    // 4. 获取其中一个元素
                    SelectionKey key = keys.next();
                    // 5. 可以移除掉
                    /*
                    channel是注册在selector中的，在后面的轮询中，是先将已准备好的channel挑选出来，即selector.select()，再通
                    过selectedKeys()生成的一个SelectionKey迭代器进行轮询的，一次轮询会将这个迭代器中的每个SelectionKey都遍历
                    一遍，每次访问后都remove()相应的SelectionKey，但是移除了selectedKeys中的SelectionKey不代表移除了selector
                    中的channel信息(这点很重要)，注册过的channel信息会以SelectionKey的形式存储在selector.keys()中，也就是说
                    每次select()后的selectedKeys迭代器中是不能还有成员的，但keys()中的成员是不会被删除的(以此来记录channel信息)。
                     */
                    keys.remove();
                    // 6. 判断有效性
                    if(key.isValid()) {
                        // 7. 状态：阻塞
                        if(key.isAcceptable()) {
                            System.out.println("阻塞key: " + key);
                            this.accept(key);
                        }

                        // 8. 状态：可读
                        if(key.isReadable()) {

                            System.out.println("可读key: " + key);
                            this.read(key);
                        }

                        // 9. 状态：可写
                        if(key.isWritable()) {
                            System.out.println("可写key: " + key);
                            this.write(key);
                        }
                    }

                }

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

    }

    private void accept(SelectionKey key) {
        try {
            // 1. 获取服务器通道
            ServerSocketChannel ssc = (ServerSocketChannel)key.channel();
            // 2. 执行阻塞方法
            SocketChannel sc = ssc.accept();
            // 3. 设置阻塞模式：非阻塞
            sc.configureBlocking(false);
            // 4. 注册到选择器上，并设置可读
            sc.register(this.selector, SelectionKey.OP_READ);

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

    }

    private void read(SelectionKey key) {
        try {
            // 1. 清空缓冲期数据
            this.byteBuffer.clear();
            // 2. 获取之前注册到选择器的socket通道
            SocketChannel sc = (SocketChannel)key.channel();
            // 3. 读取数据
            int count = sc.read(this.byteBuffer);
            // 4. 如果没有数据
            if(count == -1) {
                key.channel().close();
                key.cancel();
                return;
            }
            // 5. 有数据就读取，读取之前需要进行flip（把position 和limit进行固定）
            this.byteBuffer.flip();
            // 6. 根据缓冲区的数据长度创建相应大小的byte数组，接受缓冲区数据
            byte[] bytes = new byte[byteBuffer.remaining()];
            // 7. 接收缓冲区数据
            this.byteBuffer.get(bytes);
            // 8. 打印结果
            String body = new String(bytes).trim();
            System.out.println("Server: " + body);

            // 9. 可以写回给客户端数据
            sc.configureBlocking(false);
            sc.register(this.selector, SelectionKey.OP_WRITE);

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

    }

    private void write(SelectionKey key) {
        SocketChannel sc = (SocketChannel)key.channel();
        try {
//            sc.register(this.selector, SelectionKey.OP_WRITE);
            System.out.println("来了没有？？？？？？？？？？？？？？？？");
            byte[] bytes = "呵呵".getBytes();
            writeBuffer.put(bytes);
            writeBuffer.flip();
            sc.write(writeBuffer);
            writeBuffer.clear();
            key.channel().close();
            key.cancel();
//            sc.register(this.selector, SelectionKey.OP_READ);

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

        }

    }

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

}

B_Client

package nio_demo_01;

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

/**
 * @Author: yesiming
 * @Platform: Mac
 * @Date: 11:39 AM 2019/10/16
 *
 * 双向通信的客户端【方法分离】
 */
public class B_Client implements Runnable {

    private SocketChannel sc = null;
    private Selector selector = null;

    public static void main(String[] args) {
        B_Client b_client = new B_Client();
        new Thread(b_client).start();

        b_client.write();

    }

    public B_Client() {
        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8910);
        try {
            sc = SocketChannel.open();

            sc.connect(address);
            sc.configureBlocking(false); // 一定要注意：必须connect之后，才能设置非阻塞，否则会在发消息时抛出NotYetConnectedException

            this.selector = Selector.open();
            sc.register(this.selector, SelectionKey.OP_READ);

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

    private void write() {
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        try {
            while (true) {
                byte[] bytes = new byte[1024];
                System.in.read(bytes);
                byteBuffer.put(bytes);
                byteBuffer.flip();
                sc.write(byteBuffer);
                byteBuffer.clear();
            }
        } catch (IOException e) {

        }

    }

    private void read(SelectionKey key) throws IOException {
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        try {
            // 2. 获取之前注册到选择器的socket通道
            SocketChannel sc = (SocketChannel)key.channel();
            // 3. 读取数据
            int count = sc.read(byteBuffer);
            // 4. 如果没有数据
            if(count == -1) {
                key.channel().close();
                key.cancel();
                return;
            }
            // 5. 有数据就读取，读取之前需要进行flip（把position 和limit进行固定）
            byteBuffer.flip();
            // 6. 根据缓冲区的数据长度创建相应大小的byte数组，接受缓冲区数据
            byte[] bytes = new byte[byteBuffer.remaining()];
            // 7. 接收缓冲区数据
            byteBuffer.get(bytes);
            // 8. 打印结果
            String body = new String(bytes).trim();
            System.out.println("Server: " + body);


            // 记住，一定要1. 关闭通道，2. 取消key。不然while(true)时，会不断取出该key
            key.channel().close();
            key.cancel();

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

        }

    }

    @Override
    public void run() {
        while(true){
            try {
                this.selector.select();
                Iterator<SelectionKey> keys = this.selector.selectedKeys().iterator();
                while (keys.hasNext()) {
                    SelectionKey key = keys.next();
                    if(key.isValid()){
                        if(key.isReadable()){
                            this.read(key);
                        }
                    }
                    keys.remove();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

好，结束

车前猛跑
关注
专栏目录
JAVA NIO 异步TCP服务端向客户端消息群发代码教程实战
洛阳泰山的博客
08-29 916
项目需要和第三方厂商的服务需要用TCP协议通讯，考虑到彼此双方可能都会有断网重连、宕机重启的情况，需要保证 发生上述情况后，服务之间能够自动实现重新通信。研究测试之后整理如下代码实现。因为发现客户端重启后，对于服务端来说原来的客户端和服务端进程进程已经关闭，启动又和服务端新开了一个进程。所以实现原理就可以通过服务端向客户端群发实现，断开重新连接通讯。之前写的是BIO阻塞机制，这次用NIO非阻塞来写。...
java nio例子_java NIO原理及实例
weixin_29668721的博客
02-12 437
1、reactor(反应器)模式使用单线程模拟多线程，提高资源利用率和程序的效率，增加系统吞吐量。下面例子比较形象的说明了什么是反应器模式：一个老板经营一个饭店，传统模式 - 来一个客人安排一个服务员招呼，客人很满意；(相当于一个连接一个线程)后来客人越来越多，需要的服务员越来越多，资源条件不足以再请更多的服务员了，传统模式已经不能满足需求。老板之所以为老板自然有过人之处，老板发现，服务员在为客人...
Java NIO学习笔记(三) 使用Selector客户端与服务器的通信
热门推荐
不能说的秘密的博客
05-11 1万+
之前在写一个即使通讯软件的时候使用了阻塞式IO来完成通讯，在服务器对于没一个客户端的链接，服务器都要启动一个线程来维持客户端的阻塞。虽然我使用了线程池来优化线程的开销，但难免还是有性能上的瓶颈
Java Socket实战之六 使用NIO包实现Socket通信
yaasshole
02-23 289
本文地址：http://blog.csdn.net/kongxx/article/details/7288896 Java Socket实战之一 单线程通信 Java Socket实战之二 多线程通信 Java Socket实战之三 传输对象 Java Socket实战之四 传输压缩对象 Java Socket实战之五 使用加密协议传输对象 前面几篇文章介绍了使用java.io和jav...
基于IO/NIO/Netty的Client/Server的java程序实现
weixin_56102526的博客
12-09 1386
一、项目环境搭建（一）创建项目（二）项目配置环境二、IO实现（一）项目结构如下（二）代码（三）运行结果参考资料 一、项目环境搭建 （一）创建项目 1.新建JAVA项目 2.项目命名路径选择 3.创建完成 （二）项目配置环境 1.浏览器打开Maven中央仓库地址 https://mvnrepository.com/ 搜索netty-all 2.选择稳定版本这里是4.1.52 3.查看Gradle的依赖，并下载jar包 4.下载成功 依赖 <!-- https://mvnrepositor.
NIO server client
C18298182575的博客
01-29 468
服务端 package com.suosuo.myprojects.netty.channel; import lombok.extern.slf4j.Slf4j; import java.io.IOException; import java.net.InetSocketAddress; import java.net.ServerSocket; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import ja
基于NIO的Client/Server程序实践
张兆坤
07-17 1万+
一个简单的基于Java的NIO来实现的客户端/服务器程序，相互之间发送和接收消息。
java nio im(server+client)
11-20
在这个Java NIO IM（即时通讯）服务器和客户端的示例中，我们将探讨如何利用NIO进行双向通信，并理解其背后的机制。 1. **NIO基础概念** - **通道（Channel）**：在NIO中，数据是通过通道进行传输的。通道类似于流...
服务器nio协议,java Nio使用NioSocket客户端与服务端交互实现方式
weixin_35900054的博客
08-11 1043
NioSocket 客户端与服务端交互实现java Nio是jdk1.4新增的io方式—–nio(new IO)，这种方式在目前来说算不算new，更合适的解释应该是non-block IO。non-block是相对于传统的io方式来讲的。传统的Io方式是阻塞的，我们拿网络io来举例，传统的io模型如下：服务端主线程负责不断地server.accept()，如果没有客户端请求主线程就会阻塞，当客户端...
java NIO实例
12-29
Java NIO，全称为Non-Blocking Input/...以上就是Java NIO的基本概念和工作流程，以及结合文件名推测的`NIOServer.java`和`NIOClient.java`可能实现的功能。学习和理解NIO，对于开发高并发、高性能的Java应用至关重要。
NIO
QuinnNorris的博客
07-20 432
NIO和BIO的区别 IO： 面向流 单向的 阻塞同步IO NIO：面向缓冲区 通道可以是单向的，也可以是双向的 非阻塞同步IO NIO的核心在于：通道和缓冲区（Buffer），获取IO设备中的通道以及用于容纳的数据缓冲区，对数据进行处理.缓冲区底层就是数组Channel负责传输，Buffer负责存储。 Buffer属性 buffer作为缓冲区，一次读取一些数据，可以减少磁盘的IO次...
Java NIO（6）：Server和Client案例
文心
05-30 2592
Server：package com.tony.app; import java.io.IOException; import java.net.InetSocketAddress; import java.net.ServerSocket; import java.nio.ByteBuffer; import java.nio.channels.SelectableChannel; impor...
分别基于IO、NIO、Netty的Java网络程序(Client/Server)
伊木子曦的博客
12-14 677
文章目录一、IO实现1. IO介绍1.1 传送IO特点1.2 原理流程图2. 代码3. 运行结果二、NIO实现1. NIO介绍1.1 NIO特点1.2 原理流程图1.3 NIO对比IO1.4 使用NIO遇到的一些问题2. 代码3. 运行结果三、Netty实现1. Netty介绍1.1 Netty特点2. 代码3.运行结果四、参考 一、IO实现 1. IO介绍 1.1 传送IO特点 1.服务端阻塞点 server.accept();获取套接字的时候 inputStream.read(bytes);输入流读取
java NIO socket 通信实例
zhuyijian135757的专栏
07-10 8220
java nio 通信简单 demo
【NIO详解】基于NIO的client与server
白夜行
06-12 4575
服务端代码public class Server_Test { public static void main(String[] args) { int port = 8080; if (args != null && args.length > 0) { try { port = Integer.val
java select 选择器_Java NIO——Selector选择器
weixin_30035343的博客
02-27 648
一、简介1.1、Java 的 NIO，用非阻塞的 IO 方式。可以用一个线程，处理多个的客户端连接，就会使用到Selector(选择器)1.2、Selector 能够检测多个注册的通道上是否有事件发生(注意：多个Channel以事件的方式可以注册到同一个Selector)，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。1...
基于IO、NIO、Netty的Client和Server之间的Java程序
qq_55691662的博客
12-12 677
文章目录一、IO实现1.1 传统IO的特点1.2 项目实现1.3 结果二、NIO实现2.1NIO特点2.2 IO与NIO的差别2.3 项目实现四、参考文献 一、IO实现 1.1 传统IO的特点 代码执行时会存在两个阻塞点 server.accept(); 等待链接 inputStream.read(bytes); 等待输入 单线程情况下只能为一个客户端服务； 用线程池可以有多个客户端连接，但是非常消耗性能； 使用传统的I/O程序读取文件内容, 并写入到另一个文件(或Socket),
java nio 基础之Select 用法
zhouzhiwengang的专栏
06-04 8610
本文参考至Java Nio 基础教程 Select (选择器)是Java Nio中能够检测一个到多个通道，并能够知道是否为诸如读写事件做好准备的组件。 这样，一个单独的线程就可以管理多个channel,从而管理多个网络连接。 为什么需要使用Select ? 仅用单个线程来处理多个Channels的好处是，只需要更少的线程来处理通道。事实上，可以只用一个线程处理所有的
java nio write_Java NIO
weixin_30545587的博客
02-16 355
1. 概述Java NIO (New IO) 由以下三个核心组件组成：Channels (通道)Buffers (缓冲区)Selectors (选择器)通常，在NIO中，IO从一个Channel开始。数据可以从Channel中读到Buffer，也可以从Buffer中写道Channel。而Selector允许单个线程处理多个Channel。2. ChannelChannels和Streams很像，但...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值