JAVA AIO 服务器与客户端实现示例

最新推荐文章于 2024-09-29 07:00:00 发布
最新推荐文章于 2024-09-29 07:00:00 发布
阅读量3.3k 收藏 2
点赞数 1
分类专栏： IO-Aio

AIO用于文件处理还是比较快乐的，但用AIO来写网络消息处理服务器端与客户端是比较麻烦的事情，当然这只是我个人意见，主要是有几点原因：

一是AIO需要操作系统支持，还好Windows与Linux(模拟)都支持；

二是AIO同时使用递归调用和异步调用容易把程序员搞晕，代码容易出错；

三是CompletionHandler会使用单独的线程跑，容易出现多线程问题，频繁线程上下文切换比较消耗资源；

四是异步写要创建队列来缓存需要写入的数据，否则肯定会遇到WritePendingException。


相对来说，NIO比较清楚直白，容易控制。


另外，笔者使用多线程模拟多个客户场景失败，代码在run方法中调用AsynchronousSocketChannel.connect()没返回，没连接上服务器，不知道为何，请大侠指教，最后只好使用多个进程模拟多个客户端，写个类似下面代码的bat文件，同时运行多个。

1
2
3
4
5
java -classpath .\ com.stevex.app.aio.Client 1
 
java -classpath .\ com.stevex.app.aio.Client 1
 
pause
服务器代码： 

package aio;

/**
 * Created by Administrator on 2016/10/28.
 */
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.StandardSocketOptions;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.AsynchronousChannelGroup;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
//import java.nio.channels.WritePendingException;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.Executors;

public class XiaoNa {
    private final AsynchronousServerSocketChannel server;
    //写队列，因为当前一个异步写调用还没完成之前，调用异步写会抛WritePendingException
    //所以需要一个写队列来缓存要写入的数据，这是AIO比较坑的地方
    private final Queue<ByteBuffer> queue = new LinkedList<ByteBuffer>();
    private boolean writing = false;

    public static void main(String[] args) throws IOException{
        XiaoNa xiaona = new XiaoNa();
        xiaona.listen();
    }

    public XiaoNa() throws IOException{
        //设置线程数为CPU核数
        AsynchronousChannelGroup channelGroup = AsynchronousChannelGroup.withFixedThreadPool(Runtime.getRuntime().availableProcessors(), Executors.defaultThreadFactory());
        server = AsynchronousServerSocketChannel.open(channelGroup);
        //重用端口
        server.setOption(StandardSocketOptions.SO_REUSEADDR, true);
        //绑定端口并设置连接请求队列长度
        server.bind(new InetSocketAddress(8383), 80);
    }

