Spring整合Quartz 实现定时job任务

最新推荐文章于 2024-07-24 14:21:39 发布

万米高空

最新推荐文章于 2024-07-24 14:21:39 发布

阅读量4k

点赞数 2

分类专栏：定时任务quartz和Scheduled 文章标签： quartz 定时任务-quartz的使用

本文链接：https://blog.csdn.net/zhanglf02/article/details/75041077

版权

定时任务quartz和Scheduled 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

接触定时轮循任务也有半年了，也不太常用，就记录下来做个备注，今天重新搭建的环境，一步步从头来，又发现几点新东西。实现定时轮循的方式有两种，一种是用：MethodInvokingJobDetailFactoryBean，两一种是用：JobDetailBean.这里就对着两种的使用情况进行具体应用。最后给上二者的区别点。

环境：maven3.0+spring4.0.+quartz1.8.5+jdk1.7

本例的目录结构先给上供参考：

这里写图片描述

1.搭建maven项目后，引入pom.xm对项目的支持。这里需要引入的spring jar包有这三个，缺一不可。spring-context-support,spring-web,spring-tx。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.zhanglf.cn</groupId>
    <artifactId>springQuarztDemo</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>springQuarztDemo Maven Webapp</name>
    <url>http://maven.apache.org</url>

    <properties>
        <spring.version>4.0.2.RELEASE</spring.version>
    </properties>
    <dependencies>
        <!--引入定时任务quartz依赖 -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>1.8.5</version>
        </dependency>

        <!-- Spring-context的扩展支持,用于MVC方面 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>springQuarztDemo</finalName>
    </build>
</project>

2.引入定时任务的配置quartz-job.xml.这里配置了上述的两种方式的job任务。也便于区分二者配置上的不同点。本项目配置不多，加上web.xml上有一些引入spring容器用来注入和加载我们的quartz-job.xml文件的配置外就没有了。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context-4.1.xsd">

    <!-- 扫包，注入service层 -->
    <context:component-scan base-package="com.zhanglf" />

    <!--*******************@第一种job********************** -->
    <!-- 我定义了一个对象和它对象的方法，如果我们需要把它封装成一个job，就把类名和对应的方法穿进去就行了，这里用name或者id来唯一标志一个bean都是可以的。 -->
    <bean name="printJob" class="com.zhanglf.quartz.MethodInvokingJobDetileFactoryBeanPrintJob"></bean>
    <!-- 第一种定时轮循的方法是用 MethodInvokingJobDetileFactoryBean。这种是最简单的 -->
    <bean name="autoPrintJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject">
            <ref bean="printJob" /><!-- 指定自定义类 -->
        </property>
        <property name="targetMethod">
            <value>sayHello</value><!-- 指定方法名 -->
        </property>
        <!-- 配置是否阻塞线程，即一个一个的调用，还是不等第一个完成就可以执行第二个，false表示阻塞执行。多个job不会并发执行，第二个不会再第一个job完成前执行 ，第二种方式没有这种配置-->
        <property name="concurrent" value="false" />
    </bean>

    <!-- 定时触发器 -->
    <bean id="autoPrintJobCronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
        <property name="jobDetail">
            <ref bean="autoPrintJob" />
        </property>
        <property name="cronExpression">
            <value>0/20 * * * * ?</value><!-- 每20秒执行一次 -->
        </property>
    </bean>
    <!--*******************@第一种job********************** 自定义任务类,这里就做个打印吧 -->

    <!-- 第二种定时轮循的方法是用 JobDetileBean。这种不用单独声明自定义类了。直接在属性中赋值为对应类，然后就会走默认的实现方法executeInternal。 -->
    <bean name="autoShowJob" class="org.springframework.scheduling.quartz.JobDetailBean">
        <property name="jobClass">
            <value>com.zhanglf.quartz.JobDetileBeanPrintJob</value><!-- 指定自定义类 -->
        </property>
        <property name="jobDataAsMap">
            <map>
                <entry key="showService" value-ref="showService" /><!-- 如果需要其他层的注入，则在这里进行注入配，然后给上set方法完成注入。 -->
            </map>
        </property>
        <!-- 使用JobDetailBean不支持这种并发操作 -->
        <!-- <property name="concurrent" value="false"/> -->
    </bean>

    <!-- 定时触发器 -->
    <bean id="autoShowJobCronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
        <property name="jobDetail">
            <ref bean="autoShowJob" />
        </property>
        <property name="cronExpression">
            <value>0/20 * * * * ?</value><!-- 每20秒执行一次 -->
        </property>
    </bean>
    <!-- 第二种定时轮循的方法是用 JobDetileBean。这种不用单独声明自定义类了。直接在属性中赋值为对应类，然后就会走默认的实现方法executeInternal。 -->


    <!-- 任务调度器 -->
    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="autoPrintJobCronTrigger" />
                <ref bean="autoShowJobCronTrigger" />
            </list>
        </property>
    </bean>

