spring中定时任务的多种实现

本文主要是记录工作中所遇到的情况，并非教学！！！ 

一、通过spring自带的@Scheduled注解实现定时任务

1.更改ApplicationContext-mvc.xml/spring.xml 等配置文件，如果不知道自己应该配置哪个文件的话去web.xml中找到<servlet>标签中的配置文件去配置就行（因为我试过配置在<context-param>标签下的ApplicationContext.xml里面会报错）

文件中需要更改的内容如下：

 

（1）xmlns:task="http://www.springframework.org/schema/task"

（2）xsi:schemaLocation中添加  （其中spring-task-3.1.xsd的版本可以更改看你的spring版本）具体参考下图

 

 

 

http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.1.xsd

 

<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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/mvc 
    http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.1.xsd">

（3）添加 task标签设置 ，可以详细配置也可以直接默认

多的部分是对与线程池的设置，配置线程池后如果多个定时任务同时执行也没问题，不配置的话spring默认是单线程模式

<!--形式一-->
<task:executor id="executor" pool-size="5" />
<task:scheduler id="scheduler" pool-size="10" />
<task:annotation-driven executor="executor" scheduler="scheduler" />


<!--形式二-->
 <task:annotation-driven />

（4）不要忘记配置你要执行的自动化程序所在的包的路径，将该包的路径加入扫描(按照自身实际情况配置)

<context:component-scan base-package="com.project.*" />

2.创建你的定时任务程序

/**
 * @author 
 * @Time 2020-07-08 17:07
 */
//必须添加注解交由spring管控才能生效
@Component
public class ScheduledDemo {
    //由于将整个类交由spring管控不必担心@Autowired注解失效的情况
    @Autowired
    private TestService testService;

    //有点缺点该注解只支持6位参数的cron表达式不支持7位的
    @Scheduled(cron = "0 0/1 * * * ? ")
    public void aaa(){
        //实现你需要的方法即可
        testService.XXX();
        System.out.println("哈哈哈哈");
    }

}    

 

二、通过quartz组件实现定时任务（有点问题按照网上的方法最后我也没成功纳入spring管理。。。）

1.通过官网下载quartz ,下载完成是下图的压缩包 解压后相应目录下有你需要的jar包，自行导入即可（其他的都是依赖jar包，最低情况只需要导入quartz自身的两个jar就行）

 

 

 

配置一下日志打印（依赖于log4j组件）

  

 2.此处就不讲quartz怎么使用了，结合网上的分享，这里提供一个工具类方便直接调用

/**
 * @author 
 * @Time 2020-07-06 17:00
 */
public class SchedulerUtil {
    private static Logger logger = Logger.getLogger(SchedulerUtil.class);// log4j记录日志
    /**
     * [简单任务调度:每次执行间隔为多少毫秒，执行多少次] <br>
     * @param jobName 任务名字
     * @param jobGroupName 任务组名字
     * @param triggerName 触发器名字
     * @param triggerGroupName 触发器组名字
     * @param jobClass 任务类
     * @param time 时间间隔
     * @param count 执行几次<br>
     */
    public static void handleSimpleTrigger(String jobName, String jobGroupName,
                                           String triggerName, String triggerGroupName, Class jobClass,
                                           int time, int count) {28         // 通过schedulerFactory获取一个调度器
        SchedulerFactory schedulerfactory = new StdSchedulerFactory();
        Scheduler scheduler = null;
        try {
            // 通过schedulerFactory获取一个调度器
            scheduler = schedulerfactory.getScheduler();
            // 创建jobDetail实例，绑定Job实现类
            // 指明job的名称，所在组的名称，以及绑定job类
            JobDetail job = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
            // 定义调度触发规则
            //使用simpleTrigger规则
            Trigger trigger=TriggerBuilder.newTrigger().withIdentity(triggerName,triggerGroupName)
                    .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(time).withRepeatCount(count))
                    .build();
            // 把作业和触发器注册到任务调度中
            scheduler.scheduleJob(job, trigger);
            // 启动调度
            scheduler.start();
        } catch (Exception e) {48             logger.error("执行"+jobName+"组"+jobName+"任务出现异常E:["+ e.getMessage() + "]");
        }
    }
    /**
     * [复杂任务调度：每天几点几分几秒定时执行任务] <br>
     * @param jobName 任务名字
     * @param jobGroupName 任务组名字
     * @param triggerName 触发器名字
     * @param triggerGroupName 触发器组名字
     * @param jobClass 任务类
     * @param cron 触发规则<br>
     */
    /**
     *
     *
     */
    public static void hadleCronTrigger(String jobName, String jobGroupName,
                                        String triggerName, String triggerGroupName, Class jobClass,String cron) {73         // 通过schedulerFactory获取一个调度器
        SchedulerFactory schedulerfactory = new StdSchedulerFactory();
        Scheduler scheduler = null;
        try {
            // 通过schedulerFactory获取一个调度器
            scheduler = schedulerfactory.getScheduler();
            // 创建jobDetail实例，绑定Job实现类
            // 指明job的名称，所在组的名称，以及绑定job类
            JobDetail job = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
            // 定义调度触发规则
            //使用cornTrigger规则  每天18点30分
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName)
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                    .build();
            // 把作业和触发器注册到任务调度中
            scheduler.scheduleJob(job, trigger);
            // 启动调度
            scheduler.start();
        } catch (Exception e) {93             logger.error("执行" + jobName + "组" + jobName + "任务出现异常E:[" + e.getMessage() + "]");
        }
    }
}

