SpringBoot整合Quartz，实现数据库方式执行定时任务

最新推荐文章于 2024-05-16 01:00:49 发布
最新推荐文章于 2024-05-16 01:00:49 发布
阅读量389 收藏 2
点赞数
分类专栏： Java 文章标签： spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52191385/article/details/132433310
版权

springboot整合quartz，实现数据库方式执行定时任务。把定时任务信息存进数据库，项目启动后自动执行定时任务。

1.引入依赖包：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>

2.配置yml：

spring:
  # quartz
  quartz:
    #相关属性配置
    properties:
      org:
        quartz:
          scheduler:
            instanceName: DefaultQuartzScheduler
            instanceId: AUTO
          jobStore:
            class: org.quartz.impl.jdbcjobstore.JobStoreTX
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
            tablePrefix: QRTZ_
            isClustered: false
            clusterCheckinInterval: 10000
            #以指示JDBCJobStore将JobDataMaps中的所有值都作为字符串，因此可以作为名称
            #- 值对存储而不是在BLOB列中以其序列化形式存储更多复杂的对象。
            #从长远来看，这是更安全的，因为您避免了将非String类序列化为BLOB的类版本问题。
            useProperties: false
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool
            threadCount: 10
            threadPriority: 5
            threadsInheritContextClassLoaderOfInitializingThread: true
 
    # 数据库方式
    job-store-type: jdbc
 
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/quartz_test?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
 
server:
  port: 8080

3.后端编码：

controller层：

@Controller
@RequestMapping(value = "/job")
@Slf4j
public class JobController {
 
    @Autowired
    private IJobService jobService;
 
 
 
    @PostMapping(value = "/add")
    @ResponseBody
    public Result addJob(@RequestBody JobInfo jobInfo) {
        return jobService.addJob(jobInfo);
    }
 
    @GetMapping(value = "/getAllJobs")
    @ResponseBody
    public List<JobInfo> getAllJobs() {
        return jobService.getAllJobs();
    }
 
    @PostMapping(value = "/pause")
    @ResponseBody
    public Result pauseJob(String name, String group) {
        return jobService.pauseJob(name,group) ? Result.success() : Result.error();
    }
 
    @PostMapping(value = "/resume")
    @ResponseBody
    public Result resumeJob(String name, String group) {
        return jobService.resumeJob(name,group) ? Result.success() : Result.error();
    }
 
    @PostMapping(value = "/reschedule")
    @ResponseBody
    public Result reScheduleJob(String name, String group, String cron) {
        return jobService.reScheduleJob(name, group, cron) ? Result.success() : Result.error();
    }
 
    @PostMapping(value = "/delete")
    @ResponseBody
    public Result deleteJob(String name, String group) {
        return jobService.deleteJob(name,group) ? Result.success() : Result.error();
    }
 
    /**
     * @description 校验是否是合法cron表达式
     * @param  cron
     * @return  com.cxh.cxhquartz.common.Result
     **/
    @PostMapping(value = "/checkCron")
    @ResponseBody
    public Result checkCron(String cron) {
        boolean valide = false;
        try {
            valide = CronExpression.isValidExpression(cron);
        }catch (Exception e){
            log.error(e.getMessage());
        }
        return valide ? Result.success() : Result.error();
    }
}

service层：

public interface IJobService {
 
