springboot 动态添加定时任务(配合数据库增删查改定时任务)

Quartz作业存储方式

Quartz提供两种基本作业存储类型。第一种类型叫做RAMJobStore,第二种类型叫做JDBC作业存储。

RAMJobStore和JDBC作业存储比较

RAMJobStore和JDBC作业存储比较
类型优点缺点
RAMJobStore不要外部数据库,配置容易,运行速度快因为调度程序信息是存储在被分配给JVM的内存里面,所以,当应用程序停止运行时,所有调度信息将被丢失。另外因为存储到JVM内存里面,所以可以存储多少个Job和Trigger将会受到限制
JDBC作业存储支持集群,因为所有的任务信息都会保存到数据库中,可以控制事物,还有就是如果应用服务器关闭或者重启,任务信息都不会丢失,并且可以恢复因服务器关闭或者重启而导致执行失败的任务运行速度的快慢取决与连接数据库的快慢

通过综上比较得出:在一般实际的项目中,一般都采用jdbc的作业存储,但是jdbc作业存储的表结构复杂且表居多,大约十一张表,每张表结构也比较复杂。下面是官方要求的十一张表,具体如下:

jdbc作业存储的数据库表

但是我们其实主要一张表就行,记录定时任务的任务就行,其他虽然有作用,但不是很明显。

CREATE TABLE `sys_corn_quartz` (
  `uuid` varchar(255) COLLATE utf8_bin NOT NULL,
  `type` tinyint(4) NOT NULL DEFAULT '0' COMMENT '类型',
  `job_group` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL COMMENT '任务组',
  `job_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL COMMENT '任务名称',
  `invoke_param` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin DEFAULT NULL COMMENT '参数',
  `quartz_time` datetime NOT NULL COMMENT '定时时间',
  `status` tinyint(4) NOT NULL DEFAULT '3' COMMENT '状态',
  `execute_endtime` datetime DEFAULT NULL COMMENT '执行任务时间',
  PRIMARY KEY (`uuid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

个人觉得定时任务这些字段基本都够用了。

我们先理清下思路,怎么实现一个实现流程?

首先我们要了解quartz三要素,了解了才知道步骤是怎么做?

  1. Scheduler:调度器。所有的调度都是由它控制。
  2. Trigger: 触发器。决定什么时候来执行任务。
  3. JobDetail & Job: JobDetail定义的是任务数据,而真正的执行逻辑是在Job中。使用JobDetail + Job而不是Job,这是因为任务是有可能并发执行,如果Scheduler直接使用Job,就会存在对同一个Job实例并发访问的问题。而JobDetail & Job 方式,sheduler每次执行,都会根据JobDetail创建一个新的Job实例,这样就可以规避并发访问的问题。

按照上面的三要素开始着手写代码实现。

代码实现:

第一步:pom 文件导入相对应的jar包

  
         <dependency>
             <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.1</version>
        </dependency>

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

第二步:在spring容器中注入scheduler统一调度器,当然也要配置一些scheduler的配置文件(ps:由于没有使用它的数据库配置,遂屏蔽了它的一些数据库配置文件,想用的朋友可以打开,但是要把这十一张表创建好)。

quartz.properties配置文件:

org.quartz.scheduler.instanceName = MyScheduler
org.quartz.scheduler.instanceId = AUTO
org.quartz.scheduler.rmi.export = false
org.quartz.scheduler.rmi.proxy = false
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false

#线程池配置
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 10
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

#持久化配置
#org.quartz.jobStore.misfireThreshold = 50000
#org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
#支持集群
#org.quartz.jobStore.isClustered = true
#org.quartz.jobStore.useProperties:true
#org.quartz.jobStore.clusterCheckinInterval = 15000

#使用weblogic连接Oracle驱动
#org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.oracle.weblogic.WebLogicOracleDelegate
#org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#org.quartz.jobStore.tablePrefix = QRTZ_
#org.quartz.jobStore.dataSource = qzDS
#数据源连接信息,quartz默认使用c3p0数据源可以被自定义数据源覆盖
#org.quartz.dataSource.qzDS.driver = com.mysql.cj.jdbc.Driver
#org.quartz.dataSource.qzDS.URL = jdbc:mysql://127.0.0.1:3306/makes?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
#org.quartz.dataSource.qzDS.user = root
#org.quartz.dataSource.qzDS.password = 123456
#org.quartz.dataSource.qzDS.maxConnections = 10

加载配置文件并注入scheduler调度器实例

@Configuration
public class SchedulerConfig  {

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        //获取配置属性
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        //在quartz.properties中的属性被读取并注入后再初始化对象
        propertiesFactoryBean.afterPropertiesSet();
        //创建SchedulerFactoryBean
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setQuartzProperties(propertiesFactoryBean.getObject());
        //这样当spring关闭时,会等待所有已经启动的quartz job结束后spring才能完全shutdown。
        factory.setWaitForJobsToCompleteOnShutdown(true);
        factory.setOverwriteExistingJobs(false);
        factory.setStartupDelay(1);
        return factory;
    }


    /**
     * 通过SchedulerFactoryBean获取Scheduler的实例
     */
    @Bean(name="scheduler")
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }

    /*@Bean 不要加,否则会重复加载
    public QuartzInitializerListener executorListener() {
        return new QuartzInitializerListener();
    }*/
}

