java--定时器

springboot中简单定时任务使用：Scheduled

1-导入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>6.0.2.RELEASE</version>
</dependency>

2-编写定时器类

/**
 * 定时任务
 */
@Component
public class ScheduledDemo {
    /**
     * 定时任务
     * @Scheduled 设置定时任务
     * 1--cron属性：cron表达式，定时任务触发时间的一个字符串表达形式
     */
    @Scheduled(cron = "0/2 * * * * ?")
    public void scheduledMethod(){
        System.out.println("定时器触发："+new Date());

    }
}

说明

 *  Cron,表达式是一个字符串，分为6或7个域，每一个域代表一个含义Cron有如下两种语法格式:
 *  (1)Seconds Minutes Hours Day Month Week Year
 *  (2) Seconds Minutes Hours Day Month Week
 *    位置 时间域名 允许值 允许的特殊字符
 *     1 秒        0-59       , _ * /
 *     2 分钟      0-59       , _ * /
 *     3 小时      0-23       , _ * /
 *     4 日期        1-31       , _ * / L W C   需配合月使用
 *     5 月        1-12       , _ * /
 *     6 星期      1-7        , _ * / ? L C #  1表示星期日，7表示星期一  星期也要配合日使用，一般只用一个
 *     7 年(可选)  1970-2099  , _ * /

星号(*):可用在所有字段中s表示对应时间城的每一个时刻s例如s在分钟字段时,表示"每分钟";
问号(?)∶该字符只在日期和星期字段中使用，它通常指定为"无意义的值"，相当于占位符﹔
减号(-):表达一个范围，如在小时字段中使用"10-12"，则表示从10到12点,即10,11,12;
逗号(,):表达一个列表值，如在星期字段中使用"MON,WED,FRI"，则表示星期一，星期三和星期五;
斜杠(/): xly 表达一个等步长序列s×为起始值,y为增里步长值。如在分钟字段中使用0/15，则表示为0,15,30和45秒,而5/15在分钟字段中表示 5,20,35,50，你也可以使用/y，它等同于0/y3
L:该字符只在日期和星期字段中使用，代表""Last"的意思，但它在两个字段中意思不同。" +
L在日期字段中，表示这个月份的最后一天，如一月的31号,非i闰年二月的28号;
如果L用在星期中，则表示星期六,等同于7○但是,如果L出现在星期字段里,
而且在前面有一个数值X,则表示"这个月的最后X天"”，例如，6L表示该月的最后星期五﹔
W:该字符只能出现在日期字段里，是对前导日期的修饰，表示离该日期最近的工作日。
例如15W表示离该月15号最近的工作日，
如果该月15号是星期六，则匹配14号星期五﹔
如果15日是星期日，则匹配16号星期一﹔
如果15号是星期二，那结果就是15号星期二，但必须注意关联的匹配日期不能够跨月，
如你指定1W，如果1号是星期六，结果匹配的是3号星期一，
而非上个月最后的那天。W字符串只能指定单一日期。而不能指定日期范围;
LW组合:在日期字段可以组合使用LW，它的意思是当月的最后一个工作日;
井号(#):该字符只能在星期字段中使用v表示当月某个工作日 如6#3表示当月的第三个星期五(6表示星期五，#3表示当前的第三个)，而4#5表示当月的第五个星期三，假设当月没有第五个星期三,忽略不触发;
C:该字符只在日期和星期字段中使用，代表"Calendar"的意思。
它的意思是计划所关联的日期,如果日期没有被关联，则相当于日历中所有日期
例如5C在日期字段中就相当于日历5日以后的第一天o1C在星期字段中相当于星期日后的第一天。
Cron表达式对特殊字符的大小写不敏感，对代表星期的缩写英文大小写也不敏感。

3-启动类开启定时任务的使用

@SpringBootApplication
@EnableScheduling
public class Sb1Application {
	public static void main(String[] args) {
		SpringApplication.run(Sb1Application.class, args);
	}
}

第三方定时任务框架：Quartz

• 1--job 任务 你要做啥
• 2--Trigger 触发器 你什么时候去做
• 3--Scheuler 任务调度 你什么时候需要去做什么事

基本使用

1-导入依赖添加坐标

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.2.1</version>
</dependency>

2-定义class继承job重写execute方法，即定义任务类编写任务

public class QuartzDemo implements Job {

    /**
     * 任务被触发是所执行的方法
     * @param jobExecutionContext
     * @throws JobExecutionException
     */
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("quartz自动任务--cexcute方法执行。。。"+new Date());
    }
}

