SpringBoot + quartz 实现定时任务

最新推荐文章于 2024-06-22 22:09:58 发布
最新推荐文章于 2024-06-22 22:09:58 发布
阅读量375 收藏 5
点赞数 1
文章标签： java 数据库
原文链接：https://my.oschina.net/u/4041837/blog/3016819
版权
SpringBoot + quartz 动态添加定时任务
  • Quartz ： 完全由Java编写的开源作业调度框架，实现了作业和触发器的多对多关系，多个作业与不同的触发器关联

Quartz 核心

  • Job : 一个具体的内容或工作
  • JobDetail ：一个具体的可执行的调度程序
  • Trigger ： 调度触发器及参数的配置
  • Scheduler ：代表一个调度容器 （一个调度容器中可注册多个JobDetail和Trigger）
  • Cron ： Cron 定时时间表达式
相关开源项目  RouYi 若依 企业开发脚手架
依赖
<!-- 定时任务 -->
		<dependency>
			<groupId>org.quartz-scheduler</groupId>
			<artifactId>quartz</artifactId>
			<version>${quartz.version}</version>
			<exclusions>
				<exclusion>
					<groupId>com.mchange</groupId>
					<artifactId>c3p0</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

创建调度类 ScheduleConfig

/**
 * 定时任务配置
 *
 *
 */
@Configuration
public class ScheduleConfig
{
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource)
    {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setDataSource(dataSource);

        // quartz参数
        Properties prop = new Properties();
        prop.put("org.quartz.scheduler.instanceName", "RuoyiScheduler");
        prop.put("org.quartz.scheduler.instanceId", "AUTO");
        // 线程池配置
        prop.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
        prop.put("org.quartz.threadPool.threadCount", "20");
        prop.put("org.quartz.threadPool.threadPriority", "5");
        // JobStore配置
        prop.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
        // 集群配置
        prop.put("org.quartz.jobStore.isClustered", "true");
        prop.put("org.quartz.jobStore.clusterCheckinInterval", "15000");
        prop.put("org.quartz.jobStore.maxMisfiresToHandleAtATime", "1");
        prop.put("org.quartz.jobStore.txIsolationLevelSerializable", "true");

        // sqlserver 启用
        // prop.put("org.quartz.jobStore.selectWithLockSQL", "SELECT * FROM {0}LOCKS UPDLOCK WHERE LOCK_NAME = ?");
        prop.put("org.quartz.jobStore.misfireThreshold", "12000");
        prop.put("org.quartz.jobStore.tablePrefix", "QRTZ_");
        factory.setQuartzProperties(prop);

        factory.setSchedulerName("RuoyiScheduler");
        // 延时启动
        factory.setStartupDelay(1);
        factory.setApplicationContextSchedulerContextKey("applicationContextKey");
        // 可选，QuartzScheduler
        // 启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了
        factory.setOverwriteExistingJobs(true);
        // 设置自动启动，默认为true
        factory.setAutoStartup(true);

        return factory;
    }
}

创建 任务调度通用常量 接口

/**
 * 任务调度通用常量
 *
 */
public interface ScheduleConstants
{
    public static final String TASK_CLASS_NAME = "__TASK_CLASS_NAME__";

    public static final String TASK_PROPERTIES = "__TASK_PROPERTIES__";

    /** 默认 */
    public static final String MISFIRE_DEFAULT = "0";

    /** 立即触发执行 */
    public static final String MISFIRE_IGNORE_MISFIRES = "1";

    /** 触发一次执行 */
    public static final String MISFIRE_FIRE_AND_PROCEED = "2";

    /** 不触发立即执行 */
    public static final String MISFIRE_DO_NOTHING = "3";

    public enum Status
    {
        /**
         * 正常
         */
        NORMAL("0"),
        /**
         * 暂停
         */
        PAUSE("1");

        private String value;

        private Status(String value)
        {
            this.value = value;
        }

        public String getValue()
        {
            return value;
        }
    }
}