第三步:创建我们的触发器Trigger 和JobDetail (即什么时候触发,触发条件是什么),我这边是把这个做成一个服务,方便其他地方动态调用,我这里只写了创建或者修改删除定时任务,比如暂停,直接调用Scheduler 里面的方法即可,都比较简单,我就不一一列举出来了

@Service
public class JobService {

    @Autowired
    private Scheduler scheduler;

    @Autowired
    private CornTriggerQuartzMapper cornTriggerQuartzMapper;


    /**
     * 新建一个任务
     *
     */
    public String updateJob(CornTriggerQuartz cornTriggerQuartz) throws SchedulerException  {

        if(cornTriggerQuartz.getQuartzTime().before(new Date())){
            return "cron time must be after now";
        }
        cornTriggerQuartz.setQuartzTime(DateUtil.afterTime(new Date(), Calendar.MINUTE,2));
        String quartzStr = DateUtil.transfToQuartzStr(cornTriggerQuartz.getQuartzTime());
        //校验定时器数据格式,表达式格式不正确
        if (!CronExpression.isValidExpression(quartzStr)) {
            return "Illegal cron expression";
        }

        JobDetail jobDetail=null;
        //构建job信息
        if(WorkOrderJob.class.getSimpleName().equals(cornTriggerQuartz.getJobGroup())) {
            jobDetail = JobBuilder.newJob(WorkOrderJob.class)
                    .withIdentity(cornTriggerQuartz.getJobName(), cornTriggerQuartz.getJobGroup()).build();
        }

        if(jobDetail == null){
            throw new SchedulerException("暂无构建的对象");
        }

        //表达式调度构建器(即任务执行的时间,不立即执行)
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder
                        .cronSchedule(quartzStr)
                        .withMisfireHandlingInstructionDoNothing();

        //按新的cronExpression表达式构建一个新的trigger
        CronTrigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(cornTriggerQuartz.getJobName(), cornTriggerQuartz.getJobGroup())
                    .startAt(cornTriggerQuartz.getQuartzTime())
                    .withSchedule(scheduleBuilder).build();

        //传递参数
        if(ObjectUtil.StringIsNotNull(cornTriggerQuartz.getInvokeParam())) {
            trigger.getJobDataMap().put(Commons.Quartz.workorder.getInvokeParamKey(),cornTriggerQuartz.getInvokeParam());
        }

        TriggerKey triggerKey = TriggerKey.triggerKey(cornTriggerQuartz.getJobName(),cornTriggerQuartz.getJobGroup());
        //如果存在则修改,不存在则插入
        if(scheduler.checkExists(jobDetail.getKey()) && scheduler.checkExists(triggerKey)){
            scheduler.rescheduleJob(triggerKey, trigger);
        }else{
            scheduler.scheduleJob(jobDetail, trigger);
        }

        if(ObjectUtil.StringIsNotNull(cornTriggerQuartz.getUuid())){
            cornTriggerQuartzMapper.updateById(cornTriggerQuartz);
        }else{
            cornTriggerQuartzMapper.insert(cornTriggerQuartz);
        }

        return "success";
    }


