Quartz从学习到踩坑到成功使用

Quartz从学习到使用Quartz的功能Quartz的实现Quartz任务管理类的使用示例,封装类代码放在最后任务调度管理类Quartz的功能Quartz是一个开源的定时作业框架…

Quartz从学习到使用
Quartz的功能
Quartz的实现
Quartz任务管理类的使用示例,封装类代码放在最后
任务调度管理类
Quartz的功能
Quartz是一个开源的定时作业框架,它可以用来定时去执行多个任务,只要按约定好的规则保存好Job和Trigger的相关参数,就可以非常方便直观地去控制任务的执行。

Quartz的实现
Quartz的组成主要为三部分:
1.调度器 :Quartz框架的核心是调度器。调度器负责管理Quartz应用运行时环境。调度器不是靠自己做所有的工作,而是依赖框架内一些非常重要的部件。Quartz不仅仅是线程和线程池管理。为确保可伸缩性,Quartz采用了基于多线程的架构。启动时,框架初始化一套worker线程,这套线程被调度器用来执行预定的作业。这就是Quartz怎样能并发运行多个作业的原理。Quartz依赖一套松耦合的线程池管理部件来管理线程环境。
2.任务:这个很简单,就是我们自己编写的业务逻辑,交给quartz帮我们执行 。
3.触发器:简单的讲就是调度作业,什么时候开始执行,什么时候结束执行。

 

