quartz集群（一）quartz集群介绍与springboot集成quartz集群方法

水深无声 2023-02-11 03:20 18阅读 0赞

一、集群介绍：quartz集群即quartz多节点。

使用quartz实现定时任务，若是部署多台机器，那么到了时间点，多台服务器便会同时均开始执行定时任务，这不符合我们的功能实现。如某些无状态的任务在同一时间希望只有一个节点在执行。  
quartz集群分为水平集群和垂直集群：水平集群即将定时任务节点部署在不同的服务器，其最大的问题就是时钟同步问题，若时钟不能同步，则会导致集群中各个节点状态紊乱，造成不可预知的后果；垂直集群则是集群各节点部署在同一台服务器，时钟同步自然不是问题，但存在单点故障问题，服务器宕机会严重影响服务的可用性。因此，要结合实际情况来考虑集群方案。

二、springBoot集成quartz集群：

quartz集群的实现方式在于11张表，集群节点相互之间不通信，而是通过定时任务持久化加锁的方式来实现集群。

1、首先创建表：

下载quartz集群需要创建的表，下载地址：[http://www.quartz-scheduler.org/downloads/][http_www.quartz-scheduler.org_downloads]

![这里写图片描述][70]

下载之后解压，进入如下目录，创建数据库表quartz-2.2.3-distribution\\quartz-2.2.3\\docs\\dbTables

注：若是mysql数据库，则使用上图的sql文件。

![这里写图片描述][70 1]

mysql中数据库表创建语句如下：（后面不需要去官网下载，可以直接使用这个SQL脚本）

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
    DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
    DROP TABLE IF EXISTS QRTZ_LOCKS;
    DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
    DROP TABLE IF EXISTS QRTZ_CALENDARS;
    
    CREATE TABLE QRTZ_JOB_DETAILS(
    SCHED_NAME VARCHAR(120) NOT NULL,
    JOB_NAME VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    JOB_CLASS_NAME VARCHAR(250) NOT NULL,
    IS_DURABLE VARCHAR(1) NOT NULL,
    IS_NONCONCURRENT VARCHAR(1) NOT NULL,
    IS_UPDATE_DATA VARCHAR(1) NOT NULL,
    REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    JOB_NAME VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    NEXT_FIRE_TIME BIGINT(13) NULL,
    PREV_FIRE_TIME BIGINT(13) NULL,
    PRIORITY INTEGER NULL,
    TRIGGER_STATE VARCHAR(16) NOT NULL,
    TRIGGER_TYPE VARCHAR(8) NOT NULL,
    START_TIME BIGINT(13) NOT NULL,
    END_TIME BIGINT(13) NULL,
    CALENDAR_NAME VARCHAR(200) NULL,
    MISFIRE_INSTR SMALLINT(2) NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
    REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    REPEAT_COUNT BIGINT(7) NOT NULL,
    REPEAT_INTERVAL BIGINT(12) NOT NULL,
    TIMES_TRIGGERED BIGINT(10) NOT NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_CRON_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    CRON_EXPRESSION VARCHAR(120) NOT NULL,
    TIME_ZONE_ID VARCHAR(80),
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_SIMPROP_TRIGGERS
      (          
        SCHED_NAME VARCHAR(120) NOT NULL,
        TRIGGER_NAME VARCHAR(200) NOT NULL,
        TRIGGER_GROUP VARCHAR(200) NOT NULL,
        STR_PROP_1 VARCHAR(512) NULL,
        STR_PROP_2 VARCHAR(512) NULL,
        STR_PROP_3 VARCHAR(512) NULL,
        INT_PROP_1 INT NULL,
        INT_PROP_2 INT NULL,
        LONG_PROP_1 BIGINT NULL,
        LONG_PROP_2 BIGINT NULL,
        DEC_PROP_1 NUMERIC(13,4) NULL,
        DEC_PROP_2 NUMERIC(13,4) NULL,
        BOOL_PROP_1 VARCHAR(1) NULL,
        BOOL_PROP_2 VARCHAR(1) NULL,
        PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_BLOB_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    BLOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_CALENDARS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    CALENDAR_NAME VARCHAR(200) NOT NULL,
    CALENDAR BLOB NOT NULL,
    PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_FIRED_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    ENTRY_ID VARCHAR(95) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    FIRED_TIME BIGINT(13) NOT NULL,
    SCHED_TIME BIGINT(13) NOT NULL,
    PRIORITY INTEGER NOT NULL,
    STATE VARCHAR(16) NOT NULL,
    JOB_NAME VARCHAR(200) NULL,
    JOB_GROUP VARCHAR(200) NULL,
    IS_NONCONCURRENT VARCHAR(1) NULL,
    REQUESTS_RECOVERY VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,ENTRY_ID))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_SCHEDULER_STATE (
    SCHED_NAME VARCHAR(120) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
    CHECKIN_INTERVAL BIGINT(13) NOT NULL,
    PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
    ENGINE=InnoDB;
    
    CREATE TABLE QRTZ_LOCKS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    LOCK_NAME VARCHAR(40) NOT NULL,
    PRIMARY KEY (SCHED_NAME,LOCK_NAME))
    ENGINE=InnoDB;
    
    CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
    CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);
    
    CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
    CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
    CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
    CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
    CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
    CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
    CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
    CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
    CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
    CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
    CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
    CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);
    
    CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
    CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
    CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
    CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
    CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
    CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
    
    commit;

