Spring+Mybatis +Quartz 实现定时任务管理

我就是我 2023-10-10 10:28 41阅读 0赞

任务要求：通过开源任务调度框架Quartz,实现定时任务的添加、修改、删除、暂停、恢复和分页查询功能。

第一步:base 模块添加quartz jar包依赖：

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

第二步：新增Quartz配置类对象：SchedulerConfig.java

import java.io.IOException;
    import java.util.Properties;
    
    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.core.io.ClassPathResource;
    import org.springframework.scheduling.quartz.SchedulerFactoryBean;
    
    import com.***.ucas.job.factory.CustomerJobFactory;
    
    @Configuration
    public class SchedulerConfig {
    	@Autowired
    	private CustomerJobFactory jobFactory;
    
    	@Bean
    	public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
    		SchedulerFactoryBean factory = new SchedulerFactoryBean();
    		factory.setOverwriteExistingJobs(true);
    		// 延时启动
    		factory.setStartupDelay(20);
    
    		// 加载quartz数据源配置
    		factory.setQuartzProperties(quartzProperties());
    
    		// 自定义Job Factory，用于Spring注入
    		factory.setJobFactory(jobFactory);
    		return factory;
    	}
    
    	@Bean
    	public Properties quartzProperties() throws IOException {
    		PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
    		propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
    		// 在quartz.properties中的属性被读取并注入后再初始化对象
    		propertiesFactoryBean.afterPropertiesSet();
    		return propertiesFactoryBean.getObject();
    	}
    
    	/*
    	 * quartz初始化监听器
    	 */
    	@Bean
    	public QuartzInitializerListener executorListener() {
    		return new QuartzInitializerListener();
    	}
    
    	/*
    	 * 通过SchedulerFactoryBean获取Scheduler的实例
    	 */
    	@Bean(name = "scheduler")
    	public Scheduler scheduler() throws Exception {
    		return schedulerFactoryBean().getScheduler();
    	}
    }

自定义定时任务工厂:CustomerJobFactory.java

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 CustomerJobFactory extends AdaptableJobFactory {
    	 @Autowired
    	 private AutowireCapableBeanFactory capableBeanFactory;
    
    	@Override
    	protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
    		// 调用父类的方法
            Object jobInstance = super.createJobInstance(bundle);
            // 进行注入
            capableBeanFactory.autowireBean(jobInstance);
            return jobInstance;
    	}
    }

三、添加Quartz的配置文件：在service模块的src/main/resource文件夹下新建quartz.properties 配置文件，配置文件的内容如下：

# 固定前缀org.quartz
    # 主要分为scheduler、threadPool、jobStore、plugin等部分
    org.quartz.scheduler.instanceName = DefaultQuartzScheduler
    org.quartz.scheduler.rmi.export = false
    org.quartz.scheduler.rmi.proxy = false
    org.quartz.scheduler.wrapJobExecutionInUserTransaction = false
    
    # 实例化ThreadPool时，使用的线程类为SimpleThreadPool
    org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
    
    # threadCount和threadPriority将以setter的形式注入ThreadPool实例
    # 并发个数
    org.quartz.threadPool.threadCount = 5
    # 优先级
    org.quartz.threadPool.threadPriority = 5
    org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true
    org.quartz.jobStore.misfireThreshold = 5000
    
    
    #MySQL 持久化
    org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
    # 表名前缀
    org.quartz.jobStore.tablePrefix = qrtz_
    # 指定数据库
    org.quartz.jobStore.dataSource = ucas
    # 指定mysql 驱动
    org.quartz.dataSource.ucas.driver = com.mysql.cj.jdbc.Driver
    # 数据库连接地址
    org.quartz.dataSource.ucas.URL = jdbc:mysql://192.168.*.**:3306/ucas?serverTimezone=UTC&useSSL=false&allowPublicKeyRetrieval=true&allowMultiQueries=true
    # 数据库账户
    org.quartz.dataSource.ucas.user = root
    # 数据库密码
    org.quartz.dataSource.ucas.password = ******
    # 配置最大连接数
    org.quartz.dataSource.ucas.maxConnections = 10

四、自定义定时任务对应的实体对象：SysCron.java

