quarz定时任务调度集成

最新推荐文章于 2024-07-28 11:29:50 发布
最新推荐文章于 2024-07-28 11:29:50 发布
阅读量200 收藏
点赞数 1
分类专栏： java 文章标签： quartz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43843279/article/details/85179943
版权

任务调度 只需做三件事，再什么时候在哪里做什么事；

一.工作原理：

1、scheduler是一个计划调度器容器（总部），容器里面可以盛放众多的JobDetail和trigger，当容器启动后，里面的每个JobDetail都会根据trigger按部就班自动去执行。

2、JobDetail是一个可执行的工作，它本身可能是有状态的。

3、Trigger代表一个调度参数的配置，什么时候去调。

4、当JobDetail和Trigger在scheduler容器上注册后，形成了装配好的作业（JobDetail和Trigger所组成的一对儿），就可以伴随容器启动而调度执行了。

5、scheduler是个容器，容器中有一个线程池，用来并行调度执行每个作业，这样可以提高容器效率。

 

二.集成

1.导包到pom

	<!-- quartz任务调度 -->
<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.3</version>
		</dependency>

<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>${spring.version}</version>
		</dependency>

     
		<dependency>
			<groupId>org.quartz-scheduler</groupId>
			<artifactId>quartz</artifactId>
			<version>2.2.1</version>
		</dependency>
		<dependency>
			<groupId>org.quartz-scheduler</groupId>
			<artifactId>quartz-jobs</artifactId>
			<version>2.2.1</version>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.0</version>
		</dependency>

 

2.创建数据库表

解压缩quartz官方发行包，找到quartz-2.2.3\docs\dbTables 下的 tables_mysql_innodb.sql在navicat中执行即可创建quartz持久化相关的表。

3.将quartz的工厂对象交给spring管理

spring-quartz.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="  
    http://www.springframework.org/schema/context  
    http://www.springframework.org/schema/context/spring-context.xsd  
    http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!-- 配置连接池 -->
	<bean id="quartzDataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="username" value="root"></property>
		<property name="password" value="root"></property>
		<property name="url" value="jdbc:mysql:///quartz?characterEncoding=utf-8"></property>
		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
	</bean>   
 <!-- quartz持久化存储 -->
    <bean name="quartzScheduler"  
        class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
        <property name="dataSource">  
            <ref bean="quartzDataSource" />  
        </property>
        <property name="applicationContextSchedulerContextKey" value="applicationContext" />  
       <!--  也可以在quartz.properties中配置   -->
        <property name="quartzProperties">  
            <props>  
                <prop key="org.quartz.scheduler.instanceName">AIGOUscheduler</prop>  
                <prop key="org.quartz.scheduler.instanceId">AUTO</prop>  
              <!--   线程池配置   -->
                <prop key="org.quartz.threadPool.class">org.quartz.simpl.SimpleThreadPool</prop>  
                <prop key="org.quartz.threadPool.threadCount">20</prop>  
                <prop key="org.quartz.threadPool.threadPriority">5</prop>  
                <prop key="org.quartz.jobStore.misfireThreshold">120000</prop>  
                <!-- JobStore 配置   -->
                <prop key="org.quartz.jobStore.class">org.quartz.impl.jdbcjobstore.JobStoreTX</prop>  
               <!--  集群配置   -->
                <prop key="org.quartz.jobStore.isClustered">true</prop>  
                <prop key="org.quartz.jobStore.clusterCheckinInterval">15000</prop>  
                <prop key="org.quartz.jobStore.maxMisfiresToHandleAtATime">1</prop>  
              <!--   数据表设置   -->
                <prop key="org.quartz.jobStore.tablePrefix">qrtz_</prop>  
                <prop key="org.quartz.jobStore.dataSource">qzDS</prop>  
            </props>  
        </property>  
      <!--   可选，QuartzScheduler启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了   -->
        <property name="overwriteExistingJobs" value="true" />  
        <!-- 设置自动启动   -->
        <property name="autoStartup" value="true" />  
    </bean>  
</beans>

整合dubbo