    /**
     * @description 查询所有任务
     * @param
     * @return  java.util.List<com.cxh.cxhquartz.quartz.JobInfo>
     **/
     List<JobInfo> getAllJobs();
    /**
     * @description 恢复任务
     * @param  jobName
     * @Param  jobGroup
     * @return  boolean
     **/
     boolean resumeJob(String jobName,String jobGroup);
    /**
     * @description 停止任务
     * @param  jobName
     * @Param  jobGroup
     * @return  boolean
     **/
     boolean pauseJob(String jobName,String jobGroup);
    /**
     * @description 修改任务执行周期表达式
     * @param  jobName
     * @Param  jobGroup
     * @Param  cronExpression
     * @return  boolean
     **/
     boolean reScheduleJob(String jobName,String jobGroup,String cronExpression);
    /**
     * @description 删除任务
     * @param  jobName
     * @Param  jobGroup
     * @return  boolean
     **/
     boolean deleteJob(String jobName,String jobGroup);
    /**
     * @description 新增任务
     * @param  jobInfo
     * @return  int
     **/
    Result addJob(JobInfo jobInfo);
     /**
      * @description 判断任务是否存在
      * @param  jobKey
      * @return  int
      **/
     int isJobExist(JobKey jobKey);
}

@Slf4j
@Service
public class JobServiceImpl implements IJobService {
 
    @Autowired
    private Scheduler scheduler;
 
    @Override
    public List<JobInfo> getAllJobs() {
        List<JobInfo> jobInfoList = new ArrayList<>();
        try{
            List<String> groupList = scheduler.getJobGroupNames();
            for(String group : groupList){
                GroupMatcher<JobKey> groupMatcher = GroupMatcher.groupEquals(group);
                Set<JobKey> jobKeySet = scheduler.getJobKeys(groupMatcher);
                for(JobKey jobKey : jobKeySet){
                    JobInfo jobInfo = new JobInfo();
                    JobDetail jobDetail = scheduler.getJobDetail(jobKey);
                    jobInfo.setJobname(jobKey.getName());
                    jobInfo.setJobgroup(jobKey.getGroup());
                    jobInfo.setJobclassname(jobDetail.getJobClass().getName());
                    Trigger trigger = scheduler.getTrigger(TriggerKey.triggerKey(jobKey.getName(), jobKey.getGroup()));
                    if(trigger != null){
                        Trigger.TriggerState state = scheduler.getTriggerState(TriggerKey.triggerKey(jobKey.getName(), jobKey.getGroup()));
                        jobInfo.setTriggername(jobKey.getName());
                        jobInfo.setTriggergroup(jobKey.getGroup());
                        try{
                            CronTrigger cronTrigger = (CronTrigger) trigger;
                            jobInfo.setCronexpression(cronTrigger.getCronExpression());
                        } catch (Exception e){
                            log.error(e.getMessage());
                        }
                        if(trigger.getNextFireTime() != null){
                            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                            jobInfo.setNextfiretime(sdf.format(trigger.getNextFireTime()));
                        }
                        jobInfo.setDescription(jobDetail.getDescription());
                        jobInfo.setState(state.name());
                        jobInfo.setId(UUID.randomUUID().toString());
                        jobInfoList.add(jobInfo);
                    } else {
                        jobInfo.setState("OVER");
                        jobInfo.setId(UUID.randomUUID().toString());
                        jobInfoList.add(jobInfo);
                    }
                }
            }
        } catch (Exception e){
            log.error(e.getMessage());
        }
        return jobInfoList;
    }
 
    @Override
    public boolean resumeJob(String jobName, String jobGroup) {
        boolean flag = true;
        try{
            scheduler.resumeJob(JobKey.jobKey(jobName, jobGroup));
        } catch (Exception e){
            flag = false;
            log.error(e.getMessage());
        }
        return flag;
    }
 
    @Override
    public boolean pauseJob(String jobName, String jobGroup) {
        boolean flag = true;
        try{
            scheduler.pauseJob(JobKey.jobKey(jobName, jobGroup));
        } catch (Exception e){
            flag = false;
            log.error(e.getMessage());
        }
        return flag;
    }
 
