springboot Quartz 实现动态定时任务

最新推荐文章于 2024-08-12 03:12:09 发布
最新推荐文章于 2024-08-12 03:12:09 发布
阅读量656 收藏 6
点赞数
分类专栏： java 文章标签： quartz java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qaz__01/article/details/108598379
版权 
                         springboot Quartz 实现动态定时任务
                           实现上参考ruoyi的quartz

一.引言

Quartz是一个开源的作业调度框架，它完全由Java写成，并设计用于J2SE和J2EE应用中。它提供了巨大的灵 活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB作业预构 建，JavaMail及其它，支持cron-like表达式等等。

该项目已经被 Terracotta收购。

二.实战

1.在springboot 中的maven中导入jar

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.2.3</version>
</dependency>

2.配置quartz

package com.nhiot.web.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import javax.sql.DataSource;
import java.util.Properties;

@Configuration
public class QuartzConfiguration
{

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource)
    {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setDataSource(dataSource);

        // quartz参数
        Properties prop = new Properties();
        prop.put("org.quartz.scheduler.instanceName", "nhiotScheduler");
        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("nhiotScheduler");
        // 延时启动
        factory.setStartupDelay(1);
        factory.setApplicationContextSchedulerContextKey("applicationContextKey");
        // 可选，QuartzScheduler
        // 启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了
        factory.setOverwriteExistingJobs(true);
        // 设置自动启动，默认为true
        factory.setAutoStartup(true);

        return factory;
    }

}

3.创建quartz 需要的表
在这里插入图片描述
4.创建任务类

package com.nhiot.entity.quartz;


import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.nhiot.constants.ScheduleConstants;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.data.annotation.CreatedBy;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedBy;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;

/**
 * @Description
 *
 * @Author www
 * @Date 2020/5/7 17:13
 *
 **/
@Data
@Entity
@Table(name = "t_task")
@EntityListeners(AuditingEntityListener.class)
@JsonIgnoreProperties({"hibernateLazyInitializer","handler"})
public class SysTask implements Serializable
{

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(columnDefinition = "BigInt(10) COMMENT '主键ID'")
     private Long id;

    @Column(columnDefinition = "VARCHAR(255) COMMENT '任务名'")
    private String jobName;

    @Column(columnDefinition = "VARCHAR(255) COMMENT '任务描述'")
    private String description;


    @Column(columnDefinition = "VARCHAR(255) COMMENT 'cron表达式'")
    private String cronExpression;

    @Column(columnDefinition = "VARCHAR(255) COMMENT '任务执行时调用哪个类的方法 包名+类名'")
    private String beanClass;


    @Column(columnDefinition = "VARCHAR(255) COMMENT '计划策略'")
    @ApiModelProperty("计划策略-0=默认,1=立即触发执行,2=触发一次执行,3=不触发立即执行")
    private String misfirePolicy = ScheduleConstants.MISFIRE_DEFAULT;

    /** 是否并发执行（0允许 1禁止） */
    @Column(columnDefinition = "VARCHAR(255) COMMENT '并发执行'")
    @ApiModelProperty("并发执行-0=允许,1=禁止")
    private String concurrent="0";

    @Column(columnDefinition = "VARCHAR(255) COMMENT '组织ID'")
    @ApiModelProperty("组织Id")
    private String  organizationId;

    @Column(columnDefinition = "VARCHAR(255) COMMENT '任务状态'")
    private String jobStatus="0";

    @Column(columnDefinition = "VARCHAR(255) COMMENT '任务分组'")
    private String jobGroup;

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    @CreatedDate
    @Column(columnDefinition = "DATETIME COMMENT '创建时间'")
    private Date createTime;

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    @LastModifiedDate
    @Column(columnDefinition = "DATETIME COMMENT '修改时间'")
    private Date updateTime;

    @CreatedBy
    @Column(columnDefinition = "VARCHAR(255) COMMENT '创建人'")
    private String createBy;

    @Column(columnDefinition = "VARCHAR(255) COMMENT '修改人'")
    @LastModifiedBy
    private String updateBy;


    @Version
    @ApiModelProperty(value = "版本号")
    @Column(columnDefinition = "int(10) COMMENT '版本号'")
    private int versionId;



}

定时任务执行日志类

package com.nhiot.entity.quartz;


