【Spring学习】spring提供的三种定时任务

叁歲伎倆 2022-08-19 14:08 150阅读 0赞

在spring中我们有三种不同的定时任务：基于Quartz的定时机制、基于Timer的定时机制、基于Executor的定时机制。

**1、基于Quartz的定时任务机制**

![这里写图片描述][20160118233851514]

下面详细解释这个类图中涉及的关键类及其使用场景

**1.1. SchedulerFactoryBean**

这是Spring中基于Quartz的定时机制入口，只要Spring容器装载了这个类，Quartz定时机制就会启动，并加载定义在这个类中的所有trigger

**1.2. CronTriggerBean**

实现了Trigger接口，基于Cron表达式的触发器。这种触发器的好处是表达式与linux下的crontab一致，能够满足非常复杂的定时需求，也容易配置

**1.3. MethodInvokingJobDetailFactoryBean**

Spring提供的一个不错的JobDetail包装工具，能够包装任何bean，并执行类中指定的任何stati或非static的方法，避免强制要求bean去实现某接口或继承某基础类。

Spring配置实例：

<?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-3.0.xsd">
    
        <bean id="jobDetail_1" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
           <property name="targetObject">
                <ref bean="TSupeviseServiceImpl" />
           </property>
           <property name="targetMethod">
                <value>processTInterface</value>
           </property>
        </bean>
    
        <bean id="cronTrigger_1" class="org.springframework.scheduling.quartz.CronTriggerBean">
           <property name="jobDetail">
                <ref bean="jobDetail_1" />
           </property>
           <property name="cronExpression">
                <value>0 0 10 * * ? *</value>
           </property>
        </bean>
    
        <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
            <property name="triggers">
                <list>
                    <ref local="cronTrigger_1" />
                </list>
            </property>
        </bean>
    
    </beans>

**1.4. SimpleTriggerBean**

该类也实现了Trigger接口，基于配置的定时调度。这个触发器的优点在于很容易配置一个简单的定时调度策略

Spring配置范例：

1.5. JobDetailBean

JobDetail类的简单扩展，能够包装一个继承自QuartzJobBean的普通Bean，使之成为定时运行的Job..缺点是包装的Bean必须继承自一个指定的类，通用性不强，对普通Job的侵入性过强，不推荐使用。

**1.6. 关于TriggerListener和JobListener**

Quartz中提供了类似WebWork的拦截器的功能，系统执行任务前或任务执行完毕后，都会检查是否有对应的Listener需要被执行，这种AOP的思想为我们带来了灵活的业务需求实现方式。  
例如现在有一个简单的业务要求：任务执行前先判断当前服务器是否为task服务器，不是则不执行任务。对于这种业务需求，我们可以简单的实现一个 TriggerListener，并将其插入SchedulerFactoryBean的globalTriggerListeners中，这样所有的 job在执行前后都会调用TriggerListener中对应的方法。

代码范例：

public class MyTaskTriggerListener implements TriggerListener {
           
        protected static final Log logger = LogFactory.getLog(MyTaskTriggerListener.class);   
    
        /**  
         * 需要运行task任务的机器列表  
         */  
        private String taskServers;   
    
        public String getName() {   
            return "MyTaskTriggerListener";   
        }   
    
        public void triggerComplete(Trigger arg0, JobExecutionContext arg1, int arg2) {   
        }   
    
        public void triggerFired(Trigger arg0, JobExecutionContext arg1) {   
        }   
    
        public void triggerMisfired(Trigger arg0) {   
        }   
    
        /**  
         * 判断当前服务器是否为task服务器，来决定是否执行task  
         * @return  
         */  
        public boolean vetoJobExecution(Trigger arg0, JobExecutionContext arg1) {   
            String serverName;   
            try {   
                serverName = InetAddress.getLocalHost().getHostName();//获取主机名   
            } catch (UnknownHostException e) {   
                e.printStackTrace();   
                return true;   
            }   
            if (taskServers.indexOf(serverName) > -1) {   
                if (logger.isInfoEnabled()) {   
                    logger.info("this is a task server, job will be executed");   
                }   
                return false;   
            } else {   
                if (logger.isInfoEnabled()) {   
                    logger.info("this is not a task server, job will be vetoed");   
                }   
                return true;   
            }   
        }   
    
        public String getTaskServers() {   
            return taskServers;   
        }   
    
        public void setTaskServers(String taskServers) {   
            this.taskServers = taskServers;   
        }   
    }  
    public class MyTaskTriggerListener implements TriggerListener {
        
     protected static final Log logger = LogFactory.getLog(MyTaskTriggerListener.class);
     /**
      * 需要运行task任务的机器列表
      */
     private String taskServers;
     public String getName() {
      return "MyTaskTriggerListener";
     }
     public void triggerComplete(Trigger arg0, JobExecutionContext arg1, int arg2) {
     }
     public void triggerFired(Trigger arg0, JobExecutionContext arg1) {
     }
     public void triggerMisfired(Trigger arg0) {
     }
     /**
      * 判断当前服务器是否为task服务器，来决定是否执行task
      * @return
      */
     public boolean vetoJobExecution(Trigger arg0, JobExecutionContext arg1) {
      String serverName;
      try {
       serverName = InetAddress.getLocalHost().getHostName();//获取主机名
      } catch (UnknownHostException e) {
       e.printStackTrace();
       return true;
      }
      if (taskServers.indexOf(serverName) > -1) {
       if (logger.isInfoEnabled()) {
        logger.info("this is a task server, job will be executed");
       }
       return false;
      } else {
       if (logger.isInfoEnabled()) {
        logger.info("this is not a task server, job will be vetoed");
       }
       return true;
      }
     }
     public String getTaskServers() {
      return taskServers;
     }
     public void setTaskServers(String taskServers) {
      this.taskServers = taskServers;
     }
    }

