zoukankan      html  css  js  c++  java
  • SpringBoot的定时任务

    springBoot定时任务可分为多线程和单线程,而单线程又分为注解形式,接口形式

    1.基于注解形式

    基于注解@Scheduled默认为单线程,开启多个任务时,任务的执行时机会受上一个任务执行时间的影响。

      1)创建定时器

      使用SpringBoot基于注解来创建定时任务非常简单,只需几行代码便可完成。 代码如下

      

    package com.cst.klocwork.service.cron;
    
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.annotation.EnableScheduling;
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Component;
    
    import com.cst.util.string.LocalDateTimes;
    
    @Component
    @Configuration      //1.主要用于标记配置类,兼备Component的效果。
    @EnableScheduling   // 2.开启定时任务
    public class Test {
        //3.添加定时任务
        @Scheduled(cron = "0/5 * * * * ?")
        //或直接指定时间间隔,例如:5秒
        //@Scheduled(fixedRate=5000)
        private void configureTasks() {
           f1();
        }
        
        public void f1() {
        	 System.err.println("执行静态定时任务时间:=== " + LocalDateTimes.nowFormat());
        }
    }
    

      Cron表达式参数分别表示:

    • 秒(0~59) 例如0/5表示每5秒
    • 分(0~59)
    • 时(0~23)
    • 日(0~31)的某天,需计算
    • 月(0~11)
    • 周几( 可填1-7 或 SUN/MON/TUE/WED/THU/FRI/SAT)

      @Scheduled:除了支持灵活的参数表达式cron之外,还支持简单的延时操作,例如 fixedDelay ,fixedRate 填写相应的毫秒数即可。

      2)启动测试

      启动springBoot项目,可以看到控制台打印出如下信息:

      

      显然,使用@Scheduled 注解很方便,但缺点是当我们调整了执行周期的时候,需要重启应用才能生效,这多少有些不方便。为了达到实时生效的效果,可以使用接口来完成定时任务。

    2.基于接口

      1)导入依赖包:

     <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>2.0.4.RELEASE</version>
        </parent>
    
        <dependencies>
            <dependency><!--添加Web依赖 -->
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency><!--添加MySql依赖 -->
                 <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            <dependency><!--添加Mybatis依赖 配置mybatis的一些初始化的东西-->
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.3.1</version>
            </dependency>
            <dependency><!-- 添加mybatis依赖 -->
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.4.5</version>
                <scope>compile</scope>
            </dependency>
        </dependencies>
    

        2)添加数据库记录:

    DROP DATABASE IF EXISTS `socks`;
    CREATE DATABASE `socks`;
    USE `SOCKS`;
    DROP TABLE IF EXISTS `cron`;
    CREATE TABLE `cron`  (
      `cron_id` varchar(30) NOT NULL PRIMARY KEY,
      `cron` varchar(30) NOT NULL  
    );
    INSERT INTO `cron` VALUES ('1', '0/5 * * * * ?');
    

      然后在项目中的application.properties添加数据库的配置

    3.创建定时器

      数据库准备好数据之后,我们编写定时任务,注意这里添加的是TriggerTask,目的是循环读取我们在数据库设置好的执行周期,以及执行相关定时任务的内容。
    具体代码如下:

    bean类:

    package com.cst.klocwork.bean.cron;
    
    import com.cst.util.bean.IBean;
    import lombok.Data;
    import lombok.experimental.Accessors;
    
    @Accessors(chain = true)
    @Data
    public class Cron implements IBean{
        private static final long serialVersionUID = 1L;
        private String cron_id;
        private String cron;
    
    }

    mapper类:

    package com.cst.klocwork.bean.cron;
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Select;
    import org.springframework.stereotype.Component;
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    
    @Mapper
    @Component
    public interface CronMapper extends BaseMapper<Cron>{
    	
    	@Select("select cron from cron where cron_id = '1'")
        String getCron();
    
    }
    

     定时器任务类:

    package com.cst.klocwork.service.cron;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.annotation.EnableScheduling;
    import org.springframework.scheduling.annotation.SchedulingConfigurer;
    import org.springframework.scheduling.config.ScheduledTaskRegistrar;
    import org.springframework.scheduling.support.CronTrigger;
    import org.springframework.stereotype.Component;
    import org.springframework.util.StringUtils;
    
    import com.cst.klocwork.bean.cron.CronMapper;
    import com.cst.util.string.LocalDateTimes;
    
    @Component
    @Configuration      //1.主要用于标记配置类,兼备Component的效果。
    @EnableScheduling   // 2.开启定时任务
    public class DynamicScheduleTask implements SchedulingConfigurer {
    
        @Autowired      //注入mapper
       private CronMapper cronMapper;
    
        /**
         * 执行定时任务.
         */
        @Override
        public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
    
            taskRegistrar.addTriggerTask(
                    //1.添加任务内容(Runnable)
                    () -> f1(),
                    //2.设置执行周期(Trigger)
                    triggerContext -> {
                        //2.1 从数据库获取执行周期
                        String cron = cronMapper.getCron();
                        //2.2 合法性校验.
                        if (StringUtils.isEmpty(cron)) {
                            // Omitted Code ..
                        }
                        //2.3 返回执行周期(Date)
                        return new CronTrigger(cron).nextExecutionTime(triggerContext);
                    }
            );
        }
    
        public void f1() {
        	System.err.println("执行动态定时任务: " + LocalDateTimes.nowFormat());
        }
    }
    

      4)、启动测试

      启动springBoot项目后,查看控制台,打印时间是我们预期的每10秒一次:

      如果此处想修改运行周期,只需要修改数据库里的时间即可改变运行周期。并且不需要我们重启应用,十分方便。

      注意: 如果在数据库修改时格式出现错误,则定时任务会停止,即使重新修改正确;此时只能重新启动项目才能恢复。

    3.多线程定时任务

      基于注解设定多线程定时任务

      1)创建多线程定时任务

    //@Component注解用于对那些比较中立的类进行注释;
    //相对与在持久层、业务层和控制层分别采用 @Repository、@Service 和 @Controller 对分层中的类进行注释
    @Component
    @EnableScheduling   // 1.开启定时任务
    @EnableAsync        // 2.开启多线程
    public class MultithreadScheduleTask {
    
            @Async
            @Scheduled(fixedDelay = 1000)  //间隔1秒
            public void first() throws InterruptedException {
                System.out.println("第一个定时任务开始 : " + LocalDateTime.now().toLocalTime() + "
    线程 : " + Thread.currentThread().getName());
                System.out.println();
                Thread.sleep(1000 * 10);
            }
    
            @Async
            @Scheduled(fixedDelay = 2000)
            public void second() {
                System.out.println("第二个定时任务开始 : " + LocalDateTime.now().toLocalTime() + "
    线程 : " + Thread.currentThread().getName());
                System.out.println();
            }
        }
    

      2)启动springBoot项目后

      查看控制台

      

    从控制台可以看出,第一个定时任务和第二个定时任务互不影响;

    并且,由于开启了多线程,第一个任务的执行时间也不受其本身执行时间的限制,所以需要注意可能会出现重复操作导致数据异常。

  • 相关阅读:
    node.js入门
    分布式爬虫
    ES6入门
    Vue.js入门
    用scrapy爬取亚马逊网站项目
    垃圾回收器
    HTTP协议详解
    有效的邮箱地址
    C#中正则表达式的使用
    抽象类
  • 原文地址:https://www.cnblogs.com/chcha1/p/11274881.html
Copyright © 2011-2022 走看看