13.SpringBoot2 整合Quartz2(二)

桃扇骨 2022-02-20 08:36 207阅读 0赞

## 3. spring整合quartz ##

### 3.1 创建Quartz配置类 ###

创建QuartzConfig.java, 解析quartz.properties配置文件, 并向spring容器中注入调度器bean

/** * @Description: quartz 框架整合配置 * @author: zongf * @date: 2019-03-13 16:31 */
    @Configuration
    public class QuartzConfig { 
    
        public static final String JOB_BEAN_NAME = "jobBeanName";
    
        // 注册quartz 调度器工厂
        @Bean
        public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource) throws IOException { 
           // 解析配置
           PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
           propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
           propertiesFactoryBean.afterPropertiesSet();
    
           SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
    
           // 设置应用启动后, 自动开始调度任务
           schedulerFactoryBean.setAutoStartup(true);
           // 设置属性信息
           schedulerFactoryBean.setQuartzProperties(propertiesFactoryBean.getObject());
           // 设置数据源
           schedulerFactoryBean.setDataSource(dataSource);
           // 可以设置spring上下文key, 在job的execute 方法中可以通过次此key获取到ApplicationContext 对象, 但是每次都获取比较麻烦, 笔者抽象出了工具类
           // JobExecutionContext.getScheduler().getContext().get("applicationContextKey");
           // schedulerFactoryBean.setApplicationContextSchedulerContextKey("applicationContextKey");
    
           return schedulerFactoryBean;
        }
    }

### 3.2 参考spring补丁程序, 自定义整合相关类 ###

*  由于spring框架bug, 导致MethodInvokingJobDetailFactoryBean 不能进行持久化, 因此笔者结合spring 官方提供的补丁程序, 进行了重构.
 *  官方提供的补丁不支持2.x版本次quartz, 因此需要修改
 *  官方补丁程序: https://jira.spring.io/secure/attachment/12821/BeanInvokingJobDetailFactoryBean.java

\*\* BeanMethodInvokingJob.java \*\*

/** * @Description: 定时任务执行类, 允许并发执行 * @author: zongf * @date: 2019-04-11 11:12 */
    public class BeanMethodInvokingJob implements Job { 
    
        protected Logger logger = LoggerFactory.getLogger(getClass());
    
        public void execute(JobExecutionContext context) throws JobExecutionException { 
    
            try { 
                // 获取目标bean 和 目标方法
                String targetBean = context.getMergedJobDataMap().getString("targetBean");
                String targetMethod = context.getMergedJobDataMap().getString("targetMethod");
    
                // 参数校验
                if(targetBean==null) throw new JobExecutionException("targetBean cannot be null.", false);
                if(targetMethod==null) throw new JobExecutionException("targetMethod cannot be null.", false);
    
                // when org.quartz.jobStore.useProperties=="true" the arguments entry (which should be an Object[]) in the JobDataMap gets converted into a String.
                Object argumentsObject = context.getMergedJobDataMap().get("arguments");
                Object[] arguments = (argumentsObject instanceof String) ? null : (Object[])argumentsObject;
    
                // 从spring容器获取bean
                Object bean = ApplicationUtil.getBean(targetBean);
                if (bean == null) throw new JobExecutionException("spring bean not exsists !", false);
    
                // 设置方法参数并调用
                MethodInvoker beanMethod = new MethodInvoker();
                beanMethod.setTargetObject(bean);
                beanMethod.setTargetMethod(targetMethod);
                beanMethod.setArguments(arguments);
                beanMethod.prepare();
                logger.info("Invoking Bean: "+targetBean+"; Method: "+targetMethod+"; arguments: "+arguments+";");
                beanMethod.invoke();
            }
            catch(JobExecutionException e) { 
                throw e;
            }
            catch(Exception e) { 
                throw new JobExecutionException(e);
            }
        }
    }
    
    /** * @Description: 定时任务执行类, 禁止并发执行. * @author: zongf * @date: 2019-04-11 11:12 */
    @DisallowConcurrentExecution
    class BeanMethodInvokingJobStateful extends BeanMethodInvokingJob { 
    }

\*\*\* BeanMethodInvokingJobDetailFactoryBean.java \*\*\*

