Spring Boot 和 Mybatis 实现数据库动态初始化定时任务

首先，需要在 pom.xml 文件中添加相应的依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>

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

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=root

mybatis.mapper-locations=classpath:mapper/*.xml

接下来，创建定时任务表的实体类和 Mapper 类，如下所示：

@Entity
@Table(name = 'job_task')
public class JobTask {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String group;
    private String cronExpression;
    private String className;
    private String methodName;
    private String param;
    private Integer status;
    private Date createTime;
    private Date updateTime;

    // getter and setter
}

@Mapper
@Repository
public interface JobTaskMapper {
    List<JobTask> findAll();
    JobTask findById(Long id);
    int add(JobTask jobTask);
    int update(JobTask jobTask);
    int deleteById(Long id);
}

然后，创建定时任务的配置类和任务执行类，如下所示：

@Configuration
public class QuartzConfig {
    @Autowired
    private JobTaskMapper jobTaskMapper;

    @Bean
    public JobDetail jobDetail() {
        return JobBuilder.newJob().ofType(JobExecutor.class)
                .withIdentity('jobExecutor')
                .withDescription('Invoke Job Executor')
                .storeDurably()
                .build();
    }

    @Bean
    public Trigger trigger() {
        return TriggerBuilder.newTrigger().forJob(jobDetail())
                .withIdentity('jobExecutorTrigger')
                .withDescription('Invoke Job Executor Trigger')
                .withSchedule(CronScheduleBuilder.cronSchedule('0/5 * * * * ?')) // 每5秒执行一次
                .build();
    }

    @Bean
    public Scheduler scheduler() throws SchedulerException {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();
        scheduler.setJobFactory(springBeanJobFactory());
        scheduler.scheduleJob(jobDetail(), trigger());
        return scheduler;
    }

    @Bean
    public SpringBeanJobFactory springBeanJobFactory() {
        return new SpringBeanJobFactory();
    }
}

@Component
public class JobExecutor implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        Long jobId = (Long) jobExecutionContext.getMergedJobDataMap().get('jobId');
        JobTask jobTask = jobTaskMapper.findById(jobId);
        // 执行任务
        // ...
    }
}

最后，在启动类中添加 @EnableScheduling 注解，启用定时任务功能：

@SpringBootApplication
@EnableScheduling
@MapperScan(basePackages = 'com.example.demo.mapper')
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

通过以上步骤，我们就可以在数据库里动态初始化定时任务了。具体实现可以通过读取数据库里的定时任务配置信息，创建相应的 Trigger 和 JobDetail 对象，并将它们添加到 Scheduler 里。Scheduler 会按照 Trigger 配置的时间间隔执行 Job。