Java使用quartz实现任务调度定时任务

已于 2022-09-21 16:14:51 修改
阅读量3.4k 收藏 17
点赞数 3
分类专栏： quartz 文章标签： java spring boot
于 2022-03-15 09:29:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tanqingfu1/article/details/123493708
版权

1、添加quartz依赖

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-quartz -->
 <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-quartz</artifactId>
       <version>2.5.4</version>
</dependency>

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.10</version>
</dependency>

2、实现功能源码

2.1 CronTaskRegistrar  Cron任务注册器

package com.shucha.digitalportalbackstage.biz.task.dispatch;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.config.CronTask;
import org.springframework.stereotype.Component;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Component
public class CronTaskRegistrar implements DisposableBean {
    private final Map<Runnable, ScheduledTask> scheduledTasks = new ConcurrentHashMap<>(16);
    @Autowired
    private TaskScheduler taskScheduler;

    public TaskScheduler getScheduler() {
        return this.taskScheduler;
    }

    /**
     * 新增定时任务
     *
     * @param task
     * @param cronExpression
     */
    public void addCronTask(Runnable task, String cronExpression) {
        addCronTask(new CronTask(task, cronExpression));
    }

    public void addCronTask(CronTask cronTask) {
        if (cronTask != null) {
            Runnable task = cronTask.getRunnable();
            if (this.scheduledTasks.containsKey(task)) {
                removeCronTask(task);
            }
            this.scheduledTasks.put(task, scheduleCronTask(cronTask));
        }
    }

    /**
     * 移除定时任务
     *
     * @param task
     */
    public void removeCronTask(Runnable task) {
        ScheduledTask scheduledTask = this.scheduledTasks.remove(task);
        if (scheduledTask != null)
            scheduledTask.cancel();
    }

    public ScheduledTask scheduleCronTask(CronTask cronTask) {
        ScheduledTask scheduledTask = new ScheduledTask();
        scheduledTask.future = this.taskScheduler.schedule(cronTask.getRunnable(), cronTask.getTrigger());
        return scheduledTask;
    }

    @Override
    public void destroy() throws Exception {
        for (ScheduledTask task : this.scheduledTasks.values()) {
            task.cancel();
        }
        this.scheduledTasks.clear();
    }
}

2.2 ScheduledTask 计划任务

package com.shucha.digitalportalbackstage.biz.task.dispatch;

import java.util.concurrent.ScheduledFuture;

public class ScheduledTask {
    public volatile ScheduledFuture<?> future;
    /**
     * 取消定时任务
     */
    public void cancel() {
        ScheduledFuture<?> future = this.future;
        if (future != null) {
            future.cancel(true);
        }
    }
}

2.3 SchedulingRunnable 调度运行

package com.shucha.digitalportalbackstage.biz.task.dispatch;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.ReflectionUtils;

import java.lang.reflect.Method;
import java.util.Objects;

public class SchedulingRunnable implements Runnable {
    private static final Logger logger = LoggerFactory.getLogger(SchedulingRunnable.class);
    private String beanName;
    private String methodName;
    private Object[] params;

    public SchedulingRunnable(String beanName, String methodName) {
        this(beanName, methodName, null);
    }

    public SchedulingRunnable(String beanName, String methodName, Object... params) {
        this.beanName = beanName;
        this.methodName = methodName;
        this.params = params;
    }

    @Override
    public void run() {
        logger.info("定时任务开始执行 - bean：{}，方法：{}，参数：{}", beanName, methodName, params);
        long startTime = System.currentTimeMillis();
        try {
            Object target = SpringContextUtils.getBean(beanName);
            Method method = null;
            if (null != params && params.length > 0) {
                Class<?>[] paramCls = new Class[params.length];
                for (int i = 0; i < params.length; i++) {
                    paramCls[i] = params[i].getClass();
                }
                method = target.getClass().getDeclaredMethod(methodName, paramCls);
            } else {
                method = target.getClass().getDeclaredMethod(methodName);
            }
            ReflectionUtils.makeAccessible(method);
            if (null != params && params.length > 0) {
                method.invoke(target, params);
            } else {
                method.invoke(target);
            }
        } catch (Exception ex) {
            logger.error(String.format("定时任务执行异常 - bean：%s，方法：%s，参数：%s ", beanName, methodName, params), ex);
        }
        long times = System.currentTimeMillis() - startTime;
        logger.info("定时任务执行结束 - bean：{}，方法：{}，参数：{}，耗时：{} 毫秒", beanName, methodName, params, times);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        SchedulingRunnable that = (SchedulingRunnable) o;
        if (params == null) {
            return beanName.equals(that.beanName) &&
                    methodName.equals(that.methodName) &&
                    that.params == null;
        }
        return beanName.equals(that.beanName) &&
                methodName.equals(that.methodName) &&
                params.equals(that.params);
    }

