quartz集群（二）简单实例

川长思鸟来 2023-02-11 04:42 183阅读 0赞

一、数据库准备：

创建quartz集群所需的11张表：

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;

再创建一张业务表，后面job往这张表写数据：

CREATE TABLE `t_group_user` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `name` varchar(255) DEFAULT NULL,
      `age` int(11) DEFAULT NULL,
      `create_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=7111 DEFAULT CHARSET=utf8;

二、代码：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70][]

1、pom：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.demo</groupId>
        <artifactId>quartzgroupdemo</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.4.1.RELEASE</version>
        </parent>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz</artifactId>
                <version>2.2.3</version>
            </dependency>
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz-jobs</artifactId>
                <version>2.2.3</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
            </dependency>
    
    
            
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.3.2</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.21</version>
            </dependency>
            
    
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.0.12</version>
            </dependency>
    
        </dependencies>
        <repositories>
            <repository>
                <id>spring-milestones</id>
                <name>Spring Milestones</name>
                <url>https://repo.spring.io/libs-milestone</url>
                <snapshots>
                    <enabled>false</enabled>
                </snapshots>
            </repository>
        </repositories>
    
    
        <build>
            <finalName>quartz-demo</finalName>
            <plugins>
                <plugin>
                    <artifactId>maven-release-plugin</artifactId>
    
                </plugin>
                <plugin>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <version>2.2.1</version>
                    <configuration>
                        <descriptors>
                            <descriptor>src/main/assemble/package.xml</descriptor>
                        </descriptors>
                    </configuration>
                    <executions>
                        <execution>
                            <id>make-assembly</id>
                            <phase>package</phase>
                            <goals>
                                <goal>single</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>2.4</version>
                    <configuration>
                        <excludes>
                            <exclude>**/*.properties</exclude>
                            <exclude>**/*.xml</exclude>
                            <exclude>**/*.html</exclude>
                            <exclude>config</exclude>
                        </excludes>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.5.1</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    
    </project>

2、配置文件：

（1）application.properties：

server.port=9999
    server.context-path=/quartzgroup
    
    my.pool.url=jdbc:mysql://xxx.xx.xxx.xx:3306/mydemo?useUnicode=true&characterEncoding=utf8
    my.pool.username = xxx
    my.pool.password= xxxxxx
    my.pool.driver-class-name = com.mysql.jdbc.Driver
    
    my.pool.defaultAutoCommit = true
    my.pool.maxWait=60000
    my.pool.maxActive = 6
    my.pool.maxIdle = 5
    my.pool.minIdle = 2
    my.pool.initialSize = 3
    my.pool.validationQuery = SELECT 1
    my.pool.testWhileIdle = true
    my.pool.timeBetweenEvictionRunsMillis=60000
    my.pool.minEvictableIdleTimeMillis=30000
    my.pool.testOnBorrow=false
    my.pool.testOnReturn=false
    
    mybatis.mapper-locations=classpath*:Mapper/*Mapper.xml

(2)myquartz.properties：

#quartz集群配置
    #调度标识名 集群中每一个实例都必须使用相同的名称
    org.quartz.scheduler.instanceName=DefaultQuartzScheduler
    #ID设置为自动获取 每一个必须不同
    org.quartz.scheduler.instanceId=AUTO
    org.quartz.scheduler.makeSchedulerThreadDaemon=true
    #线程池的实现类（一般使用SimpleThreadPool即可满足需求）
    org.quartz.scheduler.jobFactory.class  = org.quartz.simpl.SimpleJobFactory
    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
    org.quartz.jobStore.selectWithLockSQL = SELECT * FROM {0}LOCKS UPDLOCK WHERE LOCK_NAME = ?
    org.quartz.dataSource.quartzDataSource.maxConnections = 10
    org.quartz.jobStore.dataSource = quartzDataSource
    #防止重复调度（https://segmentfault.com/a/1190000015492260）
    org.quartz.jobStore.acquireTriggersWithinLock=true
    
    org.quartz.dataSource.quartzDataSource.driver = com.mysql.jdbc.Driver
    org.quartz.dataSource.quartzDataSource.URL=jdbc:mysql://xxx.xx.xxx.xx:3306/3c_bak?useUnicode=true&characterEncoding=utf8
    org.quartz.dataSource.quartzDataSource.user =xxx
    org.quartz.dataSource.quartzDataSource.password = xxxxxx

3、启动类：

package com.demo;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
    
    @SpringBootApplication
    @MapperScan("com.demo.dao")
    public class JobGroupStart {
        public static void main(String[] args) {
            SpringApplication.run(JobGroupStart.class, args);
        }
    }

4、config：

(1)：druid数据源

package com.demo.config;
    
    import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import javax.sql.DataSource;
    
    @Configuration
    public class DataSourceConfig {
        //指定当前对象作为bean
        @Bean(name = "quartzDataSource")
        //指定dataSource来DI
        //@Qualifier(value = "dataSource")
        //primary将当前数据库连接池作为默认数据库连接池
        // @Primary
        //在application.properties文件中增加前缀c3p0
        @ConfigurationProperties(prefix = "my.pool")
        public DataSource dataSource(){
            return DataSourceBuilder.create().type(com.alibaba.druid.pool.DruidDataSource.class).build();
        }
    
    }

(2)：quartz集群配置：

package com.demo.config;
    
    import java.io.IOException;
    import java.util.Properties;
    import javax.sql.DataSource;
    
    import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    import org.quartz.SchedulerFactory;
    import org.quartz.impl.StdSchedulerFactory;
    import org.quartz.spi.JobFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.beans.factory.config.PropertiesFactoryBean;
    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.SchedulerFactoryBean;
    
    
    @Configuration
    public class QuartzConfig {
    
        public static final String QUARTZ_PROPERTIES_PATH = "/myquartz.properties";
    
    
    
        @Bean
        public Scheduler scheduler() throws IOException, SchedulerException {
            SchedulerFactory schedulerFactory = new StdSchedulerFactory(quartzProperties());
            Scheduler scheduler = schedulerFactory.getScheduler();
            scheduler.start();
            return scheduler;
        }
    
    
        @Bean
        public Properties quartzProperties() throws IOException {
            PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
            propertiesFactoryBean.setLocation(new ClassPathResource(QUARTZ_PROPERTIES_PATH));
            propertiesFactoryBean.afterPropertiesSet();
            return propertiesFactoryBean.getObject();
        }
    }

package com.demo.config;
    
    import org.quartz.spi.TriggerFiredBundle;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
    import org.springframework.scheduling.quartz.SpringBeanJobFactory;
    import org.springframework.stereotype.Component;
    
    @Component
    public   class QuartzJobFactory  extends SpringBeanJobFactory{
        @Autowired
        private AutowireCapableBeanFactory capableBeanFactory;
        @Override
        protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
            Object jobInstance = super.createJobInstance(bundle);
            capableBeanFactory.autowireBean(jobInstance);
            return jobInstance;
        }
    }

5、controller：JOB的增删改，这里通过controller接口控制Scheduler中的job。（当然，如果JOB是固定的，不会经常新增、删除、修改，也可以设置在项目启动的时候就把JOB加入到schduled调度中，如通过@PostConstruct注解。）

package com.demo.controller;
    
    import com.demo.factory.ServiceFactory;
    import com.demo.job.BaseJob;
    //import com.demo.job.JobScheduler;
    import org.quartz.*;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("/job")
    public class JobController {
    
    
        @Autowired
        private Scheduler scheduler;
    
        //新增job
        @RequestMapping("/addJob")
        public void addJob(@RequestParam("jobClassName") String jobClassName,
                            @RequestParam("jobGroupName")String jobGroupName,
                            @RequestParam("cronExpression") String cronExpression){
            try {
                jobAdd(jobClassName,jobGroupName,cronExpression);
                System.out.println("新增job成功");
            } catch (Exception e) {
                System.out.println("addJob失败");
            }
        }
    
        //修改job
        @RequestMapping("/updateJob")
        public void updateJob(@RequestParam("jobClassName") String jobClassName,
                           @RequestParam("jobGroupName")String jobGroupName,
                           @RequestParam("cronExpression") String cronExpression){
            try {
                jobUpdate(jobClassName,jobGroupName,cronExpression);
                System.out.println("修改job成功");
            } catch (Exception e) {
    
            }
        }
    
        //删除job
        @RequestMapping("/deleteJob")
        public void deleteJob(@RequestParam("jobClassName") String jobClassName,
                              @RequestParam("jobGroupName")String jobGroupName){
            try {
                jobDelete(jobClassName,jobGroupName);
                System.out.println("删除job成功");
            } catch (Exception e) {
    
            }
        }
    
    
        /**
         *
         *
         */
        //新增job
        private void jobAdd(String jobClassName,
                           String jobGroupName,
                           String cronExpression) throws Exception {
            //构建job信息
            JobDetail jobDetail = JobBuilder.newJob(getClass(jobClassName).getClass()).withIdentity(jobClassName, jobGroupName).build();
            //表达式调度构建器(即任务执行的时间)
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
            //按新的cronExpression表达式构建一个新的trigger
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobClassName, jobGroupName)
                    .withSchedule(scheduleBuilder).build();
            try {
                scheduler.scheduleJob(jobDetail, trigger);
            } catch (SchedulerException e) {
                System.out.println("创建定时任务失败"+e);
                throw new Exception("创建定时任务失败");
            }
        }
    
    
        //修改job调度
        public void jobUpdate(String jobClassName,
                              String jobGroupName,
                              String cronExpression) throws Exception {
            try {
    
                TriggerKey triggerKey = TriggerKey.triggerKey(jobClassName, jobGroupName);
                // 表达式调度构建器
                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
                CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
                // 按新的cronExpression表达式重新构建trigger
                trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
                // 按新的trigger重新设置job执行
                scheduler.rescheduleJob(triggerKey, trigger);
            } catch (SchedulerException e) {
                System.out.println("更新定时任务失败"+e);
                throw new Exception("更新定时任务失败");
            }
        }
    
        /**
         * 删除job调度任务
         */
        public void jobDelete(String jobClassName,
                              String jobGroupName) throws Exception {
    
            scheduler.pauseTrigger(TriggerKey.triggerKey(jobClassName, jobGroupName));
            scheduler.unscheduleJob(TriggerKey.triggerKey(jobClassName, jobGroupName));
            scheduler.deleteJob(JobKey.jobKey(jobClassName, jobGroupName));
        }
    
    
        //暂停Job
        public  void pausejob(String jobClassName,
                              String jobGroupName) throws Exception
        {
            scheduler.pauseJob(JobKey.jobKey(jobClassName, jobGroupName));
        }
    
    
        //(暂停后)恢复job
        public void resumejob(String jobClassName,
                              String jobGroupName) throws Exception {
    
            scheduler.resumeJob(JobKey.jobKey(jobClassName, jobGroupName));
        }
    
    
        public static BaseJob getClass(String classname) throws Exception {
    
            Class<?> class1 = Class.forName(classname);
            return (BaseJob)class1.newInstance();
        }
    }

6、factory：通过springcontext获取bean的，因为在Job的实现类中，在execute中如果需要操作bean，通过@Autowired获取不        到bean

package com.demo.factory;
    
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    
    @Component
    public class ApplicationContextRegister implements ApplicationContextAware {
        private static Logger logger = LoggerFactory.getLogger(ApplicationContextRegister.class);
        private static ApplicationContext APPLICATION_CONTEXT;
        /**
         * 设置spring上下文
         * @param applicationContext spring上下文
         * @throws BeansException
         * */
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            logger.debug("ApplicationContext registed-->{}", applicationContext);
            DefaultBeanFactory.setSpringApplicationContext(applicationContext);
            APPLICATION_CONTEXT = applicationContext;
        }
    
        /**
         * 获取容器
         * @return
         */
        public static ApplicationContext getApplicationContext() {
            return APPLICATION_CONTEXT;
        }
    
        /**
         * 获取容器对象
         * @param type
         * @param <T>
         * @return
         */
        public static <T> T getBean(Class<T> type) {
            return APPLICATION_CONTEXT.getBean(type);
        }
    }

package com.demo.factory;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    
    public class DefaultBeanFactory {
    	private static ApplicationContext context = null;
    	private static DefaultBeanFactory instance = null;
    	private static Object lock = new Object();
    
    	private DefaultBeanFactory(String filepath){
    		try {
    			context = new ClassPathXmlApplicationContext(filepath);
    		} catch (Exception e) {
    		}
    	}
    	@SuppressWarnings("static-access")
    	private DefaultBeanFactory(ApplicationContext context){
    		try {
    			this.context = context;
    		} catch (Exception e) {
    		}
    	}
    
    	public static void setSpringApplicationContext(ApplicationContext context){
    		synchronized (lock) {
    			instance = new DefaultBeanFactory(context);
    		}
    	}
    	public static DefaultBeanFactory getInstance() {
    		if(instance == null || context == null){
    			throw new RuntimeException("Spring context is null!");
    		}
    		return instance;
    	}
    
    	public static DefaultBeanFactory getInstance(String filepath) {
    		synchronized (lock) {
    			instance = new DefaultBeanFactory(filepath);
    		}
    		return instance;
    	}
    	public Object getBean(String name) {
    		return context.getBean(name);
    	}
    }

package com.demo.factory;
    
    //import com.demo.job.JobScheduler;
    import com.demo.service.UserService;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    
    public class ServiceFactory {
    
    
        private static Logger logger = LoggerFactory.getLogger(ServiceFactory.class);
    
        private static ServiceFactory instance = new ServiceFactory();
    
        private final String USER_SERVICE_BEAN="userService";
    
        private final String JOB_SCHDULE="userService";
    
    
    
    
        public ServiceFactory() {
            // TODO Auto-generated constructor stub
        }
    
        public static ServiceFactory getInstance() {
            if (instance == null) {
                instance = new ServiceFactory();
            }
            return instance;
        }
    
        public UserService createUserService() {
            try {
                return (UserService) DefaultBeanFactory.getInstance().getBean(USER_SERVICE_BEAN);
            } catch (Exception e) {
                throw new RuntimeException("创建 USER_SERVICE BEAN 异常", e);
            }
        }
    
       /* public JobScheduler createJobSchedulere() {
            try {
                return (JobScheduler) DefaultBeanFactory.getInstance().getBean(JOB_SCHDULE);
            } catch (Exception e) {
                throw new RuntimeException("创建 USER_SERVICE BEAN 异常", e);
            }
        }
    */
    
    }

7、Job：

（1）BaseJob：基类：

package com.demo.job;
    
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    
    public interface BaseJob extends Job{
    	public void execute(JobExecutionContext context) throws JobExecutionException;
    }

（2）

package com.demo.job;
    
    import com.demo.dto.User;
    import com.demo.factory.ServiceFactory;
    import com.demo.service.UserService;
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    
    
    public class MyDbJob implements BaseJob{
        private static UserService userService;
        static {
          userService = ServiceFactory.getInstance().createUserService();
          //userService = (UserService) SpringContextUtil.getApplicationContext().getBean("userService");
    
        }
    
        @Override
        public void execute(JobExecutionContext arg0) throws JobExecutionException {
            System.out.print("执行db");
            User user = new User();
            user.setName("名称");
            user.setAge(18);
            userService.insert(user);
            System.out.println("执行myDbJob,写入数据");
        }
    
    }

（3）

package com.demo.job;
    
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    /**
     *
     * @Description: 需要执行的内容
     */
    public class MyJob implements BaseJob{
    
        @Override
        public void execute(JobExecutionContext arg0) throws JobExecutionException {
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd : hh:mm:ss");
            String str = dateFormat.format(new Date());
            System.out.println("MyJob1当前时间:"+str);
        }
    
    }

8、服务：

package com.demo.service.impl;
    
    import com.demo.dao.UserDao;
    import com.demo.dto.User;
    import com.demo.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service("userService")
    public class UserServiceImpl implements UserService {
    
        @Autowired
        private UserDao userDao;
    
        @Override
        public void insert(User user) {
            userDao.insertUser(user);
        }
    }

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//jobMybatis.mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    <mapper namespace="com.demo.dao.UserDao">
    
      <insert id="insertUser" >
          insert into t_group_user(name,age,create_time) values
          (#{user.name},#{user.age},NOW())
      </insert>
    
    </mapper>

三、测试：

1、下面部署两个节点，

（1）本地修改下数据

![20200525110943287.png][]

本地部署一个节点

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 1][]

（2）再在另一台远程机器上部署一个节点，从日志上可以看到可以扫描到我本地的节点在执行：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 2][]

这时候本地节点也打出扫描另一端的日志

2、新增一个JOB:

（1）新增JOB：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 3][]

运行一段时间观察数据库有重复数据：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 4][]

quartz配置文件中加上如下即不会出现任务重复执行的情况，并且不打印扫描日志：

#防止重复调度（https://segmentfault.com/a/1190000015492260）
    org.quartz.jobStore.acquireTriggersWithinLock=true

（2）再把正在执行的节点停了，另一个节点扫描到失败信息并开始写入数据：

![20200526154749553.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 6][]

3、修改JOB：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 7][]

观察一段时间，数据库正常：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 8][]

4、删除JOB：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 9][]

数据库不再写入数据。

四、总结：

1、quartz的配置文件里面加上如下配置，可以防止任务重复执行，且不打印扫描其他节点的日志：

#防止重复调度（https://segmentfault.com/a/1190000015492260）
    org.quartz.jobStore.acquireTriggersWithinLock=true

不加以上配置，任务运行一段时间可能会重复执行，且两个节点不停的打扫描日志：

![20200525194942469.png][]

2、quartz配置文件中org.quartz.jobStore.dataSource最好不要写dataSource防止spring注入默认的dataSource，可以取个别名，    比如我的：

org.quartz.jobStore.dataSource = quartzDataSource
    org.quartz.dataSource.quartzDataSource.driver = com.mysql.jdbc.Driver
    org.quartz.dataSource.quartzDataSource.URL=jdbc:mysql://xxx.xx.xxx.xx:3306/3c_bak?useUnicode=true&characterEncoding=utf8
    org.quartz.dataSource.quartzDataSource.user = xxxx
    org.quartz.dataSource.quartzDataSource.password = xxxxxx

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200526155643241.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[20200525110943287.png]: https://img-blog.csdnimg.cn/20200525110943287.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200525105701683.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200525195202859.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200525111244432.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200525111457642.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[20200526154749553.png]: https://img-blog.csdnimg.cn/20200526154749553.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/2020052511375677.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200525113813366.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200525114208603.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/2020052511440767.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/2020052511452873.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[20200525194942469.png]: https://img-blog.csdnimg.cn/20200525194942469.png