[quartz表达式解析][quartz]

**2、基于Timer的定时机制**

![这里写图片描述][20160118233920515]

下面详细解释这个类图中涉及的关键类及其使用场景

**2.1. TimerFactoryBean**

这个类非常类似Quartz中的SchedulerFactoryBean，是基于Timer的定时机制的入口，Spring容器装载此类后会自动开始定时器。

**2.2. ScheduledTimerTask**

类似于Quartz中的Trigger的SimpleTriggerBean实现，任务是在设定的时间触发并执行配置的任务，特点是配置简单、明了，使用于简单的任务触发逻辑。

**2.3. TimerTask抽象类**

普通task实现必须要继承的父类，主要包含一个run()的方法，类似Quartz中的QuartzJobBean，对应用侵入性较强，也不推荐使用。

**2.4. MethodInvokingTimerTaskFactoryBean**

类似Quartz中的MethodInvokingJobDetailFactoryBean，用于封装任何bean，并可以执行bean中的任意方法，不再复述。

简单实例：

MyTask.java

package com.lmb.springstudy.schedule.timer;
    
    public class MyTask {
        private String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
    public void run() {
            System.out.println("Run this task: " + name + ".");
        }
    
    }

Spring-timer.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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"
           default-lazy-init="true">
    
        <bean id="timerFactory" class="org.springframework.scheduling.timer.TimerFactoryBean" lazy-init="false">
            <property name="scheduledTimerTasks">
                <list>
                    <ref local="scheduledTask1"/>
                    <ref local="scheduledTask2"/>
                </list>
            </property>
        </bean>
    
        <bean id="scheduledTask1" class="org.springframework.scheduling.timer.ScheduledTimerTask">
            <property name="delay" value="0" />
            <property name="period" value="10000" />
            <property name="timerTask">
                <ref bean="methodInvokingTask1"/>
            </property>
        </bean>
    
        <bean id="scheduledTask2" class="org.springframework.scheduling.timer.ScheduledTimerTask">
            <property name="delay" value="0" />
            <property name="period" value="10000" />
            <property name="timerTask">
                <ref bean="methodInvokingTask2"/>
            </property>
        </bean>
    
        <bean id="methodInvokingTask1" class="org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean">
            <property name="targetObject" ref="myTask1"/>
            <property name="targetMethod" value="run"/>
        </bean>
    
        <bean id="methodInvokingTask2" class="org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean">
            <property name="targetObject" ref="myTask2"/>
            <property name="targetMethod" value="run"/>
        </bean>
    
        <bean id="myTask1" class="org.garbagecan.springstudy.schedule.timer.MyTask">
            <property name="name" value="task1"/>
        </bean>
    
        <bean id="myTask2" class="org.garbagecan.springstudy.schedule.timer.MyTask">
            <property name="name" value="task2"/>
        </bean>
    </beans>

原理解析：

1.  定义了两个task，task1和task2；
2.  利用spring提供的MethodInvokingTimerTaskFactoryBean类来实现来实现对对task类和方法的声明，声明目标对象和方法，从而使spring知道要运行那个类的那个方法；
3.  利用ScheduledTimerTask类来配置每个task的启动时间延时，每次启动之间的间隔，当然还有最重要的是需要运行那个对象，这里使用的上面提到的MethodInvokingTimerTaskFactoryBean类的实例；
4.  最后定义了一个TimerFactoryBean类，并且把ScheduledTimerTask类的实例作为需要调度的task；

Test.java

package lmb.springstudy.schedule.timer;
    
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
        
        public static void main(String[] args) throws Exception {
            new ClassPathXmlApplicationContext("/com/lmb/springstudy/schedule/timer/spring-timer.xml");
        }
    }

Test测试类运行结果：两个task都会启动，并且都以同样的10s作为每次运行的时间间隔。

**3、基于Executor的定时机制**

![这里写图片描述][20160118233939060]

这种定时机制与上面两种定时机制没有太大区别，特别是在配置和实现功能上，不同的是它的核心是基于ScheduledExecutorService（ScheduledThreadPoolExecutor是默认实现），一种JDK5.0中提供的基于线程的并发机制。关于Executor的详细内容请参看博主的另一篇文章。

如果需要简单的定时器可以选用基于Timer的定时机制，如果需要较复杂的定时器可以选用基于Quartz的定时机制，如果我们要用到线程池来处理异步任务，我们可以选用基于Executor的定时机制，虽然只是任务实现中用到线程池，毕竟也是一脉相承的，当然也可以用Quartz的定时器+基于Executor的任务线程池，完全没有任何冲突的。

有关Executor的详细内容，请参看本人的以下文章：[http://blog.csdn.net/lmb55/article/details/50555309][http_blog.csdn.net_lmb55_article_details_50555309]

[20160118233851514]: /images/20220731/d05c2d49bfa748118020214aa0473de8.png
[quartz]: http://blog.csdn.net/lmb55/article/details/51013044
[20160118233920515]: /images/20220731/e7b268a55654439f8b26cee8a298cca0.png
[20160118233939060]: /images/20220731/6b313770ec484ca481ea09ec1407a7ba.png
[http_blog.csdn.net_lmb55_article_details_50555309]: http://blog.csdn.net/lmb55/article/details/50555309