import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;

/**
 * 定时任务调度日志表 sys_task_log
 * 
 * @author www
 */
@Data
@Entity
@Table(name = "t_task_log")
@EntityListeners(AuditingEntityListener.class)
@JsonIgnoreProperties({"hibernateLazyInitializer","handler"})
public class SysTaskLog implements Serializable
{
    private static final long serialVersionUID = 1L;

    /** ID */
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(columnDefinition = "BigInt(10) COMMENT '主键ID'")
    private Long id;

    /** 任务名称 */
    @Column(columnDefinition = "VARCHAR(255) COMMENT '任务名称'")
    private String jobName;

    /** 任务组名 */
    @Column(columnDefinition = "VARCHAR(255) COMMENT '任务组名'")
    private String jobGroup;

    /** 调用目标字符串 */
    @Column(columnDefinition = "VARCHAR(255) COMMENT '调用目标字符串'")
    private String invokeTarget;

    /** 日志信息 */
    @Column(columnDefinition = "VARCHAR(500) COMMENT '日志信息'")
    private String jobMessage;

    /** 执行状态（0正常 1失败） */
    @Column(columnDefinition = "VARCHAR(20) COMMENT '执行状态（0正常 1失败）'")
    private String status;

    /** 异常信息 */
    @Column(columnDefinition = "VARCHAR(2000) COMMENT '异常信息'")
    private String exceptionInfo;

    /** 开始时间 */
    @Column(columnDefinition = "DATETIME COMMENT '开始时间'")
    private Date startTime;

    /** 结束时间 */
    @Column(columnDefinition = "DATETIME COMMENT '结束时间'")
    private Date endTime;


}

5.写controller控制器

      @Autowired
       private TaskService taskService;


     @RequestMapping(value = "/saveOrUpdate",method =  RequestMethod.POST)
     @ApiOperation("添加/修改定时任务")
     public Result<String> saveOrUpdate(@RequestBody  TaskAddAndEditRequest request)
     {
         return  taskService.saveOrUpdate(request);
     }



      @RequestMapping(value = "/detail",method = RequestMethod.GET)
      @ApiOperation("查询定时任务详情")
     public Result<SysTask> detailTask(String id)
     {
         return taskService.detailTask(id);
     }


     @RequestMapping(value = "/delete/ids",method = RequestMethod.DELETE)
     @ApiOperation("删除定时任务")
     public Result<String> deleteTaskByIds(String ids)
     {
         try {
             return  taskService.deleteTaskByIds(ids);
         } catch (SchedulerException e) {
             e.printStackTrace();
         }
         return null;
     }

    /**
     * 任务调度立即执行一次
     */
    @PostMapping("/run")
    @ResponseBody
    public Result<String> run(String id) throws SchedulerException
    {
        taskService.run(id);
        return Result.<String>builder().success().build();
    }