11张表功能说明：

表明    功能  
QRTZ\_CALENDARS    以 Blob 类型存储 Quartz 的 Calendar 信息  
QRTZ\_CRON\_TRIGGERS    存储 Cron Trigger，包括 Cron 表达式和时区信息  
QRTZ\_FIRED\_TRIGGERS    存储与已触发的 Trigger 相关的状态信息，以及相联 Job 的执行信息  
QRTZ\_PAUSED\_TRIGGER\_GRPS    存储已暂停的 Trigger 组的信息  
QRTZ\_SCHEDULER\_STATE    存储少量的有关 Scheduler 的状态信息，和别的 Scheduler 实例(假如是用于一个集群中)  
QRTZ\_LOCKS    存储程序的非观锁的信息(假如使用了悲观锁)  
QRTZ\_JOB\_DETAILS    存储每一个已配置的 Job 的详细信息  
QRTZ\_SIMPLE\_TRIGGERS    存储简单的 Trigger，包括重复次数，间隔，以及已触的次数  
QRTZ\_BLOG\_TRIGGERS    Trigger 作为 Blob 类型存储(用于 Quartz 用户用 JDBC 创建他们自己定制的 Trigger 类型，JobStore 并不知道如何存储实例的时候)  
QRTZ\_TRIGGER\_LISTENERS    存储已配置的 TriggerListener 的信息  
QRTZ\_TRIGGERS    存储已配置的 Trigger 的信息

2、pom添加依赖，quartz核心包：

<dependency> 
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
    </dependency>
    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz-jobs</artifactId>
    </dependency>

3、配置集群：

（1）quartz.properties

#quartz集群配置  
    #调度标识名 集群中每一个实例都必须使用相同的名称    
    org.quartz.scheduler.instanceName=DefaultQuartzScheduler
    #ID设置为自动获取 每一个必须不同  
    org.quartz.scheduler.instanceId=AUTO
    org.quartz.scheduler.makeSchedulerThreadDaemon=true
    #线程池的实现类（一般使用SimpleThreadPool即可满足需求）  
    org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
    #指定在线程池里面创建的线程是否是守护线程
    org.quartz.threadPool.makeThreadsDaemons=true
    #指定线程数，至少为1（无默认值）
    org.quartz.threadPool.threadCount:20
    #设置线程的优先级（最大为java.lang.Thread.MAX_PRIORITY 10，最小为Thread.MIN_PRIORITY 1，默认为5） 
    org.quartz.threadPool.threadPriority:5
    #数据保存方式为数据库持久化  
    org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
    #数据库代理类，一般org.quartz.impl.jdbcjobstore.StdJDBCDelegate可以满足大部分数据库  
    org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
    #表的前缀，默认QRTZ_  
    org.quartz.jobStore.tablePrefix=QRTZ_
    #是否加入集群
    org.quartz.jobStore.isClustered=true
    # 信息保存时间 默认值60秒   
    org.quartz.jobStore.misfireThreshold=25000

更多详细配置可参考如下：  
https://blog.csdn.net/huang1060/article/details/68062496

（2）配置类：