3-编写调度类测试

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzMain {
    public static void main(String[] args) throws SchedulerException {
        //1-先创建job对象：做什么
        JobDetail job = JobBuilder.newJob(QuartzDemo.class).build();

        //2-创建Trigger对象：什么时间做
        /**
         * 简单的trigger触发时间： 通过quartz提供一个方法来完成简单的重复调用
         * cron Trigger: 按照cron的表达式来给定触发时间
         */
        Trigger trigger = TriggerBuilder.newTrigger()
//                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever())//通过内置方法设置定时 知己即每秒钟重复
                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?")) //通过cron表达式来设置定时
                .build();

        //3-创建Scheduler对象： 任务调度，什么时候做什么事
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        scheduler.scheduleJob(job,trigger);//设置调度

        //启动
        scheduler.start();
    }
}

spring整合Quartz

1-引入依赖

<!--添加quartz坐标，springboot自带slf4j需排除-->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.2.1</version>
    <exclusions>
        <exclusion>
            <artifactId>slf4j-api</artifactId>
            <groupId>org.slf4j</groupId>
        </exclusion>
    </exclusions>
</dependency>

<!--添加scheduled坐标-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>6.0.2.RELEASE</version>
</dependency>
<!--spring tx 坐标-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>6.0.2.RELEASE</version>
</dependency>

2-编写任务类

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.util.Date;

public class QuartzDemo implements Job {

    /**
     * 任务被触发是所执行的方法
     * @param jobExecutionContext
     * @throws JobExecutionException
     */
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("quartz自动任务--cexcute方法执行。。。"+new Date());
    }
}

3-创建配置类返回相应对象

import com.xiaoai.quartz.QuartzDemo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;

/**
 * quartz配置类
 */
@Configuration
public class QuartzConfig {
    /**
     * 1- 创建job对象
     */
    @Bean
    public JobDetailFactoryBean jobDetailFactoryBean(){
        JobDetailFactoryBean factory = new JobDetailFactoryBean();
        //关联自己的job类
        factory.setJobClass(QuartzDemo.class);
        return factory;
    }

    /**
     * 2- 创建Trigger对象
     */
    @Bean
    public SimpleTriggerFactoryBean simpleTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){
        SimpleTriggerFactoryBean factory = new SimpleTriggerFactoryBean();
        //关联jobdetail对象
        factory.setJobDetail(jobDetailFactoryBean.getObject());
        //设置一个执行的毫秒数
        factory.setRepeatInterval(2000);
        //重复次数
        factory.setRepeatCount(5);
        return factory;
    }

    /**
     * 1- 创建Scheduler对象
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(SimpleTriggerFactoryBean simpleTriggerFactoryBean){
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        //关联Trigger
        factory.setTriggers(simpleTriggerFactoryBean.getObject());
        return factory;
    }

}

4-启动类开启定时任务

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling //开启定时任务
public class quartzdemoApplication {
	public static void main(String[] args) {
		SpringApplication.run(quartzdemoApplication.class, args);
	}
}

可以在配置类中返回一个cron实例，实现通过cron表达式设置定时

import com.xiaoai.quartz.QuartzDemo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;

/**
 * quartz配置类
 */
@Configuration
public class QuartzConfig {
    /**
     * 1- 创建job对象
     */
    @Bean
    public JobDetailFactoryBean jobDetailFactoryBean(){
        JobDetailFactoryBean factory = new JobDetailFactoryBean();
        //关联自己的job类
        factory.setJobClass(QuartzDemo.class);
        return factory;
    }

    /**
     * 2- 创建Trigger对象
     */
//    @Bean
//    public SimpleTriggerFactoryBean simpleTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){
//        SimpleTriggerFactoryBean factory = new SimpleTriggerFactoryBean();
//        //关联jobdetail对象
//        factory.setJobDetail(jobDetailFactoryBean.getObject());
//        //设置一个执行的毫秒数
//        factory.setRepeatInterval(2000);
//        //重复次数
//        factory.setRepeatCount(5);
//        return factory;
//    }
    /**
     * cron trigger
     */
    @Bean
    public CronTriggerFactoryBean cronTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){
        CronTriggerFactoryBean factory = new CronTriggerFactoryBean();
        //关联job
        factory.setJobDetail(jobDetailFactoryBean.getObject());
        //设置触发时间
        factory.setCronExpression("0/2 * * * * ?");
        return factory;
    }

    /**
     * 1- 创建Scheduler对象
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(CronTriggerFactoryBean cronTriggerFactoryBean){
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        //关联Trigger
        factory.setTriggers(cronTriggerFactoryBean.getObject());
        return factory;
    }
}

job类对象注入