6.service实现类

 @Autowired
    private TaskRepository taskRepository;


    @Autowired
    @Qualifier("schedulerFactoryBean")
    private Scheduler scheduler;




    /**
     * @Method
     * @Author www
     * @Version  1.0
     * @Description 添加/修改定时任务
     * @Return
     * @Date 2020/8/17 16:58
     */
    @Override
    public Result<String> saveOrUpdate(TaskAddAndEditRequest request)
    {
        SysTask sysTask = null;
        if(request.getId()==null)
        {
            sysTask = new SysTask();
        }else{
            sysTask = taskRepository.getOne(request.getId());
        }
        BeanUtils.copyPropertiesExcludeNull(request, sysTask);
        sysTask.setBeanClass("com.nhiot.service.bengbu.impl.BengbuServiceImpl.uploadAttendance('"+request.getJobGroup()+"')");
        sysTask.setConcurrent("0");
        sysTask.setCronExpression(CronUtils.resetCronExpression(request.getCronExpression()));
        if(!CronUtils.isValid(sysTask.getCronExpression()))
        {
             sysTask.setCronExpression(request.getCronExpression());
        }
        SysTask sysTask1 = taskRepository.saveAndFlush(sysTask);
        try {
            updateSchedulerJob(sysTask1,sysTask1.getJobGroup());
        } catch (SchedulerException e) {
            e.printStackTrace();
        } catch (TaskException e) {
            e.printStackTrace();
        }
        return Result.<String>builder().success().build();
    }



    /**
     * 项目启动时，初始化定时器
     主要是防止手动修改数据库导致未同步到定时任务处理（注：不能手动修改数据库ID和任务组名，否则会导致脏数据）
     */
    @PostConstruct
    public void init() throws SchedulerException, TaskException
    {
        scheduler.clear();
        List<SysTask> taskList = taskRepository.findAll();
        for (SysTask sysTask : taskList)
        {
            System.out.println(sysTask.getJobName());
            ScheduleUtils.createScheduleJob(scheduler, sysTask);
        }
    }

    /**
     * @Method
     * @Author www
     * @Version  1.0
     * @Description 查询定时任务详情
     * @Return
     * @Date 2020/8/17 17:23
     */
    @Override
    public Result<SysTask> detailTask(String id)
    {
        SysTask sysTask = taskRepository.findByJobGroup(id);
        return Result.<SysTask>builder().success().data(sysTask).build();
    }

    /**
     * @Method
     * @Author www
     * @Version  1.0
     * @Description 删除定时任务
     * @Return
     * @Date 2020/8/27 10:38
     */
    @Override
    public Result<String> deleteTask(String id) throws SchedulerException
    {
        if(StringUtils.isNotEmpty(id))
        {
            SysTask sysTask = taskRepository.getOne(Long.valueOf(id));
            String jobGroup = sysTask.getJobGroup();
            taskRepository.delete(sysTask);
            scheduler.deleteJob(ScheduleUtils.getJobKey(Long.valueOf(id), jobGroup));
        }
        return Result.<String>builder().success().build();
    }



    /**
     * @Method
     * @Author www
     * @Version  1.0
     * @Description 批量删除定时任务
     * @Return
     * @Date 2020/8/19 9:03
     */
    @Override
    public Result<String> deleteTaskByIds(String ids) throws SchedulerException
    {
        if(StringUtils.isNotEmpty(ids))
        {
            String[] id = ids.split(",");
            for(int i=0;i<id.length;++i)
            {
                deleteTask(id[i]);
            }
        }
        return Result.<String>builder().success().build();
    }

    @Override
    public void run(String id)
    {
        try {
            SysTask sysTask = taskRepository.getOne(Long.valueOf(id));
            // 参数
            JobDataMap dataMap = new JobDataMap();
            dataMap.put(ScheduleConstants.TASK_PROPERTIES, sysTask);
            scheduler.triggerJob(ScheduleUtils.getJobKey(Long.valueOf(id), sysTask.getJobGroup()), dataMap);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }

    /**
     * 更新任务
     *
     * @param sysTask 任务对象
     * @param jobGroup 任务组名
     */
    public void updateSchedulerJob(SysTask sysTask, String jobGroup) throws SchedulerException, TaskException
    {
        Long id = sysTask.getId();
        // 判断是否存在
        JobKey jobKey = ScheduleUtils.getJobKey(id, jobGroup);
        if (scheduler.checkExists(jobKey))
        {
            // 防止创建时存在数据问题 先移除，然后在执行创建操作
            scheduler.deleteJob(jobKey);
        }
        ScheduleUtils.createScheduleJob(scheduler, sysTask);
    }

用到的utils以及实体类

package com.nhiot.service.quartz;

import com.nhiot.constants.ScheduleConstants;
import com.nhiot.entity.quartz.SysTask;
import com.nhiot.entity.quartz.SysTaskLog;
import com.nhiot.exception.ExceptionUtil;
import com.nhiot.repository.quartz.TaskLogRepository;
import com.nhiot.spring.SpringUtils;
import com.nhiot.util.BeanUtils;

import org.apache.commons.lang3.StringUtils;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Date;

/**
 * 抽象quartz调用
 *
 * @author www
 */
public abstract class AbstractQuartzJob implements Job
{
    private static final Logger log = LoggerFactory.getLogger(AbstractQuartzJob.class);

    /**
     * 线程本地变量
     */
    private static ThreadLocal<Date> threadLocal = new ThreadLocal<>();

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException
    {
        SysTask sysTask = new SysTask();
        BeanUtils.copyProperties(context.getMergedJobDataMap().get(ScheduleConstants.TASK_PROPERTIES),sysTask);
        try
        {
            before(context, sysTask);
            if (sysTask != null)
            {
                doExecute(context, sysTask);
            }
            after(context, sysTask, null);
        }
        catch (Exception e)
        {
            log.error("任务执行异常  - ：", e);
            after(context, sysTask, e);
        }
    }

    /**
     * 执行前
     *
     * @param context 工作执行上下文对象
     * @param sysTask 系统计划任务
     */
    protected void before(JobExecutionContext context, SysTask sysTask)
    {
        System.out.println(sysTask.getJobName());
        threadLocal.set(new Date());
    }

    /**
     * 执行后
     *
     * @param context 工作执行上下文对象
     * @param sysTask 系统计划任务
     */
    protected void after(JobExecutionContext context, SysTask sysTask, Exception e)
    {
        Date startTime = threadLocal.get();
        threadLocal.remove();

        final SysTaskLog sysTaskLog = new SysTaskLog();
        sysTaskLog.setJobName(sysTask.getJobName());
        sysTaskLog.setJobGroup(sysTask.getJobGroup());
        sysTaskLog.setInvokeTarget(sysTask.getBeanClass());
        sysTaskLog.setStartTime(startTime);
        sysTaskLog.setEndTime(new Date());
        long runMs = sysTaskLog.getEndTime().getTime() - sysTaskLog.getStartTime().getTime();
        sysTaskLog.setJobMessage(sysTaskLog.getJobName() + " 总共耗时：" + runMs + "毫秒");
        if (e != null)
        {
            sysTaskLog.setStatus("1");
            e.printStackTrace();
            String errorMsg = StringUtils.substring(ExceptionUtil.getExceptionMessage(e), 0, 2000);
            sysTaskLog.setExceptionInfo(errorMsg);
        }
        else
        {
            sysTaskLog.setStatus("0");
        }
        // 写入数据库当中
        SpringUtils.getBean(TaskLogRepository.class).saveAndFlush(sysTaskLog);
    }

    /**
     * 执行方法，由子类重载
     *
     * @param context 工作执行上下文对象
     * @param sysTask 系统计划任务
     * @throws Exception 执行过程中的异常
     */
    protected abstract void doExecute(JobExecutionContext context, SysTask sysTask) throws Exception;
}

CronUtils

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());
        }
    }

    /**
     * 修改定时任务时间
     */
    public static String resetCronExpression(String cronExpression)
    {
        String[] str = cronExpression.split(" ");
        StringBuffer re = new StringBuffer();
        str[1]= String.valueOf(DateUtils.getMinute(new Date()));
        for (int i=0;i<str.length;++i) {
            if(i==0) {
                re.append(str[i]);
            }else {
                re.append(" "+str[i]);
            }
        }
        return re.toString();
    }
}