JobService 服务层

  • 被@PostConstruct修饰的方法会在服务器加载Servlet的时候运行，并且只会被服务器调用一次，类似于Serclet的inti()方法。被@PostConstruct修饰的方法会在构造函数之后，init()方法之前运行。
  • 被@PreDestroy修饰的方法会在服务器卸载Servlet的时候运行，并且只会被服务器调用一次，类似于Servlet的destroy()方法。被@PreDestroy修饰的方法会在destroy()方法之后运行，在Servlet被彻底卸载之前。
  • Servlet容器 初始化 方法init() 之前 对数据表中 的job判断是否有 表达式触发器 CronTrigger
  • 若没有 便创建 JobDetail 和 表达式构建器 以及 表达式触发器
  • 最后 判断 状态 ，若为 1 则暂停 任务
  • 否则 重写后 QuartzJobBean 中的 执行体 方法会根据 时间表达式 自动执行。
/**
 * 定时任务调度信息 服务层
 *
 */
@Service
public class SysJobServiceImpl implements ISysJobService
{
    @Autowired
    private Scheduler scheduler;

    @Autowired
    private SysJobMapper jobMapper;

    /**
     * 项目启动时，初始化定时器
     */
    @PostConstruct
    public void init()
    {
        List<SysJob> jobList = jobMapper.selectJobAll();
        for (SysJob job : jobList)
        {
            CronTrigger cronTrigger = ScheduleUtils.getCronTrigger(scheduler, job.getJobId());
            // 如果不存在，则创建
            if (cronTrigger == null)
            {
                ScheduleUtils.createScheduleJob(scheduler, job);
            }
            else
            {
                ScheduleUtils.updateScheduleJob(scheduler, job);
            }
        }
    }

    /**
     * 获取quartz调度器的计划任务列表
     * 
     * @param job 调度信息
     * @return
     */
    @Override
    public List<SysJob> selectJobList(SysJob job)
    {
        return jobMapper.selectJobList(job);
    }

    /**
     * 通过调度任务ID查询调度信息
     * 
     * @param jobId 调度任务ID
     * @return 调度任务对象信息
     */
    @Override
    public SysJob selectJobById(Long jobId)
    {
        return jobMapper.selectJobById(jobId);
    }

    /**
     * 暂停任务
     * 
     * @param job 调度信息
     */
    @Override
    public int pauseJob(SysJob job)
    {
        job.setStatus(ScheduleConstants.Status.PAUSE.getValue());
        int rows = jobMapper.updateJob(job);
        if (rows > 0)
        {
            ScheduleUtils.pauseJob(scheduler, job.getJobId());
        }
        return rows;
    }

    /**
     * 恢复任务
     * 
     * @param job 调度信息
     */
    @Override
    public int resumeJob(SysJob job)
    {
        job.setStatus(ScheduleConstants.Status.NORMAL.getValue());
        int rows = jobMapper.updateJob(job);
        if (rows > 0)
        {
            ScheduleUtils.resumeJob(scheduler, job.getJobId());
        }
        return rows;
    }

    /**
     * 删除任务后，所对应的trigger也将被删除
     * 
     * @param job 调度信息
     */
    @Override
    public int deleteJob(SysJob job)
    {
        int rows = jobMapper.deleteJobById(job.getJobId());
        if (rows > 0)
        {
            ScheduleUtils.deleteScheduleJob(scheduler, job.getJobId());
        }
        return rows;
    }

    /**
     * 批量删除调度信息
     * 
     * @param ids 需要删除的数据ID
     * @return 结果
     */
    @Override
    public void deleteJobByIds(String ids)
    {
        Long[] jobIds = Convert.toLongArray(ids);
        for (Long jobId : jobIds)
        {
            SysJob job = jobMapper.selectJobById(jobId);
            deleteJob(job);
        }
    }

    /**
     * 任务调度状态修改
     * 
     * @param job 调度信息
     */
    @Override
    public int changeStatus(SysJob job)
    {
        int rows = 0;
        String status = job.getStatus();
        if (ScheduleConstants.Status.NORMAL.getValue().equals(status))
        {
            rows = resumeJob(job);
        }
        else if (ScheduleConstants.Status.PAUSE.getValue().equals(status))
        {
            rows = pauseJob(job);
        }
        return rows;
    }

