首先在开篇前，先放一个Springboot简单使用定时器的文章：
SpringBoot 定时器简单使用，实现任务调度_小目标青年的博客-CSDN博客

那当然还有一篇稍微高级点的，动态调度：

Springboot Quartz定时任务的动态调度使用，实战详解_小目标青年的博客-CSDN博客_springboot 动态调度

现在这篇是比较传统一点的，手动配置的方式：
定时任务配置包括  ：    

jobDetail 任务实例     定时任务执行的具体内容等 -相关业务代码    

trigger 触发器     设置相关的运行周期等    -绑定任务实例      （这篇文章会介绍包括两种触发器，简单的以及设置cron的）

scheduler 调度器     决定哪些定时任务会执行  -绑定触发器 

OK，接下来我们开始。

首先是导入Quartz定时器会用到的相关依赖包：

        <!-- scheduled所属资源为spring-context-support，在Spring中对Quartz的支持，是集成在spring-context-support包中。
         org.springframework.scheduling.quartz
      -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <!-- Quartz坐标 -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
            <!-- Quartz默认需要slf4j支持。springboot中，提供了更高版本的slf4j -->
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

然后看下我们这次的实践里整体需要弄得几个文件：

创建第一个定时任务的实例，TaskJobOne.class  :   （注意这里的@EnableScheduling 别忘记了）

import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.stereotype.Component;
import java.util.Date;
import static java.lang.Thread.sleep;

/**
 * @Author : JCccc
 * @CreateTime : 2020/3/9
 * @Description :
 **/
@Component
@EnableScheduling
public class TaskJobOne {


    public  void testJobOneMethod() throws InterruptedException {
        System.out.println("1  定时任务1正在执行......"+new Date());
        sleep(1000);

        System.out.println("1  定时任务1业务代码执行完毕......"+new Date());
    }
}

 然后是创建多个，也就是第二个定时任务的实例，TaskJobTwo.class： （注意这里的@EnableScheduling 别忘记了）

import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.stereotype.Component;
import java.util.Date;
import static java.lang.Thread.sleep;

/**
 * @Author : JCccc
 * @CreateTime : 2020/3/9
 * @Description :
 **/

@Component
@EnableScheduling
public class TaskJobTwo {


    public  void testJobTwoMethod() throws InterruptedException {
        System.out.println("2  定时任务2正在执行......" + new Date());
        sleep(1000);

        System.out.println("2  定时任务2业务代码执行完毕......"+new Date());
    }
    
}

然后是给这些任务实例绑定触发器，然后将触发器加入到调度工厂里：

创建 QuartzConfiguration.class：

（注意看每一步的注释，或者看后面我的简要要点描述！）

import com.demo.elegant.quartz.taskOne.TaskJobOne;
import com.demo.elegant.quartz.taskTwo.TaskJobTwo;
import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;
import java.util.Date;

/**
 * @Author : JCccc
 * @CreateTime : 2020/3/9
 * @Description :
 **/

@Configuration
public class QuartzConfiguration {




/*
定时任务配置包括  ：
    jobDetail 任务实例
    定时任务执行的具体内容等 -相关业务代码
    trigger 触发器
    设置相关的运行周期等    -绑定任务实例
    scheduler 调度器
    决定哪些定时任务会执行  -绑定触发器
*/

    /**
     * 定时任务 1
     */

    // 配置定时任务1的任务实例
    @Bean(name = "firstJobDetail")

    public MethodInvokingJobDetailFactoryBean firstJobDetail(TaskJobOne taskJobOne) {
        MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
        // 是否并发执行
        jobDetail.setConcurrent(false);
        // 为需要执行的实体类对应的对象
        jobDetail.setTargetObject(taskJobOne);
        // 需要执行的方法
        jobDetail.setTargetMethod("testJobOneMethod");
        return jobDetail;
    }


    // 配置触发器1
    @Bean(name = "firstTrigger")
    public SimpleTriggerFactoryBean firstTrigger(JobDetail firstJobDetail) {
        SimpleTriggerFactoryBean trigger = new SimpleTriggerFactoryBean();
        trigger.setJobDetail(firstJobDetail);
        // 设置任务启动延迟
        trigger.setStartDelay(0);
        // 设置定时任务启动时间
        trigger.setStartTime(new Date());
        // 每5秒执行一次
        trigger.setRepeatInterval(5000);
        return trigger;
    }


    /**
     * 定时任务 2
     *
     * @param taskJobTwo
     * @return
     */

    // 配置定时任务2的任务实例
    @Bean(name = "secondJobDetail")
    public MethodInvokingJobDetailFactoryBean secondJobDetail(TaskJobTwo taskJobTwo) {
        MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
        // 是否并发执行
        jobDetail.setConcurrent(true);
        // 为需要执行的实体类对应的对象
        jobDetail.setTargetObject(taskJobTwo);
        // 需要执行的方法
        jobDetail.setTargetMethod("testJobTwoMethod");
        return jobDetail;
    }

    // 配置触发器2
    @Bean(name = "secondTrigger")
    public CronTriggerFactoryBean secondTrigger(JobDetail secondJobDetail) {
        CronTriggerFactoryBean trigger = new CronTriggerFactoryBean();
        trigger.setJobDetail(secondJobDetail);
        // 设置定时任务启动时间
        trigger.setStartTime(new Date());
        // cron表达式
        trigger.setCronExpression("*/7 * * * * ?");
        return trigger;
    }


    // 配置Scheduler
    @Bean(name = "scheduler")
    public SchedulerFactoryBean schedulerFactory(Trigger firstTrigger, Trigger secondTrigger) {
        SchedulerFactoryBean bean = new SchedulerFactoryBean();
        // 延时启动，应用启动1秒后
        bean.setStartupDelay(1);
        // 注册触发器
        bean.setTriggers(firstTrigger, secondTrigger);
        return bean;
    }


}

要点描述1：
将我们的实例配置成为定时任务实例

要点描述2：  

绑定触发器 简单触发器：

要点描述3：

绑定可以使用cron表达式的触发器，这次实践里面我们的任务2就是：

 

要点描述4：

将配置好的触发器加入调度工厂：

 

运行一下，可以看到2个定时任务都正常运行：

如果需要继续添加其他的定时任务，那么就是创建实例，然后在配置文件里面依次进行相关配置绑定即可。

就到此。