Spring中Quartz的配置

Posted 2023-04-11

参考技术A

　　Quartz是一个强大的企业级任务调度框架 Spring中继承并简化了Quartz 下面就看看在Spring中怎样配置Quartz:

　　首先我们来写一个被调度的类:

　　package kay quartz;

　　public class QuartzJob

　　

　　public void work()

　　

　　System out println( Quartz的任务调度!!! );

　　

　　Spring的配置文件:

　　<?xml version= encoding= UTF ?>

　　<!DOCTYPE beans PUBLIC //SPRING//DTD BEAN//EN /dtd/spring beans dtd >

　　<beans>

　　<! 要调用的工作类 >

　　<bean id= quartzJob class= kay quartz QuartzJob ></bean>

　　<! 定义调用对象和调用对象的方法 >

　　<bean id= jobtask class= springframework scheduling quartz MethodInvokingJobDetailFactoryBean >

　　<! 调用的类 >

　　<property name= targetObject >

　　<ref bean= quartzJob />

　　</property>

　　<! 调用类中的方法 >

　　<property name= targetMethod >

　　<value>work</value>

　　</property>

　　</bean>

　　<! 定义触发时间 >

　　<bean id= doTime class= springframework scheduling quartz CronTriggerBean >

　　<property name= jobDetail >

　　<ref bean= jobtask />

　　</property>

　　<! cron表达式 >

　　<property name= cronExpression >

　　<value> * * * * ?</value>

　　</property>

　　</bean>

　　<! 总管理类 如果将lazy init= false 那么容器启动就会执行调度程序  >

　　<bean id= startQuertz lazy init= false autowire= no class= springframework scheduling quartz SchedulerFactoryBean >

　　<property name= triggers >

　　<list>

　　<ref bean= doTime />

　　</list>

　　</property>

　　</bean>

　　</beans>测试程序:

　　package kay quartz;

　　import ntext ApplicationContext;

　　import ntext support ClassPathXmlApplicationContext;

　　public class MainTest

　　

　　/**

　　* @param args

　　*/

　　public static void main(String[] args)

　　

　　System out println( Test start );

　　ApplicationContext context = new ClassPathXmlApplicationContext( quartz config xml );

　　//如果配置文件中将startQuertz bean的lazy init设置为false 则不用实例化

　　//context getBean( startQuertz );

　　System out print( Test end );

　　

　　我们需要把log j的配置文件放入src目录下 启动main类就可以了

　　关于cron表达式(来自网络):

　　Cron 表达式包括以下 个字段:

　　秒

　　分

　　小时

　　月内日期

　　月

　　周内日期

　　年(可选字段)

　　特殊字符

　　Cron 触发器利用一系列特殊字符 如下所示:

　　反斜线(/)字符表示增量值 例如 在秒字段中 / 代表从第 秒开始 每 秒一次

　　问号(?)字符和字母 L 字符只有在月内日期和周内日期字段中可用 问号表示这个字段不包含具体值 所以 如果指定月内日期 可以在周内日期字段中插入 ? 表示周内日期值无关紧要 字母 L 字符是 last 的缩写 放在月内日期字段中 表示安排在当月最后一天执行 在周内日期字段中 如果 L 单独存在 就等于 否则代表当月内周内日期的最后一个实例 所以 L 表示安排在当月的最后一个星期日执行

　　在月内日期字段中的字母(W)字符把执行安排在最靠近指定值的工作日 把 W 放在月内日期字段中 表示把执行安排在当月的第一个工作日内

