java IO编程详解

举报
莫逸风 发表于 2022/07/26 15:50:36 2022/07/26
【摘要】 java IO编程详解

java IO编程详解

一、Socket

1. Sock概述

Socket,套接字就是两台主机之间逻辑连接的端点。TCP/IP协议是传输层协议,主要解决数据如何在网络中传输,而HTTP协议是应用层协议,主要解决如何包装数据。Socket是通信的基石,是支持TCP/IP协议网络通信的基本单元。他是网络通信过程中端点的抽象表示,包含进行网络通信必须的五种信息:连接使用的协议、本地主机的IP地址、本地进程的协议端口、远程主机的IP地址、远程进程的协议端口。

2. Socket整体流程

Socket主要涉及到客户端和服务器端两个方面,首先是在服务器端创建一个服务器套接字(ServerSocket),并把它附加到一个端口上,服务器从这个端口监听连接。端口号的范围是0-65535,但是0-1024是特权服务的保留端口号,可以选择任意一个当前没有被其他进程使用的端口。

客户端请求与服务器进行连接的时候,根据服务器的域名或者IP地址,加上端口号打开一个套接字。当服务器接收连接后,服务器和客户端之间的连接就像输入输出流一样进行操作。

在这里插入图片描述

3. 服务端实现

package com.myf.socket;

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

/**
 * @Author myf
 * @Date 2021/3/23 21:15
 * @Version 1.0
 */
public class serverSocket {

