栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

java使用quartz做定时任务并持久化

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

java使用quartz做定时任务并持久化

一、导包
 		
            org.springframework.boot
            spring-boot-starter-quartz
        
二、创建定时任务

创建一个定时任务如下,需要传入定时任务执行的class、定时任务名字、定时任务组名字、core表达式、执行参数、是否初始化创建(做持久化用到的)

 public void createJob(Class jobClass, String jobName, String jobGroupName, String cronExpression, JSONObject params, boolean isInit) {
        // 创建scheduler,调度器, 策略采用错过之后立即执行一次
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression).withMisfireHandlingInstructionFireAndProceed();
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(jobName, jobGroupName)
                .startNow()
                .withSchedule(scheduleBuilder)
                .build();
        // 定义一个JobDetail
        JobDetail jobDetail = JobBuilder.newJob(jobClass)
                .withIdentity(jobName, jobGroupName)
                .build();
        trigger.getJobDataMap().putAll(params);
        try {
            scheduler.scheduleJob(jobDetail, trigger);
            // 启动任务调度
            scheduler.start();
        } catch (Exception e) {
            log.error("创建定时任务失败,jobName:{},jobGroupName:{}", jobName, jobGroupName);
            throw new InterfaceException(ErrorCodeEnum.CREATE_QUARTZ_JOB_ERROR.getErrorCode(), ErrorCodeEnum.CREATE_QUARTZ_JOB_ERROR.getErrorMessage());
        }
    }
  
  

上述的定时任务类需要实现Job接口,实现的execute方法就是具体定时任务需要做的内容:

  package com.supcon.mare.tankinfo.service.closedpath.quartz.job;

import com.supcon.mare.SpringTool;
import com.supcon.mare.tankinfo.service.closedpath.ClosedPathConstants;
import com.supcon.mare.tankinfo.service.closedpath.TagWriteVO;
import com.supcon.mare.tankinfo.service.closedpath.VfTagHelper;
import com.supcon.mare.tankinfo.service.closedpath.quartz.mananer.impl.QuartzManagerImpl;
import lombok.extern.slf4j.Slf4j;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.SchedulerException;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.stereotype.Service;

import java.util.List;


@Slf4j
@Service
public class CancelWriteClosedEqpColor implements Job {

    public CancelWriteClosedEqpColor() throws SchedulerException {
    }

    @Override
    public void execute(JobExecutionContext jobExecutionContext) {
        //获取参数
        JobDataMap mergedJobDataMap = jobExecutionContext.getMergedJobDataMap();
		// 创建的时候塞了什么参数就get什么
        String modelName = mergedJobDataMap.get("modelName").toString();    

		// todo    
		
    }
}

创建的时候直接调用:

quartzManager.createJob(CancelWriteClosedEqpColor.class, modelName, ClosedPathConstants.QUARTZ_GROUP_CLOSED_WRITE_COLOR,
                        cronExpression, params, false);
三、定时任务持久化

如果创建了一个定时任务,但是这时候服务突然崩掉了,再起来的时候该做的事情并没有做(比如要对某些数据进行回退),就会留下脏数据在系统里面,因此需要在系统启动的时候把之前没删除的定时任务再装载进来继续执行
创建的时候需要对任务进行存储,如果是在系统初始化数据库中存在没有删除的定时任务,则需要创建,持久化框架我用的jpa,如下:

@Override
    @Transactional(isolation = Isolation.READ_COMMITTED, rollbackFor = Exception.class)
    public void createJob(Class jobClass, String jobName, String jobGroupName, String cronExpression, JSONObject params, boolean isInit) {
        // 创建scheduler,调度器, 策略采用错过之后立即执行一次
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression).withMisfireHandlingInstructionFireAndProceed();
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(jobName, jobGroupName)
                .startNow()
                .withSchedule(scheduleBuilder)
                .build();
        // 定义一个JobDetail
        JobDetail jobDetail = JobBuilder.newJob(jobClass)
                .withIdentity(jobName, jobGroupName)
                .build();
        trigger.getJobDataMap().putAll(params);
        try {
            scheduler.scheduleJob(jobDetail, trigger);
            // 启动任务调度
            scheduler.start();
        } catch (Exception e) {
            log.error("创建定时任务失败,jobName:{},jobGroupName:{}", jobName, jobGroupName);
            throw new InterfaceException(ErrorCodeEnum.CREATE_QUARTZ_JOB_ERROR.getErrorCode(), ErrorCodeEnum.CREATE_QUARTZ_JOB_ERROR.getErrorMessage());
        }

        if (!isInit) {
            // 持久化到数据库
            ScheduledJobEntity scheduledJobEntity = new ScheduledJobEntity();
            scheduledJobEntity.setJobName(jobName);
            scheduledJobEntity.setJobGroupName(jobGroupName);
            scheduledJobEntity.setJobClassName(jobClass.getName());
            scheduledJobEntity.setCronExpression(cronExpression);
            scheduledJobEntity.setValid(Constants.VALID_TRUE);
            scheduledJobEntity.setParams(params.toJSONString());
            schedulerJobRepository.save(scheduledJobEntity);
        }
        log.info("创建定时任务成功,jobName:{},jobGroupName:{}", jobName, jobGroupName);
    }