以下是实现一个定时任务生成的代码

    @Transactional
    public void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass, String cron, Map<String, Object> params, Date startTime) {
        try {
           // 任务名,任务组,任务执行类
            JobDetail job = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
            // 任务参数
            job.getJobDataMap().putAll(params);
            // 触发器
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
            // 触发器名,触发器组
            triggerBuilder.withIdentity(triggerName, triggerGroupName);
            triggerBuilder.startAt(startTime);
            // 触发器时间设定
            triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
            // 创建触发器对象
            CronTrigger trigger = (CronTrigger) triggerBuilder.build();
            // 调度容器设置任务和触发器
            scheduler.scheduleJob(job, trigger);
            // 启动
            if (!scheduler.isShutdown()) {
                scheduler.start();
                }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
这里是调用addJob生成任务的示例,quartz是用反射类的方法去找到需要执行的任务。

像MongoTemplate这样需要new的实例,都可以通过map传给job实现类里,这样可以很好地控制连接数,如果在job实现类中new示例的话,那有一个问题是在连接信息不同的情况下不好去分辨到底想要new哪个实例,另一个问题就是MongoDB无法手动控制关闭连接(如果有大佬知道如何手动关闭,跪求指教),只能设置超时关闭,如果创建连接速度大于关闭速度的话必然会OOM

quartzManager.addJob(jobName, jobGroupName, triggerGroupName, triggerName, Class.forName(“com.tianfu.system.agent.jobs.DayEnergyCalc”), cron, map, startTime);
1
以下是一个实现Job接口的实现类

@Component
public class ExecuteRulesJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
      System.out.println(“hellow world”);
    }
Quartz任务管理类的使用示例,封装类代码放在最后
@Service
public class QuartzServiceImpl implements IQuartzService {
    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;
    @Override
    @SneakyThrows
    public void StartSchedulerByDayEnergy(String jobName, String jobGroupName,String triggerName, String triggerGroupName, String cron,String tenantCode, String targetApp,Date startTime,Integer SourceType) {
        long first = TimeUtil.getSimpledateParse(TimeUtil.getNextExecTime(cron,2).get(0)).getTime()/1000;
        long second =TimeUtil.getSimpledateParse(TimeUtil.getNextExecTime(cron,2).get(1)).getTime()/1000;
        Integer timerCronInterval=new Long(second-first).intValue();
        Map<String,Object> map=new HashMap<>();
        map.put(“tenantCode”,tenantCode);
        map.put(“targetApp”,targetApp);
        map.put(“timerCronInterval”,timerCronInterval);
        Scheduler scheduler= schedulerFactoryBean.getScheduler();
        QuartzManager quartzManager=new QuartzManager(scheduler);
        String sourceType= TDatabaseType.getDatabaseType(SourceType).toString();
        if (sourceType== TDatabaseType.MySql.getValue()) {
            quartzManager.addJob(jobName, jobGroupName, triggerGroupName, triggerName, Class.forName(“com.tianfu.system.agent.jobs.ExecuteRulesJob”), cron, map, startTime);
        }
        else if (sourceType==TDatabaseType.MongoDB.getValue())
        {
            quartzManager.addJob(jobName, jobGroupName, triggerGroupName, triggerName, Class.forName(“com.tianfu.system.agent.jobs.ExecuteRulesByCommWay”), cron, map, startTime);
        }
    }

## 无法在Job实现类中使用@Autowired注入Servivce的解决方案
Quartz的JobFactory是不交给springboot管理的,因此在它的实现方法里就无法注入Spring的Service了,解决方法就是重写一下JobFactory里的方法,把它交给Spring管理

“`java
@Component
public class JobFactory extends AdaptableJobFactory {
    @Autowired
    private AutowireCapableBeanFactory factory;

    public JobFactory(AutowireCapableBeanFactory factory){
        this.factory=factory;
    }

    @Override
    @SneakyThrows
    protected Object createJobInstance(TriggerFiredBundle bundle){
        // 实例化对象
        Object job = super.createJobInstance(bundle);
        // 进行注入(Spring管理该Bean)
        factory.autowireBean(job);
        //返回对象
        return job;
    }
}
@Configuration
public class QuartzConfig {

    private JobFactory jobFactory;
    public QuartzConfig(JobFactory jobFactory){
        this.jobFactory = jobFactory;
    }
    /**
     * 配置SchedulerFactoryBean
     *
     * 将一个方法产生为Bean并交给Spring容器管理
     */
    @Bean(name=”SchedulerFactory”)
    @SneakyThrows
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setAutoStartup(true);
//注意这里是重点
        factory.setJobFactory(jobFactory);
        return factory;
    }

    @Bean(name=”scheduler”)
    public Scheduler scheduler(){
        return schedulerFactoryBean().getScheduler();
    }
}
创建一个包写上这两个类就可以确保Service正常注入使用了。

任务调度管理类
package com.tianfu.system.agent.quartzManager;

import org.quartz.*;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.Map;

@Service
public class QuartzManager {

    private Scheduler scheduler;

    public QuartzManager(Scheduler scheduler) {
        this.scheduler = scheduler;
    }

    /**
     * 添加一个定时任务
     *
     * @param jobName          任务名
     * @param jobGroupName     任务组名
     * @param triggerName      触发器名
     * @param triggerGroupName 触发器组名
     * @param jobClass         任务
     * @param cron             时间设置,参考quartz说明文档
     */
    @SuppressWarnings({“unchecked”, “rawtypes”})
    @Transactional
    public void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass, String cron, Map<String, Object> params, Date startTime) {
        try {
            // 任务名,任务组,任务执行类
            JobDetail job = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
            // 任务参数
            job.getJobDataMap().putAll(params);
            // 触发器
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
            // 触发器名,触发器组
            triggerBuilder.withIdentity(triggerName, triggerGroupName);
            triggerBuilder.startAt(startTime);
            // 触发器时间设定
            triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
            // 创建Trigger对象
            CronTrigger trigger = (CronTrigger) triggerBuilder.build();
            // 调度容器设置JobDetail和Trigger
            scheduler.scheduleJob(job, trigger);
            // 启动
            if (!scheduler.isShutdown()) {
                scheduler.start();

            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 修改一个任务的触发时间
     *
     * @param triggerName      触发器名
     * @param triggerGroupName 触发器组名
     * @param cron             时间设置,参考quartz说明文档
     */
    public void modifyJobTime(String triggerName, String triggerGroupName, String cron) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            if (trigger == null) {
                return;
            }

            String oldTime = trigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(cron)) {
                // 触发器
                TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
                // 触发器名,触发器组
                triggerBuilder.withIdentity(triggerName, triggerGroupName);
                triggerBuilder.startNow();
                // 触发器时间设定
                triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
                // 创建Trigger对象
                trigger = (CronTrigger) triggerBuilder.build();
                // 方式一 :修改一个任务的触发时间
                scheduler.rescheduleJob(triggerKey, trigger);

            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 移除一个任务
     *
     * @param jobName          任务名
     * @param jobGroupName     任务组名
     * @param triggerName      触发器名
     * @param triggerGroupName 触发器组名
     */
    public void removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            // 停止触发器
            scheduler.pauseTrigger(triggerKey);
            // 移除触发器
            scheduler.unscheduleJob(triggerKey);
            // 删除任务
            scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取任务是否存在
     * <p>
     * STATE_BLOCKED 4 阻塞
     * STATE_COMPLETE 2 完成
     * STATE_ERROR 3 错误
     * STATE_NONE -1 不存在
     * STATE_NORMAL 0 正常
     * STATE_PAUSED 1 暂停
     */
    public Boolean notExists(String triggerName, String triggerGroupName) {
        try {
            return scheduler.getTriggerState(TriggerKey.triggerKey(triggerName, triggerGroupName)) == Trigger.TriggerState.NONE;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
————————————————
版权声明:本文为CSDN博主「ChriszStathum」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/weixin_43866922/article/details/104000495

作者: admin

为您推荐

返回顶部