　　井号(#)字符为给定月份指定具体的工作日实例 把 MON# 放在周内日期字段中 表示把任务安排在当月的第二个星期一

　　星号(*)字符是通配字符 表示该字段可以接受任何可能的值

　　字段 允许值 允许的特殊字符

　　秒 * /

　　分 * /

　　小时 * /

　　日期 * ? / L W C

　　月份 或者 JAN DEC * /

　　星期 或者 SUN SAT * ? / L C #

　　年(可选) 留空 * /

　　表达式意义

　　 * * ? 每天中午 点触发

　　 ? * * 每天上午 : 触发

　　 * * ? 每天上午 : 触发

　　 * * ? * 每天上午 : 触发

　　 * * ? 年的每天上午 : 触发

　　 * * * ? 在每天下午 点到下午 : 期间的每 分钟触发

　　 / * * ? 在每天下午 点到下午 : 期间的每 分钟触发

　　 / * * ? 在每天下午 点到 : 期间和下午 点到 : 期间的每 分钟触发

　　 * * ? 在每天下午 点到下午 : 期间的每 分钟触发

　　 ? WED 每年三月的星期三的下午 : 和 : 触发

　　 ? * MON FRI 周一至周五的上午 : 触发

　　 * ? 每月 日上午 : 触发

　　 L * ? 每月最后一日的上午 : 触发

　　 ? * L 每月的最后一个星期五上午 : 触发

　　 ? * L 年至 年的每月的最后一个星期五上午 : 触发

　　 ? * # 每月的第三个星期五上午 : 触发

　　每天早上 点

　　 * * *

　　每两个小时

　　 */ * * *

　　晚上 点到早上 点之间每两个小时 早上八点

　　 / * * *

　　每个月的 号和每个礼拜的礼拜一到礼拜三的早上 点

　　 *

　　 月 日早上 点

lishixinzhi/Article/program/Java/ky/201311/28782

Spring Boot集成Quartz注入Spring管理的类

摘要: 在Spring Boot中使用Quartz时，在JOB中一般需要引用Spring管理的Bean，通过定义Job Factory实现自动注入。

Spring有自己的Schedule定时任务，在Spring boot中使用的时候，不能动态管理JOB，于是就使用Quartz来实现。

在Spring Boot中配置Quartz：

import java.io.IOException;
import java.util.Properties;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

@Configuration
@EnableScheduling
public class QuartzSchedule {

    @Autowired
    private MyJobFactory myJobFactory;

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();

        factory.setOverwriteExistingJobs(true);

        // 延时启动
        factory.setStartupDelay(20);

        // 加载quartz数据源配置
        factory.setQuartzProperties(quartzProperties());

        // 自定义Job Factory，用于Spring注入
        factory.setJobFactory(myJobFactory);

        return factory;
    }

    /**
     * 加载quartz数据源配置
     * 
     * @return
     * @throws IOException
     */
    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

}

 

为了在JOB中使用Spring管理的Bean，需要重新定义一个Job Factory：

@Component
public class MyJobFactory extends AdaptableJobFactory {
    
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        // 调用父类的方法
        Object jobInstance = super.createJobInstance(bundle);
        // 进行注入
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

 

然后在JOB中就可以使用Spring管理的Bean了

public class MyJob implements Job, Serializable {
    private static final long serialVersionUID = 1L;
    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private SomeService someService;

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        someService.doSomething();
    }
}

 

下面代码是创建JOB：

JobDetail jobDetail = JobBuilder.newJob(((Job) Class.forName(job.getClazz()).newInstance()).getClass())
                    .withIdentity(job.getJobName(), job.getJobGroup()).build();
            jobDetail.getJobDataMap().put("extdata", job.getExtData());

            // 表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression())
                    .withMisfireHandlingInstructionDoNothing();
            // 构建一个trigger
            TriggerBuilder<CronTrigger> triggerBuilder = TriggerBuilder.newTrigger().withIdentity(triggerKey)
                    .withSchedule(scheduleBuilder);
            if (job.getStartTime() != null) {
                triggerBuilder.startAt(job.getStartTime());
            }
            if (job.getEndTime() != null) {
                triggerBuilder.endAt(job.getEndTime());
            }
            CronTrigger trigger = triggerBuilder.build();

            scheduler.scheduleJob(jobDetail, trigger);// 注入到管理类

 

 https://my.oschina.net/hhaijun/blog/698498