SpringBoot 和 Mybatis 实现数据库初始化定时任务

本文将介绍如何使用 SpringBoot 和 Mybatis 从数据库中初始化定时任务，让你的应用可以从数据库中读取配置信息并动态创建定时任务。

1. 依赖配置

在 pom.xml 文件中添加以下依赖：

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.0</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
    <version>2.2.0.RELEASE</version>
</dependency>

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

2. 数据库连接配置

在 application.properties 文件中配置数据库连接信息：

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=root

3. 创建定时任务实体类

创建一个定时任务实体类，例如：

public class JobEntity {
    private String jobName;
    private String jobGroup;
    private String cronExpression;
    private String jobClass;
    // getter and setter
}

4. 创建 JobMapper 接口

创建一个 JobMapper 接口，定义查询数据库中所有定时任务的方法：

@Mapper
public interface JobMapper {
    @Select('SELECT job_name, job_group, cron_expression, job_class FROM job_entity')
    List<JobEntity> getAllJobs();
}

5. 创建 QuartzJobFactory 类

创建一个 QuartzJobFactory 类，用于创建定时任务并执行：

public class QuartzJobFactory implements Job {
    private static final Logger logger = LoggerFactory.getLogger(QuartzJobFactory.class);

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDetail jobDetail = context.getJobDetail();
        JobEntity jobEntity = (JobEntity) jobDetail.getJobDataMap().get('jobEntity');
        String jobName = jobEntity.getJobName();
        String jobGroup = jobEntity.getJobGroup();
        String cronExpression = jobEntity.getCronExpression();
        String jobClass = jobEntity.getJobClass();
        try {
            Class clazz = Class.forName(jobClass);
            Job job = (Job) clazz.newInstance();
            JobDetail jobDetail1 = JobBuilder.newJob(job.getClass())
                    .withIdentity(jobName, jobGroup)
                    .build();
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
            CronTrigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(jobName, jobGroup)
                    .withSchedule(scheduleBuilder)
                    .build();
            Scheduler scheduler = new StdSchedulerFactory().getScheduler();
            scheduler.scheduleJob(jobDetail1, trigger);
            scheduler.start();
            logger.info('定时任务启动成功：{}-{}', jobGroup, jobName);
        } catch (Exception e) {
            logger.error('定时任务启动失败：{}-{}', jobGroup, jobName, e);
        }
    }
}

6. 创建 QuartzJobConfig 类

创建一个 QuartzJobConfig 类，用于初始化定时任务：

@Configuration
public class QuartzJobConfig {
    @Autowired
    private JobMapper jobMapper;

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setQuartzProperties(quartzProperties());
        factory.setJobFactory(jobFactory());
        factory.setTriggers(jobTriggers());
        return factory;
    }

    @Bean
    public JobFactory jobFactory() {
        return new SpringBeanJobFactory();
    }

    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource('/quartz.properties'));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

    @Bean
    public List<Trigger> jobTriggers() {
        List<JobEntity> jobEntities = jobMapper.getAllJobs();
        List<Trigger> triggers = new ArrayList<>();
        for (JobEntity jobEntity : jobEntities) {
            JobDataMap jobDataMap = new JobDataMap();
            jobDataMap.put('jobEntity', jobEntity);
            JobDetail jobDetail = JobBuilder.newJob(QuartzJobFactory.class)
                    .withIdentity(jobEntity.getJobName(), jobEntity.getJobGroup())
                    .usingJobData(jobDataMap)
                    .build();
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(jobEntity.getCronExpression());
            CronTrigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(jobEntity.getJobName(), jobEntity.getJobGroup())
                    .withSchedule(scheduleBuilder)
                    .build();
            triggers.add(trigger);
        }
        return triggers;
    }
}

7. 创建 quartz.properties 文件

创建一个 quartz.properties 文件，用于配置定时任务调度器：

org.quartz.scheduler.instanceName = MyScheduler
org.quartz.scheduler.instanceId = AUTO
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.useProperties = false
org.quartz.jobStore.dataSource = myDataSource
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.isClustered = true
org.quartz.jobStore.clusterCheckinInterval = 20000
org.quartz.jobStore.maxMisfiresToHandleAtATime = 1
org.quartz.jobStore.misfireThreshold = 60000
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 10
org.quartz.threadPool.threadPriority = 5
org.quartz.dataSource.myDataSource.driver = com.mysql.jdbc.Driver
org.quartz.dataSource.myDataSource.URL = jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC&characterEncoding=utf8
org.quartz.dataSource.myDataSource.user = root
org.quartz.dataSource.myDataSource.password = root
org.quartz.dataSource.myDataSource.maxConnections = 10

8. 启动类配置

最后，在定时任务实体类上添加注解 @Mapper，在启动类上添加 @EnableScheduling 注解，即可从数据库里初始化定时任务。

@SpringBootApplication
@EnableScheduling
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

现在，你的 SpringBoot 应用就可以从数据库中读取定时任务配置信息，并动态创建和执行定时任务了。

总结

本文介绍了如何使用 SpringBoot 和 Mybatis 从数据库中初始化定时任务。通过以上步骤，你可以方便地将定时任务的配置信息存储在数据库中，并根据需要动态创建和执行任务，提高应用的灵活性和可维护性。