quartz集群（二）简单实例

最新推荐文章于 2021-02-21 23:24:02 发布
最新推荐文章于 2021-02-21 23:24:02 发布
阅读量460 收藏 1
点赞数
分类专栏： SpringBoot+定时
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_t_y_y/article/details/106265910
版权

一、数据库准备：

创建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;

 

二、代码：

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>

        <!-- quartz -->
        <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>


        <!-- mybatis -->
        <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>
        

        <!--druid-->
        <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）本地修改下数据

       本地部署一个节点

 

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

 

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

2、新增一个JOB:

（1）新增JOB：

    

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

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

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

 

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

3、修改JOB：

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

 

4、删除JOB：

数据库不再写入数据。 

 

四、总结：

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

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

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

  

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

 

w_t_y_y
关注
专栏目录
Quartz集群配置和示例源码
04-02
Quartz,集群,配置,源码,多线程 已经打包成jar包，解压即用，十分方便。 有问题请联系QQ：9710846
quartz集群完整应用实例
05-28
本篇将基于"quartz集群完整应用实例"来深入探讨Quartz的集群配置与实现。 Quartz的核心概念包括Job（任务）、Trigger（触发器）和Scheduler（调度器）。Job是执行的具体任务，Trigger定义了任务何时运行，而...
Quartz集群配置
anyuta5577的博客
01-12 128
Quartz集群配置（100%成功） 先看看quartz的持久化基本介绍： 引用 1 大家都清楚quartz最基本的概念就是job，在job内调用具体service完成具体功能，quartz需要把每个job存储起来，方便调度，quartz存储job方式就分三种，我们最常用的也是quartz默认的是RAMJobStore，RAMJobStore顾名思义就是把job的相关信息...
浅析Quartz的集群配置
热门推荐
踏雁寻花
02-17 3万+
1、基本信息：      Quartz是一个开源的作业调度框架，它完全由java写成，并设计用于J2Se和J2EE应用中。它提供了巨大的灵活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB作业预构建，JavaMail及其它，支持cron-like表达式等等。其中集群配置一般比较复杂，那么在Quartz中如何配置它的集群特性呢？
SpringBoot与Quartz集成实现分布式定时任务集群的代码实例
08-26
SpringBoot与Quartz集成实现分布式定时任务集群的代码实例 今天小编就为大家分享一篇关于SpringBoot与Quartz集成实现分布式定时任务集群的代码实例，分享的内容具有很好的参考价值。下面是相关的知识点： 首先，...
quartz 集群解决方法
03-25
Quartz集群需要将所有调度信息（如Job、Trigger）存储在一个共享的持久化存储中，以便所有集群节点都能访问。这通常通过实现`ISchedulerFactory`接口的`StdSchedulerFactory`类和数据库连接来完成。数据库可以选择...
Quartz 集群的简单实现
一点红 的博客
04-21 186
quartz 版本： 1.8.6 效果： 3 个 任务 TestJob 、TestJob2 、TestJob3 。 同时起4个相同引用进程： 显示如下 红色标记处 当一个应用获取到 job执行权限时，另一个进程则停止job执行。 当3个应用进程启动后： Java应用简单实现 quartz 集成于springboot项目中 ...
Quartz入门实例12-Spring4和quartz2的集群
胡小海丶
08-04 9933
使用spring4.0.6 和 quartz 2.2.1 整合进行集群
quartz与spring集群Demo
10-23
实例是基于MyEclipse开发的。针对Quartz与Spring做集群的Demo实例，主要解决了Quartz的JOB序列化问题。 源代码说明： support pkg：扩展Spring与Quartz集成的不足之处。 core pkg: 是自身调度业务的封装 实例运行依赖Oracle数据库，根据quartz框架包docs/dbTables/目录下的sql脚本文件，创建表结构，修改工程中的Spring数据源配置。 Start.java启动程序。
quartz 集群配置
03-12
spring 集成 quartz ，支持集群，job支持spring@Autowired注入及@Resource注入
spring集成quartz的集群配置实例
云淡风轻、仅此一抹
06-27 1297
原文：spring集成quartz的集群配置实例 源代码下载地址
Quartz 集群
qq_41895253的博客
08-22 138
解压 # # In your Quartz properties file, you'll need to set # org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate # # # By: Ron Cordell - roncordell # I didn't see...
Quartz Spring分布式集群搭建Demo
white__cat的专栏
09-18 279
https://www.cnblogs.com/dzpykj/p/9117716.html
quartz mysql 分布式_Quartz Spring分布式集群搭建Demo
weixin_28930859的博客
02-21 107
注:关于单节点的Quartz使用在这里不做详细介绍,直接进阶为分布式集群版的1.准备工作:使用环境Spring4.3.5,Quartz2.2.3,持久化框架JDBCTemplatepom文件如下xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">4...
Quartz总结
weixin_30576859的博客
08-31 106
前言 最近项目中有使用到Quartz，得空便总结总结，顺便记录一下这种设计模式，毕竟“好记性不如烂笔头”。 搭建 pom文件： <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> ...
quartz集群配置
henghengdh的专栏
11-13 177
quartz有两种注入方式，MethodInvokingJobDetailFactoryBean和JobDetailBean。 这里我用的是JobDetailBean。（MethodInvokingJobDetailFactoryBean也试了下，无奈不成功，看网上有人说重写两个类文件，试了下也不行，只好用JobDetailBean了） [b]1.下载quartz-1.8.6包，包的的...
Quartz集群：强大的任务调度与简易实现
通过分布式存储和复制机制，Quartz集群可以处理大规模的任务执行，并且在高负载环境下保持高效运行。 Quartz凭借其强大的功能、灵活的配置和高度的模块化设计，成为了许多Java项目中任务调度的理想选择，尤其适用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

w_t_y_y

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

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

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

打赏作者

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

抵扣说明：

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

余额充值