quartz 项目整合Springboot

最新推荐文章于 2024-07-27 07:45:00 发布

老马回头不吃草

最新推荐文章于 2024-07-27 07:45:00 发布

阅读量1.9k

点赞数 4

分类专栏： JAVA基础

本文链接：https://blog.csdn.net/u014533485/article/details/106494124

版权

JAVA基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

quartz 项目整合Springboot

首先在项目中定时器是用的比较多的需求，如果不希望整合太多的第三方组件或者是项目中任务比较少完全可以使用spring自带的任务Scheduled。

1,首先需要整合quartz

在POM文件中添加

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>

2，配置quartz 配置类

@Configuration
public class QuartzConfiguration {

    //配置JobFactory
    @Bean
    public JobFactory jobFactory(ApplicationContext applicationContext) {
        AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
        jobFactory.setApplicationContext(applicationContext);
        return jobFactory;
    }
    /**
     * SchedulerFactoryBean这个类的真正作用提供了对org.quartz.Scheduler的创建与配置，并且会管理它的生命周期与Spring同步。
     * org.quartz.Scheduler: 调度器。所有的调度都是由它控制。
     * @param dataSource 为SchedulerFactory配置数据源
     * @param jobFactory 为SchedulerFactory配置JobFactory
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource, JobFactory jobFactory) throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        //可选,QuartzScheduler启动时更新己存在的Job,这样就不用每次修改targetObject后删除qrtz_job_details表对应记录
        factory.setOverwriteExistingJobs(true);
        factory.setAutoStartup(true); //设置自行启动
        factory.setDataSource(dataSource);
        factory.setJobFactory(jobFactory);
        factory.setQuartzProperties(quartzProperties());
        return factory;
    }
    //从quartz.properties文件中读取Quartz配置属性
    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }
    //配置JobFactory,为quartz作业添加自动连接支持
    public final class AutowiringSpringBeanJobFactory 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;
        }
    }
}

配置quartz.properties，DataSource名称

org.quartz.jobStore.dataSource = dataSource
#ID设置为自动获取 每一个必须不同 （所有调度器实例中是唯一的）
org.quartz.scheduler.instanceId=AUTO
#指定调度程序的主线程是否应该是守护线程
org.quartz.scheduler.makeSchedulerThreadDaemon=true
#ThreadPool实现的类名
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
#ThreadPool配置线程守护进程
org.quartz.threadPool.makeThreadsDaemons=true
#线程数量
org.quartz.threadPool.threadCount:20
#线程优先级
org.quartz.threadPool.threadPriority:5
#数据保存方式为持久化
org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
#StdJDBCDelegate说明支持集群
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#quartz内部表的前缀
org.quartz.jobStore.tablePrefix=QRTZ_
#是否加入集群
org.quartz.jobStore.isClustered=true
#容许的最大作业延长时间
org.quartz.jobStore.misfireThreshold=25000

3,引入数据库

官网：http://www.quartz-scheduler.org/

下载下来找到自己合适的数据库表，导入数据库就可以了。

另外我们还需要建一个任务表，用来管理我们创建的任务。

4，开始启动任务

定义JOB初始化方法，即从数据库获取job任务

package com.gd.app.job;


import com.gd.activiti.frame.quartz.service.JobService;
import com.gd.app.dao.JobEntityMapper;
import com.gd.app.pojo.JobEntity;
import lombok.extern.log4j.Log4j2;
import org.quartz.DisallowConcurrentExecution;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.List;

@Component
@Log4j2
@DisallowConcurrentExecution
public class InitJob {

    @Autowired
    private JobService jobService;

    @Resource
    private JobEntityMapper jobEntityMapper;


    @PostConstruct
    public void initJob() throws Exception{
        List<JobEntity> jobEntities = jobEntityMapper.selectAllJob();
        jobEntities.forEach(jobEntity -> {
            try {
                jobService.addJob(entity);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("任务创建失败");
            }
        });

    }

}

查看具体处理类包含添加任务，暂停任务，启动一次，重设任务等。。

@Service
@DisallowConcurrentExecution
public class JobServiceImpl implements JobService {

    private final Scheduler scheduler;

    Logger logger = LoggerFactory.getLogger(JobServiceImpl.class);



    @Autowired
    public JobServiceImpl(SchedulerFactoryBean schedulerFactoryBean) {
        this.scheduler = schedulerFactoryBean.getScheduler();
    }



    @Override
    public void addJob(JobEntity form) throws Exception {


        if(scheduler.checkExists(JobKey.jobKey(form.getJobClassName(), form.getJobGroupName()))){
            return;
        }
        // 启动调度器
        scheduler.start();
        // 构建Job信息
        JobDetail jobDetail = JobBuilder.newJob(JobUtil.getClass(form.getJobClassName()).getClass()).
                withIdentity(form.getJobClassName(), form.getJobGroupName()).build();

        // Cron表达式调度构建器(即任务执行的时间)
        CronScheduleBuilder cron = CronScheduleBuilder.cronSchedule(form.getCronExpression());

        //根据Cron表达式构建一个Trigger
        CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(form.getJobClassName(), form.getJobGroupName()).withSchedule(cron).build();


        try {
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (SchedulerException e) {
            throw new ServiceErrorException("quartz.job.create");
        }
    }

    @Override
    public void deleteJob(JobEntity form) throws SchedulerException {
        scheduler.pauseTrigger(TriggerKey.triggerKey(form.getJobClassName(), form.getJobGroupName()));
        scheduler.unscheduleJob(TriggerKey.triggerKey(form.getJobClassName(), form.getJobGroupName()));
        scheduler.deleteJob(JobKey.jobKey(form.getJobClassName(), form.getJobGroupName()));
    }

    @Override
    public void startOnce(JobEntity form) throws Exception {
        TriggerKey triggerKey = new TriggerKey(form.getJobClassName(), form.getJobGroupName());
        Trigger trigger = scheduler.getTrigger(triggerKey);
        scheduler.triggerJob(trigger.getJobKey());
    }

    @Override
    public String getJobState(JobEntity form) throws SchedulerException {

        TriggerKey triggerKey = new TriggerKey(form.getJobClassName(), form.getJobGroupName());
        return scheduler.getTriggerState(triggerKey).name();
    }

    @Override
    public void pauseJob(JobEntity form) throws SchedulerException {
        scheduler.pauseJob(JobKey.jobKey(form.getJobClassName(), form.getJobGroupName()));
    }

    @Override
    public void resumeJob(JobEntity form) throws SchedulerException {

        scheduler.resumeJob(JobKey.jobKey(form.getJobClassName(), form.getJobGroupName()));
    }

    @Override
    public void cronJob(JobEntity form) throws Exception {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(form.getJobClassName(), form.getJobGroupName());
            // 表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(form.getCronExpression()).withMisfireHandlingInstructionDoNothing();

            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

            // 根据Cron表达式构建一个Trigger
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

            // 按新的trigger重新设置job执行
            scheduler.rescheduleJob(triggerKey, trigger);
        } catch (SchedulerException e) {
            throw new ServiceErrorException("quartz.job.create");
        }
    }

    @Override
    public void createJob(JobEntity form) throws Exception {
        TriggerKey triggerKey = TriggerKey.triggerKey(form.getJobClassName(), form.getJobGroupName());
        // 判断定时任务是否存在
        if (scheduler.checkExists(triggerKey)) {
            cronJob(form);
        } else {
            addJob(form);
        }
    }

    @Override
    public JobEntity createJob(String oldCron, String newCron, String message, String className, String groupName) throws Exception {
        JobEntity  JobEntity = new JobEntity();
        JobEntity.setJobClassName(className);
        JobEntity.setJobGroupName(groupName);
        if (CronExpression.isValidExpression(newCron)) {
            // 记录cron
            oldCron = newCron;
        } else {
            logger.error(message);
        }
        JobEntity.setCronExpression(oldCron);
        createJob(JobEntity);
        return  JobEntity;
    }
}

看一下具体的实现效果