    @Override
    public int hashCode() {
        if (params == null) {
            return Objects.hash(beanName, methodName);
        }
        return Objects.hash(beanName, methodName, params);
    }
}

2.4 SpringContextUtils 

package com.shucha.digitalportalbackstage.biz.task.dispatch;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class SpringContextUtils implements ApplicationContextAware {
    private static ApplicationContext applicationContext = null;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if (SpringContextUtils.applicationContext == null) {
            SpringContextUtils.applicationContext = applicationContext;
        }
    }
    //获取applicationContext
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }
    //通过name获取 Bean.
    public static Object getBean(String name) {
        return getApplicationContext().getBean(name);
    }
    //通过class获取Bean.
    public static <T> T getBean(Class<T> clazz) {
        return getApplicationContext().getBean(clazz);
    }
    //通过name,以及Clazz返回指定的Bean
    public static <T> T getBean(String name, Class<T> clazz) {
        return getApplicationContext().getBean(name, clazz);
    }
}

2.5  QuartzConfig 配置和项目启动初始化

package com.shucha.digitalportalbackstage.biz.task.quartz.config;

import com.shucha.digitalportalbackstage.biz.model.QuartzJob;
import com.shucha.digitalportalbackstage.biz.service.QuartzJobService;
import com.shucha.digitalportalbackstage.biz.task.quartz.JobFactory;
import com.shucha.digitalportalbackstage.biz.task.quartz.service.QuartzService;
import org.quartz.Scheduler;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import javax.annotation.PostConstruct;
import java.io.IOException;
import java.util.List;
import java.util.Properties;
import java.util.UUID;

@Configuration
public class QuartzConfig {
    @Autowired
    private JobFactory jobFactory;
    @Autowired
    private QuartzJobService quartzJobService;
    @Autowired
    private QuartzService quartzService;

    @Bean("schedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        //设置调度类quartz属性
        schedulerFactoryBean.setQuartzProperties(quartzProperties());
        //设置jobFactory
        schedulerFactoryBean.setJobFactory(jobFactory);
        return schedulerFactoryBean;
    }

    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        //若不做额外配置,会有默认的配置文件加载 在jar org.quartz里面 有一份quartz.properties
        //propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

    @Bean
    public QuartzInitializerListener initializerListener() {
        return new QuartzInitializerListener();
    }

    @Bean("scheduler")
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }

    @PostConstruct
    public void init() {
        List<QuartzJob> quartzJobList = quartzJobService.lambdaQuery().list();
        for (QuartzJob q : quartzJobList) {
            quartzService.addJob(q);
        }
    }

    private static String getUuid() {
        return UUID.randomUUID().toString().replace("-", "");
    }
}

QuartzJob实体类

package com.shucha.digitalportalbackstage.biz.model;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.sdy.common.model.BaseModel;
import com.sdy.common.utils.DateUtil;
import com.shucha.digitalportalbackstage.biz.dto.job.SaveJobDTO;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.util.Date;

/**
 * <p>
 *
 * </p>
 *
 * @author tqf
 * @since 2022-03-14
 */
@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
public class QuartzJob extends BaseModel {
    private static final long serialVersionUID = 1L;

    /**
     * UUID
     */
    @ApiModelProperty(value = "UUID")
    @TableId(value = "job_id", type = IdType.INPUT)
    private String jobId;

    /**
     * 定时任务示例的 class路径
     */
    @ApiModelProperty(value = "定时任务示例的 class路径")
    private String className;

    /**
     * cron表达式
     */
    @ApiModelProperty(value = "cron表达式")
    private String cronExpression;

    /**
     * 定时任务名称
     */
    @ApiModelProperty(value = "定时任务名称")
    private String jobName;

    /**
     * 定时任务组
     */
    @ApiModelProperty(value = "定时任务组")
    private String jobGroup;

    /**
     * 触发器名称
     */
    @ApiModelProperty(value = "触发器名称")
    private String triggerName;

    /**
     * 触发器组
     */
    @ApiModelProperty(value = "触发器组")
    private String triggerGroup;

    /**
     * 参数
     */
    @ApiModelProperty(value = "参数")
    private String data;