    public static void main(String[] args) throws IOException {
        // 创建一个线程池,如果有客户端与服务器连接就与其建立连接
        final ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        final ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务器已经启动");
        while (true){
            final Socket accept = serverSocket.accept();
            System.out.println("有客户端连接");
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    hadler(accept);
                }
            });
        }
    }

    private static void hadler(Socket accept) {
        try {
            System.out.println("线程ID:"+Thread.currentThread().getId()+"线程名称:"+Thread.currentThread().getName());
            final InputStream inputStream = accept.getInputStream();
            byte[] bytes = new byte[1024];
            final int read = inputStream.read(bytes);
            final String s = new String(bytes, 0, read);
            System.out.println("客户端消息:"+s);
            final OutputStream outputStream = accept.getOutputStream();
            outputStream.write("hello".getBytes());
            outputStream.flush();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                accept.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

4. 客户端实现

package com.myf.socket;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/**
 * @Author myf
 * @Date 2021/3/24 13:34
 * @Version 1.0
 */
public class ClientSocket {
    public static void main(String[] args) {
        try {
            while (true){
                Socket socket = new Socket("127.0.0.1",9999);
                final OutputStream outputStream = socket.getOutputStream();
                outputStream.write("你好".getBytes());
                final InputStream inputStream = socket.getInputStream();
                byte[] bytes = new byte[1024];
                final int read = inputStream.read(bytes);
                final String s = new String(bytes, 0, read);
                System.out.println(s);
                socket.close();
                Thread.sleep(1000);
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

二、IO模型

  1. IO模型简单的理解:就是用什么样的通道进行数据的发送和接收,很大程度上决定了程序通信的性能。
  2. java共支持三种网络IO模型:BIO(同步阻塞)、NIO(同步非阻塞)、AIO(异步非阻塞)

阻塞与非阻塞

主要是访问IO的线程是否会阻塞(或处于等待)

线程访问资源,该资源是否准备就绪的一种处理方式(主要是在未就绪的情况下的处理方式)

在这里插入图片描述

同步和异步

主要是指数据的请求方式

同步和异步是指访问数据的一种机制

在这里插入图片描述

1. BIO(同步并阻塞)

java BIO就是传统的Socket编程。

BIO(blocking IO):同步阻塞,服务器实现模式为一个连接一个线程,即客户端有一个连接请求时,服务端就需要启动一个线程进行处理,如果这个线程不做任何事情会造成不必要的线程开销,可以通过线程池机制改善。

在这里插入图片描述

BIO问题分析

  1. 每个请求都需要创建独立的线程,与对应的客户端进行数据Read,业务处理,数据Write。
  2. 并发数较大时,需要建立大量的线程来处理连接,系统资源占用较大。
  3. 连接建立后,如果当前线程暂时没有数据可读,线程就回阻塞在Read上,造成线程资源浪费。

2. NIO(同步非阻塞)

同步非阻塞,服务器实现模式为一个线程处理多个请求(连接),即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有IO请求就进行处理。

在这里插入图片描述

3. AIO(异步非阻塞)

AIO引入异步通道的概念,采用了Proactor模式,简化了程序编写,有效的请求才启动线程。它的特点是先由操作系统完成后才通知服务器程序启动线程去处理,一般适用于连接较多且连接时间较长的应用。

Proactor模式是一个消息异步通知的设计模式,Proactor通知的不是就绪事件,而是操作完成事件,这也就是操作系统异步IO的主要模型。

4. BIO、NIO、AIO适用场景分析

  1. BIO(同步并阻塞)方式适用于连接数目较小且固定的架构,这种方式对服务器资源要求较高,并发局限于应用中,JDK1.4之前的唯一选择,但程序简单易理解。
  2. NIO(同步非阻塞)方式适用于连接比较多且连接比较短的架构,比如聊天服务器、弹幕系统、服务器间通信等。编程比较复杂,JDK1.4开始支持。
  3. AIO(异步非阻塞)方式适用于连接比较多且连接比较长的架构,比如相册服务器,充分调用OS参与并发操作,编程比较复杂,JDK1.7开始支持。

三、NIO编程

1. NIO介绍

java NIO全称java non-blocking IO,是指java提供的新的API。从JDK1.4开始,java提供了一系列改进的输入\输出的新特性,被统称为NIO(New IO),是同步非阻塞的。

  1. NIO有三大核心部件:Channel(通道),Buffer(缓冲区),Selector(选择器)。
  2. NIO是面向缓冲区编程的。数据读取到一个缓冲区中,需要时可在缓冲区前后移动,这就增加了处理过程的灵活性,使用它可以提供非阻塞式的高伸缩网络。
  3. java NIO的非阻塞模式,使一个线程从某通道发送请求或者读取数据,但是他仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取,而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以做其他的事情。非阻塞写也是这样,一个线程请求写入一些数据到某个通道,但不需要等待他完全写入,这个线程同时可以去做别的事情。通俗理解:NIO可以做到用一个线程来处理多个操作。假设有10000个请求过来,可以分配50或者100个线程来处理。不想之前的阻塞IO那样非得分配10000个线程。

2. NIO和BIO的比较

  1. BIO是以流的方式处理数据,而NIO是以缓冲区的方式处理数据,缓冲区IO的效率比流IO的效率高很多。
  2. BIO是阻塞的,NIO是非阻塞的。
  3. BIO是基于字节流和字符流进行操作的,而NIO基于Channel(通道)和Buffer(缓冲区)进行操作,数据总是从通道读取到缓冲区中,或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道事件(比如:连接请求,数据到达等),因此使用单个线程就可以监听多个客户端通道。

3. NIO三大核心原理示意图

一张图描述NIO的Selector、Channel和Buffer的关系

在这里插入图片描述

  1. 每个Channel都会对应一个Buffer。
  2. Selector对应一个线程,一个线程对应多个channel。
  3. 每个channel都注册到Selector选择器上。
  4. Selector不断轮询查看channel上的事件,事件是通道channel非常重要的概念。
  5. Selector会根据不同的事件,完成不同的处理操作。
  6. Buffer就是一个内存块,底层就是一个数组。
  7. 数据的读取写入是通过Buffer,这个和BIO不同,BIO要么是输入流,或者是输出流,不能双向。但是NIO的Buffer是可以读也可以写,channel是双向的。

4. 缓冲区(Buffer)

4.1 基本介绍

缓冲区(Buffer):本质上是一个可以读写数据的内存块。可以理解成一个数组,该对象提供了一组方法,可以轻松的使用内存块。缓冲区内置了一些机制,能够跟踪和记录缓冲区的状态变化情况,Channel提供从网络读取数据的通道,但是读取和写入数据都必须经过Buffer。

在这里插入图片描述

4.2 Buffer常用API介绍

  1. Buffer类及其子类

在这里插入图片描述

在NIO中,Buffer是一个顶层父类,他是一个抽象类,以上是类的层次关系图,常见的缓冲区分别对应7中基本数据类型,byte、short、int、long、float、double、char。

  1. 缓冲区对象的创建

    方法名 说明
    static ByteBuffer allocate(长度) 创建byte类型的指定长度的缓冲区
    static ByteBuffer wrap(byte[] array) 创建一个有内容的byte类型缓冲区

    示例代码:

    public class CreateBufferDemo {
        public static void main(String[] args) {
            // 创建指定长度的缓冲区 ByteBuffer为例
            final ByteBuffer allocate = ByteBuffer.allocate(5);
            for (int i = 0; i < 5; i++) {
                System.out.println(allocate.get());
            }
            //System.out.println(allocate.get());
    
            // 创建一个有内容的缓冲区
            final ByteBuffer wrap = ByteBuffer.wrap("myfff".getBytes());
            for (int i = 0; i < 5; i++) {
                System.out.println(wrap.get());
            }
        }
    }
    
  2. 缓冲区对象添加数据

    方法名 说明
    int position()/position(int newPosition) 获取当前要操作的索引/修改当前要操作索引的位置
    int limit()/limit(int newLimit) 最多能操作到哪个索引/修改最多能够操作的索引位置
    int capacity() 返回缓冲区总长度
    int remaining()/boolean hasRemaining() 还有多少能够操作索引的个数/是否还能操作
    put(byte b)/put(byte[] src) 添加一个字节/添加字节数组

    图解:

在这里插入图片描述

示例代码:

/**
 * 向缓冲区添加数据
 * @Author myf
 * @Date 2021/3/31 1:17
 * @Version 1.0
 */
public class PutBufferDemo {
    public static void main(String[] args) {
        // 创建一个缓冲区
        final ByteBuffer allocate = ByteBuffer.allocate(10);
        // 当前索引的位置
        System.out.println(allocate.position());
        // 最多能操作到哪个索引
        System.out.println(allocate.limit());
        // 返回缓冲区总长度
        System.out.println(allocate.capacity());
        // 还有多少能操作的个数
        System.out.println(allocate.remaining());

        // 修改当前索引所在的位置
        allocate.position(1);
        // 修改最多能够操作的索引的位置
        allocate.limit(9);
        System.out.println("======================");
        // 当前索引的位置
        System.out.println(allocate.position());
        // 最多能操作到哪个索引
        System.out.println(allocate.limit());
        // 返回缓冲区总长度
        System.out.println(allocate.capacity());
        // 还有多少能操作的个数
        System.out.println(allocate.remaining());

        // 添加一个字节
        allocate.put((byte) 97);
        System.out.println("======================");
        // 当前索引的位置
        System.out.println(allocate.position());
        // 最多能操作到哪个索引
        System.out.println(allocate.limit());
        // 返回缓冲区总长度
        System.out.println(allocate.capacity());
        // 还有多少能操作的个数
        System.out.println(allocate.remaining());

        // 添加一个数组
        allocate.put("myf".getBytes());
        System.out.println("======================");
        // 当前索引的位置
        System.out.println(allocate.position());
        // 最多能操作到哪个索引
        System.out.println(allocate.limit());
        // 返回缓冲区总长度
        System.out.println(allocate.capacity());
        // 还有多少能操作的个数
        System.out.println(allocate.remaining());

        // 如果缓冲区满了,可以调整position位置,就可以重复写了,会覆盖之前索引位置的值
        allocate.position(0);
        allocate.put("myf".getBytes());
        System.out.println("======================");
        // 当前索引的位置
        System.out.println(allocate.position());
        // 最多能操作到哪个索引
        System.out.println(allocate.limit());
        // 返回缓冲区总长度
        System.out.println(allocate.capacity());
        // 还有多少能操作的个数
        System.out.println(allocate.remaining());
    }
}
  1. 缓冲区对象读取数据

    方法名 介绍
    flip() 写切换读模式 limit设置position位置, position设置0
    get() 读一个字节
    get(byte[] dst) 读多个字节
    get(int index) 读指定索引的字节
    rewind() 将position设置为0,可以重复读
    clear() 切换写模式 position设置为0 , limit 设置为 capacity
    array() 将缓冲区转换成字节数组返回

    **图解:flip()方法 **

在这里插入图片描述

**图解:clear()方法 **

在这里插入图片描述

实例代码:

/**
 * 从缓冲区读取数据
 * @Author myf
 * @Date 2021/3/31 2:03
 * @Version 1.0
 */
public class GetBufferDemo {
    public static void main(String[] args) {
        // 创建指定长度的缓冲区
        final ByteBuffer allocate = ByteBuffer.allocate(10);
        allocate.put("0123".getBytes());
        System.out.println(allocate.position());
        System.out.println(allocate.limit());
        System.out.println(allocate.capacity());
        System.out.println(allocate.remaining());

        // 切换读模式
        System.out.println("=======================");
        allocate.flip();
        System.out.println(allocate.position());
        System.out.println(allocate.limit());
        for (int i = 0; i < allocate.limit(); i++) {
            System.out.println(allocate.get());
        }

        System.out.println("读取指定位置数据");
        System.out.println(allocate.get(1));
        System.out.println("读取多个字节数据");
        // 重复读取
        allocate.rewind();
        byte[] bytes = new byte[4];
        System.out.println(allocate.get(bytes));
        for (byte aByte : bytes) {
            System.out.println(aByte);
        }

        System.out.println("将缓冲区转换成字节数组返回");
        final byte[] array = allocate.array();
        System.out.println(new String(array));

        // 切换写模式
        allocate.clear();
        System.out.println(allocate.position());
        System.out.println(allocate.limit());
        allocate.put("987".getBytes());
        final byte[] array2 = allocate.array();
        System.out.println(new String(array2));
    }
}
  1. capacity:容量(长度)limit:界限(最多能读/写到哪里)position:位置(读/写哪个索引)
  2. 读取缓冲区里面数据之前,需要调用flip方法
  3. 再次写数据之前,需要调用clear方法,但是数据还未消失,等再次写入数据,被覆盖了才会消失。

5.通道(Channel)

5.1 基本介绍

通常来说NIO中所有IO都是从Channel(通道)开始的。NIO通道类似于流,但有些区别如下:

  1. 通道可以读也可以写,流一般是单向的(只能读或写)
  2. 通道可以异步读写
  3. 通道总是基于缓冲区Buffer来读写

在这里插入图片描述

5.2 Channel常用类介绍

  1. Channel接口

    常用的Channel实现类有:FileChannel,DatagramChannel,ServerSocketChannel和SocketChannel。FileChannel用于文件数据的读写,DatagremChannel用于UDP数据的读写,ServerSocketChannel和SocketChannel用于TCP数据的读写

  2. SocketChannel与ServerSocketChannel

    类似Socket与ServerSocket可以完成客户端与服务器端数据的通信工作。

5.3 ServerSocketChannel

服务端实现步骤:

  1. 打开一个服务端通道。
  2. 绑定对应的端口号。
  3. 通道默认为阻塞的,设置为非阻塞。
  4. 检查是否有客户端连接,有客户端连接会返回对应的通道。
  5. 获取客户端传递过来的数据,并把数据放在ByteBuffer这个缓冲区中。
  6. 给客户端回写数据。
  7. 释放资源。

代码实现:

public class NioServer {
    public static void main(String[] args) throws IOException, InterruptedException {
        //1. 打开一个服务端通道。
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //2. 绑定对应的端口号。
        serverSocketChannel.bind(new InetSocketAddress(9999));
        //3. 通道默认为阻塞的,设置为非阻塞。
        serverSocketChannel.configureBlocking(false);
        System.out.println("服务端启动成功。。。。");
        //4. 检查是否有客户端连接,有客户端连接会返回对应的通道。
        while (true){
            // 不会阻塞在这里
            final SocketChannel socketChannel = serverSocketChannel.accept();
            if (socketChannel==null){
                System.out.println("没有客户端连接。。。我去做别的事情");
                Thread.sleep(1000);
                continue;
            }
            //5. 获取客户端传递过来的数据,并把数据放在ByteBuffer这个缓冲区中。
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            // 返回值
            // 正数:表示本次读到的字节数
            // 0:表示本次没有读到数据
            // 1:表示读到末尾
            final int read = socketChannel.read(byteBuffer);
            System.out.println("客户端消息" + new String(byteBuffer.array(),0,read, StandardCharsets.UTF_8));
            //6. 给客户端回写数据。
            socketChannel.write(ByteBuffer.wrap("没钱".getBytes(StandardCharsets.UTF_8)));
            //7. 释放资源。
            socketChannel.close();
        }
    }
}

5.4 SocketChannel

客户端实现步骤:

  1. 打开通道
  2. 设置连接IP和端口号
  3. 写出数据
  4. 读取服务器写回的数据
  5. 释放资源

代码实现:

public class NioClient {
    public static void main(String[] args) throws IOException {
        //1. 打开通道
        final SocketChannel socketChannel = SocketChannel.open();
        //2. 设置连接IP和端口号
        socketChannel.connect(new InetSocketAddress("127.0.0.1",9999));
        //3. 写出数据
        socketChannel.write(ByteBuffer.wrap("老板还钱吧".getBytes(StandardCharsets.UTF_8)));
        //4. 读取服务器写回的数据
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        final int read = socketChannel.read(byteBuffer);
        System.out.println("服务端消息:" + new String(byteBuffer.array(),0,read,StandardCharsets.UTF_8));
        //5. 释放资源
        socketChannel.close();
    }
}

6.选择器(Selector)

可以用一个线程,处理多个的客户端连接,就会使用到NIO的Selector(选择器). Selector 能够检测多个注册的服务端通道上是否有事件发生,如果有事件发生,便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道,也就是管理多个连接和请求。

在这里插入图片描述

在这种没有选择器的情况下,每个连接对应一个处理线程,但是线程并不会马上发出消息,会造成资源浪费

在这里插入图片描述

只有在通道读写事件真正发生时,才会进行读写,就大大减少了系统开销,并且不必为每个连接都创建一个连接,不用去维护多个线程,避免了多线程之间上下文切换造成的开销

6.1 常用API介绍

  1. Selecter类是一个抽象类

    常用方法

    • Selector.open() : //得到一个选择器对象
    • selector.select() : //阻塞 监控所有注册的通道,当有对应的事件操作时, 会将SelectionKey放入集合内部并返回事件数量
    • selector.select(1000): //阻塞 1000 毫秒,监控所有注册的通道,当有对应的事件操作时, 会将SelectionKey放入集合内部并返回
    • selector.selectedKeys() : // 返回存有SelectionKey的集合
  2. SelectionKey

    常用方法

    • SelectionKey.isAcceptable(): 是否是连接继续事件
    • SelectionKey.isConnectable(): 是否是连接就绪事件
    • SelectionKey.isReadable(): 是否是读就绪事件
    • SelectionKey.isWritable(): 是否是写就绪事件

    SelectionKey中定义的4种事件:

    • SelectionKey.OP_ACCEPT —— 接收连接继续事件,表示服务器监听到了客户连接,服务器可以接收这个连接了
    • SelectionKey.OP_CONNECT —— 连接就绪事件,表示客户端与服务器的连接已经建立成功
    • SelectionKey.OP_READ —— 读就绪事件,表示通道中已经有了可读的数据,可以执行读操作了(通道目前有数据,可以进行读操作了)
    • SelectionKey.OP_WRITE —— 写就绪事件,表示已经可以向通道写数据了(通道目前可以用于写操作)

6.2 Selecter编码

服务端实现步骤

  1. 打开一个服务端通道
  2. 绑定对应的端口号
  3. 通道默认是阻塞的,需要设置为非阻塞
  4. 创建选择器
  5. 将服务端通道注册到选择器上,并指定注册监听的事件为OP_ACCEPT
  6. 检查选择器是否有事件
  7. 获取事件集合
  8. 判断事件是否是客户端连接事件SelectionKey.isAcceptable()
  9. 得到客户端通道,并将通道注册到选择器上, 并指定监听事件为OP_READ
  10. 判断是否是客户端读就绪事件SelectionKey.isReadable()
  11. 得到客户端通道,读取数据到缓冲区
  12. 给客户端回写数据
  13. 从集合中删除对应的事件, 因为防止二次处理

代码实现:

public class NIOSelectorServer {
    public static void main(String[] args) throws IOException {
        // 1. 打开一个服务端通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 2. 绑定对应的端口号
        serverSocketChannel.bind(new InetSocketAddress(9999));
        // 3. 通道默认是阻塞的,需要设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        // 4. 创建选择器
        Selector selector = Selector.open();
        // 5. 将服务端通道注册到选择器上,并指定注册监听的事件为OP_ACCEPT
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.printf("服务端启动成功");

        while (true){
            // 6. 检查选择器是否有事件
            int select = selector.select(2000);
            if (select==0){
                System.out.println("没有事件发生");
                continue;
            }
            // 7. 获取事件集合
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            // 8. 判断事件是否是客户端连接事件SelectionKey.isAcceptable()
            for (SelectionKey selectionKey : selectionKeys) {
                if (selectionKey.isAcceptable()){
                    // 9. 得到客户端通道,并将通道注册到选择器上, 并指定监听事件为OP_READ
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    System.out.println("有客户端连接");
                    // 将通道设置未非阻塞的状态,因为Selector需要轮训监听每个通道
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector,SelectionKey.OP_READ);
                }
                // 10. 判断是否是客户端读就绪事件SelectionKey.isReadable()
                if (selectionKey.isReadable()){
                    SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                    ByteBuffer allocate = ByteBuffer.allocate(1024);
                    // 11. 得到客户端通道,读取数据到缓冲区
                    int read = socketChannel.read(allocate);
                    if (read>0){
                        System.out.printf("客户端消息:"+new String(allocate.array(),0,read));
                        // 12. 给客户端回写数据
                        socketChannel.write(ByteBuffer.wrap("没钱".getBytes(StandardCharsets.UTF_8)));
                        socketChannel.close();
                    }
                }
                // 13. 从集合中删除对应的事件, 因为防止二次处理
                selectionKeys.remove(selectionKey);
            }
        }
    }
}
public class NIOClient {
    public static void main(String[] args) throws IOException {
        // 打开通道
        SocketChannel socketChannel = SocketChannel.open();
        // 绑定端口
        socketChannel.connect(new InetSocketAddress("127.0.0.1",9999));
        // 发送数据
        socketChannel.write(ByteBuffer.wrap("老板还钱".getBytes(StandardCharsets.UTF_8)));
        // 读取服务端数据
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        int read = socketChannel.read(byteBuffer);
        System.out.println("服务端返回数据" + new String(byteBuffer.array(),0,read));
        socketChannel.close();
    }
}
【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。