    /**
     * 删除某个任务
     * @return
     * @throws SchedulerException
     */
    public String  deleteJob(String jobGroupName,String jobName) throws SchedulerException {
        JobKey jobKey = new JobKey(jobName, jobGroupName);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if (jobDetail == null ) {
            return "jobDetail is null";
        }else if(!scheduler.checkExists(jobKey)) {
            return "jobKey is not exists";
        }else {
            scheduler.deleteJob(jobKey);
            return "success";
        }
    }

第四步:定时器执行时执行的方法类Job,定义一个WorkOrderJob类实现 Job接口中execute方法。

@Component
public class WorkOrderJob implements Job {

    private static final Logger log = LoggerFactory.getLogger(WorkOrderJob.class);

    @Override
    public void execute(JobExecutionContext context)  {
        log.debug("★★★★★★★★★★★"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+ "定时任务开始★★★★★★★★★★★");
        //获取定时器传输的参数
        JobDataMap jobDataMap = context.getMergedJobDataMap();
        //.....执行业务逻辑
    }
}

第五步:考虑可能发生的情况

1.有多个触发器,可以创建多个Job,但是记得在JobDeatil 中根据类型执行不同的job实现,实现比较简单,你们自行实现

2.重启之后定时任务会销毁的情况(思路:在spring容器重启之后,自动把定时任务加入到队列中)

  • 创建ApplicationStartedListener 类,实现ApplicationListener<ContextRefreshedEvent>接口中的onApplicationEvent,可以从这方法中获取spring容器的bean。

/**
 * spring容器启动监听
 * @author fangh
 */
public class ApplicationStartedListener implements ApplicationListener<ContextRefreshedEvent> {

    private static final Logger logger = LoggerFactory.getLogger(ApplicationStartedListener.class);

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {

        if(event!= null && event.getApplicationContext()!= null){

            //获取定时任务mapper对象,然后查询数据库
            CornTriggerQuartzMapper cornTriggerQuartzMapper = ApplicationContextUtil.getBean(CornTriggerQuartzMapper.class);
            JobService jobService = ApplicationContextUtil.getBean(JobService.class);
            QueryWrapper<CornTriggerQuartz> cornTriggerQuartzQueryWrapper  =new QueryWrapper<>();
            cornTriggerQuartzQueryWrapper.eq("status" , Commons.Status.pend.getCode());
            List<CornTriggerQuartz> cornTriggerQuartzList = cornTriggerQuartzMapper.selectList(cornTriggerQuartzQueryWrapper);
            cornTriggerQuartzList.stream().forEach(cornTriggerQuartz -> {
                try {
                    jobService.updateJob(cornTriggerQuartz);
                } catch (SchedulerException e) {
                    logger.error(e.getMessage());
                }
            });
        }

    }
}
  • 从容器中获取实例,封装成工具类
/**
 * spring 容器中获取注入的bean 实例
 * @author  fangh
 */
@Getter
@Setter
public class ApplicationContextUtil implements ApplicationContextAware {

    /** 用于保存ApplicationContext的引用,set方式注入*/
    private static ApplicationContext applicationContext = null ;

    @Override
    public void setApplicationContext(ApplicationContext applicationContexts) throws BeansException {
        applicationContext = applicationContexts;
    }

    /**
     * 获取spring容器中属性
     * @param cls t
     * @return
     */
    public static <T> T getBean(Class<T> cls){
        return applicationContext.getBean(cls);
    }
}

 

©️2020 CSDN 皮肤主题: 黑客帝国 设计师:上身试试 返回首页