导读

由于项目需要，使用的是Gun企业级后台框架，对应gitee地址。可以使用一键生成代码之类的。

使用

I. 样式

页面说明

首页

侧边栏

代码生成

菜单管理

角色管理

登录日志

详细的可以自行去gitree上下载启动。

II. 定时任务配置（重点）

因为项目中使用了定时任务可视化，这里面就将其简单介绍下如何使用。

1、依赖

  <!--springboot 2.0 版本以后定时任务quart -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>

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

2、工具类QuartzManager

需要三个文件

QuartzManager
QuartzFactory
QuartzConfig

QuartzManager工具类

package cn.common.project.core.scheduleTask;

import org.quartz.*;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import java.util.HashMap;
import java.util.List;

public class QuartzManager {
    private static SchedulerFactoryBean schedulerFactory;

    public static void setSchedulerFactory(SchedulerFactoryBean schedulerFactory) {
        QuartzManager.schedulerFactory = schedulerFactory;
    }

    /**
     * 功能： 添加一个定时任务
     *
     * @param jobName          任务名
     * @param jobGroupName     任务组名
     * @param triggerName      触发器名
     * @param triggerGroupName 触发器组名
     * @param jobClass         任务的类类型  eg:TimedMassJob.class
     * @param cron             时间设置 表达式，参考quartz说明文档
     */
    public static void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass, String cron, HashMap<String, Object> hashMap) {
        try {
            Scheduler scheduler = schedulerFactory.getScheduler();
            // 任务名，任务组，任务执行类
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
            //触发器名，触发器组
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName);
            triggerBuilder.startNow();
            if (!hashMap.isEmpty()) {
                triggerBuilder.usingJobData("rows", hashMap.get("rows").toString());
            }
            // 触发器时间设定
            triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
            // 创建Trigger对象
            CronTrigger trigger = (CronTrigger) triggerBuilder.build();
            // 调度容器设置JobDetail和Trigger
            scheduler.scheduleJob(jobDetail, trigger);
            // 启动
            if (!scheduler.isShutdown()) {
                scheduler.start();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 功能：修改一个任务的触发时间
     *
     * @param jobName
     * @param jobGroupName
     * @param triggerName      触发器名
     * @param triggerGroupName 触发器组名
     * @param cron             时间设置，参考quartz说明文档
     */
    public static void modifyJobTime(String jobName, String jobGroupName, String triggerName, String triggerGroupName, String cron, HashMap<String, Object> hashMap) {
        try {
            Scheduler scheduler = schedulerFactory.getScheduler();

            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            if (trigger == null) {
                return;
            }

            //自定义参数
            String oldRows = "";
            String newRows = "";
            if (!hashMap.isEmpty()) {
                oldRows = hashMap.get("oldRows").toString();
                newRows = hashMap.get("rows").toString();
            }
            String oldTime = trigger.getCronExpression();

            if (!oldTime.equalsIgnoreCase(cron) || !oldRows.equalsIgnoreCase(newRows)) {
                //触发器名，触发器组
                TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName);
                triggerBuilder.startNow();

                //传递参数
                triggerBuilder.usingJobData("rows", hashMap.get("rows").toString());
                // 设置任务触发的时间表达式
                triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));

                //创建Trigger对象
                CronTrigger newTrigger = (CronTrigger) triggerBuilder.build();
                scheduler.rescheduleJob(triggerKey, newTrigger);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 功能: 移除一个任务
     *
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param triggerGroupName
     */
    public static void removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
        try {
            Scheduler scheduler = schedulerFactory.getScheduler();

            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            // 停止触发器
            scheduler.pauseTrigger(triggerKey);
            // 移除触发器
            scheduler.unscheduleJob(triggerKey);
            // 删除任务
            scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 功能：启动所有定时任务
     */
    public static void startJobs() {
        try {
            Scheduler scheduler = schedulerFactory.getScheduler();
            if (!scheduler.isStarted()) {
                scheduler.start();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 功能：关闭所有定时任务
     */
    public static void shutdownJobs() {
        try {
            Scheduler scheduler = schedulerFactory.getScheduler();
            if (!scheduler.isShutdown()) {
                scheduler.shutdown();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}

自定义QuartzFactory，解决注入为null的问题

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(value = "myJobFactory")
public class QuartzFactory extends AdaptableJobFactory{
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        //创建job实例
        Object jobInstance = super.createJobInstance(bundle);
        //进行注入
        capableBeanFactory.autowireBean(jobInstance);

        return jobInstance;
    }
}

定时任务配置QuartzConfig

package cn.common.project.core.scheduleTask;


import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

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

@Configuration
public class QuartzConfig {
    @Autowired
    Environment ev;

    @Autowired
    DataSource dataSource;

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(QuartzFactory myJobFactory) {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();

        schedulerFactoryBean.setDataSource(dataSource);
        // 使job实例(本文中job实例是MyJobBean)支持spring 容器管理
        schedulerFactoryBean.setOverwriteExistingJobs(true);
        schedulerFactoryBean.setJobFactory(myJobFactory);
        // schedulerFactoryBean.setApplicationContextSchedulerContextKey("applicationContext");
        // org.springframework.core.io.Resource res=new
        // ClassPathResource("quartz.properties");
        // schedulerFactoryBean.setConfigLocation(res);
        schedulerFactoryBean.setQuartzProperties(quartzProperties());
        // 延迟60s启动quartz
//        schedulerFactoryBean.setStartupDelay(10);

        QuartzManager.setSchedulerFactory(schedulerFactoryBean);

        return schedulerFactoryBean;
    }

    @Bean
    public Scheduler scheduler(SchedulerFactoryBean schedulerFactoryBean) {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        try {
            scheduler.start();
        } catch (SchedulerException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return scheduler;
    }

    public Properties quartzProperties() {
        Properties prop = new Properties();
        prop.put("quartz.scheduler.instanceName", "schedulerFactoryBean");
        prop.put("org.quartz.scheduler.instanceId", "AUTO");
        prop.put("org.quartz.scheduler.skipUpdateCheck", "true");
        // prop.put("org.quartz.scheduler.jobFactory.class",
        // "org.quartz.simpl.SimpleJobFactory");
        // JobStoreTX
        // prop.put("org.quartz.jobStore.class",
        // "org.quartz.impl.jdbcjobstore.JobStoreTX");
        prop.put("org.quartz.jobStore.class",
                "org.quartz.impl.jdbcjobstore.JobStoreCMT");
        prop.put("org.quartz.jobStore.driverDelegateClass",
                "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
        prop.put("org.quartz.jobStore.dataSource", "quartzDataSource");
        prop.put("org.quartz.jobStore.tablePrefix", "QRTZ_");
        prop.put("org.quartz.jobStore.isClustered", "true");
        prop.put("org.quartz.threadPool.class",
                "org.quartz.simpl.SimpleThreadPool");
        prop.put("org.quartz.threadPool.threadCount", "5");

        prop.put("org.quartz.jobStore.maxMisfiresToHandleAtATime", "1");
        prop.put("org.quartz.jobStore.misfireThreshold", "50000");
        // org.quartz.jobStore.txIsolationLevelSerializable 如果为true 会出现无法连续事物的错误
        prop.put("org.quartz.jobStore.txIsolationLevelSerializable", "false");
        prop.put("org.quartz.jobStore.useProperties", "true");

        // prop.put("org.quartz.dataSource.quartzDataSource.driver",
        // "oracle.jdbc.driver.OracleDriver");
        // prop.put("org.quartz.dataSource.quartzDataSource.URL",
        // "jdbc:oracle:thin:@127。0.0.1/orcl");
        // prop.put("org.quartz.dataSource.quartzDataSource.user", "spcp");
        // prop.put("org.quartz.dataSource.quartzDataSource.password", "spcp");
        // prop.put("org.quartz.dataSource.quartzDataSource.maxConnections",
        // "10");

        prop.put("org.quartz.jobStore.dontSetAutoCommitFalse", "false");

        return prop;
    }
}

3、数据库建立

自定义数据库定时任务表

CREATE TABLE `schedule_task_switch` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `parent_id` varchar(32) DEFAULT NULL COMMENT '父级ID',
  `table_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '定时任务中文名',
  `table_en_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '定时任务英文名',
  `class_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '类名',
  `cron` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT 'cron表达式',
  `remark` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '描述',
  `rows` int(11) NOT NULL COMMENT '每次查询的数据量(条)',
  `is_enable` tinyint(4) NOT NULL DEFAULT '0' COMMENT '开启-0，停止-1',
  PRIMARY KEY (`id`),
  UNIQUE KEY `table_en_name` (`table_en_name`)
) ENGINE=InnoDB AUTO_INCREMENT=147 DEFAULT CHARSET=utf8;

定时所需的表

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;

CREATE TABLE QRTZ_JOB_DETAILS(
SCHED_NAME VARCHAR(120) NOT NULL,
JOB_NAME VARCHAR(190) NOT NULL,
JOB_GROUP VARCHAR(190) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
JOB_CLASS_NAME VARCHAR(250) NOT NULL,
IS_DURABLE VARCHAR(1) NOT NULL,
IS_NONCONCURRENT VARCHAR(1) NOT NULL,
IS_UPDATE_DATA VARCHAR(1) NOT NULL,
REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
JOB_NAME VARCHAR(190) NOT NULL,
JOB_GROUP VARCHAR(190) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
NEXT_FIRE_TIME BIGINT(13) NULL,
PREV_FIRE_TIME BIGINT(13) NULL,
PRIORITY INTEGER NULL,
TRIGGER_STATE VARCHAR(16) NOT NULL,
TRIGGER_TYPE VARCHAR(8) NOT NULL,
START_TIME BIGINT(13) NOT NULL,
END_TIME BIGINT(13) NULL,
CALENDAR_NAME VARCHAR(190) NULL,
MISFIRE_INSTR SMALLINT(2) NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
REPEAT_COUNT BIGINT(7) NOT NULL,
REPEAT_INTERVAL BIGINT(12) NOT NULL,
TIMES_TRIGGERED BIGINT(10) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_CRON_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
CRON_EXPRESSION VARCHAR(120) NOT NULL,
TIME_ZONE_ID VARCHAR(80),
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(190) NOT NULL,
    TRIGGER_GROUP VARCHAR(190) NOT NULL,
    STR_PROP_1 VARCHAR(512) NULL,
    STR_PROP_2 VARCHAR(512) NULL,
    STR_PROP_3 VARCHAR(512) NULL,
    INT_PROP_1 INT NULL,
    INT_PROP_2 INT NULL,
    LONG_PROP_1 BIGINT NULL,
    LONG_PROP_2 BIGINT NULL,
    DEC_PROP_1 NUMERIC(13,4) NULL,
    DEC_PROP_2 NUMERIC(13,4) NULL,
    BOOL_PROP_1 VARCHAR(1) NULL,
    BOOL_PROP_2 VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_BLOB_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
BLOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_CALENDARS (
SCHED_NAME VARCHAR(120) NOT NULL,
CALENDAR_NAME VARCHAR(190) NOT NULL,
CALENDAR BLOB NOT NULL,
PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
ENGINE=InnoDB;

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_FIRED_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
ENTRY_ID VARCHAR(95) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
INSTANCE_NAME VARCHAR(190) NOT NULL,
FIRED_TIME BIGINT(13) NOT NULL,
SCHED_TIME BIGINT(13) NOT NULL,
PRIORITY INTEGER NOT NULL,
STATE VARCHAR(16) NOT NULL,
JOB_NAME VARCHAR(190) NULL,
JOB_GROUP VARCHAR(190) NULL,
IS_NONCONCURRENT VARCHAR(1) NULL,
REQUESTS_RECOVERY VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,ENTRY_ID))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SCHEDULER_STATE (
SCHED_NAME VARCHAR(120) NOT NULL,
INSTANCE_NAME VARCHAR(190) NOT NULL,
LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
CHECKIN_INTERVAL BIGINT(13) NOT NULL,
PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
ENGINE=InnoDB;

CREATE TABLE QRTZ_LOCKS (
SCHED_NAME VARCHAR(120) NOT NULL,
LOCK_NAME VARCHAR(40) NOT NULL,
PRIMARY KEY (SCHED_NAME,LOCK_NAME))
ENGINE=InnoDB;

CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);

CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);

CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);

commit;

4、工具类的使用

添加

try {
           // 从数据库查询的内容		
            ScheduleTaskSwitch taskInfos = scheduleTaskSwitchService.selectById(scheduleId);
           //启动定时任务
            logger.info("开始启动定时任务:" + taskInfos.getTableName());
            //传递参数--这里传递的是查询的条数
            HashMap<String, Object> hashMap = new HashMap<>();
            hashMap.put("rows", taskInfos.getRows());
            QuartzManager.addJob(taskInfos.getTableEnName() + "jobName", taskInfos.getRemark(), taskInfos.getTableEnName() + "triggerName", taskInfos.getTableEnName() + "triggerGroupName",
                    Class.forName(taskInfos.getClassName()), taskInfos.getCron(), hashMap);
            logger.info("定时任务启动成功:" + taskInfos.getTableName());
        } catch (Exception e) {
            logger.error("开始启动定时任务失败", e.getMessage());
            e.printStackTrace();
        }

修改

 ScheduleTaskSwitch taskInfos = scheduleTaskSwitchService.selectById(scheduleTaskSwitch.getId());
        //判断传递过来的查询总数据量和数据库的是否一致，如果不一致做更新定时任务操作，否则判断的时间是否一致，如果不一致，那么同样修改。
        if (!scheduleTaskSwitch.getRows().equals(taskInfos.getRows())) {
            //传递参数--这里传递的是查询的条数
            HashMap<String, Object> hashMap = new HashMap<>();
            hashMap.put("rows", scheduleTaskSwitch.getRows());
            hashMap.put("oldRows", taskInfos.getRows());
            //如果传递过来的cron不为空，且cron和数据库的不一致，并且处于运行中，那么将定时任务修改，否则的话，只需要修改数据库就行
            QuartzManager.modifyJobTime(taskInfos.getTableEnName() + "jobName", taskInfos.getRemark(),
                    taskInfos.getTableEnName() + "triggerName", taskInfos.getTableEnName() + "triggerGroupName", scheduleTaskSwitch.getCron(), hashMap);
        } else if (StringUtils.isNotEmpty(scheduleTaskSwitch.getCron())
                && !scheduleTaskSwitch.getCron().equals(taskInfos.getCron())
                && taskInfos.getIsEnable().equals("1")) {
            //传递参数--这里传递的是查询的条数
            HashMap<String, Object> hashMap = new HashMap<>();
            hashMap.put("rows", scheduleTaskSwitch.getRows());
            hashMap.put("oldRows", taskInfos.getRows());
            //如果传递过来的cron不为空，且cron和数据库的不一致，并且处于运行中，那么将定时任务修改，否则的话，只需要修改数据库就行
            QuartzManager.modifyJobTime(taskInfos.getTableEnName() + "jobName", taskInfos.getRemark(),
                    taskInfos.getTableEnName() + "triggerName", taskInfos.getTableEnName() + "triggerGroupName", scheduleTaskSwitch.getCron(), hashMap);
        }

删除

 if (taskInfos.getIsEnable().equals("1")) {
     //如果传递过来的cron不为空，且cron和数据库的不一致，并且处于运行中，那么将定时任务修改，否则的话，只需要修改数据库就行
     QuartzManager.removeJob(taskInfos.getTableEnName() + "jobName", taskInfos.getRemark(), taskInfos.getTableEnName() + "triggerName", taskInfos.getTableEnName() + "triggerGroupName");
     logger.info("停止定时任务成功:" + taskInfos.getTableName());
 }

批量添加

try {
            List<ScheduleTaskSwitch> scheduleTaskSwitch = scheduleTaskSwitchService.selectTasksByParentId(parentId);
            //一键开启所有的定时任务
            logger.info("一键开启所有的定时任务启动");
            scheduleTaskSwitch.forEach(taskInfos -> {
                try {
                    //传递参数--这里传递的是查询的条数
                    HashMap<String, Object> hashMap = new HashMap<>();
                    hashMap.put("rows", taskInfos.getRows());
                    QuartzManager.addJob(taskInfos.getTableEnName() + "jobName", taskInfos.getRemark(), taskInfos.getTableEnName() + "triggerName", taskInfos.getTableEnName() + "triggerGroupName",
                            Class.forName(taskInfos.getClassName()), taskInfos.getCron(), hashMap);
                } catch (ClassNotFoundException e) {
                    logger.error("类名ClassName不能为空", e.getMessage());
                    e.printStackTrace();
                }
            });
            logger.info("一键开启所有的定时任务结束");
            //根据父级Id修改定时任务状态
            this.scheduleTaskSwitchService.setStatusByParentId(parentId, ManagerStatus.OK.getCode());
        } catch (Exception e) {
            logger.error("一键开启所有的定时任务失败", e.getMessage());
            e.printStackTrace();
        }

批量关闭

 try {
            //一键开启所有的定时任务
            List<ScheduleTaskSwitch> scheduleTaskSwitch = scheduleTaskSwitchService.selectTasksByParentId(parentId);
            //一键开启所有的定时任务
            logger.info("一键关闭所有定时任务启动");
            scheduleTaskSwitch.forEach(taskInfos -> {
                QuartzManager.removeJob(taskInfos.getTableEnName() + "jobName", taskInfos.getRemark(), taskInfos.getTableEnName() + "triggerName", taskInfos.getTableEnName() + "triggerGroupName");
            });
            logger.info("一键关闭所有定时任务结束");
            //根据父级Id修改定时任务状态
            this.scheduleTaskSwitchService.setStatusByParentId(parentId, ManagerStatus.STOP.getCode());
        } catch (Exception e) {
            logger.error("一键关闭所有定时任务失败", e.getMessage());
            e.printStackTrace();
        }

执行定时任务类（必须实现Job接口，Override的execute方法）

import cn.common.project.exchange.mapper.SyncCountryMapper;
import cn.common.project.exchange.service.IUpdatePsService;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UpdatePsServiceImpl implements IUpdatePsService, Job {
    @Autowired
    SyncCountryMapper syncCountryMapper;

    @Override
    public void execute(String postfix,String rows) {
        syncCountryMapper.updatePs(postfix,rows);
    }

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //执行定时任务--传递表名后缀，执行的哪个表
        String postfix = jobExecutionContext.getJobDetail().getKey().getGroup();
        //传递查询的总条数
        String rows = jobExecutionContext.getTrigger().getJobDataMap().get("rows").toString();
        execute(postfix, rows);
    }
}

5、最终详情

III. 问题--传参

使用的时候出现传参异常，这里有几种方式传参。

1、创建JobDetail时

JobDetail jobDetail = JobBuilder.newJob(clazz)
					.withIdentity(jobName, jobGroupName)
					.usingJobData("info", jobName)
					.build();

2、创建Trigger时

trigger = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName)
					.usingJobData("info", triggerName)
					.withSchedule(scheduleBuilder)
					.build();

3、在创建JobDetail或者Trigger之后添加对应的参数

JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
Map<String,Object> params = new HashMap<>();
params.put("pInfo", triggerName);
jobDetail.getJobDataMap().put("info", params);

END

请查看chaohen：www.yuque.com/heioky

搞定~

Guns后台模板自动生成--定时任务可视化

导读

使用

I. 样式

页面说明

II. 定时任务配置（重点）

1、依赖

2、工具类QuartzManager

3、数据库建立

4、工具类的使用

5、最终详情

III. 问题--传参

1、创建JobDetail时

2、创建Trigger时

3、在创建JobDetail或者Trigger之后添加对应的参数

END