import java.util.Date;
    
    import com.***.common.model.BaseModel;
    
    @SuppressWarnings("serial")
    public class SysCron extends BaseModel {
        private String id;
    
        private String jobName;
    
        private String jobDescription;
    
        private String jobGroupName;
    
        private String jobClassName;
    
        private String triggerName;
    
        private String triggerGroupName;
    
        private String prevFireTime;
    
        private String nextFireTime;
    
        private String cronExpression;
    
        private String triggerState;
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id == null ? null : id.trim();
        }
    
        public String getJobName() {
            return jobName;
        }
    
        public void setJobName(String jobName) {
            this.jobName = jobName == null ? null : jobName.trim();
        }
    
        public String getJobDescription() {
            return jobDescription;
        }
    
        public void setJobDescription(String jobDescription) {
            this.jobDescription = jobDescription == null ? null : jobDescription.trim();
        }
    
        public String getJobGroupName() {
            return jobGroupName;
        }
    
        public void setJobGroupName(String jobGroupName) {
            this.jobGroupName = jobGroupName == null ? null : jobGroupName.trim();
        }
    
        public String getJobClassName() {
            return jobClassName;
        }
    
        public void setJobClassName(String jobClassName) {
            this.jobClassName = jobClassName == null ? null : jobClassName.trim();
        }
    
        public String getTriggerName() {
            return triggerName;
        }
    
        public void setTriggerName(String triggerName) {
            this.triggerName = triggerName == null ? null : triggerName.trim();
        }
    
        public String getTriggerGroupName() {
            return triggerGroupName;
        }
    
        public void setTriggerGroupName(String triggerGroupName) {
            this.triggerGroupName = triggerGroupName == null ? null : triggerGroupName.trim();
        }
    
        public String getPrevFireTime() {
            return prevFireTime;
        }
    
        public void setPrevFireTime(String prevFireTime) {
            this.prevFireTime = prevFireTime;
        }
    
        public String getNextFireTime() {
            return nextFireTime;
        }
    
        public void setNextFireTime(String nextFireTime) {
            this.nextFireTime = nextFireTime;
        }
    
        public String getCronExpression() {
            return cronExpression;
        }
    
        public void setCronExpression(String cronExpression) {
            this.cronExpression = cronExpression == null ? null : cronExpression.trim();
        }
    
        public String getTriggerState() {
            return triggerState;
        }
    
        public void setTriggerState(String triggerState) {
            this.triggerState = triggerState == null ? null : triggerState.trim();
        }
    }

自定义接口服务层：SysCronService.java

import java.util.List;
    import java.util.Map;
    import com.***.common.model.PageParam;
    import com.***.common.page.PageData;
    import com.***.ucas.domain.SysCron;
    
    public interface SysCronService{
    	
    	// 全部查询
    	List<SysCron> selectAll(Map<String,Object> parame);
    	//分页查询
    	PageData<SysCron> selectAllPage(Map<String,Object> parame, PageParam rb);
    	// 添加定时任务
    	public boolean addSysCron(SysCron entity);
    	// 更新定时任务
    	public boolean updateSysCron(SysCron entity);
    	// 删除定时任务
    	public boolean deleteSysCron(SysCron entity);
    	// 暂时定时任务
    	public boolean pauseSysCron(SysCron entity);
    	// 恢复定时任务
    	public boolean resumeJob(SysCron entity);
    }

自定义接口服务实现层：SysCronServiceImpl .java （核心代码：实现定时任务新增、修改、暂停、恢复和删除功能）