    /**
     * 备注
     */
    @ApiModelProperty(value = "备注")
    private String description;

    /**
     * 创建时间
     */
    @ApiModelProperty(value = "创建时间")
    @JsonFormat(pattern = DateUtil.DATETIME_FORMAT)
    private Date createTime;

    /**
     * 修改时间
     */
    @ApiModelProperty(value = "修改时间")
    @JsonFormat(pattern = DateUtil.DATETIME_FORMAT)
    private Date updateTime;

    public QuartzJob() {
    }

    public QuartzJob(SaveJobDTO save) {
        this.jobId = save.getJobId();
        this.className = save.getClassName();
        this.cronExpression = save.getCronExpression();
        this.jobName = save.getGroup() + save.getId();
        this.jobGroup = save.getGroup();
        this.triggerName = save.getGroup() + save.getId();
        this.triggerGroup = save.getGroup();
        this.data = JSONObject.toJSONString(save.getData());
        this.description = save.getDescription();
        this.createTime = new Date();
    }
}

2.6 MessageJob 具体的任务调度执行的业务

package com.shucha.digitalportalbackstage.biz.task.quartz.job;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.sdy.common.utils.DateUtil;
import com.shucha.digitalportalbackstage.biz.dto.MaxTimeDTO;
import com.shucha.digitalportalbackstage.biz.mapper.RemindDataMapper;
import com.shucha.digitalportalbackstage.biz.model.*;
import com.shucha.digitalportalbackstage.biz.service.*;
import com.shucha.digitalportalbackstage.biz.utils.SendMsgUtil;
import lombok.SneakyThrows;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Component
public class MessageJob implements Job {
    @Autowired
    private QuartzJobService quartzJobService;
    @Autowired
    private RemindDataService remindDataService;
    @Autowired
    private ZzdUserAllService zzdUserAllService;
    @Autowired
    private RemindModuleService moduleService;
    @Autowired
    private RemindTemplateService templateService;
    @Autowired
    private RemindMessageService remindMessageService;
    @Autowired
    private RemindDataMapper remindDataMapper;
    @Autowired
    private SendMsgUtil sendMsgUtil;

    private static Pattern pattern = Pattern.compile("(\\$\\{)([\\w]+)(\\})");

    private static Logger log = LoggerFactory.getLogger(MessageJob.class);