/** * @Description: 任务详情工厂类 * @author: zongf * @date: 2019-04-11 11:12 */
    public class BeanMethodInvokingJobDetailFactoryBean
            implements FactoryBean<JobDetailImpl>,InitializingBean { 
    
        private Logger logger = LoggerFactory.getLogger(getClass());
    
        // spring容器中bean名称, 也是此任务的jobName
        private String name;
    
        // 分组名称
        private String group = Scheduler.DEFAULT_GROUP;
    
        // 是否允许并发
        private boolean concurrent = true;
    
        // 出现故障时,是否恢复执行.此参数暂未发觉如何使用
        private boolean shouldRecover = false;
    
        // 任务详情
        private JobDetailImpl jobDetail;
    
        // 目标bean
        private String targetBean;
    
        // 目标方法
        private String targetMethod;
    
        // 目标方法参数
        private Object[] arguments;
    
        // 任务描述
        private String description;
    
        // 省略setters and getters...
    
        public void afterPropertiesSet(){ 
            jobDetail = new JobDetailImpl();
            jobDetail.setName(name);
            jobDetail.setGroup(group);
            jobDetail.setJobClass(concurrent ? BeanMethodInvokingJob.class : BeanMethodInvokingJobStateful.class);
            jobDetail.setDescription(description);
            jobDetail.setRequestsRecovery(shouldRecover);
            jobDetail.getJobDataMap().put("targetBean", targetBean);
            jobDetail.getJobDataMap().put("targetMethod", targetMethod);
            jobDetail.getJobDataMap().put("arguments", arguments);
        }
    }

### 3.3 创建spring容器初始化监听器, 统一注册定时任务 ###

笔者希望能在spring容器初始化完成之后, 对所有定时任务统一注册. 因此采用监听器的方式处理

/** * @Description: quartz 监听spring容器初始化完成. spring容器初始化完成后, 初始化定时任务 * @author: zongf * @date: 2019-04-11 11:59 */
    @Component
    public class ApplicationListenerForQuartz implements ApplicationListener<ContextRefreshedEvent> { 
    
        Logger logger = LoggerFactory.getLogger(getClass());
    
        @Override
        public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) { 
    
            // 获取spring 上下文
            ApplicationContext applicationContext = contextRefreshedEvent.getApplicationContext();
    
            // 获取quartz 调度器, 采用工厂类方式注入, 实则是Scheduler对象
            Scheduler scheduler = (Scheduler) applicationContext.getBean("schedulerFactoryBean");
    
            // 获取所有Trigger 类型的bean, 准备调度
            Map<String, Trigger> triggers = applicationContext.getBeansOfType(Trigger.class);
    
            for (Trigger trigger : triggers.values())
                try { 
    
                    // 获取trigger 关联的job bean
                    String jobBeanName = (String) trigger.getJobDataMap().get(QuartzConfig.JOB_BEAN_NAME);
                    JobDetail jobDetail = ApplicationUtil.getBean(jobBeanName, JobDetail.class);
    
                    // 转换trigger为hashSet, 否则不能进行覆盖
                    HashSet<Trigger> hashSet = new HashSet<>();
                    hashSet.add(trigger);
    
                    // 使用这个API,进行覆盖, 直接设置SchedulerFactoryBean.setOverwriteExistingJobs(true); 不生效.
                    scheduler.scheduleJob(jobDetail, hashSet, true);
    
                } catch (SchedulerException e) { 
                    throw new RuntimeException(e);
                }
        }
    }

## 4. 开发定时任务 ##

### 4.1 创建普通类, 并注册为spring的组件 ###

/** * @Description: 普通定时任务 * @author: zongf * @date: 2019-04-11 11:36 */
    @Component
    public class HelloTask { 
    
        private int times = 0;
    
        public void sayHello() throws InterruptedException { 
    
            times = times +1;
    
            System.out.println(LocalDateTime.now() + "-" + getClass().getName() + "-" + times + "-hello-start");
    
            // 模拟定时任务耗时, 可以测试定时任务并发性
            Thread.sleep(5000l);
    
            System.out.println(LocalDateTime.now() + "-" + getClass().getName() + "-" + times + "-hello-ended");
        }
    }

### 4.2 将spring bean的方法注册作为定时任务 ###

