SpringBoot实现异步调用的几种方式

已于 2023-06-14 17:26:55 修改
阅读量6.9k 收藏 26
点赞数 4
文章标签： java 开发语言
于 2023-06-07 22:18:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qinxun2008081/article/details/131093083
版权

一、使用 CompletableFuture 实现异步任务

CompletableFuture 是 Java 8 新增的一个异步编程工具，它可以方便地实现异步任务。使用 CompletableFuture 需要满足以下条件：

  1. 异步任务的返回值类型必须是 CompletableFuture 类型；

  2. 在异步任务中使用 CompletableFuture.supplyAsync() 或 CompletableFuture.runAsync() 方法来创建异步任务；

  3. 在主线程中使用 CompletableFuture.get() 方法获取异步任务的返回结果。

我们创建一个服务类，里面包含了异步方法和普通方法。

import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 异步服务类
 */
@Service
public class AsyncService {


    /**
     * 普通任务操作1
     */
    public String task1() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        return "任务执行完成1";
    }

    /**
     * 普通任务操作2
     */
    public String task2() throws InterruptedException {
        TimeUnit.SECONDS.sleep(2);
        return "任务执行完成2";
    }

    /**
     * 普通任务操作3
     */
    public String task3() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        return "任务执行完成3";
    }

    /**
     * 异步操作1
     */
    public CompletableFuture<String> asyncTask1() {
        return CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "异步任务执行完成1";
        });
    }

    /**
     * 异步操作2
     */
    public CompletableFuture<String> asyncTask2() {
        return CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "异步任务执行完成2";
        });
    }

    /**
     * 异步操作3
     */
    public CompletableFuture<String> asyncTask3() {
        return CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "异步任务执行完成3";
        });
    }
}

我们先测试普通方法的情况，看看最后耗时

import cn.hutool.core.date.StopWatch;
import com.example.quartzdemo.service.AsyncService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 异步处理测试
 */
@SpringBootTest
public class AsyncTest {

    @Autowired
    private AsyncService asyncService;

    @Test
    void test1() throws InterruptedException {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();

        // 异步操作
       /* CompletableFuture<String> completableFuture1 = asyncService.asyncTask1();
        CompletableFuture<String> completableFuture2 = asyncService.asyncTask2();
        CompletableFuture<String> completableFuture3 = asyncService.asyncTask3();

        System.out.println(completableFuture1.get());
        System.out.println(completableFuture2.get());
        System.out.println(completableFuture3.get());*/

        // 同步操作
        System.out.println(asyncService.task1());
        System.out.println(asyncService.task2());
        System.out.println(asyncService.task3());

        stopWatch.stop();
        System.out.println("耗时:" + stopWatch.getTotalTimeMillis());
    }
}

程序执行的结果:

任务执行完成1
任务执行完成2
任务执行完成3
耗时:8008

我们可以发现，普通同步方法是按顺序一个个操作的，各个方法不会同时处理。下面我们把这些操作换成异步的方法测试。

import cn.hutool.core.date.StopWatch;
import com.example.quartzdemo.service.AsyncService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 异步处理测试
 */
@SpringBootTest
public class AsyncTest {

    @Autowired
    private AsyncService asyncService;

    @Test
    void test1() throws InterruptedException, ExecutionException {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();

        // 异步操作
        CompletableFuture<String> completableFuture1 = asyncService.asyncTask1();
        CompletableFuture<String> completableFuture2 = asyncService.asyncTask2();
        CompletableFuture<String> completableFuture3 = asyncService.asyncTask3();

        System.out.println(completableFuture1.get());
        System.out.println(completableFuture2.get());
        System.out.println(completableFuture3.get());

        // 同步操作
        /*System.out.println(asyncService.task1());
        System.out.println(asyncService.task2());
        System.out.println(asyncService.task3());*/

        stopWatch.stop();
        System.out.println("耗时:" + stopWatch.getTotalTimeMillis());
    }
}

程序执行结果:

异步任务执行完成1
异步任务执行完成2
异步任务执行完成3
耗时:3008

发现几个方法是异步同时进行的，没有先后的顺序，大大提高了程序执行效率。

二、基于注解 @Async实现异步任务

@Async 注解是 Spring 提供的一种轻量级异步方法实现方式，它可以标记在方法上，用来告诉 Spring 这个方法是一个异步方法，Spring 会将这个方法的执行放在异步线程中进行。使用 @Async 注解需要满足以下条件：

  1. 需要在 Spring Boot 主类上添加 @EnableAsync 注解启用异步功能；

  2. 需要在异步方法上添加 @Async 注解。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
// 主类上加上这个注解,开启异步功能
@EnableAsync
public class QuartzDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(QuartzDemoApplication.class, args);
    }

}