    /**
     * 立即运行任务
     * 
     * @param job 调度信息
     */
    @Override
    public int run(SysJob job)
    {
        return ScheduleUtils.run(scheduler, selectJobById(job.getJobId()));
    }

    /**
     * 新增任务
     * 
     * @param job 调度信息 调度信息
     */
    @Override
    public int insertJobCron(SysJob job)
    {
        job.setStatus(ScheduleConstants.Status.PAUSE.getValue());
        int rows = jobMapper.insertJob(job);
        if (rows > 0)
        {
            ScheduleUtils.createScheduleJob(scheduler, job);
        }
        return rows;
    }

    /**
     * 更新任务的时间表达式
     * 
     * @param job 调度信息
     */
    @Override
    public int updateJobCron(SysJob job)
    {
        int rows = jobMapper.updateJob(job);
        if (rows > 0)
        {
            ScheduleUtils.updateScheduleJob(scheduler, job);
        }
        return rows;
    }
    
    /**
     * 校验cron表达式是否有效
     * 
     * @param cronExpression 表达式
     * @return 结果
     */
    @Override
    public boolean checkCronExpressionIsValid(String cronExpression)
    {
        return CronUtils.isValid(cronExpression);
    }   
}

创建任务类


/**
 * 定时任务调度测试
 *
 */
@Component("Task")
public class Task
{
    public void Params(String params)
    {
        System.out.println("执行有参方法：" + params);
    }

    public void NoParams()
    {
        System.out.println("执行无参方法");
    }
}
定时任务工具类

  • "cronExpression"的配置说明

  • 字段 允许值 允许的特殊字符

  • 秒 0-59 , - * /

  • 分 0-59 , - * /

  • 小时 0-23 , - * /

  • 日期 1-31 , - * ? / L W C

  • 月份 1-12 或者 JAN-DEC , - * /

  • 星期 1-7 或者 SUN-SAT , - * ? / L C #

  • 年（可选） 留空, 1970-2099 , - * /

  • - 区间

  • * 通配符

  • ? 你不想设置那个字段

Cron表达式工具类

/**
 * cron表达式工具类
 *
 */
public class CronUtils
{
    /**
     * 返回一个布尔值代表一个给定的Cron表达式的有效性
     *
     * @param cronExpression Cron表达式
     * @return boolean 表达式是否有效
     */
    public static boolean isValid(String cronExpression)
    {
        return CronExpression.isValidExpression(cronExpression);
    }

    /**
     * 返回一个字符串值,表示该消息无效Cron表达式给出有效性
     *
     * @param cronExpression Cron表达式
     * @return String 无效时返回表达式错误描述,如果有效返回null
     */
    public static String getInvalidMessage(String cronExpression)
    {
        try
        {
            new CronExpression(cronExpression);
            return null;
        }
        catch (ParseException pe)
        {
            return pe.getMessage();
        }
    }

    /**
     * 返回下一个执行时间根据给定的Cron表达式
     *
     * @param cronExpression Cron表达式
     * @return Date 下次Cron表达式执行时间
     */
    public static Date getNextExecution(String cronExpression)
    {
        try
        {
            CronExpression cron = new CronExpression(cronExpression);
            return cron.getNextValidTimeAfter(new Date(System.currentTimeMillis()));
        }
        catch (ParseException e)
        {
            throw new IllegalArgumentException(e.getMessage());
        }
    }
}

创建 多线程 Job类

/**
 * 执行定时任务
 *
 */
public class ScheduleRunnable implements Runnable
{
    private static final Logger log = LoggerFactory.getLogger(ScheduleRunnable.class);

    private Object target;
    private Method method;
    private String params;

    public ScheduleRunnable(String beanName, String methodName, String params)
            throws NoSuchMethodException, SecurityException
    {
        this.target = SpringContextUtil.getBean(beanName);
        this.params = params;

        if (StringUtils.isNotEmpty(params))
        {
            this.method = target.getClass().getDeclaredMethod(methodName, String.class);
        }
        else
        {
            this.method = target.getClass().getDeclaredMethod(methodName);
        }
    }

