Java网络编程之NIO(ServerSocketChannel/SocketChannel)-yellowcong

最新推荐文章于 2024-07-23 09:00:00 发布
最新推荐文章于 2024-07-23 09:00:00 发布
阅读量774 收藏 4
点赞数
分类专栏： Java高级开发 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yelllowcong/article/details/78169318
版权

NIO编程中，需要知道的的重要概念 通道（Channel，封装的Socket）、缓冲区(ByteBuffer等类，用于服务端和客户端数据传递)、选择器（Selector,用于处理Channel）。NIO处理时异步非阻塞的IO，NIO(只有Selector的一个线程，不断轮询处理Channel)效率比BIO高很多（BIO是一个请求一个线程）。NIO中常用的框架有Netty和Mina。

基本概念

NIO网络编程中，重要的类有，
ByteBuffer、（缓冲区）
Channel(ServerSocketChannel/SocketChannel) 通道，双向的
Selector(多路复用器，选择器)

1、缓冲区： 在操作系统中缓冲区是为了解决CPU的计算速度和外设输入输出速度不匹配的问题，因为外设太慢了，如果没有缓冲区，那么CPU在外设输入的时候就要一直等着，就会造成CPU处理效率的低下，引入了缓冲之后，外设直接把数据放到缓冲中，当数据传输完成之后，给CPU一个中断信号，通知CPU：“我的数据传完了，你自己从缓冲里面去取吧”。如果是输出也是一样的道理。

2、通道： 那么通道用来做什么呢？其实从他的名字就可以看出，它就是一条通道，您想传递出去的数据被放置在缓冲区中，然后缓冲区中怎么从哪里传输出去呢？或者外设怎么把数据传输到缓冲中呢？这里就要用到通道。它可以进一步的减少CPU的干预，同时更有效率的提高整个系统的资源利用率，例如当CPU要完成一组相关的读操作时，只需要向I/O通道发送一条指令，以给出其要执行的通道程序的首地址和要访问的设备，通道执行通道程序便可以完成CPU指定的I/O任务。

3、选择器： 另外一项创新是选择器，当我们使用通道的时候也许通道没有准备好，或者有了新的请求过来，或者线程遇到了阻塞，而选择器恰恰可以帮助CPU了解到这些信息，但前提是将这个通道注册到了这个选择器。

NIO编程中，采用的是Channel对Socket的封装，解决了TCP三次握手的问题，每一个客户端（SocketChannel）访问服务器，都会注册到Selector中，并以SelectionKey的集合形式存储起来，在轮询中，对SelectionKey的状态进行检查和业务操作。
SelectionKey.OP_CONNECT //连接
SelectionKey.OP_ACCEPT //接受请求
SelectionKey.OP_READ //读操作
SelectionKey.OP_WRITE　 //写操作

这里写图片描述

案例

这个案例中，我做了两个Client,不同的是一个Client只有些数据的作用，另外一个具有读写等功能

服务器端

服务器端中，需要注意的是selectionKey.isAcceptable()判断后，需要获取到服务器端的ServerSocketChannel ,然后再获取到客户端发过来的SocketChannel ，并注册。

//获取到SelectionKey 里面的Channel
ServerSocketChannel channel = (ServerSocketChannel) selectionKey.channel();

//线程阻塞，获取客户端的SocketChannel,注册到服务器端
// 接受到此通道套接字的连接。  
SocketChannel sc = channel.accept();

//设定非阻塞
sc.configureBlocking(false);

//注册准备读的事件
sc.register(this.selector,SelectionKey.OP_READ);

完整代码 

package yellowcong.socket.nio;

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

import org.junit.experimental.theories.Theories;

/**
 * 创建日期:2017年10月7日 <br/>
 * 创建用户:yellowcong <br/>
 * 功能描述:  
 */
public class Server implements Runnable{
    //多路复用器
    private Selector selector ;

    private ByteBuffer byteBuff  = ByteBuffer.allocate(1024);;