    @Override
    public boolean reScheduleJob(String jobName, String jobGroup, String cronExpression) {
        boolean flag = true;
        try{
           Trigger.TriggerState state = scheduler.getTriggerState(TriggerKey.triggerKey(jobName, jobGroup));
           CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(TriggerKey.triggerKey(jobName, jobGroup));
           if(cronTrigger != null && cronExpression != null && !cronTrigger.getCronExpression().equals(cronExpression)){
               CronTrigger cronTriggerNew = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroup).withSchedule(CronScheduleBuilder.cronSchedule(cronExpression)).build();
               scheduler.rescheduleJob(TriggerKey.triggerKey(jobName, jobGroup), cronTriggerNew);
               if(state.name().equals("PAUSED")){
                   this.pauseJob(jobName, jobGroup);
               }
           }
        } catch (Exception e){
            flag = false;
            log.error(e.getMessage());
        }
        return flag;
    }
 
    @Override
    public boolean deleteJob(String jobName, String jobGroup) {
        boolean flag = true;
        try{
            List<? extends Trigger> triggerList = scheduler.getTriggersOfJob(JobKey.jobKey(jobName, jobGroup));
            if(triggerList.size() > 0){
                if(!"PAUSED".equals(scheduler.getTriggerState(TriggerKey.triggerKey(jobName, jobGroup)).name())){
                    scheduler.pauseTrigger(TriggerKey.triggerKey(jobName, jobGroup));
                }
                scheduler.unscheduleJob(TriggerKey.triggerKey(jobName, jobGroup));
            }
            scheduler.deleteJob(JobKey.jobKey(jobName, jobGroup));
        } catch (Exception e){
            flag = false;
            log.error(e.getMessage());
        }
        return flag;
    }
 
    @Override
    public Result addJob(JobInfo jobInfo) {
        int isJobExist = this.isJobExist(JobKey.jobKey(jobInfo.getJobname(), jobInfo.getJobgroup()));
        if(isJobExist == 1){
            return Result.error("任务已存在！");
        }
        try{
            JobDetail jobDetail = null;
            if(isJobExist == 0){
                jobDetail = scheduler.getJobDetail(JobKey.jobKey(jobInfo.getJobname(), jobInfo.getJobgroup()));
            } else if(isJobExist == -1){
                jobDetail = JobBuilder.newJob(
                        (Class<? extends Job>) Class.forName(jobInfo.getJobclassname()))
                        .withIdentity(jobInfo.getJobname(), jobInfo.getJobgroup())
                        .withDescription(jobInfo.getDescription())
                        .storeDurably().build();
            }
            //如果jobInfo的cron表达式为空，则创建常规任务，反之创建周期任务
            if(jobInfo.getCronexpression() != null){
                CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(jobInfo.getTriggername(), jobInfo.getTriggergroup())
                        .withSchedule(CronScheduleBuilder.cronSchedule(jobInfo.getCronexpression()))
                        .build();
                scheduler.scheduleJob(jobDetail, cronTrigger);
 
            } else {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Trigger trigger = TriggerBuilder.newTrigger().withIdentity(jobInfo.getJobname(), jobInfo.getJobgroup())
                        .startAt(sdf.parse(jobInfo.getNextfiretime()))
                        .withSchedule(SimpleScheduleBuilder.simpleSchedule().withRepeatCount(0))
                        .build();
                scheduler.scheduleJob(jobDetail, trigger);
            }
        } catch (SchedulerException e){
            log.error(e.getMessage());
            return Result.error("添加任务失败！");
        } catch (ParseException e){
            log.error(e.getMessage());
            return Result.error("时间转换出错！");
        } catch (Exception e){
            log.error(e.getMessage());
            return Result.error(e.getMessage());
        }
        return Result.success("添加任务成功！");
    }
 
    @Override
    public int isJobExist(JobKey jobKey) {
       int flag = -1;
       try{
           JobDetail jobDetail = scheduler.getJobDetail(jobKey);
           List<? extends  Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
           if(jobDetail != null && triggers.size() > 0){
               flag = 1;
           } else if(jobDetail != null && triggers.size() == 0){
                flag = 0;
           }
       } catch (Exception e){
           flag = -1;
           log.error(e.getMessage());
       }
       return flag;
    }
}

entity层：