    @Override
    public void run()
    {
        try
        {
            ReflectionUtils.makeAccessible(method);
            if (StringUtils.isNotEmpty(params))
            {
                method.invoke(target, params);
            }
            else
            {
                method.invoke(target);
            }
        }
        catch (Exception e)
        {
            log.error("执行定时任务  - ：", e);
        }
    }
}

继承 QuartzJobBean 并重写 执行体 （自定义）

  • 创建线程池 和 job 对应的线程并提交执行
  • @DisallowConcurrentExecution 禁止并发执行多个相同定义的JobDetail, 这个注解是加在Job类上的, 但意思并不是不能同时执行多个Job, 而是不能并发执行同一个Job Definition(由JobDetail定义), 但是可以同时执行多个不同的JobDetail。
/**
 * 定时任务处理
 *
 */
@DisallowConcurrentExecution
public class ScheduleJob extends QuartzJobBean
{
    private static final Logger log = LoggerFactory.getLogger(ScheduleJob.class);
  • 创建一个ExecutorService 单线程池对象。（一个一个执行）
  • 如每次需要使用线程时，都new 一个Thread的话，难免会造成资源的浪费，而且可以无限制创建，之间相互竞争，会导致过多占用系统资源导致系统瘫痪,不利于扩展.
private ExecutorService service = Executors.newSingleThreadExecutor();


private final static ISysJobLogService jobLogService = (ISysJobLogService) SpringContextUtil.getBean("sysJobLogServiceImpl");

[@Override](https://my.oschina.net/u/1162528)
protected void executeInternal(JobExecutionContext context) throws JobExecutionException
{
    SysJob job = new SysJob();
    BeanUtils.copyBeanProp(job, context.getMergedJobDataMap().get(ScheduleConstants.TASK_PROPERTIES));

    SysJobLog jobLog = new SysJobLog();
    jobLog.setJobName(job.getJobName());
    jobLog.setJobGroup(job.getJobGroup());
    jobLog.setMethodName(job.getMethodName());
    jobLog.setMethodParams(job.getMethodParams());
    jobLog.setCreateTime(new Date());

    long startTime = System.currentTimeMillis();

    try
    {
        // 执行任务
        log.info("任务开始执行 - 名称：{} 方法：{}", job.getJobName(), job.getMethodName());
        ScheduleRunnable task = new ScheduleRunnable(job.getJobName(), job.getMethodName(), job.getMethodParams());
  • 将task任务委任给ExecutorService线程池，同时接收一个 Runnable 的实现作为参数，但是会返回一个 Future 对象。
  • Future 对象可以用于判断 Runnable 是否结束执行
            Future<?> future = service.submit(task);


        future.get();
        long times = System.currentTimeMillis() - startTime;
        // 任务状态 0：成功 1：失败
        jobLog.setStatus(Constants.SUCCESS);
        jobLog.setJobMessage(job.getJobName() + " 总共耗时：" + times + "毫秒");

        log.info("任务执行结束 - 名称：{} 耗时：{} 毫秒", job.getJobName(), times);
    }
    catch (Exception e)
    {
        log.info("任务执行失败 - 名称：{} 方法：{}", job.getJobName(), job.getMethodName());
        log.error("任务执行异常  - ：", e);
        long times = System.currentTimeMillis() - startTime;
        jobLog.setJobMessage(job.getJobName() + " 总共耗时：" + times + "毫秒");
        // 任务状态 0：成功 1：失败
        jobLog.setStatus(Constants.FAIL);
        jobLog.setExceptionInfo(StringUtils.substring(e.getMessage(), 0, 2000));
    }
    finally
    {
        jobLogService.addJobLog(jobLog);
    }
}

}

定时任务工具类

/**
 * 定时任务工具类
 *
 */
public class ScheduleUtils
{
    private static final Logger log = LoggerFactory.getLogger(ScheduleUtils.class);

    /**
     * 获取触发器key
     */
    public static TriggerKey getTriggerKey(Long jobId)
    {
        return TriggerKey.triggerKey(ScheduleConstants.TASK_CLASS_NAME + jobId);
    }