修改测试的服务层

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;

import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 异步服务类
 */
@Service
public class AsyncService {


    /**
     * 同步任务操作1
     */
    public String task1() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        return "任务执行完成1";
    }

    /**
     * 同步任务操作2
     */
    public String task2() throws InterruptedException {
        TimeUnit.SECONDS.sleep(2);
        return "任务执行完成2";
    }

    /**
     * 同步任务操作3
     */
    public String task3() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        return "任务执行完成3";
    }


    /**
     * 异步操作1
     */
    @Async
    public Future<String> asyncTask1() throws InterruptedException {
        long currentTimeMillis = System.currentTimeMillis();
        TimeUnit.SECONDS.sleep(3);
        long currentTimeMillis1 = System.currentTimeMillis();
        System.out.println("task1任务耗时:" + (currentTimeMillis1 - currentTimeMillis) + "ms");
        return new AsyncResult<>("task1完成");
    }

    /**
     * 异步操作2
     */
    @Async
    public Future<String> asyncTask2() throws InterruptedException {
        long currentTimeMillis = System.currentTimeMillis();
        TimeUnit.SECONDS.sleep(2);
        long currentTimeMillis1 = System.currentTimeMillis();
        System.out.println("task1任务耗时:" + (currentTimeMillis1 - currentTimeMillis) + "ms");
        return new AsyncResult<>("task2完成");
    }

    /**
     * 异步操作3
     */
    @Async
    public Future<String> asyncTask3() throws InterruptedException {
        long currentTimeMillis = System.currentTimeMillis();
        TimeUnit.SECONDS.sleep(3);
        long currentTimeMillis1 = System.currentTimeMillis();
        System.out.println("task1任务耗时:" + (currentTimeMillis1 - currentTimeMillis) + "ms");
        return new AsyncResult<>("task3完成");
    }

}

创建一个测试类

import com.example.quartzdemo.service.AsyncService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion:
 */
@RestController
public class AsyncController {

    @Autowired
    private AsyncService asyncService;


    /**
     * 测试异步
     */
    @RequestMapping("/async")
    public String testAsync() throws InterruptedException, ExecutionException {
        long currentTimeMillis = System.currentTimeMillis();

        Future<String> task1 = asyncService.asyncTask1();
        Future<String> task2 = asyncService.asyncTask2();
        Future<String> task3 = asyncService.asyncTask3();
        while (true) {
            if (task1.isDone() && task2.isDone() && task3.isDone()) {
                // 三个任务都调用完成，退出循环等待
                break;
            }
        }
        System.out.println(task1.get());
        System.out.println(task2.get());
        System.out.println(task3.get());
        long currentTimeMillis1 = System.currentTimeMillis();
        return "task任务总耗时:" + (currentTimeMillis1 - currentTimeMillis) + "ms";
    }
}

执行测试方法

task1任务耗时:2006ms
task1任务耗时:3011ms
task1任务耗时:3011ms
task1完成
task2完成
task3完成

三、使用 TaskExecutor 实现异步任务

TaskExecutor 是 Spring 提供的一个接口，它定义了一个方法 execute()，用来执行异步任务。使用 TaskExecutor 需要满足以下条件：

  1. 需要在 Spring 配置文件中配置一个 TaskExecutor 实例；

  2. 在异步方法中调用 TaskExecutor 实例的 execute() 方法来执行异步任务。

创建一个异步配置类

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.aop.interceptor.SimpleAsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 异步处理配置类
 */
@Configuration
public class AsyncConfig implements AsyncConfigurer {

    @Bean(name = "asyncExecutor")
    public TaskExecutor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(20);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("async-");
        executor.initialize();
        return executor;
    }

    @Override
    public Executor getAsyncExecutor() {
        return asyncExecutor();
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new SimpleAsyncUncaughtExceptionHandler();
    }
}

修改下服务类，我们使用自定义的异步配置

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 异步服务类
 */
@Service
public class AsyncService {

    @Autowired
    @Qualifier("asyncExecutor")
    private TaskExecutor taskExecutor;


    /**
     * 同步任务操作1
     */
    public String task1() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        return "任务执行完成1";
    }

    /**
     * 同步任务操作2
     */
    public String task2() throws InterruptedException {
        TimeUnit.SECONDS.sleep(2);
        return "任务执行完成2";
    }

    /**
     * 同步任务操作3
     */
    public String task3() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        return "任务执行完成3";
    }


    /**
     * 异步操作1
     */
    @Async
    public void asyncTask1() {
        taskExecutor.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println("异步任务执行完成1");
    }

    /**
     * 异步操作2
     */
    @Async
    public void asyncTask2() throws InterruptedException {
        taskExecutor.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println("异步任务执行完成2");
    }

    /**
     * 异步操作3
     */
    @Async
    public void asyncTask3() throws InterruptedException {
        taskExecutor.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println("异步任务执行完成3");
    }
    
}