    public void listen() {
        System.out.println(Thread.currentThread().getName() + ": run in listen method" );
        //开始接受第一个连接请求
        server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>(){
            @Override
            public void completed(AsynchronousSocketChannel channel,
                                  Object attachment) {
                System.out.println(Thread.currentThread().getName() + ": run in accept completed method" );

                //先安排处理下一个连接请求，异步非阻塞调用，所以不用担心挂住了
                //这里传入this是个地雷，小心多线程
                server.accept(null, this);
                //处理连接读写
                handle(channel);
            }

            private void handle(final AsynchronousSocketChannel channel) {
                System.out.println(Thread.currentThread().getName() + ": run in handle method" );
                //每个AsynchronousSocketChannel，分配一个缓冲区
                final ByteBuffer readBuffer = ByteBuffer.allocateDirect(1024);
                readBuffer.clear();
                channel.read(readBuffer, null, new CompletionHandler<Integer, Object>(){

                    @Override
                    public void completed(Integer count, Object attachment) {
                        System.out.println(Thread.currentThread().getName() + ": run in read completed method" );

                        if(count > 0){
                            try{
                                readBuffer.flip();
                                //CharBuffer charBuffer = CharsetHelper.decode(readBuffer);
                                CharBuffer charBuffer = Charset.forName("UTF-8").newDecoder().decode(readBuffer);
                                String question = charBuffer.toString();
                                String answer = Helper.getAnswer(question);
                                /*//写入也是异步调用，也可以使用传入CompletionHandler对象的方式来处理写入结果
                                //channel.write(CharsetHelper.encode(CharBuffer.wrap(answer)));
                                try{
                                    channel.write(Charset.forName("UTF-8").newEncoder().encode(CharBuffer.wrap(answer)));
                                }
                                //Unchecked exception thrown when an attempt is made to write to an asynchronous socket channel and a previous write has not completed.
                                //看来操作系统也不可靠
                                catch(WritePendingException wpe){
                                    //休息一秒再重试，如果失败就不管了
                                    Helper.sleep(1);
                                    channel.write(Charset.forName("UTF-8").newEncoder().encode(CharBuffer.wrap(answer)));
                                }*/
                                writeStringMessage(channel, answer);

                                readBuffer.clear();
                            }
                            catch(IOException e){
                                e.printStackTrace();
                            }
                        }
                        else{
                            try {
                                //如果客户端关闭socket，那么服务器也需要关闭，否则浪费CPU
                                channel.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }

                        //异步调用OS处理下个读取请求
                        //这里传入this是个地雷，小心多线程
                        channel.read(readBuffer, null, this);
                    }

                    /**
                     * 服务器读失败处理
                     * @param exc
                     * @param attachment
                     */
                    @Override
                    public void failed(Throwable exc, Object attachment) {
                        System.out.println("server read failed: " + exc);
                        if(channel != null){
                            try {
                                channel.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }

                });
            }

            /**
             * 服务器接受连接失败处理
             * @param exc
             * @param attachment
             */
            @Override
            public void failed(Throwable exc, Object attachment) {
                System.out.println("server accept failed: " + exc);
            }

        });
    }

    /**
     * Enqueues a write of the buffer to the channel.
     * The call is asynchronous so the buffer is not safe to modify after
     * passing the buffer here.
     *
     * @param buffer the buffer to send to the channel
     */
    private void writeMessage(final AsynchronousSocketChannel channel, final ByteBuffer buffer) {
        boolean threadShouldWrite = false;

        synchronized(queue) {
            queue.add(buffer);
            // Currently no thread writing, make this thread dispatch a write
            if (!writing) {
                writing = true;
                threadShouldWrite = true;
            }
        }

        if (threadShouldWrite) {
            writeFromQueue(channel);
        }
    }

    private void writeFromQueue(final AsynchronousSocketChannel channel) {
        ByteBuffer buffer;

        synchronized (queue) {
            buffer = queue.poll();
            if (buffer == null) {
                writing = false;
            }
        }

        // No new data in buffer to write
        if (writing) {
            writeBuffer(channel, buffer);
        }
    }

    private void writeBuffer(final AsynchronousSocketChannel channel, ByteBuffer buffer) {
        channel.write(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer buffer) {
                if (buffer.hasRemaining()) {
                    channel.write(buffer, buffer, this);
                } else {
                    // Go back and check if there is new data to write
                    writeFromQueue(channel);
                }
            }

            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                System.out.println("server write failed: " + exc);
            }
        });
    }

    /**
     * Sends a message
     * @param msg
     * @throws CharacterCodingException
     */
    private void writeStringMessage(final AsynchronousSocketChannel channel, String msg) throws CharacterCodingException {
        writeMessage(channel, Charset.forName("UTF-8").newEncoder().encode(CharBuffer.wrap(msg)));
    }
}

客户端代码：

package aio;

/**
 * Created by Administrator on 2016/10/28.
 */
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.StandardSocketOptions;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.AsynchronousChannelGroup;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;

public class Client implements Runnable{
    private AsynchronousSocketChannel channel;
    private Helper helper;
    private CountDownLatch latch;
    private final Queue<ByteBuffer> queue = new LinkedList<ByteBuffer>();
    private boolean writing = false;

    public Client(AsynchronousChannelGroup channelGroup, CountDownLatch latch) throws IOException, InterruptedException{
        this.latch = latch;
        helper = new Helper();
        initChannel(channelGroup);
    }

    private void initChannel(AsynchronousChannelGroup channelGroup) throws IOException {
        //在默认channel group下创建一个socket channel
        channel = AsynchronousSocketChannel.open(channelGroup);
        //设置Socket选项
        channel.setOption(StandardSocketOptions.TCP_NODELAY, true);
        channel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);
        channel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        int sleepTime = Integer.parseInt(args[0]);
        Helper.sleep(sleepTime);

        AsynchronousChannelGroup channelGroup = AsynchronousChannelGroup.withFixedThreadPool(Runtime.getRuntime().availableProcessors(), Executors.defaultThreadFactory());
        //只能跑一个线程，第二个线程connect会挂住，暂时不明原因
        final int THREAD_NUM = 1;
        CountDownLatch latch = new CountDownLatch(THREAD_NUM);