JobInvokeUtils

public class JobInvokeUtil
{
    /**
     * 执行方法
     *
     * @param sysTask 系统任务
     */
    public static void invokeMethod(SysTask sysTask) throws Exception
    {
        String invokeTarget = sysTask.getBeanClass();
        String beanName = getBeanName(invokeTarget);
        String methodName = getMethodName(invokeTarget);
        List<Object[]> methodParams = getMethodParams(invokeTarget);

        if (!isValidClassName(beanName))
        {
            Object bean = SpringUtils.getBean(beanName);
            invokeMethod(bean, methodName, methodParams);
        }
        else
        {
            Object bean = Class.forName(beanName).newInstance();
            invokeMethod(bean, methodName, methodParams);
        }
    }

    /**
     * 调用任务方法
     *
     * @param bean 目标对象
     * @param methodName 方法名称
     * @param methodParams 方法参数
     */
    private static void invokeMethod(Object bean, String methodName, List<Object[]> methodParams)
            throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException,
            InvocationTargetException
    {
        if ( methodParams!=null &&methodParams.size() > 0)
        {
            Method method = bean.getClass().getDeclaredMethod(methodName, getMethodParamsType(methodParams));
            method.invoke(bean, getMethodParamsValue(methodParams));
        }
        else
        {
            Method method = bean.getClass().getDeclaredMethod(methodName);
            method.invoke(bean);
        }
    }

    /**
     * 校验是否为为class包名
     * 
     * @param invokeTarget 名称
     * @return true是 false否
     */
    public static boolean isValidClassName(String invokeTarget)
    {
        return StringUtils.countMatches(invokeTarget, ".") > 1;
    }