    @SneakyThrows
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        Date date = new Date();
        String triggerName = context.getTrigger().getKey().getName();
        log.info("******"+triggerName+"任务开始执行******");
        String jobId = context.getJobDetail().getKey().getName();
        /*jobId = jobId.substring(0, jobId.length() - name.length());
        String databaseId = name.substring(JobGroupConstants.DATABASE.length());*/
        RemindData remindData = JSONObject.toJavaObject(JSONObject.parseObject(JSONObject.toJSONString(context.getMergedJobDataMap().get("myValue"))), RemindData.class);
        if(remindData != null && remindData.getId() != null) {
            // 查询短信模板
            RemindTemplate template = templateService.getOne(Wrappers.<RemindTemplate>lambdaQuery()
                    .orderByDesc(RemindTemplate::getCreateTime),false);
            // 1、根据责任人查询姓名
            String name = "";
            ZzdUserAll zzdUserAll = zzdUserAllService.getById(remindData.getDutyId());
            if(zzdUserAll != null) {
                name = zzdUserAll.getEmployeeName();
            }
            // 2、根据模块ID查询模块名称
            String moduleName = "";
            RemindModule module = moduleService.getById(remindData.getRemindModuleId());
            if(module != null) {
                moduleName = module.getName();
            }
            // 3、不同模块查询对应的最新的创建时间和更新时间
            Integer day = getDay(remindData.getRemindModuleId(), date);

            // 短信发送文本内容
            String messageContent = messageContent(template.getContent(), name, moduleName, day);
            // 执行短信发送
            Boolean b = sendMsgUtil.sendOneMobileMsg(remindData.getPhone(), messageContent);
            if(b) {
                // 更新当前提醒记录的 提醒次数和最新提醒时间
                RemindData data = remindDataService.getById(remindData.getId());
                if(data != null) {
                    data.setRemindTime(date)
                            .setRemindNumber(data.getRemindNumber() + 1)
                            .setRemindTime(date);
                    remindDataService.updateById(data);
                }
                // 生成短信发送记录
                RemindMessage message = new RemindMessage()
                        .setContent(messageContent)
                        .setCreateTime(date)
                        .setRemindDataId(remindData.getId());
                remindMessageService.save(message);
            }
        }
        log.info("******"+triggerName+"任务执行结束******");
    }

    /**
     * 短信模板通配符替换指定的值
     * @param content
     * @param name
     * @param moduleName
     * @param day
     * @return
     */
    public String messageContent(String content, String name, String moduleName, Integer day){
        log.info("替换前：" +content);
        Map<String,Object> params = new HashMap<>();
        params.put("name", name);
        params.put("module", moduleName);
        params.put("day", day);
        //使用的时候建议定义为常量或者字段
        Matcher m = pattern.matcher(content);
        StringBuffer stringBuffer = new StringBuffer();
        while (m.find()) {
            String group = m.group()
                    .replace("$", "")
                    .replace("{", "")
                    .replace("}", "");
            if (params.get(group) == null) {
                continue;
            }
            m.appendReplacement(stringBuffer, (String) params.get(group));
        }
        m.appendTail(stringBuffer);
        Matcher m1 = pattern.matcher(stringBuffer.toString());
        //可以判断出是否替换成功
        if(!m1.find()){
            log.info("替换后："+stringBuffer.toString());
        }
        return stringBuffer.toString();
    }

    /**
     * 根据不同模块查询 最新创建时间和最新更新时间 然后和当前时间计算相差天数
     * @param id
     * @return
     */
    public int getDay(Long id, Date date){
        int day = 0;
        // id对应的不同模块
        // 1、数智乐清门户-集成入口
        // 2、数智乐清门户-通知公告
        // 3、数智乐清门户-宣传报道
        // 4、数智乐清门户-文明城市创建
        // 5、数智乐清门户-风险气象资讯
        // 6、数智乐清门户-疫苗接种
        // 7、数智乐清门户-重点指标
        // 8、数智乐清门户-新型城镇化
        // 9、数智乐清门户-重点项目
        Date maxTime = null;
        MaxTimeDTO maxTimeDTO = remindDataMapper.getMaxTime(id);
        if(maxTimeDTO != null) {
            Date createTime = maxTimeDTO.getCreateTime();
            Date updateTime = maxTimeDTO.getUpdateTime();
            if( createTime != null && updateTime != null){
                // 计算查看查看那个时间大
                maxTime = createTime.getTime() - updateTime.getTime() >0 ? createTime : updateTime;
            }
            if(updateTime == null) {
                if(createTime != null) {
                    maxTime = createTime;
                }
            }
        }
        day =  (int) ((date.getTime() - maxTime.getTime()) / (1000*3600*24));
        return day;
    }
}

2.7 QuartzService 服务类

package com.shucha.digitalportalbackstage.biz.task.quartz.service;

import com.alibaba.fastjson.JSONObject;
import com.shucha.digitalportalbackstage.biz.model.QuartzJob;

public interface QuartzService {
    /**
     * 创建Job
     *
     * @param job
     */
    Boolean addJob(QuartzJob job);

    /**
     * 执行Job
     *
     * @param job
     */
    Boolean runJob(QuartzJob job);

    /**
     * 修改Job
     *
     * @param job
     */
    Boolean updateJob(QuartzJob job);

    /**
     * 暂停Job
     *
     * @param job
     */
    Boolean pauseJob(QuartzJob job);

    /**
     * 唤醒Job
     *
     * @param job
     */
    Boolean resumeJob(QuartzJob job);

    /**
     * 删除Job
     *
     * @param job
     */
    Boolean deleteJob(QuartzJob job);

    /**
     * 获取Job
     *
     * @param job
     */
    JSONObject queryJob(QuartzJob job);
}

2.8 QuartzServiceImpl 实现类

package com.shucha.digitalportalbackstage.biz.task.quartz.service;