初始化执行方式为实现了ApplicationRunner,重写run方法,我这里的定时任务是五秒中之后执行一次就可以,这个需要根据需求自己写

@Override
    public void run(ApplicationArguments args) throws Exception {
       // 启动自动装配定时任务,执行之前未执行的任务
        List scheduledJobEntities = schedulerJobRepository.findByAttr("valid", Constants.VALID_TRUE.toString());
        for (ScheduledJobEntity scheduledJobEntity : scheduledJobEntities) {
            String jobName = scheduledJobEntity.getJobName();
            String jobGroupName = scheduledJobEntity.getJobGroupName();

            // 执行参数
            String paramsString = scheduledJobEntity.getParams();
            JSONObject params = JSONObject.parseObject(paramsString);
            Calendar calendar = Calendar.getInstance();
            calendar.add(Calendar.SECOND, 5);
            // 几分钟之后回退
            String cronExpression = Utils.formatDateByPattern(calendar.getTime(), "ss mm HH dd MM ? yyyy");
            createJob(CancelWriteClosedEqpColor.class, jobName, jobGroupName,
                    cronExpression, params, true);
        }
    }

定时任务实体类:

package com.supcon.mare.tankinfo.entity;

import lombok.Data;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

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


@Entity
@Table(name = "scheduled_job")
@Data
@EntityListeners(AuditingEntityListener.class)
public class ScheduledJobEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    
    private String jobName;

    
    private String jobGroupName;

    
    private String jobClassName;

    
    private String cronExpression;

    
    @Column(columnDefinition = "text")
    private String params;

    
    private Integer valid;

    
    @CreatedDate
    @Column(name = "gmt_create", updatable = false)
    @Temporal(TemporalType.TIMESTAMP)
    private Date gmtCreate;

    
    @LastModifiedDate
    @Column(name = "gmt_modified", insertable = false)
    @Temporal(TemporalType.TIMESTAMP)
    private Date gmtModified;
}

定时任务创建、重启装载就完成了,以下是删除定时任务以及激活一次定时任务:

@Override
    @Transactional(isolation = Isolation.READ_COMMITTED, rollbackFor = Exception.class)
    public void deleteJob(String jobName, String jobGroupName) {
        try {
            scheduler.pauseTrigger(TriggerKey.triggerKey(jobName, jobGroupName));
            scheduler.unscheduleJob(TriggerKey.triggerKey(jobName, jobGroupName));
            scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));
        } catch (Exception e) {
            log.error("删除定时任务失败,jobName:{},jobGroupName:{}", jobName, jobGroupName);
        }

        List scheduledJobEntities = schedulerJobRepository.findByJobNameAndJobGroupNameAndValid(jobName, jobGroupName, Constants.VALID_TRUE);
        if (CollectionUtil.isNotEmpty(scheduledJobEntities)) {
            for (ScheduledJobEntity scheduledJobEntity : scheduledJobEntities) {
                scheduledJobEntity.setValid(Constants.VALID_FALSE);
            }
            schedulerJobRepository.saveAll(scheduledJobEntities);
            log.info("删除定时任务成功,jobName:{},jobGroupName:{}", jobName, jobGroupName);
        }
    }

    @Override
    public void activeJob(String jobName, String jobGroupName) {
        try {
            Calendar calendar = Calendar.getInstance();
            calendar.add(Calendar.MILLISECOND, 100);
            // 几分钟之后自动取消
            String cronExpression = Utils.formatDateByPattern(calendar.getTime(), "ss mm HH dd MM ? yyyy");
            TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);
            // 表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression).withMisfireHandlingInstructionFireAndProceed();

            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

            // 根据Cron表达式构建一个Trigger
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

            // 按新的trigger重新设置job执行
            scheduler.rescheduleJob(triggerKey, trigger);

            // 等300毫秒激活定时任务,等待时间需要看定时任务执行一次需要多久时间
            Thread.sleep(300);
            deleteJob(jobName, jobGroupName);
        } catch (Exception e) {
            log.error("激活定时任务失败,message:{},jobName:{},jobGroupName:{}", e.getMessage(), jobName, jobGroupName);
        }
    }
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/953340.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号