spring-dubbo-quartz.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
	xsi:schemaLocation="  
    http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans.xsd  
    http://code.alibabatech.com/schema/dubbo 
    http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

	<!-- dubbo服务发布 -->
	<dubbo:application name="www-service-common" />
	<dubbo:protocol name="dubbo" port="20885"></dubbo:protocol>
	<import resource="classpath*:spring-dubbo-common-base.xml"/>
</beans>

spring-service-quartz.xml

spring的配置中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="  
    http://www.springframework.org/schema/context  
    http://www.springframework.org/schema/context/spring-context.xsd  
    http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans.xsd">
	
	<import resource="classpath*:spring-dubbo-quartz.xml"/>
	<import resource="classpath*:spring-quartz.xml"/>
</beans>

 

创建QuartzUtils工具类，用于动态管理任务

/**
 * Quartz调度管理器
 * 
 */
public class QuartzUtils {
	private static String JOB_GROUP_NAME = "JOB_GROUP_SYSTEM";
	private static String TRIGGER_GROUP_NAME = "TRIGGER_GROUP_SYSTEM";

	/**
	 * @Description: 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
	 * 
	 * @param sched
	 *            调度器
	 * 
	 * @param jobName
	 *            任务名
	 * @param cls
	 *            任务
	 * @param params
	 *            任务参数
	 * @param time
	 *            时间设置，参考quartz说明文档
	 * 
	 * @Title: QuartzManager.java
	 */
	public static void addJob(Scheduler sched, String jobName, @SuppressWarnings("rawtypes") Class cls, Object params,
			String time) {
		try {
			JobKey jobKey = new JobKey(jobName, JOB_GROUP_NAME);// 任务名，任务组，任务执行类
			@SuppressWarnings("unchecked")

			JobDataMap jobDataMap = new JobDataMap();
			jobDataMap.put("params", params);
			JobDetail jobDetail = newJob(cls).withIdentity(jobKey).setJobData(jobDataMap).build();
			TriggerKey triggerKey = new TriggerKey(jobName, TRIGGER_GROUP_NAME);// 触发器
			
			Trigger trigger = newTrigger().withIdentity(triggerKey).withSchedule(cronSchedule(time)).build();// 触发器时间设定
			sched.scheduleJob(jobDetail, trigger);
			if (!sched.isShutdown()) {
				sched.start();// 启动
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * @Description: 添加一个定时任务
	 * 
	 * @param sched
	 *            调度器
	 * 
	 * @param jobName
	 *            任务名
	 * @param jobGroupName
	 *            任务组名
	 * @param triggerName
	 *            触发器名
	 * @param triggerGroupName
	 *            触发器组名
	 * @param jobClass
	 *            任务
	 * @param params
	 *            任务参数
	 * @param time
	 *            时间设置，参考quartz说明文档
	 * 
	 * @Title: QuartzManager.java
	 */
	public static void addJob(Scheduler sched, String jobName, String jobGroupName, String triggerName,
			String triggerGroupName, @SuppressWarnings("rawtypes") Class jobClass,  Object params, String time) {
		try {
			JobKey jobKey = new JobKey(jobName, jobGroupName);
			JobDataMap jobDataMap = new JobDataMap();
			jobDataMap.put("params", params);
			@SuppressWarnings("unchecked")
			JobDetail jobDetail = newJob(jobClass).withIdentity(jobKey).setJobData(jobDataMap).build();
			// 触发器
			TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroupName);
			Trigger trigger = newTrigger().withIdentity(triggerKey).withSchedule(cronSchedule(time)).build();
			sched.scheduleJob(jobDetail, trigger);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * @Description: 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
	 * 
	 * @param sched
	 *            调度器
	 * @param jobName
	 * @param time
	 * 
	 * @Title: QuartzManager.java
	 */
	@SuppressWarnings("rawtypes")
	public static void modifyJobTime(Scheduler sched, String jobName, String time) {
		try {
			TriggerKey triggerKey = new TriggerKey(jobName, TRIGGER_GROUP_NAME);
			CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
			if (trigger == null) {
				return;
			}
			String oldTime = trigger.getCronExpression();
			if (!oldTime.equalsIgnoreCase(time)) {
				JobKey jobKey = new JobKey(jobName, JOB_GROUP_NAME);
				JobDetail jobDetail = sched.getJobDetail(jobKey);
				Class objJobClass = jobDetail.getJobClass();
				Object params = jobDetail.getJobDataMap().get("params");
				removeJob(sched, jobName);
				System.out.println("修改任务：" + jobName);
				addJob(sched, jobName, objJobClass, params,time);
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * @Description: 修改一个任务的触发时间
	 * 
	 * @param sched
	 *            调度器 *
	 * @param sched
	 *            调度器
	 * @param triggerName
	 * @param triggerGroupName
	 * @param time
	 * 
	 * @Title: QuartzManager.java
	 */
	public static void modifyJobTime(Scheduler sched, String triggerName, String triggerGroupName, String time) {
		try {
			TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroupName);
			CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
			if (trigger == null) {
				return;
			}
			String oldTime = trigger.getCronExpression();
			if (!oldTime.equalsIgnoreCase(time)) {
				// 修改时间
				trigger.getTriggerBuilder().withSchedule(cronSchedule(time));
				// 重启触发器
				sched.resumeTrigger(triggerKey);
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * @Description: 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
	 * 
	 * @param sched
	 *            调度器
	 * @param jobName
	 * 
	 * @Title: QuartzManager.java
	 */
	public static void removeJob(Scheduler sched, String jobName) {
		try {
			TriggerKey triggerKey = new TriggerKey(jobName, TRIGGER_GROUP_NAME);
			sched.pauseTrigger(triggerKey);// 停止触发器
			sched.unscheduleJob(triggerKey);// 移除触发器
			JobKey jobKey = new JobKey(jobName, JOB_GROUP_NAME);
			sched.deleteJob(jobKey);// 删除任务
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * @Description: 移除一个任务
	 * 
	 * @param sched
	 *            调度器
	 * @param jobName
	 * @param jobGroupName
	 * @param triggerName
	 * @param triggerGroupName
	 * 
	 * @Title: QuartzManager.java
	 */
	public static void removeJob(Scheduler sched, String jobName, String jobGroupName, String triggerName,
			String triggerGroupName) {
		try {
			TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroupName);
			sched.pauseTrigger(triggerKey);// 停止触发器
			sched.unscheduleJob(triggerKey);// 移除触发器
			JobKey jobKey = new JobKey(jobName, jobGroupName);
			sched.deleteJob(jobKey);// 删除任务
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * @Description:启动所有定时任务
	 * 
	 * @param sched  调度器
	 * 
	 * @Title: QuartzManager.java
	 */
	public static void startJobs(Scheduler sched) {
		try {
			sched.start();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * @Description:关闭所有定时任务
	 * 
	 * @param sched
	 *            调度器
	 * 
	 */
	public static void shutdownJobs(Scheduler sched) {
		try {
			if (!sched.isShutdown()) {
				sched.shutdown();
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
}

 

创建任务执行类

public class MainJob implements Job{

	@Override
	public void execute(JobExecutionContext context)
			throws JobExecutionException {
		
		JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();  
        Map<String, Object>  params = (Map<String, Object>) jobDataMap.get("params");
		System.out.println("Hello World...."+params);
	}

}

 

 测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath*:spring-service-quartz.xml")
public class JobTest {
	@Autowired
	private SchedulerFactoryBean schedulerFactory;
	@Test
	public void testName() throws Exception {
		//schedulerFactory通过spring注入
		Scheduler sche = schedulerFactory.getScheduler();
		String job_name = "JOB_NAME";
		String clazz = "cn.itsource.aigou.job.MainJob";
		String cron = "/1 * * * * ? ";
		Map<String, Object> params = new HashMap<>();
		params.put("firstJob", 1);
		params.put("firstName", "myFirstName");
		QuartzUtils.addJob(sche, job_name, Class.forName(clazz), params, cron);
         // System.in.read();
		Thread.sleep(10000);     
		System.out.println("【移除定时】开始...");
		QuartzUtils.removeJob(sche, job_name);
		System.out.println("【移除定时】成功");
	}

 

解决quartz的job无法注入spring对象  全网仅此一份

/**
 * 以静态变量保存Spring ApplicationContext, 可在任何代码任何地方任何时候取出ApplicaitonContext.
 * 
 */
@Service
@Lazy(false)
public class SpringContextHolder implements ApplicationContextAware, DisposableBean {

    private static ApplicationContext applicationContext = null;


    /**
     * 取得存储在静态变量中的ApplicationContext.
     */
    public static ApplicationContext getApplicationContext() {
        assertContextInjected();
        return applicationContext;
    }

    /**
     * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) {
        assertContextInjected();
        return (T) applicationContext.getBean(name);
    }

    /**
     * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
     */
    public static <T> T getBean(Class<T> requiredType) {
        assertContextInjected();
        return applicationContext.getBean(requiredType);
    }

    /**
     * 清除SpringContextHolder中的ApplicationContext为Null.
     */
    public static void clearHolder() {
        applicationContext = null;
    }

    /**
     * 实现ApplicationContextAware接口, 注入Context到静态变量中.
     */
    public void setApplicationContext(ApplicationContext appContext) {
        applicationContext = appContext;
    }

    /**
     * 实现DisposableBean接口, 在Context关闭时清理静态变量.
     */
    public void destroy() throws Exception {
        SpringContextHolder.clearHolder();
    }

    /**
     * 检查ApplicationContext不为空.
     */
    private static void assertContextInjected() {
        Validate.validState(applicationContext != null, "applicaitonContext属性未注入, 请在applicationContext.xml中定义SpringContextHolder.");
    }
}

 

优点是：解耦性强，不必改别人的代码

还有一种方法可解决，就是用static方法解决，但是这样任务多了，每个类都要写就麻烦了

希望我的文章能帮到你

 

 

【SpringBoot】82、SpringBoot集成Quartz实现动态管理定时任务
Asurplus
06-29 3万+
Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中。它提供了巨大的灵 活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB 作业预构 建，JavaMail 及其它，支持 cron-like 表达式等等
SpringBoot系列：Spring Boot集成定时任务Quartz
2301_79963818的博客
04-17 858
首先定义定时具体执行逻辑Job，创建类QuartzJob1，这里集继承QuartzJobBean实现executeInternal即可，该方法即定时执行任务逻辑，这里简单打印了下当前时间。@Override然后创建QuartzConfig，接着定义JobDetail，JobDetail由JobBuilder构建，同时关联了任务QuartzJob1。@Bean。
sping quartz定时任务的使用
skydar的专栏
09-09 505
背景：最近项目，需要用到定时任务，所以就网上查了些资料，然后配置了下，因为项目用的是spring ，所以看的也是关于spring的定时任务，下面就说下自己的理解，记录下，也是便于自己下次用到的时候便于查看。 实现技术：因为使用的是spring MVC 所以使用spring的quartz ，下面就来说下具体流程： 1.配置调度工厂 2
集成quartz调度框架
Be yourself,everyone else is already taken
01-19 368
quartz定时器是做什么的 Quartz是一个任务调度框架，实现动态定时任务实现，比如你想在每天的12点删除一些日志信息等。或者想每隔1小时，备份一些动作片到云盘。 搭建框架 1. 基础环境配置 a. 创建数据库表 CREATE TABLE `QRTZ_LOCKS` ( `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL DEFAULT '', `LOCK_NAME` varchar(40) CH
集成定时任务
weixin_30553837的博客
08-29 82
集成定时任务 数据校正 统计存储类的封装（重点） 完成关注/粉丝数量的查询 转载于:https://www.cnblogs.com/oklizz/p/11432120.html
脚手架搭建之 集成定时任务
weixin_45637293的博客
05-29 153
1.引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz</artifactId> </dependency> 2.与application 集成 quartz: properties: org:
Quartz的集成
Y_vocefenrir的博客
04-03 282
1.创建springBoot项目 2.引入Quartz相关依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>4.3.18.RELEASE</...
springboot快速集成定时任务
阅微草堂
12-04 256
1、启动类增加 @EnableScheduling 注解 @SpringBootApplication @ComponentScan({"com.xxl.job.admin.controller","com.xxl.job.admin.core.conf","com.xxl.job.admin.localjob","com.xxl.job.admin.service"}) @MapperScan("com.xxl.job.admin.dao") @EnableScheduling public clas
quartz 定时任务调度
04-09
总结，Quartz定时任务调度是Java开发中不可或缺的工具，尤其对于需要定时执行任务的系统来说。通过学习和掌握Quartz的使用，以及cron表达式的编写，我们可以构建出强大且灵活的任务调度系统。同时，利用插件系统和...
基于Spring+Quartz集成的Java定时任务调度器设计源码
最新发布
10-05
该项目采用Spring框架与Quartz集成，打造了一个支持集群环境的Java定时任务调度器，包含27个文件，涵盖5个XML配置文件、4个Java源文件、3个属性文件、3个SQL文件以及相关配置文件，旨在实现高效、稳定的定时任务管理...
spring-boot集成quartz实现动态任务管理，支持集群
01-15
spring-boot集成quartz实现动态任务管理，采用数据库存储方式，建表语句已经打包在一起，支持分布式集群。 代码开箱即用，没有集成业务模块，大家可以根据自己的业务场景自己去实现Job类即可。
ss-deamon:Spring和qz定时调度任务的整合
07-02
ss-deamon Spring和qz定时调度任务的整合 系统有很多个mysql和mongo库，用户中心，订单中心，库存中心。因为没有统一的抽象业务层，所以定时任务需要直接连接这些不同的数据库。同时考虑到后期会有很多不同的定时任务加入，所以写了一个整合方式。希望能够把spring管理的bean通过注解，直接生成job，而不需要每次开发qz的复杂JobDetail。同时不能失去qz固有的扩展性，比如集群，定时任务的持久等。 1.dynamic包中主要实现了，通过拦截的方式，实现对动态数据源的切换功能 DataSource注解为拦截标志，用于指定目标数据源－目前作用域为对象级别 DynamicMethodInterceptor为拦截执行点，在这里，会根据反射的类，来切换数据源 DynamicMongoFactory这里是为了扩展spring原有的mongofactory，使之能够动态切换不同的
Quartz+Spring Boot实现动态管理定时任务
08-26
最近做项目遇到动态管理定时任务的需求，刚拿到这个需求还真不知道从哪下手，经过一番思考，终于找出实现思路，接下来通过本文给大家介绍了Quartz+Spring Boot实现动态管理定时任务的相关知识,需要的朋友可以参考下
Spring 3整合Quartz 2实现定时任务三：动态暂停 恢复 修改和删除任务
07-17
Spring 3整合Quartz 2实现定时任务三：动态暂停 恢复 修改和删除任务，原http://blog.csdn.net/phantomes/article/details/37880551博客的源码例子
springboot整合Quartz实现动态配置定时任务源码
06-10
springboot整合Quartz实现动态配置定时任务源码
spring整合quartz定时任务调度
05-18
Spring框架作为Java领域广泛使用的轻量级框架，提供了与第三方库Quartz的整合，使得开发者能够轻松地在Spring应用中实现复杂的定时任务调度。Quartz是一款开源的作业调度框架，支持丰富的调度策略，可以满足各种定时...
springboot项目集成xxl-job定时任务框架
m0_74399067的博客
07-28 675
定时任务时基于给定的时间点、给定的时间间隔或者给定的执行次数自动执行的程序。任务调度是系统的重要组成部分，同时涉及到多线程并发、运行时间规则定制及解析、线程池的维护等诸多方面的工作。
调度管理集成说明
return031116的专栏
11-15 553
调度管理集成说明   调度管理有单独的应用包newschedule. 1.     集成文件 将调度包文件文件（包括classes）按照目录结构全部合并到要集成到的系统文件结构中去，如果有重名文件，采用原系统的文件，即合并过程中不覆盖。 （如将newschedule\mis2与demo\mis2合并，保留demo中的文件）。 2 . 修改配置文件 1）WEB-INF\gezConfi
对定时任务调度集成的总结
iushnauh的专栏
11-09 101
1.TimerTask &gt;&gt;配置文件default-lazy-init="false"如果为true则不会启动Timer &gt;&gt;INFO [org.springframework.scheduling.timer.TimerFactoryBean] - Initializing Timer 表示启动了定时. &gt;&gt;但是用AbstractDependencyInjec...
Spring整合Quartz定时任务详解
"这篇教程详细介绍了如何基于Quartz实现定时调度任务，并提供了Spring整合Quartz的配置示例。" Quartz是一个强大的开源任务调度库，适用于Java环境，无论是J2EE还是J2SE项目，都能方便地集成使用。它允许开发者创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值