3.方式一  ：创建自己的job类，然后通过@PostConstruct注解在项目启动后调用（配合第二条使用）

/**
 * @author 
 * @Time 2020-07-06 17:40
 */
@DisallowConcurrentExecution //不允许job并发执行，防止重复调用，只对于同一实例有效，不同jobDetails引用同一个job时不起作用
public class TPersonFollowUpJob implements Job {

    @Autowired
    private TestService testService;

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

//因为没有被纳入spring管理，所以这里通过这个方法实现调用spring管理的组件让该页面的@Autowired 注解生效   SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this);
        //自己要实现的方法
        testService.XXX();
        System.out.println("哈哈哈哈");
    }
}

下面是调用方法

//该注解保证了该方法可以在程序启动后自动调用执行一次    
@PostConstruct
    public void start(){
        //这里使用我们前面定义好的工具类来调用我们的Job方法类，这里的cron表达式支持最多7位参数    
        SchedulerUtil.hadleCronTrigger("任务名字", "任务组名字","触发器名字", "触发器组名字", TPersonFollowUpJob.class,"0 0/1 * * * ? *");
    }

4.方式二  ：直接通过spring的xml配置完成（在web.xml的<context-param>标签下的ApplicationContext.xml中进行配置，别的位置会报错），独立使用

<!--定时器任务配置（开始） -->
    <!--配置JOB -->
    <!--TPersonFollowUpTasksService这个bean是为了指定你早已经写好的为了定时执行的方法所在的实现类 -->
    <bean id="TPersonFollowUpTasksService" class="com.msunsoft.service.personMana.Impl.TPersonFollowUpTasksServiceImpl"></bean>
    <bean id="JobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject">
            <ref bean="TPersonFollowUpTasksService" />
        </property>
        <property name="targetMethod">
<!--在这里指定需要定时执行的方法名-->
            <value>createFollowUpTasks</value>
        </property>
        <property name="concurrent">
            <value>false</value>
        </property>
    </bean>
    <!--配置Trigger -->
    <bean id="deleteDataTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail">
            <ref bean="JobDetail" />
        </property>
        <property name="cronExpression">
            <!-- 这里支持7个参数的corn表达式  每个小时的每分钟执行一次 -->
            <value>0 0/1 * * * ? *</value>
        </property>
    </bean>
    <!--配置Scheduler -->
    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean" lazy-init="false" autowire="no">
        <property name="triggers">
            <list>
                <ref bean="deleteDataTrigger" />
            </list>
        </property>
        <property name="autoStartup">
            <value>true</value>
        </property>
    </bean>
    <!--定时器任务配置（结束） -->