    /**
     * 获取bean名称
     * 
     * @param invokeTarget 目标字符串
     * @return bean名称
     */
    public static String getBeanName(String invokeTarget)
    {
        String beanName = StringUtils.substringBefore(invokeTarget, "(");
        return StringUtils.substringBeforeLast(beanName, ".");
    }

    /**
     * 获取bean方法
     * 
     * @param invokeTarget 目标字符串
     * @return method方法
     */
    public static String getMethodName(String invokeTarget)
    {
        String methodName = StringUtils.substringBefore(invokeTarget, "(");
        return StringUtils.substringAfterLast(methodName, ".");
    }

    /**
     * 获取method方法参数相关列表
     * 
     * @param invokeTarget 目标字符串
     * @return method方法相关参数列表
     */
    public static List<Object[]> getMethodParams(String invokeTarget)
    {
        String methodStr = StringUtils.substringBetween(invokeTarget, "(", ")");
        if (StringUtils.isEmpty(methodStr))
        {
            return null;
        }
        String[] methodParams = methodStr.split(",");
        List<Object[]> classs = new LinkedList<>();
        for (int i = 0; i < methodParams.length; i++)
        {
            String str = StringUtils.trimToEmpty(methodParams[i]);
            // String字符串类型，包含'
            if (StringUtils.contains(str, "'"))
            {
                classs.add(new Object[] { StringUtils.replace(str, "'", ""), String.class });
            }
            // boolean布尔类型，等于true或者false
            else if (StringUtils.equals(str, "true") || StringUtils.equalsIgnoreCase(str, "false"))
            {
                classs.add(new Object[] { Boolean.valueOf(str), Boolean.class });
            }
            // long长整形，包含L
            else if (StringUtils.containsIgnoreCase(str, "L"))
            {
                classs.add(new Object[] { Long.valueOf(StringUtils.replaceIgnoreCase(str, "L", "")), Long.class });
            }
            // double浮点类型，包含D
            else if (StringUtils.containsIgnoreCase(str, "D"))
            {
                classs.add(new Object[] { Double.valueOf(StringUtils.replaceIgnoreCase(str, "D", "")), Double.class });
            }
            // 其他类型归类为整形
            else
            {
                classs.add(new Object[] { Integer.valueOf(str), Integer.class });
            }
        }
        return classs;
    }

    /**
     * 获取参数类型
     * 
     * @param methodParams 参数相关列表
     * @return 参数类型列表
     */
    public static Class<?>[] getMethodParamsType(List<Object[]> methodParams)
    {
        Class<?>[] classs = new Class<?>[methodParams.size()];
        int index = 0;
        for (Object[] os : methodParams)
        {
            classs[index] = (Class<?>) os[1];
            index++;
        }
        return classs;
    }

    /**
     * 获取参数值
     * 
     * @param methodParams 参数相关列表
     * @return 参数值列表
     */
    public static Object[] getMethodParamsValue(List<Object[]> methodParams)
    {
        Object[] classs = new Object[methodParams.size()];
        int index = 0;
        for (Object[] os : methodParams)
        {
            classs[index] = (Object) os[0];
            index++;
        }
        return classs;
    }
}

QuartzDisallowConcurrentExecution:

/**
 * 定时任务处理（禁止并发执行）
 * 
 * @author www
 *
 */
@DisallowConcurrentExecution
public class QuartzDisallowConcurrentExecution extends AbstractQuartzJob
{
    @Override
    protected void doExecute(JobExecutionContext context, SysTask sysTask) throws Exception
    {
        JobInvokeUtil.invokeMethod(sysTask);
    }
}

QuartzJobExecution:

/**
 * 定时任务处理（允许并发执行）
 * 
 * @author www
 *
 */
public class QuartzJobExecution extends AbstractQuartzJob
{
    @Override
    protected void doExecute(JobExecutionContext context, SysTask sysTask) throws Exception
    {
        JobInvokeUtil.invokeMethod(sysTask);
    }
}

ScheduleUtils:

/**
 * 定时任务工具类
 * 
 * @author www
 *
 */
