java开发中常用的定时器

工作中常用的定时器

参考[http://www.javaboy.org/2019/0418/springboot-schedule-task.html]

两种方式

1. Spring自带的定时任务处理器
2. Quartz

第一种使用方式：@Scheduled

1、创建项目后，在启动类上添加 @EnableScheduling 注解，开启定时任务。

@EnableScheduling
@SpringBootApplication
public class SchedulerDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SchedulerDemoApplication.class, args);
    }

}

2、配置定时任务

@Service
public class HelloService {

    @Scheduled(fixedDelay = 2000)
    public void fixedDelay(){
        System.out.println("fixedDelay >>>1" + new Date());
    }

    @Scheduled(fixedRate = 2000)
    public void fixedRate(){
        System.out.println("fixedRate >>>2" + new Date());
    }

    @Scheduled(initialDelay = 2000, fixedRate = 2000)
    public void initialDelay(){
        System.out.println("initialDelay >>>3" + new Date());
    }
    
}

参数说明：

1. 首先使用 @Scheduled 注解开启一个定时任务。
2. fixedRate 表示任务执行之间的时间间隔，具体是指两次任务的开始时间间隔，即第二次任务开始时，第一次任务可能还没结束。
3. fixedDelay 表示任务执行之间的时间间隔，具体是指本次任务结束到下次任务开始之间的时间间隔。
4. initialDelay 表示首次任务启动的延迟时间。
5. 所有时间的单位都是毫秒。

上面这是一个基本用法，除了这几个基本属性之外，@Scheduled 注解也支持 cron 表达式，使用 cron 表达式，可以非常丰富的描述定时任务的时间。

cron 表达式格式如下：

[秒] [分] [小时] [日] [月] [周] [年]

例如，在scheduler注解中使用cron表达式，每5秒触发一次：

@Scheduled(cron = "0/5 * * * * *")
public void cron(){
    System.out.println(new Date());
}

第二种使用方式： quartz

1. 添加依赖

   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-quartz</artifactId>
   </dependency>
   

2. 在启动类上添加注解 @EnableScheduling ,开启定时任务

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

3. Quartz 在使用过程中，有两个关键概念，一个是JobDetail（要做的事情），另一个是触发器（什么时候做），要定义 JobDetail，需要先定义 Job，Job 的定义有两种方式：

   第一种方式，直接定义一个Bean：

   @Component
   public class MyFirstJob {
   
       public void sayHello(){
           System.out.println("my first job say hello:" + new Date());
       }
   }
   
   

   关于这种定义方式说两点：

   1. 首先将这个 Job 注册到 Spring 容器中。

   2. 这种定义方式有一个缺陷，就是无法传参。

   第二种定义方式，则是继承 QuartzJobBean 并实现默认的方法：

   public class MySecondJob extends QuartzJobBean {
   
       private String name;
   
       public void setName(String name) {
           this.name = name;
       }
   
       @Override
       protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
           System.out.println("my second job say hello:" + name + ":" + new Date());
       }
   }
   

   和第1种方式相比，这种方式支持传参，任务启动时，executeInternal 方法将会被执行。

4. 创建配置类， 配置 JobDetail 和 Trigger 触发器

   @Configuration
   public class QuartzConfig {
   
       @Bean
       MethodInvokingJobDetailFactoryBean methodInvokingJobDetailFactoryBean(){
           MethodInvokingJobDetailFactoryBean bean = new MethodInvokingJobDetailFactoryBean();
           bean.setTargetBeanName("myFirstJob");
           bean.setTargetMethod("sayHello");
           return bean;
       }
   
       @Bean
       JobDetailFactoryBean jobDetailFactoryBean(){
           JobDetailFactoryBean bean = new JobDetailFactoryBean();
           JobDataMap jobDataMap = new JobDataMap();
           jobDataMap.put("name", "lee");
           bean.setJobDataMap(jobDataMap);
           bean.setJobClass(MySecondJob.class);
           return bean;
       }
   
       /**
        * 触发器
        * @return
        */
       @Bean
       SimpleTriggerFactoryBean simpleTriggerFactoryBean(){
           SimpleTriggerFactoryBean bean = new SimpleTriggerFactoryBean();
           bean.setJobDetail(methodInvokingJobDetailFactoryBean().getObject());
           // 开始的时间 -- 立刻开始
           bean.setStartTime(new Date());
           // 时间间隔
           bean.setRepeatInterval(2000);
           // 重复的次数 -- 默认无限循环
           bean.setRepeatCount(3);
           return bean;
       }
   
       @Bean
       CronTriggerFactoryBean cronTriggerFactoryBean(){
           CronTriggerFactoryBean bean = new CronTriggerFactoryBean();
           bean.setJobDetail(jobDetailFactoryBean().getObject());
           // 设置cron表达式 -- 每秒执行一次
           bean.setCronExpression("* * * * * ?");
           return bean;
       }
   
       @Bean
       SchedulerFactoryBean schedulerFactoryBean(){
           SchedulerFactoryBean bean = new SchedulerFactoryBean();
           bean.setTriggers(simpleTriggerFactoryBean().getObject(), cronTriggerFactoryBean().getObject());
           return bean;
       }
   
   }
   

   配置说明：

   1. JobDetail 的配置有两种方式：MethodInvokingJobDetailFactoryBean 和 JobDetailFactoryBean 。

   2. 使用 MethodInvokingJobDetailFactoryBean 可以配置目标 Bean 的名字和目标方法的名字，这种方式不支持传参。

   3. 使用 JobDetailFactoryBean 可以配置 JobDetail ，任务类继承自 QuartzJobBean ，这种方式支持传参，将参数封装在 JobDataMap 中进行传递。

   4. Trigger 是指触发器，Quartz 中定义了多个触发器，这里向大家展示其中两种的用法，SimpleTrigger 和 CronTrigger 。

   5. SimpleTrigger 有点类似于前面说的 @Scheduled 的基本用法。

   6. CronTrigger 则有点类似于 @Scheduled 中 cron 表达式的用法。

全部定义完成后，启动 Spring Boot 项目就可以看到定时任务的执行了。