import java.util.List;
    import java.util.Map;
    import org.quartz.CronScheduleBuilder;
    import org.quartz.CronTrigger;
    import org.quartz.JobBuilder;
    import org.quartz.JobDetail;
    import org.quartz.JobKey;
    import org.quartz.Scheduler;
    import org.quartz.TriggerBuilder;
    import org.quartz.TriggerKey;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import com.***.common.job.BaseJob;
    import com.***.common.model.PageParam;
    import com.***.common.page.PageData;
    import com.***.ucas.api.SysCronService;
    import com.***.ucas.domain.SysCron;
    import com.***.ucas.mapper.SysCronMapper;
    import com.github.pagehelper.PageHelper;
    import com.github.pagehelper.PageInfo;
    
    @Service
    public class SysCronServiceImpl implements SysCronService {
    	private static final Logger log = LoggerFactory.getLogger(SysCronServiceImpl.class);
    
    	@Autowired
    	private Scheduler scheduler;
    	@Autowired
    	private SysCronMapper mapper;
    	
    	@Override
    	public List<SysCron> selectAll(Map<String, Object> parame) {
    		return mapper.selectAll(parame);
    	}
    
    	@Override
    	public PageData<SysCron> selectAllPage(Map<String, Object> parame, PageParam rb) {
    		// TODO Auto-generated method stub
    		PageData<SysCron> pageData = new PageData<SysCron>();
    		
    		PageHelper.startPage(rb.getPageNo(), rb.getLimit());
    		List<SysCron> rs = mapper.selectAll(parame);
    		
    		PageInfo<SysCron> pageInfo = new PageInfo<SysCron>(rs);
    		pageData.setData(pageInfo.getList());
    		pageData.setPageNum(pageInfo.getPageNum());
    		pageData.setPageSize(pageInfo.getPageSize());
    		pageData.setTotalCount(pageInfo.getTotal());
    		return pageData;
    	}
    
    	
    	@Override
    	public boolean addSysCron(SysCron entity) {
    		boolean target = false;
    		try {
    			// 启动调度器
    			scheduler.start();
    			// 构建job信息
    			JobDetail jobDetail = JobBuilder.newJob(getClass(entity.getJobClassName()).getClass())
    					.withIdentity(entity.getJobClassName(), entity.getJobGroupName()).build();
    			// 表达式调度构建器(即任务执行的时间)
    			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(entity.getCronExpression());
    			// 按新的cronExpression表达式构建一个新的trigger
    			CronTrigger trigger = TriggerBuilder.newTrigger()
    					.withIdentity(entity.getJobClassName(), entity.getJobGroupName()).withSchedule(scheduleBuilder)
    					.build();
    
    			scheduler.scheduleJob(jobDetail, trigger);
    			target = true;
    		} catch (Exception e) {
    			log.error("创建定时任务异常" + e.getMessage());
    			return target;
    		}
    		return target;
    	}
    
    	@Override
    	public boolean updateSysCron(SysCron entity) {
    		boolean target = false;
    		try {
    			TriggerKey triggerKey = TriggerKey.triggerKey(entity.getJobClassName(), entity.getJobGroupName());
    			// 表达式调度构建器
    			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(entity.getCronExpression());
    			CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
    			// 按新的cronExpression表达式重新构建trigger
    			trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
    			// 按新的trigger重新设置job执行
    			scheduler.rescheduleJob(triggerKey, trigger);
    			target = true;
    		} catch (Exception e) {
    			log.error("定时任务更新失败" + e.getMessage());
    			return target;
    		}
    
    		return target;
    	}
    
    	@Override
    	public boolean deleteSysCron(SysCron entity) {
    		boolean target = false;
    		try {
    			scheduler.pauseTrigger(TriggerKey.triggerKey(entity.getJobClassName(), entity.getJobGroupName()));
    			scheduler.unscheduleJob(TriggerKey.triggerKey(entity.getJobClassName(), entity.getJobGroupName()));
    			scheduler.deleteJob(JobKey.jobKey(entity.getJobClassName(), entity.getJobGroupName()));
    			target = true;
    		} catch (Exception e) {
    			log.error("定时任务删除失败" + e.getMessage());
    			return target;
    		}
    		return target;
    	}
    
    	@Override
    	public boolean pauseSysCron(SysCron entity) {
    		boolean target = false;
    		try {
    			scheduler.pauseJob(JobKey.jobKey(entity.getJobClassName(), entity.getJobGroupName()));
    			target = true;
    		} catch (Exception e) {
    			log.error("暂停定时任务失败" + e.getMessage());
    			return target;
    		}
    		return target;
    	}
    
    	@Override
    	public boolean resumeJob(SysCron entity) {
    		boolean target = false;
    		try {
    			scheduler.resumeJob(JobKey.jobKey(entity.getJobClassName(), entity.getJobGroupName()));
    			target = true;
    		} catch (Exception e) {
    			log.error("恢复定时任务失败" + e.getMessage());
    			return target;
    		}
    		return target;
    	}
    
    	/**
    	 * 
    	 * @param classname
    	 * @return
    	 * @throws Exception
    	 */
    	public static BaseJob getClass(String classname) throws Exception {
    		Class<?> class1 = Class.forName(classname);
    		return (BaseJob) class1.newInstance();
    	}
    
    	
    
    }