    /**
     * 获取jobKey
     */
    public static JobKey getJobKey(Long jobId)
    {
        return JobKey.jobKey(ScheduleConstants.TASK_CLASS_NAME + jobId);
    }

    /**
     * 获取表达式触发器
     */
    public static CronTrigger getCronTrigger(Scheduler scheduler, Long jobId)
    {
        try
        {
            return (CronTrigger) scheduler.getTrigger(getTriggerKey(jobId));
        }
        catch (SchedulerException e)
        {
            log.error("getCronTrigger 异常：", e);
        }
        return null;
    }

    /**
     * 创建定时任务的 JobDetail调度程序 和 时间表达式触发器
     */
    public static void createScheduleJob(Scheduler scheduler, SysJob job)
    {
        try
        {
            // 构建job信息
            JobDetail jobDetail = JobBuilder.newJob(ScheduleJob.class).withIdentity(getJobKey(job.getJobId())).build();

            // 表达式调度构建器
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
            cronScheduleBuilder = handleCronScheduleMisfirePolicy(job, cronScheduleBuilder);

            // 按新的cronExpression表达式构建一个新的trigger
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(getTriggerKey(job.getJobId()))
                    .withSchedule(cronScheduleBuilder).build();

            // 放入参数，运行时的方法可以获取
            jobDetail.getJobDataMap().put(ScheduleConstants.TASK_PROPERTIES, job);

            scheduler.scheduleJob(jobDetail, trigger);

            // 暂停任务
            if (job.getStatus().equals(ScheduleConstants.Status.PAUSE.getValue()))
            {
                pauseJob(scheduler, job.getJobId());
            }
        }
        catch (SchedulerException e)
        {
            log.error("createScheduleJob 异常：", e);
        }
        catch (TaskException e)
        {
            log.error("createScheduleJob 异常：", e);
        }
    }

    /**
     * 更新定时任务
     */
    public static void updateScheduleJob(Scheduler scheduler, SysJob job)
    {
        try
        {
            TriggerKey triggerKey = getTriggerKey(job.getJobId());

            // 表达式调度构建器
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
            cronScheduleBuilder = handleCronScheduleMisfirePolicy(job, cronScheduleBuilder);

            CronTrigger trigger = getCronTrigger(scheduler, job.getJobId());

            // 按新的cronExpression表达式重新构建trigger
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(cronScheduleBuilder).build();

            // 参数
            trigger.getJobDataMap().put(ScheduleConstants.TASK_PROPERTIES, job);

            scheduler.rescheduleJob(triggerKey, trigger);

            // 暂停任务
            if (job.getStatus().equals(ScheduleConstants.Status.PAUSE.getValue()))
            {
                pauseJob(scheduler, job.getJobId());
            }

        }
        catch (SchedulerException e)
        {
            log.error("SchedulerException 异常：", e);
        }
        catch (TaskException e)
        {
            log.error("SchedulerException 异常：", e);
        }
    }

    /**
     * 立即执行任务
     */
    public static int run(Scheduler scheduler, SysJob job)
    {
        int rows = 0;
        try
        {
            // 参数
            JobDataMap dataMap = new JobDataMap();
            dataMap.put(ScheduleConstants.TASK_PROPERTIES, job);

            scheduler.triggerJob(getJobKey(job.getJobId()), dataMap);
            rows = 1;
        }
        catch (SchedulerException e)
        {
            log.error("run 异常：", e);
        }
        return rows;
    }

    /**
     * 暂停任务
     */
    public static void pauseJob(Scheduler scheduler, Long jobId)
    {
        try
        {
            scheduler.pauseJob(getJobKey(jobId));
        }
        catch (SchedulerException e)
        {
            log.error("pauseJob 异常：", e);
        }
    }

    /**
     * 恢复任务
     */
    public static void resumeJob(Scheduler scheduler, Long jobId)
    {
        try
        {
            scheduler.resumeJob(getJobKey(jobId));
        }
        catch (SchedulerException e)
        {
            log.error("resumeJob 异常：", e);
        }
    }

