精华内容
下载资源
问答
  • springboot设置定时任务
    2020-02-27 11:10:49

    一:创建定时任务

    创建core→tesks→tesk.java

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    package com.example.demo.core.tasks;

     

    import org.springframework.scheduling.annotation.EnableScheduling;

    import org.springframework.scheduling.annotation.Scheduled;

    import org.springframework.stereotype.Component;

     

    import java.util.Date;

     

    @Component

    /**

     * 开启定时任务的注解

     */

    @EnableScheduling

    public class tesk {

     

        @Scheduled(fixedRate = 5000)

        public void job1(){

            System.out.println("定时任务1" new Date());

        }

     

        @Scheduled(cron = "0/5 * * * * ?")

        public void job2(){

            System.out.println("定时任务2" new Date());

        }

    }

      

    二:@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设置定时任务

    千次阅读 2022-04-06 14:09:25
    springboot设置定时任务

    1.在启动类上加上@EnableScheduling注解,开启定时注解的功能

    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.scheduling.annotation.EnableAsync;
    import org.springframework.scheduling.annotation.EnableScheduling;
    
    
    @EnableAsync   // 开启异步注解功能
    @EnableScheduling  // 开启定时功能的注解
    @SpringBootApplication
    public class Springboot09TestApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(Springboot09TestApplication.class, args);
        }
    
    }
    

    2.创建一个service,在该类中设置定时方法

    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Service;
    
    @Service
    public class ScheduledService {
    
        // 在一个特定的时间执行这个方法
        // cron表达式
        // 秒 分 时 日 月 星期
        @Scheduled(cron = "0/2 * * * * ?")   // 每两秒执行一次该方法
        public void hello(){
            System.out.println("hello,kobe...");
        }
    }
    

    展开全文
  • 主要为大家详细介绍了SpringBoot实现定时任务和异步调用,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • SpringBoot设置定时任务

    2019-06-24 14:43:57
    在实际开发中,很多时候都会需要用到定时任务,能够自动执行所需要执行的方法,不过不同框架配置定时任务的方法也是不同的,下面我介绍下在Springboot中如何配置定时任务。 开启定时任务 @RestController @...

    前言

    在实际开发中,很多时候都会需要用到定时任务,能够自动执行所需要执行的方法,不过不同框架配置定时任务的方法也是不同的,下面我介绍下在Springboot中如何配置定时任务。

    开启定时任务

    @RestController
    @EnableScheduling // 这个注解必须添加
    public class BatchController  {
    
        @Scheduled(fixedRate = 10000) // 必须添加
        public void test(){
            System.out.println("定时任务" + TimeUtil.getCurrentTimeString("yyyy-MM-dd HH:mm:ss"));
        }
    }
    

    在test方法上方有个 @Scheduled注解,这是规定该方法多久执行一次,我这里用的是fixedRate,表示每10秒执行一次。当然也有下面的主流用法:

    @RestController
    @EnableScheduling // 这个注解必须添加
    public class BatchController  {
    
        @Scheduled(cron="0/10 * * * * ?") // 这里指的是每10秒执行一次
        public void test(){
            System.out.println("定时任务" + TimeUtil.getCurrentTimeString("yyyy-MM-dd HH:mm:ss"));
        }
    }
    

    下面是执行时间的表达式以及示例:
    在这里插入图片描述
    示例:
    在这里插入图片描述

    结果

    下面我们来测试下定时任务是否执行:

    定时任务2019-06-24 14:41:49
    定时任务2019-06-24 14:41:59
    定时任务2019-06-24 14:42:09
    定时任务2019-06-24 14:42:19
    

    测试完成!大家如果有兴趣,可以自己写一个来试下,毕竟说的好不如做的好,哈哈!

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

    千次阅读 2020-09-28 10:29:44
    定时任务Quartz1. Quartz Scheduler2. Quartz 的线程3. 数据存储4. 使用方法4.1 引入依赖4.2 创建目标任务job4.3 创建配置类QuartzConfig4.3 查看打印 Quartz 1. Quartz Scheduler 主要设计以下元素: scheduler:...

    Quartz

    1. Quartz Scheduler

    主要设计以下元素:

    • scheduler:任务调度器;
    • trigger:触发器,用于定义任务调度的时间规划;
    • job:被调度的任务;
    • misfire:错过的,指本来应该执行,但实际没有被执行的任务调度。

    其中trigger和job是任务调度的元数据,scheduler是实际执行调度的控制器。

    • trigger 是用于定义调度时间的元素,即按照什么时间规则去执行任务。Quartz 中主要提供了四种类型的 trigger: SimpleTrigger,CronTirgger,DateIntervalTrigger,和 NthIncludedDayTrigger。
    • job:无状态的(stateless)和有状态的(stateful)。对于同一个 trigger 来 说,有状态的 job 不能被并行执行,只有上一次触发的任务被执行完之后,才能触发下一次执行。Job 主要有两种属性:volatility 和 durability,其中 volatility 表示任务是否被持久化到数据库存储,而 durability 表示在没有 trigger 关联的时候任务是否被保留。两者都是在值为 true 的时候任务被持久化或保留。
    • 一个 job 可以被多个 trigger 关联,但是一个 trigger 只能关联一个 job。
    • scheduler 由 scheduler 工厂创建:DirectSchedulerFactory 或者 StdSchedulerFactory。 一般使用 StdSchedulerFactory 工厂 较多。 Scheduler 主要有三种:RemoteMBeanScheduler, RemoteScheduler 和 StdScheduler。最常用的为 StdScheduler。

    2. Quartz 的线程

    • 在 Quartz 中,有两类线程,Scheduler 调度线程和任务执行线程,其中任务执行线程通常使用一个线程池维护一组线程。
    • Scheduler 调度线程主要有两个: 执行常规调度的线程,和执行 misfired trigger 的线程。常规调度线程轮询存储的所有 trigger, 如果有需要触发的 trigger,即到达了下一次触发的时间,则从任务执行线程池获取一个空闲线程,执行与该 trigger 关联的任 务。Misfire 线程是扫描所有的 trigger,查看是否有 misfired trigger,如果有的话根据 misfire 的策略分别处理。

    3. 数据存储

    • Quartz 中的 trigger 和 job 需要存储下来才能被使用。Quartz 中有两种存储方式:RAMJobStore, JobStoreSupport,其中RAMJobStore 是将 trigger 和 job 存储在内存中, 而 JobStoreSupport 是基于 jdbc 将 trigger 和 job 存储到数据库中。RAMJobStore 的存取速度非常快, 但是由于其在系统被停止后所有的数据都会丢失, 所以在通常应用中, 都是使用JobStoreSupport。
    • 在 Quartz 中,JobStoreSupport 使用一个驱动代理来操作 trigger 和 job 的数据存储:StdJDBCDelegate。StdJDBCDelegate 实现了大部分基于标准 JDBC 的功能接口,但是对于各种数据库来说,需要根据其具体实现的特点做某些特殊处理,因此各种数据库需要扩展 StdJDBCDelegate 以实现这些特殊处理。Quartz 已经自带了一些数据库的扩展实现,可以直接使用。

    4. 使用方法

    4.1 引入依赖

    • 这里springboot使用的是2.3.1.RELEASE
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
    </dependency>
    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
        <version>2.3.1</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
    </dependency>
    

    在这里插入图片描述

    4.2 创建目标任务job

    1. 使用实现 org.quartz.Job 接口的方式创建任务BusinessJob

    在这里插入图片描述

    package com.example.demo.job;
    
    import lombok.extern.slf4j.Slf4j;
    import org.quartz.Job;
    import org.quartz.JobDataMap;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    
    @Slf4j
    public class BusinessJob implements Job {
        int i = 0;
    
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            JobDataMap dataMap = jobExecutionContext.getJobDetail().getJobDataMap();
            String time = dataMap.get("time").toString();
            business(time);
        }
    
        public void business(String time) {
            i++;
            log.info("time:{},threadName:{},i:{}", time, Thread.currentThread().getName(), i);
        }
    }
    
    1. 普通任务类

    在这里插入图片描述

    package com.example.demo.job;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Component;
    
    @Slf4j
    @Component
    public class JobService {
    
        int i = 0;
        public void business() {
            i++;
            log.info("定时任务,业务方法执行,thread:{},i:{}", Thread.currentThread().getName(), i);
        }
    }
    

    4.3 创建配置类QuartzConfig

    在这里插入图片描述

    package com.example.demo.config;
    
    import com.example.demo.job.BusinessJob;
    import com.example.demo.job.JobService;
    import org.quartz.JobDataMap;
    import org.quartz.JobDetail;
    import org.quartz.Trigger;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.quartz.*;
    
    import java.time.LocalDateTime;
    
    @Configuration
    public class QuartzConfig {
    
        //配置任务,多例的业务bean,耦合业务类,需要实现Job接口
        @Bean(name = "businessJobDetail")
        public JobDetailFactoryBean businessJobDetail() {
            LocalDateTime localDateTime = LocalDateTime.now();
            JobDetailFactoryBean jobDetailFactoryBean = new JobDetailFactoryBean();
            jobDetailFactoryBean.setJobClass(BusinessJob.class);
            //将参数传给job
            JobDataMap jobDataMap = new JobDataMap();
            jobDataMap.put("time", localDateTime);
            jobDetailFactoryBean.setJobDataAsMap(jobDataMap);
            return jobDetailFactoryBean;
        }
    
        //配置任务,单例的业务bean
        @Bean(name = "jobServiceBeanDetail")
        public MethodInvokingJobDetailFactoryBean jobServiceBeanDetail(JobService jobService) {
            MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
            //是否并发执行
            jobDetail.setConcurrent(false);
            //需要执行的实体bean
            jobDetail.setTargetObject(jobService);
            //需要执行的方法
            jobDetail.setTargetMethod("business");
            return jobDetail;
        }
    
        //配置简单触发器
        @Bean(name = "simpleTrigger")
        public SimpleTriggerFactoryBean simpleTrigger(JobDetail businessJobDetail) {//businessJobDetail
            SimpleTriggerFactoryBean trigger = new SimpleTriggerFactoryBean();
            trigger.setJobDetail(businessJobDetail);
            //设置启动延迟
            trigger.setStartDelay(0);
            //每隔5s执行一次
            trigger.setRepeatInterval(5000);
            return trigger;
        }
    
        //配置cron触发器
        @Bean(name = "cronTrigger")
        public CronTriggerFactoryBean cronTrigger(JobDetail jobServiceBeanDetail) {//目标任务jobServiceBeanDetail
            CronTriggerFactoryBean triggerFactoryBean = new CronTriggerFactoryBean();
            triggerFactoryBean.setJobDetail(jobServiceBeanDetail);
            //每隔6s执行一次
            triggerFactoryBean.setCronExpression("0/6 * * * * ?");
            return triggerFactoryBean;
        }
    
        //配置调用工厂,将所有的触发器引入
        @Bean(name = "scheduler")
        public SchedulerFactoryBean schedulerFactory(Trigger cronTrigger, Trigger simpleTrigger) {//需要管理的触发器cronTrigger,simpleTrigger
            SchedulerFactoryBean bean = new SchedulerFactoryBean();
            //延迟1s启动
            bean.setStartupDelay(1);
            //注册触发器,可以注册多个
            bean.setTriggers(cronTrigger, simpleTrigger);
            return bean;
        }
    }
    

    4.3 查看打印

    在这里插入图片描述
    在这里插入图片描述

    spring task

    • Spring 从 3.0 开始增加了自己的任务调度器,它是通过扩展 java.util.concurrent 包下面的类来实现的。使用 spring task 非常简单,只需要给定时任务类添加@Component 和 @EnableScheduling注解,给任务方法添加@Scheduled注解,并让 Spring 扫描到该类即可。

    1. 创建任务TaskService

    package com.example.demo.schedule;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Component;
    
    import java.util.concurrent.TimeUnit;
    
    @Slf4j
    @Component
    @EnableScheduling
    public class TaskService {
    
        //每隔1s执行一次
        @Scheduled(fixedRate = 1000)
        public void fixMethod() {
            try {
                log.info("fixMethod,thread:{}",Thread.currentThread().getName());
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        //前一个任务执行完5s后执行
        @Scheduled(fixedDelay = 5000)
        public void delayMethod() {
            log.info("delayMethod,thread:{}",Thread.currentThread().getName());
        }
    
        //每隔10s执行一次
        @Scheduled(cron = "0/10 * * * * ?")
        public void cronMethod() {
            log.info("cronMethod,thread:{}",Thread.currentThread().getName());
        }
    
    }
    
    • 启动项目,查看打印
    • fixMethod方法没有每隔1s执行一次;
    • delayMethod方法没有在前一个delayMethod方法执行后5s执行;
    • cronMethod方法也没有每隔10s执行一次;
    • 通过打印可以看出定时任务只有scheduling-1一个线程在执行,属于单线程,fixMethod方法执行时间是2s,即使设置时间间隔是1s,后一次执行也要等到前一次代码执行完才能执行,属于同步执行

    在这里插入图片描述

    2. 多线程配置

    • 当前项目中存在多个任务时,可以配置 executor 线程池,这里 executor 的含义和 java.util.concurrent.Executor 是一样的,pool-size 的大小官方推荐为 5~10。
    • 创建配置类ScheduleConfig,实现SchedulingConfigurer接口

    在这里插入图片描述

    package com.example.demo.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.annotation.SchedulingConfigurer;
    import org.springframework.scheduling.config.ScheduledTaskRegistrar;
    
    import java.util.concurrent.Executor;
    import java.util.concurrent.Executors;
    
    @Configuration
    public class ScheduleConfig implements SchedulingConfigurer {
    
    
        @Override
        public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
            taskRegistrar.setScheduler(taskExecutor());
        }
    
        //配置线程池--触发器和任务共用
        @Bean
        public Executor taskExecutor(){
            return Executors.newScheduledThreadPool(10);
        }
    }
    
    
    • 查看打印
    • 线程池内有10个线程,即使任务多了也不影响线程之间的执行时间间隔。

    在这里插入图片描述

    3. 异步

    • 配置类中添加注解@EnableAsync

    在这里插入图片描述

    • 任务类在方法上添加注解@Async

    在这里插入图片描述

    • 查看打印

    在这里插入图片描述

    代码下载地址

    https://gitee.com/fisher3652/exportDemo

    展开全文
  • 主要介绍了springboot schedule 解决定时任务不执行的问题,本文给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • SpringBoot实现定时任务的动态开启关闭,如有疑问联系wx: hsj179540
  • 主要介绍了SpringBoot执行定时任务@Scheduled的方法,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • springboot动态配置定时任务(schedule),可不重启项目实现开关重启任务,改变任务定时规则
  • SpringBoot定时任务

    2022-07-15 11:31:51
    springboot项目中,可能有定时任务的需求,springboot自带有定时任务的功能 用法: 首先,需要在启动类中开启定时任务的配置,即@EnableScheduling注解
  • 主要介绍了SpringBoot并发定时任务动态定时任务实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 本篇文章主要介绍了SpringBoot 创建定时任务(配合数据库动态执行),小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • springboot定时任务

    万次阅读 多人点赞 2020-08-05 11:43:35
    使用SpringBoot创建定时任务非常简单,目前主要有以下三种创建方式: 一、基于注解(@Scheduled) 二、基于接口(SchedulingConfigurer) 前者相信大家都很熟悉,但是实际使用中我们往往想从数据库中读取指定时间来...
  • SpringBoot 框架, Spring scheduling
  • SpringBoot设置动态定时任务

    千次阅读 2022-03-22 10:40:17
    之前写过文章记录怎么在SpringBoot项目中简单使用定时任务,不过由于要借助cron表达式且都提前定义好放在配置文件里,不能在项目运行中动态修改任务执行时间,实在不太灵活。 经过网上搜索学习后,特此记录如何在...
  • 主要为大家详细介绍了基于Springboot执行多个定时任务并动态获取定时任务信息,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 1. SpringBoot 自定义线程池以及多线程间的异步调用(@Async、@EnableAsync) 2.Java多线程之定时任务 以及 SpringBoot多线程实现定时任务 3.@EnableScheduling 与 @Scheduled
  • 在实际设计开发“测试集”功能的时候,为每一个测试集提供了一个定时任务cron表达式字段,代码需要实现将具备cron表达式的测试集动态加入到定时任务中,按cron表达式的规则定时执行测试集中的接口用例 二、...
  • 使用springboot 构建的 spring task 定时任务,采用异步任务形式,防止任务堵塞.
  • 主要为大家详细介绍了SpringBoot下RabbitMq实现定时任务,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 在传统的Spring项目中使用Spring Task设置定时任务,其执行时间配置到applicationContext.xml中指定执行方法即可;但是由于现在换做了SpringBoot框架,虽然Spring Task是集成在SpringBoot中的,但是大多是用注解直接...
  • 点击关注公众号,利用碎片时间学习序言SpringBoot创建定时任务,目前主要有以下三种实现方式:基于注解(@Scheduled): 基于注解@Scheduled默认为单线程,开启多个任务时,任务的执行时机会受上一个任务执行时间的...
  • SpringBoot执行定时任务

    2022-06-21 16:51:23
    两步实现SpringBoot定时任务
  • SpringBoot开启定时任务

    2022-07-26 14:41:54
    SpringBoot自带的定时任务
  • Springboot开启定时任务

    千次阅读 2022-01-21 14:27:00
    @SpringBootApplication //扫描mybatis通用mapper所在的包 @MapperScan(basePackages = "com.xpf.mapper") //扫描所有包,以及相关组件包 @ComponentScan(basePackages = {"com.xpf","org.n3r.idworker"}) //开启...
  • 首先经过了解,@Scheduled是单线程的,如果有多个定时任务,势必需要前一个任务执行完才会执行后面的任务,先放代码: package com.wl.standard.task; import com.wl.standard.entity.City; import ...
  • Springboot集成定时任务

    2021-08-06 17:14:07
    @SpringBootApplication @EnableScheduling public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } } 2、任务
  • springboot中通过读取数据库的定时任务信息,动态生成quartz定时任务

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,208
精华内容 13,683
关键字:

springboot设置定时任务

spring 订阅
友情链接: Programabble-Power-SCPI.zip