/** * @Description: quartz 定时任务配置. 定时任务job与触发器trigger 应成对出现.命名规则, 任务:xxxJob, 触发器:xxxTrigger * @author: zongf * @date: 2019-03-13 16:31 */
    @Configuration
    public class QuartzTaskConfig { 
    
        public static final String JOB_BEAN_NAME = "jobBeanName";
    
    
        // 方法名为bean 名称
        @Bean
        public BeanMethodInvokingJobDetailFactoryBean helloJob() throws Exception{ 
            BeanMethodInvokingJobDetailFactoryBean jobDetailFactoryBean = new BeanMethodInvokingJobDetailFactoryBean();
    
            /*************** 必要属性设置 ***************/
            // 设置任务名称, 必须设置
            jobDetailFactoryBean.setName("helloJob");
            // 设置spring容器中bean名称, 执行任务时会从spring容器中获取bean
            jobDetailFactoryBean.setTargetBean("helloTask");
            // 设置目标bean的目标方法, 会反射执行方法
            jobDetailFactoryBean.setTargetMethod("sayHello");
            // 设置是否允许并发,默认允许并发. 禁止并发是指当前定时任务未完成时, 不允许触发第二次同一任务
            jobDetailFactoryBean.setConcurrent(false);
            // 设置目标方法参数
            jobDetailFactoryBean.setArguments(null);
    
            /*************** 非必要属性设置 ***************/
            // 设置任务分组名称, 默认为DEFAULT
            jobDetailFactoryBean.setGroup("group1");
            // 设置任务描述, 建议设置
            jobDetailFactoryBean.setDescription("This is hello job!");
            return jobDetailFactoryBean;
        }
    
        // 方法名为bean名称
        @Bean
        public CronTriggerFactoryBean helloTrigger() throws Exception { 
    
            CronTriggerFactoryBean triggerFactoryBean = new CronTriggerFactoryBean();
    
            /*************** 必要属性设置 ***************/
            // 设置触发器名称
            triggerFactoryBean.setName("helloTrigger");
            // 设置触发器表达式
            triggerFactoryBean.setCronExpression("0/3 * * * * ?");
            // 设置任务对象,其实是为了设置任务的jobKey, 绑定触发器和定时任务的关系
            triggerFactoryBean.setJobDetail(helloJob().getObject());
            // 设置触发器绑定的定时任务bean名称
            triggerFactoryBean.getJobDataMap().put(JOB_BEAN_NAME, "helloJob");
    
            /*************** 非必要属性设置 ***************/
            // 设置触发器分组, 默认DEFAULT
            triggerFactoryBean.setGroup("group1");
            // 设置定时任务描述
            triggerFactoryBean.setDescription("This is trigger for hello!");
            // 设置定时任务优先级, 默认为5
            triggerFactoryBean.setPriority(5);
            return triggerFactoryBean;
        }
    
    }

## 5. 运行结果 ##

### 5.1 允许并发时 ###

设置: jobDetailFactoryBean.setConcurrent(true);

2019-04-11T16:25:34.948-org.zongf.learn.quartz.l021.jobs.HelloTask-1-hello-start
    2019-04-11T16:25:36.012-org.zongf.learn.quartz.l021.jobs.HelloTask-2-hello-start
    2019-04-11T16:25:39.012-org.zongf.learn.quartz.l021.jobs.HelloTask-3-hello-start
    2019-04-11T16:25:39.948-org.zongf.learn.quartz.l021.jobs.HelloTask-3-hello-ended
    2019-04-11T16:25:41.012-org.zongf.learn.quartz.l021.jobs.HelloTask-3-hello-ended
    2019-04-11T16:25:42.012-org.zongf.learn.quartz.l021.jobs.HelloTask-4-hello-start
    2019-04-11T16:25:44.012-org.zongf.learn.quartz.l021.jobs.HelloTask-4-hello-ended

### 5.2 禁止并发时 ###

设置: jobDetailFactoryBean.setConcurrent(false);

2019-04-11T16:26:27.144-org.zongf.learn.quartz.l021.jobs.HelloTask-1-hello-start
    2019-04-11T16:26:32.145-org.zongf.learn.quartz.l021.jobs.HelloTask-1-hello-ended
    2019-04-11T16:26:32.180-org.zongf.learn.quartz.l021.jobs.HelloTask-2-hello-start
    2019-04-11T16:26:37.180-org.zongf.learn.quartz.l021.jobs.HelloTask-2-hello-ended
    2019-04-11T16:26:37.203-org.zongf.learn.quartz.l021.jobs.HelloTask-3-hello-start
    2019-04-11T16:26:42.203-org.zongf.learn.quartz.l021.jobs.HelloTask-3-hello-ended
    2019-04-11T16:26:42.233-org.zongf.learn.quartz.l021.jobs.HelloTask-4-hello-start
    2019-04-11T16:26:47.234-org.zongf.learn.quartz.l021.jobs.HelloTask-4-hello-ended