    /**
     * 删除定时任务
     */
    public static void deleteScheduleJob(Scheduler scheduler, Long jobId)
    {
        try
        {
            scheduler.deleteJob(getJobKey(jobId));
        }
        catch (SchedulerException e)
        {
            log.error("deleteScheduleJob 异常：", e);
        }
    }

    public static CronScheduleBuilder handleCronScheduleMisfirePolicy(SysJob job, CronScheduleBuilder cb)
            throws TaskException
    {
        switch (job.getMisfirePolicy())
        {
            case ScheduleConstants.MISFIRE_DEFAULT:
                return cb;
            case ScheduleConstants.MISFIRE_IGNORE_MISFIRES:
                return cb.withMisfireHandlingInstructionIgnoreMisfires();
            case ScheduleConstants.MISFIRE_FIRE_AND_PROCEED:
                return cb.withMisfireHandlingInstructionFireAndProceed();
            case ScheduleConstants.MISFIRE_DO_NOTHING:
                return cb.withMisfireHandlingInstructionDoNothing();
            default:
                throw new TaskException("The task misfire policy '" + job.getMisfirePolicy() + "' cannot be used in cron schedule tasks", Code.CONFIG_ERROR);
        }
    }
}

Spring 上下文环境中获取 Bean 的工具类

/**
 * spring管理环境中获取bean
 *
 */
@Service("springContextUtil")
public class SpringContextUtil implements ApplicationContextAware
{
    // Spring应用上下文环境
    private static ApplicationContext applicationContext;

    /**
     * 实现ApplicationContextAware接口的回调方法，设置上下文环境
     * 
     * @param applicationContext
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext)
    {
        SpringContextUtil.applicationContext = applicationContext;
    }

    /**
     * @return ApplicationContext
     */
    public static ApplicationContext getApplicationContext()
    {
        return applicationContext;
    }