        //创建个多线程模拟多个客户端，模拟失败，无效
        //只能通过命令行同时运行多个进程来模拟多个客户端
        for(int i=0; i<THREAD_NUM; i++){
            Client c = new Client(channelGroup, latch);
            Thread t = new Thread(c);
            System.out.println(t.getName() + "---start");
            t.start();
            //让主线程等待子线程处理再退出, 这对于异步调用无效
            //t.join();
        }

        latch.await();

        if(channelGroup !=null){
            channelGroup.shutdown();
        }
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "---run");

        //连接服务器
        channel.connect(new InetSocketAddress("localhost", 8383), null, new CompletionHandler<Void, Void>(){
            final ByteBuffer readBuffer = ByteBuffer.allocateDirect(1024);

            @Override
            public void completed(Void result, Void attachment) {
                //连接成功后, 异步调用OS向服务器写一条消息
                try {
                    //channel.write(CharsetHelper.encode(CharBuffer.wrap(helper.getWord())));
                    writeStringMessage(helper.getWord());
                } catch (CharacterCodingException e) {
                    e.printStackTrace();
                }

                //helper.sleep();//等待写异步调用完成
                readBuffer.clear();
                //异步调用OS读取服务器发送的消息
                channel.read(readBuffer, null, new CompletionHandler<Integer, Object>(){

                    @Override
                    public void completed(Integer result, Object attachment) {
                        try{
                            //异步读取完成后处理
                            if(result > 0){
                                readBuffer.flip();
                                CharBuffer charBuffer = CharsetHelper.decode(readBuffer);
                                String answer = charBuffer.toString();
                                System.out.println(Thread.currentThread().getName() + "---" + answer);
                                readBuffer.clear();

                                String word = helper.getWord();
                                if(word != null){
                                    //异步写
                                    //channel.write(CharsetHelper.encode(CharBuffer.wrap(word)));
                                    writeStringMessage(word);
                                    //helper.sleep();//等待异步操作
                                    channel.read(readBuffer, null, this);
                                }
                                else{
                                    //不想发消息了，主动关闭channel
                                    shutdown();
                                }
                            }
                            else{
                                //对方已经关闭channel，自己被动关闭，避免空循环
                                shutdown();
                            }
                        }
                        catch(Exception e){
                            e.printStackTrace();
                        }
                    }

                    /**
                     * 读取失败处理
                     * @param exc
                     * @param attachment
                     */
                    @Override
                    public void failed(Throwable exc, Object attachment) {
                        System.out.println("client read failed: " + exc);
                        try {
                            shutdown();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }

                });
            }

            /**
             * 连接失败处理
             * @param exc
             * @param attachment
             */
            @Override
            public void failed(Throwable exc, Void attachment) {
                System.out.println("client connect to server failed: " + exc);

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

    private void shutdown() throws IOException {
        if(channel != null){
            channel.close();
        }

        latch.countDown();
    }

    /**
     * Enqueues a write of the buffer to the channel.
     * The call is asynchronous so the buffer is not safe to modify after
     * passing the buffer here.
     *
     * @param buffer the buffer to send to the channel
     */
    private void writeMessage(final ByteBuffer buffer) {
        boolean threadShouldWrite = false;

        synchronized(queue) {
            queue.add(buffer);
            // Currently no thread writing, make this thread dispatch a write
            if (!writing) {
                writing = true;
                threadShouldWrite = true;
            }
        }

        if (threadShouldWrite) {
            writeFromQueue();
        }
    }

    private void writeFromQueue() {
        ByteBuffer buffer;

        synchronized (queue) {
            buffer = queue.poll();
            if (buffer == null) {
                writing = false;
            }
        }

        // No new data in buffer to write
        if (writing) {
            writeBuffer(buffer);
        }
    }

    private void writeBuffer(ByteBuffer buffer) {
        channel.write(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer buffer) {
                if (buffer.hasRemaining()) {
                    channel.write(buffer, buffer, this);
                } else {
                    // Go back and check if there is new data to write
                    writeFromQueue();
                }
            }

            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
            }
        });
    }

    /**
     * Sends a message
     * @param msg
     * @throws CharacterCodingException
     */
    public void writeStringMessage(String msg) throws CharacterCodingException {
        writeMessage(Charset.forName("UTF-8").newEncoder().encode(CharBuffer.wrap(msg)));
    }
}


工具类： 

package aio;

/**
 * Created by Administrator on 2016/10/28.
 */