public class ScheduleUtils
{
    /**
     * 得到quartz任务类
     *
     * @param sysTask 执行计划
     * @return 具体执行任务类
     */
    private static Class<? extends Job> getQuartzJobClass(SysTask sysTask)
    {
        boolean isConcurrent = "0".equals(sysTask.getConcurrent());
        return isConcurrent ? QuartzJobExecution.class : QuartzDisallowConcurrentExecution.class;
    }

    /**
     * 构建任务触发对象
     */
    public static TriggerKey getTriggerKey(Long jobId, String jobGroup)
    {
        return TriggerKey.triggerKey(ScheduleConstants.TASK_CLASS_NAME + jobId, jobGroup);
    }

    /**
     * 构建任务键对象
     */
    public static JobKey getJobKey(Long jobId, String jobGroup)
    {
        return JobKey.jobKey(ScheduleConstants.TASK_CLASS_NAME + jobId, jobGroup);
    }

    /**
     * 创建定时任务
     */
    public static void createScheduleJob(Scheduler scheduler, SysTask sysTask) throws SchedulerException, TaskException
    {
        Class<? extends Job> jobClass = getQuartzJobClass(sysTask);
        // 构建job信息
        Long  id = sysTask.getId();
        String jobGroup = sysTask.getJobGroup();
        JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(getJobKey(id, jobGroup)).build();

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

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

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

        // 判断是否存在
        if (scheduler.checkExists(getJobKey(id, jobGroup)))
        {
            // 防止创建时存在数据问题 先移除，然后在执行创建操作
            scheduler.deleteJob(getJobKey(id, jobGroup));
        }

        scheduler.scheduleJob(jobDetail, trigger);

        // 暂停任务
        if (sysTask.getJobStatus().equals(ScheduleConstants.Status.PAUSE.getValue()))
        {
            scheduler.pauseJob(ScheduleUtils.getJobKey(id, jobGroup));
        }
    }

    /**
     * 设置定时任务策略
     */
    public static CronScheduleBuilder handleCronScheduleMisfirePolicy(SysTask sysTask, CronScheduleBuilder cb)
            throws TaskException
    {
        switch (sysTask.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 '" + sysTask.getMisfirePolicy()
                        + "' cannot be used in cron schedule tasks", TaskException.Code.CONFIG_ERROR);
        }
    }
}

效果：
在这里插入图片描述

在这里插入图片描述