    /**
     * 获取对象
     * 
     * @param name
     * @return Object
     * @throws BeansException
     */
    public static Object getBean(String name) throws BeansException
    {
        return applicationContext.getBean(name);
    }
}

转载于:https://my.oschina.net/u/4041837/blog/3016819

chengyikan9284
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot+quartz定时任务实现 纯代码
03-30
最新springboot+Quartz实现动态定时任务,源代码. 包括controller,service,impl,和配置文件,pom文件,实体类,直接导入springboot项目,配置好数据库就能使用.欢迎下载好评!
Springboot整合Quartz实现定时任务数据库动态配置
03-17
本篇文章将详细探讨如何在Spring Boot项目中整合Quartz，并通过MySQL数据库实现定时任务的动态配置。 首先，我们需要在项目中添加依赖。在Spring Boot的`pom.xml`文件中，引入Spring Boot的`spring-boot-starter-...
oracle之schedule job
各研发管理
03-13 1292
-- job 权限 grant create job to somebody; -- job 创建 begin dbms_scheduler.create_job ( job_name =&gt; 'AGENT_LIQUIDATION_JOB', job_type =&gt; 'STORED_PROCEDURE', job_action =&gt; 'AGENT_LI...
Spring框架 计划任务Schedule job demo
编程日常记录与总结 https://franciswmf.iteye.com
02-20 266
[code="java"] import java.util.Date; import java.util.List; import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans...
若依框架的基本使用及实战案例
最新发布
2303_80556719的博客
06-22 1504
1）若依提供了企业级后台管理系统基础通用的功能，免去开发者去搭建和配置繁琐项目环境2）提供了代码生成技术：通过数据库表就可以自动生成（java后端代码，前端vue页面）
JAVA可控定时任务（quartz）
qq_42581267的博客
08-01 1316
运行环境jdk1.8+springboot+maven
SpringBoot学习日志之DAY13整合定时任务（基于Quartz框架实现定时任务的暂停，启动，单次执行和修改）
光滑的秃头
01-23 935
什么是Quartz？ 一个定时任务调度框架，简单易用，功能强大。如果项目当中对定时调度要求较高，使用这个框架非常合适。 springboot整合Quartz定时调度框架 ...
Quartz详解与开发用例
深圳市多克创新科技有限公司
01-23 1787
Quartz详解与开发用例
springboot+quartz以持久化的方式实现定时任务的代码
08-18
SpringBoot+Quartz实现定时任务的代码 本篇文章主要介绍了使用SpringBoot和Quartz实现定时任务的相关知识，并通过实例代码详细地介绍了相关实现方式。 Quartz简介 Quartz是一个开源的任务调度框架，提供了强大的...
springboot+quartz实现动态定时任务调度
12-08
基于SpringBoot+Quartz实现动态任务调度，可作为...项目运行中就可实现定时任务的动态增删改查，不用启停项目，摆脱了普通SpringBoot定时任务注解，需要重启才能生效定时任务的缺陷。具体使用方法在README.md中有介绍。
springboot+quartz 定时处理数据任务
11-06
为了方便管理和监控定时任务，你可以集成Quartz提供的Web界面或使用SpringBoot的Actuator模块，展示任务状态和调度信息。另外，Quartz还提供了API供你在程序中动态管理任务，如暂停、恢复或删除任务。 6. **异常...
任务调度Quartz 2框架 页面配置调度任务
才这么点的博客
04-08 850
spring整合Quart 任务信息持久化到数据库,实现可以在页面配置任务 新增 暂定 删除 恢复 任务 1.定时任务配置类 /** * 定时任务配置 * */ @Configuration public class ScheduleConfig { @Bean public SchedulerFactoryBean schedulerFactoryBean(@Qu...
springboot集成quartz实时性的任务调度
liang_336的博客
12-11 554
quartz简介（官网搬下来的!!!）： Quartz是功能强大的开源作业调度库，几乎可以集成到任何Java应用程序中-从最小的独立应用程序到最大的电子商务系统。Quartz可用于创建简单或复杂的计划，以执行数以万计，数以万计的工作。任务定义为标准Java组件的作业，它们实际上可以执行您可以对其执行的任何编程操作。Quartz Scheduler包含许多企业级功能，例如对JTA事务和集群的支持。Quartz是免费使用的，并根据Apache 2.0许可获得许可。 quartz官网：http://www.q
抽取工具类
qq_39323945的博客
08-10 269
*1.权限获取工具类**
SpringBoot - 集成Quartz框架之CRON表达式
记录并分享
09-13 1121
CRON表达式是一个字符串，字符串由5个或6个空格隔开，分为6个或7个域，每一个域代表一个含义，表达如如下：秒 分 时 日 月 周 年[可选]。
springboot基于quartz实现自定义时间的定时调度
bankq的博客
04-22 1156
Quartz是一套轻量级的任务调度框架，只需要定义了 Job（任务），Trigger（触发器）和 Scheduler（调度器），即可实现一个定时调度能力。
Quartz详解和使用CommandLineRunner在项目启动时初始化定时任务
qq_41358574的博客
12-16 2482
文章目录Quartz介绍自定义CommandLineRunner类：创建、更新定时任务service层自定义QuartzJobBean定时任务实体类：mapper接口：时间触发器的一些写法 之前与定时任务相关的一个文章记录： springboot使用@Scheduled作定时任务详细用法 Quartz介绍 Quartz是一个完全由java编写的功能丰富的开源作业调度库，可以集成到几乎任何Java应用程序中，小到独立应用程序，大到大型的电子商务系统。Quartz可以用来创建执行数十，数百乃至数万个作业的简单或
CronTrigger表达式和Quartz使用实例入门
飞鸟快快的专栏
08-20 1558
CronTriggers往往比SimpleTrigger更有用，如果您需要基于日历的概念，而非SimpleTrigger完全指定的时间间隔，如每月8日发工资的定时任务。 CronTrigger，你可以指定触发的时间表如“每星期五中午”，或“每个工作日9:30时”，甚至“每5分钟一班9:00和10:00逢星期一上午，星期三星期五“。 一、Cron Expressions cro
springboot+vue+quartz 实现定时任务调度
05-22
最后，在 Vue 中实现调用后端接口来启动和停止任务调度器。可以使用 Axios 进行 HTTP 请求。例如： ```javascript import axios from 'axios' // 启动任务调度器 export function startScheduler () { return ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值