import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class Helper {
    private static BlockingQueue<String> words;
    private static Random random;

    public Helper() throws InterruptedException{
        words = new ArrayBlockingQueue<String>(5);
        words.put("hi");
        words.put("who");
        words.put("what");
        words.put("where");
        words.put("bye");

        random = new Random();
    }

    public String getWord(){
        return words.poll();
    }

    public void sleep() {
        try {
            TimeUnit.SECONDS.sleep(random.nextInt(3));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void sleep(long l) {
        try {
            TimeUnit.SECONDS.sleep(l);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static String getAnswer(String question){
        String answer = null;

        switch(question){
            case "who":
                answer = "我是小娜\n";
                break;
            case "what":
                answer = "我是来帮你解闷的\n";
                break;
            case "where":
                answer = "我来自外太空\n";
                break;
            case "hi":
                answer = "hello\n";
                break;
            case "bye":
                answer = "88\n";
                break;
            default:
                answer = "请输入 who， 或者what， 或者where";
        }

        return answer;
    }
}

package aio;

/**
 * Created by Administrator on 2016/10/28.
 */

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;

public class CharsetHelper {
    private static final String UTF_8 = "UTF-8";
    private static CharsetEncoder encoder = Charset.forName(UTF_8).newEncoder();
    private static CharsetDecoder decoder = Charset.forName(UTF_8).newDecoder();

    public static ByteBuffer encode(CharBuffer in) throws CharacterCodingException{
        return encoder.encode(in);
    }

    public static CharBuffer decode(ByteBuffer in) throws CharacterCodingException{
        return decoder.decode(in);
    }
}



Java AIO
JustinMars的博客
08-04 537
Java AIO
Java AIO 实例（转）
04-26
NULL 博文链接：https://pzh9527.iteye.com/blog/2361692
java aio_JAVA AIO 服务器与客户端实现示例
weixin_34746924的博客
02-16 333
AIO用于文件处理还是比较快乐的，但用AIO来写网络消息处理服务器端与客户端是比较麻烦的事情，当然这只是我个人意见，主要是有几点原因：一是AIO需要操作系统支持，还好Windows与Linux(模拟)都支持；二是AIO同时使用递归调用和异步调用容易把程序员搞晕，代码容易出错；三是CompletionHandler会使用单独的线程跑，容易出现多线程问题，频繁线程上下文切换比较消耗资源；四是异步写要创...
Java中的NIO与AIO：构建高性能网络应用的实战指南
最新发布
微赚淘客系统开发者博客
09-29 634
今天我们来聊聊Java中的NIO（New I/O）和AIO（Asynchronous I/O），这是构建高性能网络应用的利器。Java NIO引入了面向块（Buffer）、通道（Channel）、选择器（Selector）的I/O操作，允许开发者以非阻塞的方式进行数据读写。AIO是Java 7引入的异步I/O框架，支持完全异步的I/O操作，即读写操作都不会阻塞线程。：当面对高延迟的I/O操作或不希望阻塞线程的场景时，AIO能够提供更加流畅的异步操作体验，例如文件传输、大数据处理等。
java之AIO实例
程序员的博客
03-31 1688
AIO介绍 JDK1.7升级了NIO类库，升级后的NIO类库被称为NIO 2.0，Java正式提供了异步文件I/O操作，同时提供了与UNIX网络编程事件驱动I/O对应的AIO。AIO是真正的异步非阻塞I/O。它不需要通过多路复用器（Selector）对注册的通道进行轮询操作即可实现异步读写，从而简化了NIO的编程模型。NIO 2.0引入了新的异步通道的概念，并提供了异步文件通道和异步套接字通道的...
javaAio例子
broust的博客
02-25 488
例子见 http://blog.csdn.net/xxb2008/article/details/42424105 修改下例子中的代码，打印出启动线程id和回调函数执行时的线程id 发现每次回调的线程id是不同的 这里备注下aio模式 用户线程1------------------------------------------------------
基于java的BIO、NIO、AIO通讯模型代码实现
03-24
压缩包中的文件可能包含了实现这三种通信模型的Java代码示例，通过学习和理解这些代码，你可以更好地掌握Java I/O的运用，并根据需求选择合适的模型。建议从简单的BIO开始，逐步过渡到更复杂的NIO和AIO，理解其工作...
基于javaaio实现，开源、简单、易用、低延迟、高性能百万级java mqtt client组件和java mqtt br服务
04-09
基于Java AIO实现的MQTT客户端和broker服务，如标题和描述中提到的，旨在提供一个开源、简单、易用、低延迟且高性能的解决方案，特别适合于物联网（IoT）、边缘计算以及大规模服务器应用中处理大量的设备连接和消息...
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析
01-04
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析 IO模型在计算机编程中扮演着至关重要的角色，特别是在网络通信中。Java提供了三种主要的IO模型：BIO（Blocking IO），NIO（Non-blocking IO），...
【Java】AIO实例
weixin_43358075的博客
07-29 482
一、blocking/non-blocking | sync/async 1.blocking/non-blocking: 描述的是方法会不会阻塞线程的执行，使线程进入blocking状态 2.sync/async:描述的是数据读写方式 sync:用户线程参与数据读写 由内核线程发起读写，用户只需要关注I/O完成后的回调，不需要参与具体的I/O过程 二、AIO(Asynchronous In...
Java中网络IO的实现方式（BIO、NIO、AIO）介绍
08-31
主要介绍了Java中网络IO的实现方式（BIO、NIO、AIO）介绍的相关资料,需要的朋友可以参考下
java aio 编程
qq_26847293的博客
03-23 388
Java NIO (JSR 51)定义了Java new I/O API，提案2000年提出,2002年正式发布。 JDK 1.4起包含了相应的API实现。 JAVA NIO2 (JSR 203)定义了更多的 New I/O APIs， 提案2003提出，直到2011年才发布， 最终在JDK 7中才实现。 JSR 203除了提供更多的文件系统操作API(包括可插拔的自定义的文件系统)， 还提供了
java nio bio aio实例_Java的BIO，NIO，AIO
weixin_33899835的博客
02-25 261
1. 前言有一些概念总是Java I/O一块出现，比如同步与异步，阻塞与非阻塞，这些概念往往也是非常难以区分。在介绍Java I/O之前，本文先通俗地介绍一下这两组概念的区别：同步和异步: 同步和异步的区分点在消息的通知机制。如果是程序主动获取消息，为同步，程序被动获取消息，为异步。例如烧水，如果我们时不时去看看水是否烧开，则为同步。而如果水壶是会响笛的水壶，我们听见响笛则认为水烧开了，则为异步。...
aio java_JAVA aio简单使用
weixin_39922374的博客
02-12 142
使用aio，实现客户端和服务器 对一个数进行轮流累加//服务器端public class Server {private static ExecutorService executorService = Executors.newFixedThreadPool(4);public static void main(String[] args) {try {AsynchronousChannelGr...
java aio 客户端_Java AIO
weixin_39692761的博客
02-17 181
感觉上NIO开发要比AIO简单一点。上面文章的代码已经非常好了，注释也写的非常好，这里需要补充一些需要注意的地方：解码：attachment.flip();CharsetDecoder decoder = Charset.forName("UTF-8").newDecoder();decoder.onMalformedInput(CodingErrorAction.IGNORE); // 注意co...
Java AIO总结与示例
热门推荐
x_i_y_u_e的专栏
08-16 1万+
AIO是异步IO的缩写，虽然NIO在网络操作中，提供了非阻塞的方法，但是NIO的IO行为还是同步的。对于NIO来说，我们的业务线程是在IO操作准备好时，得到通知，接着就由这个线程自行进行IO操作，IO操作本身是同步的。 但是对AIO来说，则更加进了一步，它不是在IO准备好时再通知线程，而是在IO操作已经完成后，再给线程发出通知。因此AIO是不会阻塞的，此时我们的业务逻辑将变成一个回调函数，等待I
java aio源码_Java AIO入门实例源码教程
weixin_30336949的博客
02-27 209
Java AIO入门实例源码教程。NIO.2中引入了新的异步通道的概念，并提供了异步Socket通道的实现。阻塞式的Socket通道的使用方式都是同步进行的，调用者会处于阻塞状态；费阻塞Socket通道的实现方式则是依靠选择器(select)来完成。异步通道一般提供两种使用方式：一种是通过Java同步工具包中的java.util.concurrent.Future类的对象来表示异步操作的结果；另一...
java AIO 服务端代码实现
暮鼓的博客
07-14 3837
java 7引入AIO  基于linux epoll， window iocp异步 I/O（简称 AIO）AIO 的核心概念：发起非阻塞方式的 I/O 操作。当 I/O 操作完成时通知。应用程序的责任就是：什么时候发起操作？ I/O 操作完成时通知谁？AIO 的 I/O 操作，有两种方式的 API 可以进行：Future 方式  和 Callback 方式。Future 方式：即提交一个 I/O ...
Java服务器编程：ServerSocket实现多线程聊天室
"Java Socket编程实现多线程服务器，通过`ServerSocket`监听客户端连接，并转发消息至所有已连接客户端。" 在Java编程中，`ServerSocket`是用于服务器端的网络通信类，它允许服务器应用程序接收来自客户端的连接...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值