</beans>

3.在web.xml中引入配置和引入spring容器。

<?xml version="1.0" encoding="UTF-8"?>  
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xmlns="http://java.sun.com/xml/ns/javaee"  
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  
    version="3.0">  
    <display-name>Archetype Created Web Application</display-name>  
    <!-- Spring和mybatis的配置文件 -->  
    <context-param>  
        <param-name>contextConfigLocation</param-name>  
        <param-value>classpath:/MATE-INF/quartz/quartz-job.xml</param-value>  
    </context-param>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>

4.quartz/JobDetileBeanPrintJob.java 和MethodInvokingJobDetileFactoryBeanPrintJob.java类

package com.zhanglf.quartz;

import javax.annotation.Resource;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Component;

import com.zhanglf.service.IShowService;
@Component
public class JobDetileBeanPrintJob extends QuartzJobBean {
    //这里的注入只能是set方法注入好使,使用註解不行！这也是和MethodInvokingJobDetileFactoryBean的区别之一。
//  @Resource(name=IShowService.SERVICEID)
    private IShowService showService;

    public void setShowService(IShowService showService) {
        this.showService = showService;
    }

    @Override
    protected void executeInternal(JobExecutionContext context)
            throws JobExecutionException {
        show();
    }

    public void show(){
        showService.print("JobDetileBeanPrintJob");
    }

}

package com.zhanglf.quartz;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;

import com.zhanglf.service.IShowService;

@Component
public class MethodInvokingJobDetileFactoryBeanPrintJob {

    @Resource(name=IShowService.SERVICEID)
    private IShowService showService;

    public void sayHello(){
        showService.print("MethodInvokingJobDetileFactoryBeanPrintJob");
    }
}

为了结合spring的注入，我们引入了service层来说明二者的区别：MethodInvokingJobDetileFactoryBeanPrintJob不会影响spring对各层的bean管理，通过注解方式即可完成注入，但是JobDetileBeanPrintJob会影响spring对继承了这个类的spring注入。@Resource注解在JobDetileBeanPrintJob类中起不到bean注入的作用，而只能用set方法来注入。

5.service/IShowService.java接口和其实现类ShowServiceImpl.java

package com.zhanglf.service;

public interface IShowService {
    final String SERVICEID="showService";
    public void print(String name);
}

package com.zhanglf.service;

import org.springframework.stereotype.Service;

@Service(IShowService.SERVICEID)
public class ShowServiceImpl implements IShowService{
    public void print(String name){
        System.out.println("你好  "+name);
    }
}

这就搭建完成了。启动项目，可以看到控制台每个20秒打印出的结果。

这里写图片描述

总结：
1.定时轮循的任务实现方式有两种：MethodInvokinJobDetailFactoryBean 简称为@M, JobDetailBean 简称为@J.简称有利于我后面的总结。其中第一种@M这种简单易操作。建议使用这种方式的定时任务。

2.在配置文件中@M的配置分为四步：
a. 自定义任务类声明-给上id/name来唯一标识，便后面配置引用。
b.将自定义类封装称job–把对应的自定义id和方法名传入即可。
c.将封装成的job引入定时触发器。
d.将触发器加入调度器进行调度任务。

@J的配置分为三步，省略了@M的第一步。二者主要区别在封装称job这里，三四步是相同的。
a.将自定义类封装称job–对应的类路径+类名（调用的方法是固定的，就是@J的实现方法executeInternal）和自定义类中需要注入的别的层的类的实例（比如本例的private IShowService showService;）。
b.将封装成的job引入定时触发器。
c.将触发器加入调度器进行调度任务。

3.由于结合了spring容器管理。所以需要加入扫描注解的配置和在web.xml中加入spring容器的监听器，以便web容器初始化就会初始化spring容器。

4.重点注意@J的自定义job任务类:JobDetileBeanPrintJob是要继承 QuartzJobBean 类，重写父类的executeInternal方法，则调度器就会调用这个方法。
如果方法要使用别的层的方法，则注入的方式只能是set方法，注解不好使，这个父类影响了spring的注入方式。：

//  @Resource(name=IShowService.SERVICEID)
private IShowService showService;
    public void setShowService(IShowService showService) {
        this.showService = showService;
    }

@M的自定义任务类是不用继承，实现任何别的类。就是纯净的自定义类，自定义的无参方法。然后依据你在job的配置文件里指定调用那个方法，就会走那个方法。且不影响spring的注入。

5.注意这里的job调用的方法均为无参的方法。