import com.alibaba.fastjson.JSONObject;
import com.shucha.digitalportalbackstage.biz.model.QuartzJob;
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class QuartzServiceImpl implements QuartzService{
    private static Logger log = LoggerFactory.getLogger(QuartzServiceImpl.class);
    @Autowired
    @Qualifier("scheduler")
    private Scheduler scheduler;


    @Override
    public Boolean addJob(QuartzJob job) {
        try {
//            JSONObject data = job.getData();
            JSONObject data =JSONObject.parseObject(job.getData());
            log.info("当前任务携带的业务参数={}", data.toJSONString());
            JobDataMap jobDataMap = new JobDataMap();
            jobDataMap.put("myValue", data);
            String jobId = job.getJobId();
            String jobName = job.getJobName();
            String jobUnique = jobId + jobName;
            JobDetail jobDetail = JobBuilder
                    .newJob((Class<? extends Job>) Class.forName(job.getClassName()))
                    // 指定执行类
                    .withIdentity(jobUnique, job.getJobGroup())
                    // 指定name和group
                    .requestRecovery().withDescription(job.getDescription())
                    .setJobData(jobDataMap)
                    .build();
            // 创建表达式调度构建器
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder
                    .cronSchedule(job.getCronExpression());
            // 创建触发器
            CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                    .withIdentity(job.getTriggerName(), job.getTriggerGroup())
                    .withDescription(job.getDescription())

                    .withSchedule(cronScheduleBuilder).build();
            scheduler.scheduleJob(jobDetail, cronTrigger);
            scheduler.start();
            log.info("定时任务[{}]创建成功,开始执行", jobId + jobName);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public Boolean runJob(QuartzJob job) {
        try {
            String jobId = job.getJobId();
            String jobName = job.getJobName();
            String jobUnique = jobId + jobName;
            scheduler.triggerJob(JobKey.jobKey(jobUnique,
                    job.getJobGroup()));
            log.info("定时任务[{}]执行成功", jobUnique);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public Boolean updateJob(QuartzJob job) {
        try {
            String jobId = job.getJobId();
            String jobName = job.getJobName();
            String jobUnique = jobId + jobName;
            TriggerKey triggerKey = new TriggerKey(job.getTriggerName(),
                    job.getTriggerGroup());
            CronTrigger cronTrigger = (CronTrigger) scheduler
                    .getTrigger(triggerKey);
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder
                    .cronSchedule(job.getCronExpression());
            // 重新构件表达式
            CronTrigger trigger = cronTrigger.getTriggerBuilder()
                    .withIdentity(triggerKey).withSchedule(cronScheduleBuilder)
                    .withDescription(job.getDescription())
                    .build();
            scheduler.rescheduleJob(triggerKey, trigger);
            log.info("定时任务[{}]更新成功", jobUnique);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public Boolean pauseJob(QuartzJob job) {

        try {
            String jobId = job.getJobId();
            String jobName = job.getJobName();
            String jobUnique = jobId + jobName;
            scheduler.pauseJob(JobKey.jobKey(jobUnique,
                    job.getJobGroup()));
            log.info("定时任务[{}]暂停成功", jobUnique);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public Boolean resumeJob(QuartzJob job) {
        try {
            String jobId = job.getJobId();
            String jobName = job.getJobName();
            String jobUnique = jobId + jobName;
            scheduler.resumeJob(JobKey.jobKey(jobUnique,
                    job.getJobGroup()));
            log.info("定时任务[{}]唤醒成功", jobUnique);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public Boolean deleteJob(QuartzJob job) {

        try {
            String jobId = job.getJobId();
            String jobName = job.getJobName();
            String jobUnique = jobId + jobName;
            scheduler.deleteJob(JobKey.jobKey(jobUnique, job.getJobGroup()));
            log.info("定时任务[{}]删除成功", jobUnique);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public JSONObject queryJob(QuartzJob job) {
        TriggerKey triggerKey = new TriggerKey(job.getTriggerName(),
                job.getTriggerGroup());
        try {
            CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            if (null == cronTrigger) {
                return null;
            }
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("expression", cronTrigger.getCronExpression());
            jsonObject.put("state", scheduler.getTriggerState(triggerKey));
            jsonObject.put("description", cronTrigger.getDescription());
            return jsonObject;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

2.9 JobFactory

package com.shucha.digitalportalbackstage.biz.task.quartz;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;

@Component
public class JobFactory extends AdaptableJobFactory {
    @Autowired
    private AutowireCapableBeanFactory beanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Object jobInstance = super.createJobInstance(bundle);
        beanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

2.10 JobGroupConstants

package com.shucha.digitalportalbackstage.biz.task.quartz;

import java.util.HashMap;
import java.util.Map;

public class JobGroupConstants {
    private static final Map<String, String> groupClass = new HashMap<>();
    public static final String MESSAGE = "message";

    public static final String MESSAGE_CLASS = "com.shucha.digitalportalbackstage.biz.task.quartz.job.MessageJob";

    static {
        groupClass.put(MESSAGE, MESSAGE_CLASS);
    }

    public static String getGroupClass(String group) {
        return groupClass.get(group);
    }
}

2.11 SaveJobDTO 实体类

package com.shucha.digitalportalbackstage.biz.dto.job;

import lombok.Data;

import java.util.Map;

@Data
public class SaveJobDTO {

    private String jobId;
    /**
     * 组
     */
    private String group;


    private String className;

    /**
     * 组对应的表的 主键ID
     */
    private Long id;
    /**
     * cron 表达式
     */
    private String cronExpression;
    /**
     * 参数
     */
    private Map<String, Object> data;

    /**
     * 备注
     */
    private String description;

    public SaveJobDTO(String group, Long id, String cronExpression, Map<String, Object> data) {
        this.group = group;
        this.id = id;
        this.cronExpression = cronExpression;
        this.data = data;
    }

    public SaveJobDTO() {
    }
}

2.12 任务调度表结构

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for quartz_job
-- ----------------------------
DROP TABLE IF EXISTS `quartz_job`;
CREATE TABLE `quartz_job`  (
  `job_id` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT 'UUID',
  `class_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '定时任务示例的 class路径',
  `cron_expression` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'cron表达式',
  `job_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '定时任务名称',
  `job_group` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '定时任务组',
  `trigger_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '触发器名称',
  `trigger_group` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '触发器组',
  `data` text CHARACTER SET utf8 COLLATE utf8_general_ci NULL COMMENT '参数',
  `description` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '备注',
  `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime(0) NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP(0) COMMENT '修改时间',
  PRIMARY KEY (`job_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '定时任务表' ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of quartz_job
-- ----------------------------
INSERT INTO `quartz_job` VALUES ('032925693ba04290a133fda816476a1c', 'com.shucha.digitalportalbackstage.biz.task.quartz.job.MessageJob', '0 25 12 15 * ?', 'message5', 'message', 'message5', 'message', '{\"cycleType\":0,\"monthWeek\":\"15\",\"createTime\":1647250687831,\"phone\":\"17816857416\",\"remindNumber\":0,\"createId\":214,\"remindModuleId\":1,\"dutyId\":465,\"id\":5,\"time\":\"12:25\"}', NULL, '2022-03-14 17:38:08', NULL);

SET FOREIGN_KEY_CHECKS = 1;

2.13 项目结构

dispath文件夹下的文件可以删除掉，这里没有使用

2.14 源码demo下载

demo源码下载https://download.csdn.net/download/tanqingfu1/84932500

2.15 QuartzJobService 

package com.shucha.digitalportalbackstage.biz.service;

import com.sdy.common.model.BizException;
import com.sdy.mvc.service.BaseService;
import com.shucha.digitalportalbackstage.biz.dto.job.SaveJobDTO;
import com.shucha.digitalportalbackstage.biz.model.QuartzJob;

/**
 * <p>
 * 服务类
 * </p>
 *
 * @author
 * @since 2022-03-14
 */
public interface QuartzJobService extends BaseService<QuartzJob> {
    Boolean saveJob(SaveJobDTO save) throws BizException;

    Boolean deleteJob(Long id, String group);

    Boolean updateJob(SaveJobDTO save) throws BizException;

//    QuartzJob getJobByGroupAndId(String group, Long id);
}

 2.16 QuartzJobServiceImpl

package com.shucha.digitalportalbackstage.biz.service.impl;

import com.sdy.common.model.BizException;
import com.sdy.common.utils.Assert;
import com.sdy.mvc.service.impl.BaseServiceImpl;
import com.shucha.digitalportalbackstage.biz.dto.job.SaveJobDTO;
import com.shucha.digitalportalbackstage.biz.mapper.QuartzJobMapper;
import com.shucha.digitalportalbackstage.biz.model.QuartzJob;
import com.shucha.digitalportalbackstage.biz.service.QuartzJobService;
import com.shucha.digitalportalbackstage.biz.task.quartz.JobGroupConstants;
import com.shucha.digitalportalbackstage.biz.task.quartz.service.QuartzService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.UUID;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author tqf
 * @since 2022-03-14
 */
@Slf4j
@Service
public class QuartzJobServiceImpl extends BaseServiceImpl<QuartzJob> implements QuartzJobService {
    @Autowired
    private QuartzJobMapper quartzJobMapper;
    @Autowired
    private QuartzService quartzService;

    /**
     * 新增 定时任务
     *
     * @param saveJob
     * @return
     * @throws BizException
     */
    @Override
    public Boolean saveJob(SaveJobDTO saveJob) throws BizException {
        String groupClass = JobGroupConstants.getGroupClass(saveJob.getGroup());
        Assert.isNull(groupClass, "请添加定时任务的Class！");
        saveJob.setClassName(groupClass);
        saveJob.setJobId(getUuid());
        QuartzJob quartzJob = new QuartzJob(saveJob);
        boolean save = save(quartzJob);
        Assert.notTrue(save, "新增失败！");
        return quartzService.addJob(quartzJob);
    }

    /**
     * 删除定时任务
     *
     * @param id
     * @param group
     * @return
     */
    @Override
    public Boolean deleteJob(Long id, String group) {
        Boolean b;
        QuartzJob quartzJob = lambdaQuery().eq(QuartzJob::getJobGroup, group)
                .eq(QuartzJob::getJobName, group + id).one();
        // 需要判断是否存在定时任务
        if(quartzJob != null) {
            removeById(quartzJob.getJobId());
            b = quartzService.deleteJob(quartzJob);
        } else {
            b = true;
        }
        return b;
    }

    /**
     * 修改定时任务
     *
     * @param update
     * @return
     * @throws BizException
     */
    @Override
    public Boolean updateJob(SaveJobDTO update) throws BizException {
        QuartzJob quartzJob = getById(update.getJobId());
        Assert.isNull(quartzJob, "定时任务不存在！");
        lambdaUpdate().eq(QuartzJob::getJobId, update.getJobId())
                .set(QuartzJob::getCronExpression, update.getCronExpression())
                .update();
        quartzJob.setCronExpression(update.getCronExpression());
        return quartzService.updateJob(quartzJob);
    }

    private static String getUuid() {
        return UUID.randomUUID().toString().replace("-", "");
    }
}

2.17 定时任务调用

2.17.1 新建定时任务 

// 新建定时任务
JSON jsons = (JSON) JSON.toJSON(remindData);
Map<String, Object> paramMap = JSONObject.parseObject(jsons.toString());
quartzJobService.saveJob(new SaveJobDTO(JobGroupConstants.MESSAGE, remindData.getId(), cronExp, paramMap));

cronExp 字段是cron表达式，参照下面文章获取
// https://blog.csdn.net/tanqingfu1/article/details/123474993?spm=1001.2014.3001.5502

// 下面方法校验cron表达式是否正确
CronExpression.isValidExpression("0 0 29 ? *")

2.17.2 更新定时任务

// 更新定时任务
String jobName = JobGroupConstants.MESSAGE + remindData.getId();
QuartzJob quartzJob = quartzJobService.lambdaQuery().eq(QuartzJob::getJobName, jobName).one();
SaveJobDTO dto = new SaveJobDTO();
dto.setJobId(quartzJob.getJobId());
dto.setCronExpression(cronExp);
quartzJobService.updateJob(dto);

cronExp 字段是cron表达式，参照下面文章获取
// https://blog.csdn.net/tanqingfu1/article/details/123474993?spm=1001.2014.3001.5502

2.17.3 删除定时任务

// 删除定时任务
quartzJobService.deleteJob(id, JobGroupConstants.MESSAGE);
码奴生来只知道前进~
关注
  • 3
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java应用多机器部署解决大量定时任务问题
08-25
主要介绍了Java应用多机器部署解决大量定时任务问题,两台服务器同时部署了同一套代码， 代码中写有spring自带的定时任务，但是每次执行定时任务时只需要一台机器去执行,需要的朋友可以参考下
Java实验-模拟比赛通知的发布
Volta小白
05-24 120
模拟比赛通知的发布 不同的学生关注不同类型的比赛，学生能及时接收所关注的比赛的通知； import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Scanner; /** * 名称：比赛通知的发布 * 不同的学生关注不同类型的比赛，接收所关注的比赛的通知； */ public class Main { public static void main(String
Java实战：Spring Boot 集成任务调度框架 Quartz
oandy0的博客
02-29 983
本文将介绍如何在 Spring Boot 中集成任务调度框架 Quartz，包括 Quartz 的基本概念、集成方式以及具体示例。通过本文，读者可以了解到 Quartz 的核心组件、配置方法以及在 Spring Boot 应用中的使用技巧。
Java远程公告_远程通知推送后台代码（ PHP 和 java ）
weixin_36318506的博客
02-26 237
// 本文件为远程通知服务端代码，不做他用// 以下是以 PHP 为写服务器端的代码// ###### @begin ###$deviceToken = '38c866dd bb323b39 ffa73487 5e157ee5 a85e0b7ce90d56e9 fe145bcc 6c2c594b'; // 手机端传给服务器的deviceToken// Passphrase for th...
管理公告java_java – 如何在报警管理器中处理预定时间列表以推送通知
weixin_35782943的博客
02-25 154
我正在尝试将存储在Sqlite中的时间列表(它有小时和分钟)检索到警报管理器中以通过通知执行提醒.我的方法是将存储在Sqlite中的所有预定时间循环到警报管理器中,以根据存储的时间列表执行通知,但通知不会发出蜂鸣声.但是,当我指定一次(小时和分钟)时,它可以工作.下面是有效的代码示例,但我不想这样：alarmManager = (AlarmManager) getSystemService(ALA...
Java定时任务调度实战(2)Quart框架的简单介绍
刘墨泽
07-12 1514
目录 一、前言 二、Quartz的简单介绍 一、前言 在之前的文章《Java定时任务调度实战（1）深入Timer、TimerTask源码，我发现都是《数据结构》必考点》中已经介绍了一种实现定时任务调度的方法——Java原生提供的TimerTask，适用于一些简单的业务需求。 回顾一下，TimerTask的原理总结起来就是下面这个图： 其实仔细想想，是不是可以抽象出来几个部分？ 任务调度，首先要有任务，TimerTask就是具体任务。有了任务之后是不是要给这个任务设置一下啥时候调，多久调
Quartz Job实现java任务调度
03-27
Quartz是功能强大的开源作业调度库，几乎可以集成到任何Java应用程序中-从最小的独立应用程序到最大的电子商务系统。Quartz可用于创建简单或复杂的计划，以执行数以万计，数以万计的工作；任务定义为标准Java组件的作业，它们实际上可以执行您可以编写的所有内容。Quartz Scheduler包含许多企业级功能，例如对JTA事务和集群的支持。
Java任务调度框架Quartz入门
weixin_30561425的博客
10-14 146
　　Quartz[kwɔːts]：石英，其框架和名字一样简单朴素又不失魅力，在Java程序界，Quartz大名鼎鼎，很多Java应用几乎都集成或构建了一个定时任务调度系统，Quartz是一个定时任务调度框架（Quartz官网：http://www.quartz-scheduler.org/）。这个工具 在美团中的有大量使用，详见他们的官方博客：http://tech.meituan.com/。...
JAVA任务调度之quartz
weixin_44705131的博客
04-15 645
转载大佬文章 https://www.cnblogs.com/wuzhenzhao/p/11751504.html cron表达式转换参考地址 https://www.matools.com/cron/
Java 任务调度框架 Quartz
方糖世界
12-13 774
文章目录1、Quartz1.1 引入依赖1.2 入门案例1.3 Job 与 JobDetail1.4 JobExecutionContext1.5 JobDataMap1.6 Job 状态1.7 Trigger1.8 SimpleTripper 1、Quartz 1.1 引入依赖 <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifac
java任务调度(Quartz篇)
jbgtwang的专栏
04-26 134
java任务调度(Quartz篇) 1、Timer介绍 建立任务：使用Timer调度的任务应该继承TimerTask抽象类，该类实现Runnable接口，因些具备多线程的能力，实现该接口的run方法，该方法是需要高度的任务执行体。 调度任务：调度任务通过Timer类完成,调度任务通过schedul方法完成，查一下java doc文档: void schedule(Ti...
Java中使用Quartz实现任务自动调度的经典例子！
12-31
使用Quartz实现作业、任务自动调度的经典例子—— 简单、清晰、明了，使你仅花几分钟就可快速掌握Java作业、任务自动调度的基本用法！
Java中Spring使用Quartz任务调度定时器
08-31
本篇文章主要介绍了Java中Spring使用Quartz任务调度定时器，具有一定的参考价值，有兴趣的可以了解一下。
定时任务quartz实现分组串行并行动态配置
05-06
定时任务quartz实现分组串行并行动态配置
quartz.rar_java 定时任务_quartz
07-15
一个灵活性很好的定时任务调度工具,有兴趣的朋友可以下载
利用Quartz实现任务调度的集群
11-18
公众企业应用几乎都会碰到任务调度的需求，任务调度本身涉及到多...如果直接使用自定义线程这种刀耕火种的原始办法，开发任务调度程序是一项颇具挑战性的工作。Java开源的好处就是：领域问题都能找到现成的解决方案。
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 969
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
最新发布
m0_46053885的博客
04-27 923
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
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
发出的红包

打赏作者

码奴生来只知道前进~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值