package com.button.timer.conf;
    
    import java.io.IOException;
    import java.util.Properties;
    
    import javax.sql.DataSource;
    
    import org.quartz.JobDetail;
    import org.quartz.Trigger;
    import org.quartz.spi.JobFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.beans.factory.config.PropertiesFactoryBean;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.io.ClassPathResource;
    import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
    import org.springframework.scheduling.quartz.JobDetailFactoryBean;
    import org.springframework.scheduling.quartz.SchedulerFactoryBean;
    
    import com.button.timer.job.ButtonTimerJob;
    
    @Configuration
    public class QuartzConfigure {
    	// 配置文件路径
    	private static final String QUARTZ_CONFIG = "/quartz.properties";
    	
    	@Autowired
        @Qualifier(value = "dataSource")
        private DataSource dataSource;
    	
    	@Value("${quartz.cronExpression}")
    	private String cronExpression;
    
    	/**
    	 * 从quartz.properties文件中读取Quartz配置属性
    	 * @return
    	 * @throws IOException
    	 */
        @Bean
        public Properties quartzProperties() throws IOException {
            PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
            propertiesFactoryBean.setLocation(new ClassPathResource(QUARTZ_CONFIG));
            propertiesFactoryBean.afterPropertiesSet();
            return propertiesFactoryBean.getObject();
        }
        
        /**
         * JobFactory与schedulerFactoryBean中的JobFactory相互依赖,注意bean的名称
         * 在这里为JobFactory注入了Spring上下文
         * 
         * @param applicationContext
         * @return
         */
        @Bean
        public JobFactory buttonJobFactory(ApplicationContext applicationContext) {
        	AutoWiredSpringBeanToJobFactory jobFactory = new AutoWiredSpringBeanToJobFactory();
            jobFactory.setApplicationContext(applicationContext);
            return jobFactory;
        }
    
        /**
         * 
         * @param buttonJobFactory  为SchedulerFactory配置JobFactory
         * @param cronJobTrigger  
         * @return
         * @throws IOException
         */
        @Bean
        public SchedulerFactoryBean schedulerFactoryBean(JobFactory buttonJobFactory, Trigger... cronJobTrigger) throws IOException {
            SchedulerFactoryBean factory = new SchedulerFactoryBean();
            factory.setJobFactory(buttonJobFactory);
            factory.setOverwriteExistingJobs(true);
            factory.setAutoStartup(true); // 设置自行启动
            factory.setQuartzProperties(quartzProperties());
            factory.setTriggers(cronJobTrigger);
            factory.setDataSource(dataSource);// 使用应用的dataSource替换quartz的dataSource
            return factory;
        }
    
        /**
         * 配置JobDetailFactory
         * JobDetailFactoryBean与CronTriggerFactoryBean相互依赖,注意bean的名称
         * 
         * @return
         */
        @Bean
        public JobDetailFactoryBean buttonobDetail() {
             //集群模式下必须使用JobDetailFactoryBean，MethodInvokingJobDetailFactoryBean 类中的 methodInvoking 方法，是不支持序列化的
             JobDetailFactoryBean jobDetail = new JobDetailFactoryBean();
             jobDetail.setDurability(true); 
             jobDetail.setRequestsRecovery(true);
             jobDetail.setJobClass(ButtonTimerJob.class); 
             return jobDetail; 
        }
        
        /**
         * 配置具体执行规则
         * @param buttonobDetail
         * @return
         */
        @Bean
        public CronTriggerFactoryBean cronJobTrigger(JobDetail buttonobDetail) {
            CronTriggerFactoryBean tigger = new CronTriggerFactoryBean();
            tigger.setJobDetail(buttonobDetail);
            tigger.setStartDelay(2000);   //延迟启动
            tigger.setCronExpression(cronExpression);  //从application.yml文件读取
            return tigger;
        }
    }

package com.button.timer.conf;
    
    import org.quartz.spi.TriggerFiredBundle;
    import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.scheduling.quartz.SpringBeanJobFactory;
    /**
     * 
     * @author Button
     * 为JobFactory注入SpringBean,否则Job无法使用Spring创建的bean
     */
    public class AutoWiredSpringBeanToJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {
    	private transient AutowireCapableBeanFactory beanFactory;
    
        @Override
        public void setApplicationContext(final ApplicationContext context) {
            beanFactory = context.getAutowireCapableBeanFactory();
        }
    
        @Override
        protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
            final Object job = super.createJobInstance(bundle);
            beanFactory.autowireBean(job);
            return job;
        }
    }

4、定时：

package com.button.timer.job;
    
    import org.quartz.DisallowConcurrentExecution;
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    /**
     * @DisallowConcurrentExecution : 此标记用在实现Job的类上面,意思是不允许并发执行.
     * 注org.quartz.threadPool.threadCount的数量有多个的情况,@DisallowConcurrentExecution才生效
     */
    @DisallowConcurrentExecution
    public class ButtonTimerJob implements Job{
        private static final Logger logger = LoggerFactory.getLogger(ButtonTimerJob.class);
    
        /**
         * 核心方法,Quartz Job真正的执行逻辑.
         * @param JobExecutionContext中封装有Quartz运行所需要的所有信息
         * @throws JobExecutionException execute()方法只允许抛出JobExecutionException异常
         */
    	@Override
    	public void execute(JobExecutionContext context) throws JobExecutionException {
    		logger.info("--------------定时任务执行逻辑---------------------");
    	}
    }

三、使用quartz集群第一次通过scheduler.scheduleJob(jobDetail, trigger)加载的Job，项目重启后还在；而普通的quartz调度，项目重启后就不在了，故需要在项目初始化时查询所有的job并通过scheduler.scheduleJob(jobDetail, trigger)加载才会加入到调度中。

原理应该是quartz集群源码做了处理。

[http_www.quartz-scheduler.org_downloads]: http://www.quartz-scheduler.org/downloads/
[70]: https://img-blog.csdn.net/20180916184504470?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2NzA5NDU5/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 1]: https://img-blog.csdn.net/2018091618442589?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2NzA5NDU5/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70