    //port 端口号
    public Server(int port) {
        try {
            this.selector = Selector.open();
            ServerSocketChannel channel = ServerSocketChannel.open();

            //设定是否是线程阻塞的
            channel.configureBlocking(false);

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

            //注册channel  到Selecor(多路复用器)中
            channel.register(this.selector, SelectionKey.OP_ACCEPT);

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    public void run() {
        System.out.println("服务器启动");
        //在服务器端，轮询操作
        while(true){
            try {
                //开启多路复用器监听操作
                this.selector.select();

                //获取Selector 里面注册的 SelectionKey（每注册一个Channel ，就会有一个SelectionKey，SelectionKey里面有Channel对象 ）
                Iterator<SelectionKey> keys = this.selector.selectedKeys().iterator();

                while(keys.hasNext()){
                    SelectionKey selectionKey = keys.next();

                    //直接从容器中移除就可以了,不然重复处理同一条Channel
                    keys.remove();

                    //可以连接的情况 ，刚开始连接时比较特别的，需要获取到客户端管道，然后再注册到服务器端Selector
                    if(selectionKey.isAcceptable()){

                        //获取到SelectionKey 里面的Channel
                        ServerSocketChannel channel = (ServerSocketChannel) selectionKey.channel();

                        //线程阻塞，获取客户端的SocketChannel,注册到服务器端
                        // 接受到此通道套接字的连接。  
                        // 此方法返回的套接字通道（如果有）将处于阻塞模式。  
                        SocketChannel sc = channel.accept();

                        //设定非阻塞
                        sc.configureBlocking(false);

                        //注册准备读的事件
                        sc.register(this.selector,SelectionKey.OP_READ);
                    }

                    //可读的情况
                    if(selectionKey.isReadable()){

                        //获取到客户端的SocketChannel
                        SocketChannel sc =(SocketChannel) selectionKey.channel();

                        //晴空数据
                        this.byteBuff.clear();
                        int cnt = sc.read(this.byteBuff);

                        //数据没有的情况
                        if(cnt == -1){
                            selectionKey.channel().close();
                            selectionKey.cancel();
                            return;
                        }
                        //复位 ,将position置为1
                        this.byteBuff.flip();

                        //建立一个数组,大小 为传递过来的  数据长度
                        byte [] data = new byte[this.byteBuff.remaining()];
                        //将buffer数据读取到 数组中
                        this.byteBuff.get(data);

                        //打印传送过来的数据内容
                        System.out.println("服务器端:\t"+new String(data));

                        //进行下一步，注册写数据
                        sc.register(this.selector, SelectionKey.OP_WRITE);
                    }else if(selectionKey.isWritable()){//可写的情况
                        this.write(selectionKey);
                    }
                }

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

        }
    }
    /**
     * 写数据到客户端
     * 创建日期:2017年10月7日<br/>
     * 创建用户:yellowcong<br/>
     * 功能描述:
     * @param selectionKey
     */
    public void write(SelectionKey selectionKey){
        try {
            //获取客户端Channel
            SocketChannel clientChannel = (SocketChannel) selectionKey.channel();

            String sendText = "hello client"; //写道客户端的数据
            this.byteBuff.clear(); //在使用ByteBuff前，清空里面数据
            this.byteBuff.put(sendText.getBytes());
            this.byteBuff.flip();        //写完数据后调用此方法，设定Bytebuff的postion为0
            clientChannel.write(byteBuff);

            //设置Channel的下一步操作时 读取
            clientChannel.register(this.selector, SelectionKey.OP_READ);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Server server = new Server(8080);

        new Thread(server).start();
    }
}

客户端1

这个客户端中，我们可以发现，没有用到Selector(选择器)，直接就可以发送请求到服务器端

package yellowcong.socket.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.concurrent.CountDownLatch;

/**
 * 创建日期:2017年10月7日 <br/>
 * 创建用户:yellowcong <br/>
 * 功能描述:  
 */
public class Client {

    private static final String  ADDR = "127.0.0.1";
    private static final Integer PORT = 8080;

    public static void  main(String [] args){
        try {

            //打开Socker Channel
            SocketChannel channel = SocketChannel.open();

            //打开链接
            channel.connect(new InetSocketAddress(ADDR, PORT));


            ByteBuffer buff =ByteBuffer.allocate(1024);

            while(true){
                //不断重控制台读取数据
                byte [] data = new byte[1024];
                System.in.read(data);

//              buff.put("发送文本".getBytes());

                //写数据到buff里面
                buff.put(data);

                //复位
                buff.flip();

                //写道服务器
                channel.write(buff);

                //清空
                buff.clear();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

客户端2

客户端2里面有发送和接收的请求和操作，这个客户端和服务端，在获取连接的地方有些区别if(selectionKey.isConnectable()){}判断的是是否获取到了连接，而服务器段是判断if(selectionKey.isAcceptable()){}

package yellowcong.socket.nio;

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;

/**
 * 创建日期:2017年10月7日 <br/>
 * 创建用户:yellowcong <br/>
 * 功能描述:  
 */
public class Client2  implements Runnable{

    private static final String  ADDR = "127.0.0.1";
    private static final Integer PORT = 8080;

    private Selector selector;
    private ByteBuffer byteBuff =ByteBuffer.allocate(1024);

    public Client2() {
        try {
            this.selector = Selector.open();

            //打开Socker Channel
            SocketChannel channel = SocketChannel.open();

            //设定连接
            channel.configureBlocking(false);

            //打开链接
            channel.connect(new InetSocketAddress(ADDR, PORT));

            // 注册连接服务端socket动作  
            channel.register(this.selector, SelectionKey.OP_CONNECT);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
    public void run() {

        while(true){

            try {
                Thread.sleep(1000);
                //多路复用器 监听开始， 这个地方是阻塞的
                this.selector.select();

                //获取所有的 Channel 信息
                Iterator<SelectionKey>  selectedKeys = this.selector.selectedKeys().iterator();

                //当存在Channel的情况
                while(selectedKeys.hasNext()){
                    //获取SelectionKey后，删掉集合里面的这个SelectionKey
                    SelectionKey selectionKey = selectedKeys.next();
                    selectedKeys.remove();//保证channel只遍历一次

                    if(selectionKey.isConnectable()){
                        //连接
                        SocketChannel channel  = (SocketChannel) selectionKey.channel();
                        // 判断此通道上是否正在进行连接操作。  
                        // 完成套接字通道的连接过程。  
                        if (channel.isConnectionPending()) {  
                            channel.finishConnect();  
                            System.out.println("完成连接!");  
                            byteBuff.clear();  
                            byteBuff.put("Hello,Server".getBytes());  
                            byteBuff.flip();  
                            channel.write(byteBuff);

                        }  
                        channel.register(this.selector, SelectionKey.OP_READ);  
                    }else if(selectionKey.isReadable()){
                        //可读
                        SocketChannel channel = (SocketChannel) selectionKey.channel();
                        //获取到客户端的SocketChannel
                        SocketChannel sc =(SocketChannel) selectionKey.channel();

                        //晴空数据
                        this.byteBuff.clear();
                        int cnt = sc.read(this.byteBuff);

                        //数据没有的情况
                        if(cnt == -1){
                            selectionKey.channel().close();
                            selectionKey.cancel();
                            return;
                        }
                        //复位 ,将position置为1
                        this.byteBuff.flip();

                        //建立一个数组,大小 为传递过来的  数据长度
                        byte [] data = new byte[this.byteBuff.remaining()];
                        //将buffer数据读取到 数组中
                        this.byteBuff.get(data);
                        System.out.println("接收数据");
                        //打印传送过来的数据内容
                        System.out.println("客户端:\t"+new String(data));

                        //进行下一步，注册写数据
                        sc.register(this.selector, SelectionKey.OP_WRITE);

                    }else if(selectionKey.isWritable()){
                        //可写
                        SocketChannel channel = (SocketChannel) selectionKey.channel();

                        byteBuff.clear();

                        //不断重控制台读取数据
                        byteBuff.put("Hello Server,I'm Client ".getBytes());

                        //复位
                        byteBuff.flip();

                        //写道服务器
                        channel.write(byteBuff);

                        //清空
                        byteBuff.clear();

                        //设定这个Channel的操作是发送到Read
                        channel.register(this.selector, SelectionKey.OP_READ);
                    }
                }
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    }

    public static void  main(String [] args){

        Client2 client = new Client2();

        new Thread(client).start();
    }



}
狂飙的yellowcong
关注
专栏目录
95-30-017-Channel-NioServerSocketChannel
九师兄
03-14 157
文章目录1. 概述2. 类图2.1 继承关系2.2 类图简介3. bind4. doReadMessages5. doClose6. 构造方法 1. 概述 你肯定已经使用过NioServerSocketChannel，作为处于Channel最底层的子类，NioServerSocketChannel会实现I/O事件框架的底层细节。首先需要注意的是：NioServerSocketChannel只支持bind、read和close操作。 2. 类图 2.1 继承关系 2.2 类图简介 3. bind @O
Java NIO 之 ServerSocketChannel SocketChannel
wojiushimogui的博客
10-10 1674
Java NIO 之 ServerSocketChannel/SocketChannelServerSocketChannel介绍Java NIO中ServerSocketChannel是一个可以监听新进来的TCP 连接的通道。既然是监听新的TCP连接，因此ServerSocketChannel一般用于服务器端，与Socket网络编程中的ServerSocket功能类似。在一般的编程实现的逻辑
Netty4.x 源码实战系列（三）：NioServerSocketChannel全剖析
weixin_33904756的博客
12-31 225
根据上一篇《Netty4.x 源码实战系列（二）：服务端bind流程详解》所述，在进行服务端开发时，必须通过ServerBootstrap引导类的channel方法来指定channel类型， channel方法的调用其实就是实例化了一个用于生成此channel类型对象的工厂对象。 并且在bind调用后，会调用此工厂对象来生成一个新chan...
Netty技术全解析：NioServerSocketChannel类详解
最新发布
码到三十五
07-23 1281
ioServerSocketChannel是Netty框架中用于服务器端的一个重要类，它基于Java NIO的ServerSocketChannel实现。通过深入了解NioServerSocketChannel的实现原理和功能，我们可以更好地利用Netty框架开发高性能的网络服务器应用。在实际开发中，我们应该根据具体的需求配置和使用NioServerSocketChannel，以确保网络服务器的稳定性和性能。
Java NIO 之 ServerSocketChannel 与 SocketChannel
weixin_33742618的博客
09-26 170
ServerSocketChannelServerSocketChannel作用？就是专职干什么的？1、监听新进来的TCP链接通道，2、创建新的SocketChannelServerSocketChannel 不具备 什么能力ServerSocketChannel并不能进行数据传输的能力如何创建ServerSocketChannel实例...
Netty-NioServerSocketChannel与NioSocketChannel
xiaopang2020的博客
04-17 767
NioServerSocketChannel与NioSocketChannel
NioServerSocketChannel
qq_44587855的博客
12-27 962
在netty Bootstrap启动之后会执行 channel，此时将NioServerSocketChannel的Class对象加入到BootStrap 的ChannelFactory之中，这个ChannelFactory是ReflectiveChannelFactory类型的 但是什么时候真正使用该Channel呢？ 这里调用ReflectiveChannelFactory的 首先执行 newSocket方法 ......
Java的NIO之网络通信的SocketChannel
惜暮
12-05 841
Java的NIO中的SocketChannel是一个连接到TCP网络套接字的通道(SocketChannel这个通道一般用于客户端，服务端一般使用ServerSocketChannel)。可以通过以下2种方式创建SocketChannel： 1. 打开一个SocketChannel并连接到互联网的某台服务器上。 2. 一个新的连接到达ServerSocketChannel时，server端会创建
Netty架构篇 - NioServerSocketChannel、NioSocketChannel
The Secret
08-10 2917
本文主要介绍Netty的NioServerSocketChannel、NioSocketChannel模型，在Netty底层中如何实例化、初始化、注册。
【IT十八掌徐培成】Java基础第27天-02.NIO-ServerSocketChannel-SocketChannel.zip
08-07
总的来说，本教程将围绕ServerSocketChannel和SocketChannel展开，讲解如何在Java NIO框架下创建服务器并接受客户端连接，以及如何通过非阻塞的方式进行数据交换，这对于我们理解和掌握Java NIO编程至关重要。...
netty源码分析3-NioServerSocketChannel,NioSocketChannel
chenchangqun11的专栏
12-03 594
本文分析内容如下 Channel主要接口分析 AbstractChannel分析 AbstractNioChannel分析 AbstractNioByteChannel分析 AbstractNioMessageChannel 分析 NioSocketChannel分析 AbstractNioMessageServerChannel分析 NioServerSocketChannel分...
使用非阻塞ServerSocketChannel、SocketChannel代替ServerSocket和Socket
04-22
NIO(服务端和客户端代码) 博文链接：https://songjianyong.iteye.com/blog/1757406
java网络编程NIO视频教程
09-12
Java NIO-NIO编程步骤总结 - **主要内容**：总结NIO编程的一般步骤和注意事项。 - **学习目标**：形成系统性的NIO编程思路。 #### 27. Java NIO-Pipe-介绍和代码示例 - **主要内容**：介绍Pipe（管道）的概念及其...
【NIO】ServerSocketChannel
热门推荐
yhl_jxy的博客
02-18 1万+
前言 Github：https://github.com/yihonglei/java-all Project：java-nio 一 ServerSocketChannel概述 Java NIO中的ServerSocketChannel类定义在java.nio.channels包中。 ServerSocketChannel是一个可以监听新进来的TCP连接的通道，就像标准IO中的Serve...
Java netty之NioServerSocketChannel
fjs的专栏
06-25 3861
在上一篇文章中分析了AbstractNioChannel，那么在这一篇文章中就分析一个具体的NioChannel类。。。 NioServerSocketChannel类用过netty的应该都比较熟悉吧，如果做服务器端的编程，那么我们一般情况下都是使用的这种类型的channel。 按照惯例，我们还是先来分析一下它的继承体系： NioServerSocketChannel直接继承自Abs
网络编程之channel
weixin_45239670的博客
06-15 358
ServerSocketChannel nio服务端 ServerSocketChannel 是一个基于通道的 socket 监听器(本身不传数据，而是一个监听器)。 由于 ServerSocketChannel 没有 bind()方法，因此有必要取出对等的 socket 并使用它来绑定到一个端口以开始监听连接。我们也是使用对等 ServerSocket 的 API 来根据需要设置其他的 socket 选项。 SocketChannel nio客户端 1、SocketChannel 介绍 Java N
Netty源码解析-NioServerSocketChannel
恐龙弟旺仔的博客
12-27 870
前言： 通过之前那么多的分拆知识点讲解，终于到了最重要的阶段了。无论之前的EventLoop还是ByteBufAllocate，终归都是为Channel服务的。Channel的实现类才是最终连接、读写事件的执行者。 本文主要聚焦于NioServerSocketChannel，作为Server端，主要用于接收客户端连接，并为该连接注册事件，我们通过源码的角度来分析下连接的整个过程。 1.NioServerSocketChannel构造图 分析类的时候，尤其Netty框架这种结构层特别多的关键类时，要学
java NIO套接字编程
whdongzxiao的博客
10-13 280
在java的套接字编程中，大部分一般使用阻塞IO套接字编程。套接字的读取和写入会阻塞(也就是说不管现在有没有写入/读出数据 调用read和write方法将会阻塞)。而NIO将I/O事件注册，当特定的注册I/O事件到达时会通知您。不需要轮询，也不需要创建大量的线程下面一个例子：下载 Server代码   package simple.socket;      impo
NIO09——ServerSocketChannel
如不來的博客
10-30 703
 ServerSocketChannel 可以监听进来的 TCP 连接，类似于 Java 网络编程中的 ServerSocket。ServerSocketChannel 类位于 java.nio.channels 包中。下面是一个示例： ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); //绑定一个端口 se...
Java网络编程基础：TCP/IP协议解析
"JAVA的网络编程" Java的网络编程是开发跨平台网络应用的关键技术，它允许应用程序通过网络发送和接收数据。在Java中，网络编程主要依赖于`java.net`包，该包提供了丰富的类和接口，使得程序员可以方便地实现网络...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

狂飙的yellowcong

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值