qaz__01
关注
专栏目录
【SpringBoot】82、SpringBoot集成Quartz实现动态管理定时任务
Asurplus
06-29 3万+
Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中。它提供了巨大的灵 活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB 作业预构 建，JavaMail 及其它，支持 cron-like 表达式等等
SpringBoot搭配Quartz实现动态定时任务
wl_Honest的博客
12-27 2410
前面2篇文章讲述了如何实现简单的定时任务，不过由于执行周期是写在配置文件里的，如果想要修改周期或者暂停任务都是比较麻烦的事情，那么能不能在不修改代码和暂停服务的情况下动态修改定时任务周期或者手动暂停任务？ 通过Quartz是可以实现这一目标的，本文参考了GitHub上的文章，写了个动态定时任务的demo，特此记录。 参考链接：https://github.com/xkcoding/spring-boot-demo/tree/master/demo-task-quartz 首先引入需要的jar包：
Springboot实现quartz定时
jialiang的博客
12-01 2万+
quartz实现定时，单任务和多任务。 MethodInvokingJobDetailFactoryBean CronTriggerFactoryBean SchedulerFactoryBean CronTrigger JobDetail CronScheduleBuilder
spring boot动态定时任务
最新发布
weixin_36963061的博客
08-12 249
Spring Boot 动态定时任务 在现代软件开发中，定时任务是实现定期执行某些操作（例如，数据备份、邮件发送等）的有效方式。Spring Boot 作为一种流行的微服务框架，提供了简洁的定时任务机制。然而，很多时候，我们需要根据业务需求动态地调整定时任务的执行频率。本文将介绍如何在 Spring Boot 中实现动态定...
SpringBoot动态定时任务
客官不爱喝酒的博客
10-24 568
之前在SpringBoot项目中简单使用定时任务，不过由于要借助cron表达式且都提前定义好放在配置文件里，不能在项目运行中动态修改任务执行时间，实在不太灵活。现在我们就来实现可以动态修改cron表达式的定时任务。
springboot 动态定时任务
木杨的博客
08-17 135
通过Springboot的ThreadPoolTaskScheduler类实现定时任务，将提交定时任务后得到的ScheduledFuture实例存到Map进行维护。不支持多节点部署，多节点部署请使用分布式定时任务框架。
SpringBoot 动态定时任务
qq_42291606的博客
11-22 222
既然是动态就必须牵扯到数据库 -- ---------------------------- -- Table structure for scheduled_task -- ---------------------------- DROP TABLE IF EXISTS `scheduled_task`; CREATE TABLE `scheduled_task` ( `id` int...
Springboot整合Quartz实现定时任务数据库动态配置
03-17
本篇文章将详细探讨如何在Spring Boot项目中整合Quartz，并通过MySQL数据库实现定时任务的动态配置。 首先，我们需要在项目中添加依赖。在Spring Boot的`pom.xml`文件中，引入Spring Boot的`spring-boot-starter-...
Springboot2-Quartz 后台可动态配置的定时任务
02-28
本项目“Springboot2-Quartz 后台可动态配置的定时任务”是基于SpringBoot 2.x版本与Quartz Scheduler整合的一个示例，它展示了如何在后台管理系统中动态地创建、更新和删除定时任务，以及监控这些任务的状态，为...
SpringBoot集成quartz实现动态定时任务
xxgaojiashuo的博客
09-11 1425
SpringBoot集成quartz实现动态定时任务 （1）Quartz简介 Quartz三大组件： 一、调度器scheduler 二、任务job 三、触发器tigger 1、job：job是一个接口，通过实现job接口，可实现需要定时执行的代码逻辑。 2、JobDetail：JobDetail主要是用来描述job的相关信息，比如任务在scheduler中的组名等信息，job的子类。 2、tigger：可以通过cron表达式设置定时任务的触发时间。 3、scheduler：JobDetail和tigger需
spring+quartz实现动态设置定时任务
10-28
spring+quartz实现动态设置定时任务，自己的例子+心得+sql语句
SPRING BOOT 动态定时任务
hudeyong926的专栏
06-14 1万+
动态定时任务
Springboot实现动态定时任务
北尘
09-09 4117
该动态定时任务主配置类是 ScheduledConfig，代码如下；最近有幸要开发个动态定时任务，这里简单再梳理一下。到这里核心类已经走完，剩下的就是获取数据相关类。紧接着是这个类，用于控制任务的执行与否；最后就是要测试的接口。
SpringBoot实现动态定时任务
热门推荐
我滴太阳233的博客
07-12 2万+
项目情况：         在当前项目中需要一个定时任务来清除过期的校验码，如果使用数据库存储过程的话不方便维护。因此采用SpringBoot自带的方式来设置定时任务。技术说明：         SpringBoot自带的方式有两种可以实现：        一种是使用@Scheduled注解的方式，只需要在启动类或者它所在的类上添加@EnableScheduling注解允许执行定时任务，并且设置S...
spring boot中实现动态定时任务
erxiaoouba的博客
08-04 428
在网上找的资料最后整理出来的, 不过找不到原文章地址了, 感谢原作者的奉献 这里总共创建以下几个类: DynamicCronJob: 动态定时任务, 包含了对定时任务的启动, 停止, 重启. 添加定时任务的功能没有加, 可以自行添加, 参考启动功能 ScheduledTaskConfig: 动态定时任务配置, 这是一个配置类, 配置ThreadPoolTaskScheduler线程池的, 还有就是初始化存放所有动态定时任务的map, 初始化map也就死创建一个map对象, 具体的初始化方法在下面的Sc.
springboot 中动态实现定时任务
VringSbsda的博客
02-20 210
基于注解@Scheduled实现需在启动类配合 @EnableScheduling（开启定时任务）、@EnableAsync（开启异步任务）一起使用 import org.springframework.scheduling.annotation.Async; import org.springframework.scheduling.annotation.Scheduled; public class Quartz { /** * @Description: 每日凌晨初始化财务统计
SpringBoot搭配Quartz实现动态定时任务源码
06-06
好的，以下是 SpringBoot 搭配 Quartz 实现动态定时任务的源码： 1. 首先，我们需要引入 Quartz 和 SpringBoot 的依赖： ```xml <!-- Quartz相关依赖 --> <groupId>org.quartz-scheduler <artifactId>quartz ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值