测试类进行测试

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 异步处理测试
 */
@SpringBootTest
public class AsyncTest {
    
    @Autowired
    @Qualifier("asyncExecutor")
    private TaskExecutor taskExecutor;


    @Test
    void test1() {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();

        // 异步操作
       /* asyncService.asyncTask1();
        asyncService.asyncTask2();
        asyncService.asyncTask3();*/
        taskExecutor.execute(() -> System.out.println("异步任务"));

        // 同步操作
        /*System.out.println(asyncService.task1());
        System.out.println(asyncService.task2());
        System.out.println(asyncService.task3());*/

        stopWatch.stop();
        System.out.println("耗时:" + stopWatch.getTotalTimeMillis());
    }
}
耗时:6
异步任务执行完成3
异步任务执行完成1
异步任务执行完成2

qinxun2008081
关注
  • 4
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
详解springboot中使用异步的常用两种方式及其比较
08-25
使用 @Async 注解的方式简单易用，但需要遵守一定的规则和限制，例如不能在本类中异步调用、不能有返回值等。 使用 CompletableFuture 的方式更加灵活，可以实现更加复杂的异步处理逻辑，但是需要手动处理异步任务...
SpringBoot异步任务使用方法详解
08-19
SpringBoot异步任务使用方法详解主要包括以下几个步骤： 1. 添加异步任务业务类 首先，需要创建一个异步任务业务类，该类需要使用@Component注解标记，以便SpringBoot可以自动地将其注入到应用程序中。在该类中，...
SpringBoot 如何异步编程，老鸟们都这么玩的
飘渺Jam的博客
12-01 2928
大家好，我是飘渺。今天继续给大家带来SpringBoot老鸟系列的第六篇，来聊聊在SpringBoot项目中如何实现异步编程。 老鸟系列文章导读： 1. SpringBoot 如何统一后端返回格式？老鸟们都是这样玩的！ 2. SpringBoot 如何进行参数校验？老鸟们都是这么玩的！ 3. SpringBoot 如何生成接口文档，老鸟们都这么玩的！ 4. SpringBoot 如何进行对象复制，老鸟们都这么玩的！ 5. SpringBoot 生成接口文档，我用smart-doc 6. SpringBoot
java的异步执行方式 - @EnableAsync和@Async注解
che_lys的博客
06-12 853
通过这类注解执行异步调用，其实底层是通过生成代理对象去操作了多线程（底层就是多线程原理，运用了Executors），所以对应的，会存在一些失效情况（例如同类中，没有加@Async的方法调用了需要异步执行的@Async方法），这类失效情况与@Transactions基本雷同，可以理解为只要被调用对象的代理对象失效，那么方法执行就会变成单线程。@Async注解可以放置于类上，会表示该类下的所有方法都会是异步的，也可以放置于指定方法上，该方法被调用时会异步执行。一般来说，常用的异步调用方式可以分为以下几种。
SpringBoot实现异步调用的三种实现方式
weixin_43702295的博客
01-09 1318
1.基于注解的方式优点：-简单易用，只需要在方法上添加@Async注解即可。-依赖Spring框架，集成度高，可以与其他Spring组件无缝协作。缺点：方法必须是public，否则异步执行无效。-不能直接获取异步执行结果，需要使用Future或CompletableFuture等类型。2.实现AsyncConfigurer接口的方式优点：-更加灵活，可以配置线程池等异步执行的相关参数。
【SpringBoot系列】如何优雅地实现异步调用
热门推荐
Venus's Blog
05-11 8万+
SpringBoot想必大家都用过，但是大家平时使用发布的接口大都是同步的，那么你知道如何优雅的实现异步呢？这篇文章就是关于如何在中实现异步行为的。但首先，让我们看看同步和异步之间的区别。调用者会阻塞,直到方法执行完成并返回结果。方法体的逻辑在调用线程中直接执行。异步编程调用者会立即返回,而不会阻塞等待方法执行完成。方法体的逻辑会在其他线程中执行。通常会通过回调或Future模式来获取方法的执行结果。这些都是Spring Boot中实现异步调用的优雅方式。
SpringBoot异步调用 实现方式
崔向阳@李晓的博客
03-30 628
534545
springboot实现异步调用的几种方式@Async失效
weixin_42052678的博客
04-11 297
业务需求，用户下单后创建订单入库，并且发邮件及短信通知给发货人。所以通知的业务可以异步处理，不阻塞订单的创建，简单来说如果创建订单需要1秒，发送通知需要10秒，那么前端期望1秒之后拿到请求结果。在使用以下方法时，你需要确保Spring Boot应用的@EnableAsync注解已经开启，以启用Spring的异步支持。因为我这里B方法的入参，有A方法返回的结果，所以是在一个方法中调用，具体可以根据自己的情况来定。（当然也可以在controller中先调用A方法，再调用B方法（有@Async的异步方法））
SpringBoot异步调用方法
行知致简的专栏
04-23 6964
SpringBoot异步调用方法 一、spring boot--使用异步请求，提高系统的吞吐量 https://blog.csdn.net/liuchuanhong1/article/details/78744138 1.使用Callable来实现 2. 通过WebAsyncTask，也能实现异步调用 这种方式和上面的callable方式最大的区别就是，WebAsyncTask支持...
springboot实现Java异步线程的几种方法
王sir的博客
05-20 546
实现异步线程的几种方法
SpringBoot异步调用
ppjsyw的博客
05-20 2759
什么是异步调用 方法调用默认是同步的,同步就是指方法必须一行一行的往下面执行,需要等待上一行代码执行完后才能执行下面的代码,而异步调用则是不需要等待上一行代码执行完后,就可以立即执行。 使用场景 当我们的代码不需要考虑事物时,并且也不需要即时响应,这时候我们可以选择使用异步调用来减少程序的相应时间。比如注册时发送确认邮件通知、写入日志等场景 下面我们将以demo的形式来完成异步调用。 一、启动类上加注解 import org.springframework.scheduling.annotation
SpringBoot利用@Async注解实现异步调用
何哥的博客
01-04 8588
前言：异步编程是让程序并发运行的一种手段。它允许多个事情同时发生，当程序调用需要长时间运行的方法时，它不会阻塞当前的执行流程，程序可以继续运行，当方法执行完成时通知给主线程根据需要获取其执行结果或者失败异常的原因。使用异步编程可以大大提高我们程序的吞吐量，可以更好的面对更高的并发场景并更好的利用现有的系统资源，同时也会一定程度上减少用户的等待时间等。 一、异步编程 1.1、什么是异步调用？ 异步调用是相对于同步调用而言的，同步调用是指程序按预定顺序一步步执行，每一步必须等到上一步执行完后才能执行，异步
详解SpringBoot中RestTemplate的几种实现
08-25
本篇文章将深入探讨在Spring Boot中使用`RestTemplate`的几种不同实现方式，以及它们各自的特性和应用场景。 1. **JDK默认的http library实现** Spring Boot默认情况下，`RestTemplate`使用的是JDK内置的`java.net...
springboot 同步解耦 异步化
03-26
在SpringBoot中实现同步到异步的转换，可以采用以下几种方式： 1. **AsyncConfigurer**：SpringBoot提供了`@EnableAsync`注解，配合`AsyncConfigurer`接口，可以全局配置一个线程池来处理异步任务。只需在配置类上...
新手也能看懂的SpringBoot异步编程指南(简单易懂)
08-25
Future模式是一种异步调用模式，在处理耗时操作和多任务处理的场景下非常有用。其核心思想是异步调用，即当我们执行一个方法时，该方法中有多个耗时的任务需要同时去做，而不着急等待这个结果时，可以让客户端立即...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 610
1.导入hutool的maven依赖。2.复制一下代码执行。
深入理解Java注解
最新发布
weixin_55745942的博客
08-01 563
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
社区养老服务小程序的设计
Karen198的博客
07-31 520
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
springboot异步调用
08-30
在Spring Boot中，我们可以使用@Async注解来实现异步方法调用。首先，我们需要在主类上添加@EnableAsync注解，以开启异步功能。然后，在需要异步执行的方法上添加@Async注解。Spring会将这些方法的执行放在异步线程中进行。使用@Async注解需要满足以下条件： 在测试类中，我们可以通过创建一个TaskExecutor来执行异步任务。首先，我们需要在测试类中注入TaskExecutor的实例。然后，我们可以使用taskExecutor.execute方法来执行异步任务。例如，在测试类中的test1方法中，我们使用taskExecutor.execute(() -> System.out.println("异步任务"));来执行一个异步任务。同时，我们还可以使用同步操作来进行对比。执行完成后，我们可以通过StopWatch来计算耗时，并输出结果。 因此，通过添加@Async注解和使用TaskExecutor来执行异步任务，我们可以在Spring Boot中实现异步调用。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [SpringBoot实现异步调用的几种方式](https://blog.csdn.net/qinxun2008081/article/details/131093083)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

qinxun2008081

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

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

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

打赏作者

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

抵扣说明：

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

余额充值