数据库mapp 接口定义和mapp 查询映射

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.digipower.ucas.mapper.SysCronMapper">
    
      
      <sql id="condition">
      		<if test="jobClassName != null">
      			and jd.job_class_name = #{jobClassName,jdbcType=VARCHAR}
      		</if>
      		<if test="jobGroupName != null">
      			and jd.job_group = #{jobGroupName,jdbcType=VARCHAR}
      		</if>
      		<if test="triggerName != null">
      			and t.trigger_name = #{triggerName,jdbcType=VARCHAR}
      		</if>
      		<if test="triggerGroupName != null">
      			and t.trigger_group = #{triggerGroupName,jdbcType=VARCHAR}
      		</if>
      		<if test="triggerState != null">
      			and t.trigger_state = #{triggerState, jdbcType=VARCHAR}
      		</if>
      </sql>
    
    	 
        <select id="selectAll" resultType="com.digipower.ucas.domain.SysCron">
                select
                    jd.job_name as jobname,
                    jd.description as jobdescription,
                    jd.job_group as jobgroupname,
                    jd.job_class_name as jobclassname,
                    t.trigger_name as triggername,
                    t.trigger_group as triggergroupname,
                    from_unixtime(t.prev_fire_time/1000,'%y-%m-%d %t') as prevfiretime,
                    from_unixtime(t.next_fire_time/1000,'%y-%m-%d %t') as nextfiretime,
                    ct.cron_expression as cronexpression,
                    t.trigger_state as triggerstate
                from
                    qrtz_job_details jd
                join qrtz_triggers t
                join qrtz_cron_triggers ct on jd.job_name = t.job_name
                and t.trigger_name = ct.trigger_name
                and t.trigger_group = ct.trigger_group
                where 1 = 1
                <include refid="condition" />
        </select>
    </mapper>

至此，Spring + Mybatis + Quartz 实现定义任务管理的基本功能封装完毕。

效果截图：待补充

第五步：添加自定义定时任务：

定义通用公共基础任务:BaseJob.java

import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    
    /**
     * 定时任务基础类
     * @author zzg
     *
     */
    public interface BaseJob extends Job {
    	public void execute(JobExecutionContext context) throws JobExecutionException;
    }

添加自定义Job

import java.util.Date;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import com.***.common.job.BaseJob;
    
    public class SimpleJob implements BaseJob {
    	private static final Logger log = LoggerFactory.getLogger(SimpleJob.class);
    	
    	public SimpleJob(){
    		System.out.println(new Date() + "SimpleJob");
            try {
                Thread.sleep(10000);
                System.out.println("任务 SimpleJob 开始干活。。。");
            } catch (InterruptedException e) {
                e.printStackTrace();
                log.error("SimpleJob 定时任务报错：" + e.getMessage());
            }
            System.out.println(new Date() + "SimpleJob 任务结束------------------------------------");
    	}
    
    	@Override
    	public void execute(JobExecutionContext context) throws JobExecutionException {
    		// TODO Auto-generated method stub
    		 System.out.println("SimpleJob执行时间: " + new Date());
    	}
    
    }

import java.util.List;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.springframework.beans.factory.annotation.Autowired;
    import com.alibaba.fastjson.JSONObject;
    import com.***.common.job.BaseJob;
    import com.***.ucas.domain.SysDataCategory;
    import com.***.ucas.mapper.SysDataCategoryMapper;
    
    public class SysDataCategoryJob implements BaseJob {
    
    	@Autowired
    	private SysDataCategoryMapper mapper;
    	
    	@Override
    	public void execute(JobExecutionContext context) throws JobExecutionException {
    		List<SysDataCategory> list = mapper.selectAll();
    		if(list != null && list.size() > 0){
    			String json = JSONObject.toJSONString(list);
    			System.out.println("json 内容:" + json);
    		}
    	}
    
    }

补充说明：Quartz.2.x MySQL 建库脚本：请参考：[https://blog.csdn.net/zhouzhiwengang/article/details/101776655][https_blog.csdn.net_zhouzhiwengang_article_details_101776655]

[https_blog.csdn.net_zhouzhiwengang_article_details_101776655]: https://blog.csdn.net/zhouzhiwengang/article/details/101776655