@Data
public class JobInfo implements Serializable {
    private String id;
    private String jobname;
    private String jobgroup;
    private String jobclassname;
    private String triggername;
    private String triggergroup;
    private String cronexpression;
    private String description;
    private String prefiretime;
    private String nextfiretime;
    private String state;
}

定时任务：

@Slf4j
public class DemoJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        JobDetail jobDetail = jobExecutionContext.getJobDetail();
        log.info("任务名：" + jobDetail.getKey().getName() + ",组名：" +
                jobDetail.getKey().getGroup() + "------执行的定时任务工作内容！");
    }
}

4.创建数据库表：quartz保存定时任务信息表

  5.运行项目，打开postman发起请求：

 6.运行结果：

_江屿_
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
quartz 2.0持久化到mysql_SpringBoot2.0整合Quartz定时任务（持久化到数据库，更为简单的方式）...
weixin_39923806的博客
02-03 242
1. pom文件添加依赖org.springframework.bootspring-boot-starterorg.springframework.bootspring-boot-starter-testtestorg.springframework.bootspring-boot-starter-weborg.springframework.bootspring-boot-starter-qu...
SpringBoot如何结合Quartz来实现定时任务？
2301_76607156的博客
04-04 836
假设我们有这样两个需求：1、用户注册1分钟后给用户发送欢迎通知。2、每天8点钟给用户发送当天温度通知。接下来我们就准备实现上述两个需求，关于通知发送就只是简单地控制台输出，没有真正实现该功能。关于定时任务框架的选择，本文将选用 Quartz 来实现上述需求，下面简单介绍一下 Quartz。强大的调度功能，例如支持丰富多样的调度方法，可以满足各种常规及特殊需求；灵活的应用方式，例如支持任务和调度的多种组合方式，支持调度数据的多种存储方式；
spring boot2.0实现对quartz的集成
weixin_33755557的博客
09-02 169
最近项目中需要集成quartz这个定时任务，记录集成方法如下： pom.xml的相关引入 <dependency> <groupId>org.springframework.boot</groupId> <arti...
SpringBoot 集成 Quartz + MySQL
Java技术攻略的博客
04-18 707
实现方式参考：若依(RuoYi)，他是新建了一张中间表，通过 init() 方法，利用中心中间表进行定时任务的初始化。保存 QRTZ_JOB_DETAILS、QRTZ_TRIGGERS => QRTZ_CRON_TRIGGERS。字段，可以是一个对像，以执行定时任务时，会把该字段反序列化，根据前期设定的内容进行业务处理。暂停后，qrtz_triggers 表的 TRIGGER_STATE = PAUSED。将 job.getJobDataMap()，对像序列化后，存入。获取 Quartz Job 任务。
SpringBoot整合Quartz定时任务（持久化到数据库）_spring boot集成quartz并将数据持久化到数据库
最新发布
2401_85012088的博客
05-16 744
所以决定采用 JDBC作业存储的方式。
springboot整合quartz实现定时任务，数据库获取cron表达式多动态多任务
weixin_43931918的博客
02-16 1810
springboot整合quartz实现定时任务，数据库获取cron表达式多动态多任务
Springboot整合quartz实现数据库配置定时任务
gangye19970101的博客
03-21 6178
Spring Boot结合quartz实现数据库动态启动Bean下的方法 项目代码参考git： https://github.com/qigangye/springboot_quartz_schedule 相关任务以及执行结果： Bean实例addNumWorker下定时任务方法work插入结果(上述cron表达式为每天17点4分每个20秒插入一批数据) Bean实例下proStat...
【Spring Boot、Quartz】Spring Boot 整合 Quartz定时任务框架，读取数据库配置
apple_csdn的博客
04-12 2861
一、介绍 简单高效。Quartz用起来非常简单。你只要写一个继承org.quartz.Job的job类，将逻辑写入execute()方法，并将这个类设定好时间，之后Quartz就能自动帮你监控这个任务，到了指定时间自动执行，就不再需要你管这些任务了。 容错。 如果其中的一个节点挂了，并不会影响其他节点上面任务的执行。 支持分布式 二、主要API Scheduler - 与调度器交互的主要API。 Job - 需要被调度器调度的任务必须实现的接口。 JobDetail - 用于定义任务的实例。 Tri
SpringBoot 中实现定时任务的几种方式
m0_73311735的博客
05-24 3262
这种方式很简单，主要就是先@EnableScheduling开启定时任务功能，然后在相应的方法上添加@Scheduled()中间写上相应的cron表达式即可。示例如下：schedule.ScheduleTask: Cron表达式参数参考：建议：直接在线生成Cron表达式比较方便：www.matools.com/cron/@Scheduled：除了支持灵活的参数表达式cron之外，还支持 fixedDelay，fixedRate，initialDelay 这些延时性的操作。启动测试就实现了基本的定时任务功
mysql quartz_springBoot+mysql整合quartz（拿来即用）
weixin_33270404的博客
01-20 3156
一、首先我们要谈及一个定时框架，就是quartz，本片博客涉及的实例主要是运行用了quartz的任务和触发器的灵活组合以及任务统一灵活的管理的优点二、quartz中的核心组件：1、Job：Job为作业的接口，为任务调度的对象。2、JobDetail：用来描述Job实现类及其它相关的静态信息，如Job名字、关联监听器等信息。3、Trigger：触发器，用于定义任务调度的时间规则，其中CronTrig...
Spring Boot集成Quartz动态实现数据库任务
weixin_46178852的博客
12-03 2382
1. Quartz简介 1.1. 什么是Quartz Quartz是一个开源的任务调度框架。作用是基于定时、定期的策略来执行任务。 它是OpenSymphony开源组织在Job scheduling领域又一个开源项目。 “任务进度管理器”就是一个在预先被纳入日程，当时间到达时，负责执行（或者通知）其他软件组件的系统。 简单来说就是实现“计划(或定时)任务”的系统，例如：订单下单后未付款，15分钟后自动撤消订单，并自动解锁锁定的商品。 官网：http://www.quartz-scheduler.org 参考
Springboot整合Quartz实现定时任务数据库动态配置
03-17
Springboot整合Quartz实现定时任务数据库动态配置，新增任务、修改cron表达式、暂停任务、恢复任务、删除任务等操作
使用Springboot+mybatis整合Quartz定时任务框架实现定时向数据库插入一条数据
qq_44325532的博客
10-21 961
使用Springboot+mybatis整合Quartz定时任务框架实现定时向数据库插入一条数据
Spring整合Quartz案例使用JDBC存储方式
z1340954953
08-02 2807
目录 创建数据库表 配置数据库连接池 创建工作类 工作类中调用的业务类  工作类 配置JobDetail和Trigger，并交给Scheduler注册 测试 Quartz集群中如何工作 Quartz集群环境下配置 quartz.properties 工作类 SchedulerFactory的xml配置 JobDetail的xml配置 测试集群 quartz水平集群和垂...
Quartz(三) JDBC存储方式(有两种)
codezhuyc的博客
07-17 149
一概念介绍 默认情况，Quartz的触发器，调度，任务等信息都是放在内存中的，叫做RAMJobStore。 好处是快速，坏处是一旦系统重启，那么信息就丢失了，就得全部从头来过。 所以Quartz还提供了另一个方式，可以把这些信息存放在数据库做，叫做 JobStoreTX。 好处是就算系统重启了，目前运行到第几次了这些信息都是存放在数据库中的，那么就可以继续原来的步伐把计划任务无缝地继续做下去。 坏...
Spring Boot 集成Quartz
qq_19891197的博客
02-05 4771
Spring Boot 集成Quartz
Quartz使用切换数据库源运行定时任务以及注意事项
梦寒君的博客
02-12 1403
Quartz使用切换数据库源运行定时任务以及注意事项
定制定时任务 quartz + springboot + mysql
jjy_smile的博客
08-12 648
（文末有做好的完整项目）↓↓↓ 做springboot项目时遇到的需求是： 提供给用户前端接口 让用户自由地赋予一些需要定时执行任务的触发时间 并且能够修改触发时间。 传统的@scheduler注解只能在开发时写死触发时间，无法动态修改。所以尝试了新的更灵活的quartz定时，实现需求。 在文末的完整项目中，只需要按照com.jjy.quartzjar.job.impl.MyJob类作为模板，即可在没有quartz开发经验的前提下，也可以定制出需要的定时任务。步骤分别是： 在com.jjy.quar
springboot整合quartz实战
Fastree的博客
10-30 2155
最常用的还是使用StdSchedulerFactory初始化
springboot整合quartz示例，任务存储在数据库中
07-08
当您需要将Quartz任务存储在数据库中时，可以使用Quartz提供的`JobStoreTX`和`JobStoreCMT`来实现。 首先，您需要在Spring Boot项目中添加以下依赖项： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz</artifactId> </dependency> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.2</version> </dependency> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz-jobs</artifactId> <version>2.3.2</version> </dependency> ``` 接下来，您需要创建一个Quartz的配置类，用于配置Quartz的相关属性和任务： ```java @Configuration public class QuartzConfig { @Autowired private DataSource dataSource; @Autowired private ApplicationContext applicationContext; @Bean public SchedulerFactoryBean schedulerFactoryBean() { SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean(); schedulerFactoryBean.setJobFactory(springBeanJobFactory()); schedulerFactoryBean.setDataSource(dataSource); schedulerFactoryBean.setQuartzProperties(quartzProperties()); // 其他配置属性... return schedulerFactoryBean; } @Bean public SpringBeanJobFactory springBeanJobFactory() { AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory(); jobFactory.setApplicationContext(applicationContext); return jobFactory; } @Bean public Properties quartzProperties() { Properties properties = new Properties(); properties.setProperty("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX"); properties.setProperty("org.quartz.jobStore.driverDelegateClass", "org.quartz.impl.jdbcjobstore.PostgreSQLDelegate"); properties.setProperty("org.quartz.jobStore.tablePrefix", "QRTZ_"); properties.setProperty("org.quartz.jobStore.isClustered", "false"); properties.setProperty("org.quartz.jobStore.dataSource", "quartzDataSource"); properties.setProperty("org.quartz.dataSource.quartzDataSource.driver", "org.postgresql.Driver"); properties.setProperty("org.quartz.dataSource.quartzDataSource.URL", "jdbc:postgresql://localhost:5432/quartz"); properties.setProperty("org.quartz.dataSource.quartzDataSource.user", "quartz"); properties.setProperty("org.quartz.dataSource.quartzDataSource.password", "quartz"); properties.setProperty("org.quartz.dataSource.quartzDataSource.maxConnections", "10"); return properties; } } ``` 然后，您需要创建一个定时任务的类，继承`QuartzJobBean`并实现`executeInternal`方法： ```java public class MyJob extends QuartzJobBean { @Override protected void executeInternal(JobExecutionContext context) throws JobExecutionException { // 在这里编写定时任务的逻辑 System.out.println("Hello Quartz!"); } } ``` 接下来，您可以在数据库中创建Quartz相关的表。您可以使用Quartz提供的`quartz_tables_postgres.sql`脚本来创建PostgreSQL数据库表。 最后，在您的应用程序中，您可以使用`@Scheduled`注解来触发定时任务： ```java @Component public class MyScheduledTasks { @Scheduled(cron = "0/10 * * * * ?") public void runJob() { // 在这里编写定时任务的逻辑 System.out.println("Hello Scheduled Tasks!"); } } ``` 这样，您的定时任务将会存储在数据库中，并由Quartz进行调度执行。希望对您有所帮助！如果还有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值