精华内容
下载资源
问答
  • 2021-11-29 10:56:47
    /**
     * description: @EnableScheduling    @EnableAsync        
     *
     * @date 2021/11/29 10:37
     */
    @RestController
    @EnableScheduling // 1.开启定时任务
    @EnableAsync // 2.开启多线程执行
    public class PcController {
        private static final Logger LOGGER = LoggerFactory.getLogger(PcController .class);
    
       @PostMapping("/task")
       @Async
       @Scheduled(fixedRate=3000)//设置三秒执行一次
        public void taskTest() {
            LOGGER.info("执行定时任务....");
        }
    }
    

    @Scheduled介绍
    @Scheduled为设置定时任务周期的注解,参数常用的为两种:

    第一种就是fixedRate,他表示以一种固定频率去执行,单位为毫秒,例如@Scheduled(fixedRate = 5000) 表示为每五秒执行一次

    第二种为cron,他可以表达某种特定频率,例如每天晚上三点执行,每个星期三中午十二点等

    具体cron表达式用法大家可以百度,这里列出几个常用的:

    每隔5秒执行一次:*/5 * * * * ?

    每隔1分钟执行一次:0 */1 * * * ?

    每天23点执行一次:0 0 23 * * ?

    每天凌晨1点执行一次:0 0 1 * * ?

    每月1号凌晨1点执行一次:0 0 1 1 * ?

    每月最后一天23点执行一次:0 0 23 L * ?

    每周星期天凌晨1点实行一次:0 0 1 ? * L

    在26分、29分、33分执行一次:0 26,29,33 * * * ?

    每天的0点、13点、18点、21点都执行一次:0 0 0,13,18,21 * * ?

    每隔5分钟执行一次:0 0/5 * * * ?

    更多相关内容
  • 主要为大家详细介绍了SpringBoot实现定时任务和异步调用,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • springboot实现定时任务

    2021-05-15 15:17:20
    springboot实现定时任务有两种,一种是使用 Spring 自带的定时任务处理器 @Scheduled 注解,另一种就是使用第三方框架 Quartz ,下面看一下在springboot中如何使用这两种定时器。 @Scheduled 使用 @Scheduled 非常...

    springboot实现定时任务有两种,一种是使用 Spring 自带的定时任务处理器 @Scheduled 注解,另一种就是使用第三方框架 Quartz ,下面看一下在springboot中如何使用这两种定时器。

    @Scheduled

    使用 @Scheduled 非常容易,直接创建一个 Spring Boot 项目,并且添加 web 依赖 spring-boot-starter-web,项目创建成功后,添加 @EnableScheduling 注解,开启定时任务:

    如下:

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

    接下来配置定时任务:

    @Service
    public class HelloService {
        @Scheduled(fixedDelay = 2000)//前面任务的结束时间和后面任务的开始时间间隔是2秒
        public void fixDelay(){
            //System.out.println("fixDelay>>>"+new Date());
        }
    ​
        //两次定时任务开启的时间间隔为2秒,不管第一个任务有没有执行完毕,2秒后开启下一个任务
        @Scheduled(fixedRate = 2000)
        public void fixedRate(){
            //System.out.println("fixedRate"+new Date());
        }
    ​
        //cron表达式写法
        //分别表示秒、分、时、日、月、周、年(可以不写)
        @Scheduled(cron = "0/5 56 * * * ?")
        public void corn(){
            System.out.println("corn>>>"+new Date());
        }
    }
    1. 首先使用 @Scheduled 注解开启一个定时任务。

    2. fixedRate 表示任务执行之间的时间间隔,具体是指两次任务的开始时间间隔,即第二次任务开始时,第一次任务可能还没结束。

    3. fixedDelay 表示任务执行之间的时间间隔,具体是指本次任务结束到下次任务开始之间的时间间隔。

    4. initialDelay 表示首次任务启动的延迟时间。

    5. 所有时间的单位都是毫秒。

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

    从左到右依次表示 秒、分、时、日、月、周、年

    具体取值如下:

    序号说明是否必填允许填写的值允许的通配符
    10-59- * /
    20-59- * /
    30-23- * /
    41-31- * ? / L W
    51-12 or JAN-DEC- * /
    61-7 or SUN-SAT- * ? / L #
    71970-2099- * /

    这一块需要大家注意的是,月份中的日期和星期可能会起冲突,因此在配置时这两个得有一个是 ?

    通配符含义:

    • ? 表示不指定值,即不关心某个字段的取值时使用。需要注意的是,月份中的日期和星期可能会起冲突,因此在配置时这两个得有一个是 ?

    • * 表示所有值,例如:在秒的字段上设置 *,表示每一秒都会触发

    • , 用来分开多个值,例如在周字段上设置 “MON,WED,FRI” 表示周一,周三和周五触发

    • - 表示区间,例如在秒上设置 “10-12”,表示 10,11,12秒都会触发

    • / 用于递增触发,如在秒上面设置”5/15” 表示从5秒开始,每增15秒触发(5,20,35,50)

    • # 序号(表示每月的第几个周几),例如在周字段上设置”6#3”表示在每月的第三个周六,(用 在母亲节和父亲节再合适不过了)

    • 周字段的设置,若使用英文字母是不区分大小写的 ,即 MON 与mon相同

    • L 表示最后的意思。在日字段设置上,表示当月的最后一天(依据当前月份,如果是二月还会自动判断是否是润年), 在周字段上表示星期六,相当于”7”或”SAT”(注意周日算是第一天)。如果在”L”前加上数字,则表示该数据的最后一个。例如在周字段上设置”6L”这样的格式,则表示”本月最后一个星期五”

    • W 表示离指定日期的最近工作日(周一至周五),例如在日字段上设置”15W”,表示离每月15号最近的那个工作日触发。如果15号正好是周六,则找最近的周五(14号)触发, 如果15号是周未,则找最近的下周一(16号)触发,如果15号正好在工作日(周一至周五),则就在该天触发。如果指定格式为 “1W”,它则表示每月1号往后最近的工作日触发。如果1号正是周六,则将在3号下周一触发。(注,”W”前只能设置具体的数字,不允许区间”-“)

    • LW 可以一组合使用。如果在日字段上设置”LW”,则表示在本月的最后一个工作日触发(一般指发工资 )

    例如,在 @Scheduled 注解中来一个简单的 cron 表达式,每隔5秒触发一次,如下:

    //cron表达式写法
        //分别表示秒、分、时、日、月、周、年(可以不写)
        @Scheduled(cron = "0/5 * * * * ?")
        public void corn(){
            System.out.println("corn>>>"+new Date());
        }

    上面是使用@Scheduled 注解的方式来实现定时任务 。

    Quartz

    使用Quartz做定时任务在建项目的时候要导入相应的依赖:

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

    项目创建完成后,也需要添加开启定时任务的注解:

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

    Quartz 在使用过程中,有两个关键概念,一个是JobDetail(要做的事情),另一个是触发器(什么时候做),要定义 JobDetail,需要先定义 Job,Job 的定义有两种方式:

    第一种方式:

    @Component//MyFirst定义一个bean,使用springboot直接将该类定义成一个bean,这种方式无法传参
    public class MyFirstJob {
        public void sayHello(){
            System.out.println("first say hello"+new Date());
        }
    }

    第二种定义方式,则是继承 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("second say hello:"+name+new Date());
        }
    }

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

    Job 有了之后,接下来创建类,配置 JobDetail 和 Trigger 触发器,如下:

    @Configuration
    public class QuartzConfig {
        //配置MyFirstJob的定时方式
        @Bean
        MethodInvokingJobDetailFactoryBean methodInvokingJobDetailFactoryBean(){
            MethodInvokingJobDetailFactoryBean bean = new MethodInvokingJobDetailFactoryBean();
            bean.setTargetBeanName("myFirstJob");//配置定时任务的类(bean名称)
            bean.setTargetMethod("sayHello");//配置要执行的定时任务的方法
            return bean;
        }
    ​
        //第二种配置方式(MySecondJob实现定时任务方式)
        @Bean
        JobDetailFactoryBean jobDetailFactoryBean(){
            JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
            JobDataMap map = new JobDataMap();
            //传递参数
            map.put("name","changan");
            factoryBean.setJobDataMap(map);
            factoryBean.setJobClass(MySecondJob.class);
            return factoryBean;
    ​
        }
    ​
        //配置触发器
        @Bean
        SimpleTriggerFactoryBean simpleTriggerFactoryBean(){
            SimpleTriggerFactoryBean triggerFactoryBean = new SimpleTriggerFactoryBean();
            triggerFactoryBean.setJobDetail(methodInvokingJobDetailFactoryBean().getObject());
            //设置开始时间
            triggerFactoryBean.setStartTime(new Date());
            //设置间隔时间
            triggerFactoryBean.setRepeatInterval(2000);
            //设置重复次数
            triggerFactoryBean.setRepeatCount(5);
            return triggerFactoryBean;
        }
    ​
        //cron表达式方式配置触发器
        @Bean
        CronTriggerFactoryBean cronTriggerFactoryBean(){
            CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();
            cronTriggerFactoryBean.setJobDetail(jobDetailFactoryBean().getObject());
            cronTriggerFactoryBean.setCronExpression("* * * * * ?");
            return cronTriggerFactoryBean;
        }
    ​
        @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 表达式的用法。

    以上就是在springboot中使用两种定时任务的方式

     

    参考自:http://springboot.javaboy.org/2019/0418/springboot-schedule-task

    展开全文
  • 定时任务就是企业级开发中最为常见的功能之一,比如定时发送短信,邮件,定时统计各种数量 1. @Scheduled 注解 此注解是由 Spring 提供的定时任务注解,使用方便,配置简单,可以解决工作中大部分要使用到定时任务的...

    定时任务就是企业级开发中最为常见的功能之一,比如定时发送短信,邮件,定时统计各种数量

    1. @Scheduled 注解

    此注解是由 Spring 提供的定时任务注解,使用方便,配置简单,可以解决工作中大部分要使用到定时任务的场景,使用方式如下:
    在启动类上添加 @EnableScheduling 注解开启定时任务,代码如下:

    @SpringBootApplication
    @EnableScheduling // 启动类添加此注解就表示开启了定时任务功能
    public class SoftApplication {
    	public static void main(String[] args) {
    		SpringApplication.run(SoftApplication.class, args);
    	}
    }
    

    2. 配置定时任务

    定时任务主要通过 @Scheduled 注解进行配置,代码如下:

    public class MyScheduled {
    	@Scheduled(fixedDelay = 1000)
    	public void test1() {
    		System.out.println('test1() = ' + new Date());
    	}
    
    	@Scheduled(fixedRate = 2000)
    	public void test2() {
    		System.out.println('test2() = ' + new Date());
    	}
    
    	@Scheduled(initialDelay = 1000, fixedRate = 2000)
    	public void test3() {
    		System.out.println('test3() = ' + new Date());
    	}
    
    	@Scheduled(cron = "0 * * * * ?")
    	public void test4() {
    		System.out.println('test4() = ' + new Date());
    	}
    }
    

    通过 @Scheduled 注解来标记一个定时任务,其中 fixedDelay = 1000 表示在当前任务执行结束1秒后开启另一个任务,fixedRate = 2000 表示在当前任务开始执行2秒后开启另一个定时任务,initialDelay = 1000 则表示首次执行任务的延迟时间为1秒

    @Scheduled 注解中也可以使用 cron 表达式,cron = "0 * * * * ?" 表示此任务每分钟执行一次

    展开全文
  • springBoot 实现定时任务

    springBoot 实现定时任务

    今天有一个需求:使用定时任务实现对数据的更新

    重点

    • mybaits-plus 实现对数据的更新
    • spring boot 的定时任务的实现

    实现逻辑

    1. 链接数据库
    2. mybaits-plus 反向生成 CRUD 接口
    3. 书写 service层对数据批量更新的service
    4. spring boot定时任务的书写
    5. 代码测试

    代码实现

    这里省略了1和2,3的步骤,直接从4开始

    package com.sun.tast;
    
    import com.sun.service.ITimeService;
    import com.sun.service.impl.CronServiceImpl;
    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 java.time.LocalDateTime;
    
    /**
     * @author user
     */
    @Configuration
    @EnableScheduling
    public class DynamicScheduleTask implements SchedulingConfigurer {
    
        @Autowired
        private CronServiceImpl cronServiceImpl;
    
        @Autowired
        private ITimeService iTimeService;
    
        /**
         * 执行定时任务.
         */
        @Override
        public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
    
            taskRegistrar.addTriggerTask(
                    //1.添加任务内容(Runnable)
                    () -> System.out.println("执行动态定时任务: " + LocalDateTime.now().toLocalTime()),
                    //2.设置执行周期(Trigger)
                    triggerContext -> {
                        int i = iTimeService.updateTimeForCreateTime();
                        System.out.println(i);
                        //2.1 从数据库获取执行周期
                        String cron = null;
                        try {
                            cron = cronServiceImpl.getFirstName().get(0).getCron();
                            return new CronTrigger(cron).nextExecutionTime(triggerContext);
                        } catch (Exception e) {
                            return null;
                        }
                    }
            );
        }
    }
    

    代码截图为

    执行动态定时任务: 16:37:50.015
    Creating a new SqlSession
    SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3af52cab] was not registered for synchronization because synchronization is not active
    JDBC Connection [HikariProxyConnection@1670670346 wrapping com.mysql.cj.jdbc.ConnectionImpl@3c7f8c25] will not be managed by Spring
    ==>  Preparing: UPDATE time SET static_value=? WHERE (static_value = ? AND create_time > ?)
    ==> Parameters: 2(Integer), 0(Integer), 2022-03-30 16:37:50.015(Timestamp)
    <==    Updates: 0
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3af52cab]
    0
    Creating a new SqlSession
    SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@2c62c3a6] was not registered for synchronization because synchronization is not active
    JDBC Connection [HikariProxyConnection@1071719157 wrapping com.mysql.cj.jdbc.ConnectionImpl@3c7f8c25] will not be managed by Spring
    ==>  Preparing: SELECT cron_id,cron FROM cron
    ==> Parameters: 
    <==    Columns: cron_id, cron
    <==        Row: 1, 0/10 * * * * ?
    <==      Total: 1
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@2c62c3a6]
    

    项目地址

    请移步gitee进行下载

    展开全文
  • 定时任务是企业级开发中最常见的功能之一,如定时推送短信和邮件、数据库备份、定时统计收益、定时统计访客等,简单的定时任务可以直接通过Spring中的@Scheduled注解来实现,复杂的定时任务则可以通过集成Quartz来...
  • 基于springboot实现定时任务 springboot 框架本身的定时任务比较简单,在启动类中使用 @EnableScheduling 注解开启定时任务,会自动扫描,相当于一个开关,把这个开关开完之后,那么只要在相应的任务类中做相应的任务...
  • 主要介绍了SpringBoot 实现定时任务的方法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • SpringBoot实现定时任务

    2021-06-07 23:26:59
    1、引包 pom 包里面只需要引入 Spring Boot Starter 包即可 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <...2、创建定时任务 @Co
  • SpringBoot实现定时任务的三种方式

    千次阅读 2022-04-08 12:44:50
    利用Timer这个api,去实现定时任务,用Timertask去创建一个任务 public class javaJob { public static void main(String[] args) { //利用java的api Timer来完成一个定时任务 Timer timer = new Timer(); //...
  • 在平常的开发工作中,我们经常会用到定时任务,比如定时刷新数据,定时去执行某个业务操作,定时任务,我们经常使用,那么springboot可以怎样实现定时任务呢? 1:创建定时任务:方法上添加@Scheduled注解,定义...
  • 主要为大家详细介绍了SpringBoot下RabbitMq实现定时任务,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • SpringBoot实现动态定时任务,是Springboot做的动态定时任务,可以暂停,恢复,添加,删除,等操作
  • 最新springboot+Quartz实现动态定时任务,源代码. 包括controller,service,impl,和配置文件,pom文件,实体类,直接导入springboot项目,配置好数据库就能使用.欢迎下载好评!
  • Springboot整合Quartz实现定时任务数据库动态配置,新增任务、修改cron表达式、暂停任务、恢复任务、删除任务等操作
  • 点击关注公众号,利用碎片时间学习序言SpringBoot创建定时任务,目前主要有以下三种实现方式:基于注解(@Scheduled): 基于注解@Scheduled默认为单线程,开启多个任务时,任务的执行时机会受上一个任务执行时间的...
  • SpringBoot 实现定时任务的两种方式:基于注解(@Scheduled)的简单定时器,基于接口SchedulingConfigurer的动态定时任务
  • 第一步,创建一个定时任务类,例如 LineSegmentCacheTask 代码示例 import lombok.extern.slf4j.Slf4j; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype....
  • 写一个SpringBoot的启动类 启动类里面使用@EnableScheduling 注解开启定时任务功能。 @SpringBootApplication @EnableScheduling @MapperScan("com.less.parent.dao") public class App { public static void main...
  • SpringBoot定时任务实现Oracle和mysql数据同步
  • springboot实现定时任务时间可配置

    千次阅读 2018-12-27 18:25:41
    在使用springboot定时任务时,cron 表达式是写在程序中的,感觉这样写是不好的,如果想改时间就得改代码,是不是可以将时间配置在配置文件中呢?当然是可以的。 在application.yml中配置如下: configtask: ...
  • 在spring boot项目中,可以通过@EnableScheduling注解和@Scheduled注解实现定时任务,也可以通过SchedulingConfigurer接口来实现定时任务。但是这两种方式不能动态添加、删除、启动、停止任务。要实现动态增删启停...
  • 主要介绍了Spring Boot 中实现定时任务的两种方式,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Springboot @Scheduled 默认是单线程的, 也就是说当我们定义了多个定时任务时,如果有本应该是相同时间触发的定时任务, 会进行排队, 如果某个定时任务执行时间过长, 就会导致其他定时并未按照设置时间来触发执行...
  • 本篇文章主要介绍了SpringBoot 创建定时任务(配合数据库动态执行),小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,907
精华内容 8,362
关键字:

springboot实现定时任务

spring 订阅