数据拉取之Quartz实现动态job（一）

目录

前言

在业务中我们经常会使用定时任务去处理一些需求。而一般的应用场景主要为数据同步，数据推送，定时处理一些业务数据等。而java传统的做法为

• TimerTask
  java自带的java.util.Timer类，使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行

• ScheduledExecutorService
  jdk自带的一个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响

• Spring Task
  Spring3.0以后自带的task,以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多

• Quartz
  可以让你的程序在指定时间执行，也可以按照某个频度执行

传统做法

TimerTask

先上代码

  public static void main(String[] args) {
        //1 创建定时任务
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                System.out.println("task :"+new Date());
            }
        };

        //2 创建定时器
        Timer timer = new Timer();

        //3 开始执行(每隔3s打印当前时间)
        timer.schedule(task,10,3000);

    }

而其调用只需要一个Timer类，主要用来维护定时任务，以及TimerTask 类用来执行具体任务的类，而任务类实现Runnable类，并且重写了run方法

I 源码分析之Timer

public class Timer {
    /**
     * 任务队列，存放待执行的任务
     */
    private final TaskQueue queue = new TaskQueue();

    /**
     * TimerThread线程，负责管理待执行的任务，并且以quene为参数构造
     */
    private final TimerThread thread = new TimerThread(queue);

而TaskQuene中维护了一个数组，调用schedule时，用来添加相应元素，并且根据执行时间的先后对数组元素进行排序，从而确定最先开始执行的任务

class TaskQueue {
    /**
     * 数组，保存元素
     */
    private TimerTask[] queue = new TimerTask[128];

TimerThread线程在对象初始化时，执行run方法

  public void run() {
        try {
            mainLoop();
        } finally {
            // Someone killed this Thread, behave as if Timer cancelled
            synchronized(queue) {
                newTasksMayBeScheduled = false;
                queue.clear();  // Eliminate obsolete references
            }
        }
    }

该线程中mainLoop方法，可以发现，当队列为空时，让queue去休息区区等待，并且跳出循环。
如果队列不为空，得到任务队列的首元素，并判断是否达到执行时间，如果没有，则进行休眠
private void mainLoop() {
        while (true) {
            try {
                TimerTask task;
                boolean taskFired;
                synchronized(queue) {
                    // Wait for queue to become non-empty
                    while (queue.isEmpty() && newTasksMayBeScheduled)
                        queue.wait();
                    if (queue.isEmpty())
                        break; // Queue is empty and will forever remain; die

                    // Queue nonempty; look at first evt and do the right thing
                    long currentTime, executionTime;
                    task = queue.getMin();
                    synchronized(task.lock) {
                        if (task.state == TimerTask.CANCELLED) {
                            queue.removeMin();
                            continue;  // No action required, poll queue again
                        }
                        currentTime = System.currentTimeMillis();
                        executionTime = task.nextExecutionTime;
                        if (taskFired = (executionTime<=currentTime)) {
                            if (task.period == 0) { // Non-repeating, remove
                                queue.removeMin();
                                task.state = TimerTask.EXECUTED;
                            } else { // Repeating task, reschedule
                                queue.rescheduleMin(
                                  task.period<0 ? currentTime   - task.period
                                                : executionTime + task.period);
                            }
                        }
                    }
                    if (!taskFired) // Task hasn't yet fired; wait
                        queue.wait(executionTime - currentTime);
                }
                if (taskFired)  // Task fired; run it, holding no locks
                    task.run();
            } catch(InterruptedException e) {
            }
        }
    }

timer执行scheduler方法，会向队列添加元素，并唤醒TaskQueue队列上的线程，这时候TimerThread会被唤醒，继续执行mainLoop

   public void schedule(TimerTask task, long delay, long period) {
        if (delay < 0)
            throw new IllegalArgumentException("Negative delay.");
        if (period <= 0)
            throw new IllegalArgumentException("Non-positive period.");
        sched(task, System.currentTimeMillis()+delay, -period);
    }

 private void sched(TimerTask task, long time, long period) {
        if (time < 0)
            throw new IllegalArgumentException("Illegal execution time.");

        // Constrain value of period sufficiently to prevent numeric
        // overflow while still being effectively infinitely large.
        if (Math.abs(period) > (Long.MAX_VALUE >> 1))
            period >>= 1;

        synchronized(queue) {
            if (!thread.newTasksMayBeScheduled)
                throw new IllegalStateException("Timer already cancelled.");

            synchronized(task.lock) {
                if (task.state != TimerTask.VIRGIN)
                    throw new IllegalStateException(
                        "Task already scheduled or cancelled");
                task.nextExecutionTime = time;
                task.period = period;
                task.state = TimerTask.SCHEDULED;
            }

            queue.add(task);
            if (queue.getMin() == task)
                queue.notify();
        }
    }

可以发现通过timer和timer task可以实现一个简单的定时任务。并且线程与队列的巧妙结合很值得借鉴。但是如果任务过多时，会生成很多资源，这个比较耗资源，同时线程的调度也非常占资源。所以基本很少用该方式

ScheduledExecutorService

先上代码

 public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
        service.scheduleAtFixedRate(()->System.out.println("task: "+new Date()), 0, 3, TimeUnit.SECONDS);
    }

该方式是基于线程池的方式进行创建的，而线程池主要有四个
I newSingleThreadExecutor：单线程池，同时只有一个线程在跑。
II newCachedThreadPool() ：回收型线程池，可以重复利用之前创建过的线程，运行线程最大数是Integer.MAX_VALUE。
III newFixedThreadPool() ：固定大小的线程池，跟回收型线程池类似，只是可以限制同时运行的线程数量
IV newSingleThreadScheduledExecutor():可以实现循环或延迟任务

而对比timer，可以知道
ScheduledExecutorService支持多个任务并发执行 后者是单线程，如果程序运行报错时，timer会停止所有任务的运行，同时timer时间间隔是依赖于系统的时间，而ScheduledExecutorService是基于时间的延迟

ThreadPoolExecutor一些参数配置，如
corePoolSize: 线程池中的核心线程数,如果当前线程数为corePoolSize，继续提交的任务被保存到阻塞队列中，等待被执行
maximumPoolSize: 线程池中允许的最大线程数。如果当前阻塞队列满了，且继续提交任务，则创建新的线程执行任务，前提是当前线程数小于maximumPoolSize
keepAliveTime：线程空闲时的存活时间，即当线程没有任务执行时，继续存活的时间

Spring Task

先上代码
任务执行类

@Component
public class SpringTaskDemo {

    @Scheduled(cron = "0/5 * * * * *")
    public void scheduledTest() {
        System.out.println("Scheduled: "+System.currentTimeMillis());
    }

   //固定速率
    @Scheduled(fixedRate = 5000)
    public void fixedRate() {
        System.out.println("fixedRate: "+System.currentTimeMillis());
    }
    //延迟速率
    @Scheduled(fixedDelay = 5000)
    public void fixedDelay() {
        System.out.println("fixedDelay: "+System.currentTimeMillis());
    }

}

在线cron生成：http://qqe2.com/cron/index
在启动类上加上@EnableScheduling，并且运行
而这里的任务是同步执行的，如果某个任务延迟比较严重，会阻塞当前线程，所以一般采取异步方式执行，即通过线程池方式去执行任务

@Configuration
@EnableAsync
public class AsyncConfig {

    private int corePoolSize = 10;
    private int maxPoolSize = 50;
    private int queueCapacity = 10;
    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.initialize();
        return executor;
    }

}

新增如上配置类，同时启动类加上@Async注解

Quartz

笔者工作中遇到任务量少，复杂性低的时候，采用了第二种与第三种方式，如用ScheduledExecutorService去异步发送邮件和执行非关键路径业务，用Spring Task去做一些简单的任务，如某张表的置顶过期时间到了定时处理，定时处理一些日志数据等。而这些之前都是耦合在主体业务服务包中。而如果有很多不同类型的业务数据需要从其他系统远程拉取，显然使用更高级的Quzrtz更符合场景（主要从精确度和功能 、任务类的数量、对异常的处理等角度对比）

设计job表

原则上应该有两张表，sys_token(用来保存token)，sys_job（记录每隔任务配置信息）,客户端通过OAuth2 密码模式获取授权和返回access_token保存在sys_token表中，job中有token的更新和业务job，这里简化业务只要sys_job表和利用restTemple拉取文章数据（后面博文将介绍和实战服务端推送与客户端集成xxl-job拉取）

DROP TABLE IF EXISTS `sys_job_detail`;
CREATE TABLE `sys_job_detail`  (
  `id` int(11) NOT NULL COMMENT '主键id',
  `job_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '定时任务名称',
  `job_group` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '定时任务组名',
  `job_class_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '定时任务类包位置',
  `job_cron` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '定时任务cron表达式',
  `job_type` int(11) NULL DEFAULT NULL COMMENT '定时任务启动/停止   0停止  1启动',
  `create_time` datetime(0) NULL DEFAULT NULL COMMENT '定时任务创建时间',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

INSERT INTO `sys_job_detail` VALUES (1, 'test', 'group', 'com.slycmiaoxi.job.job.bpArticleJob', '0 47 21 * * ? *', 1, NULL);

SET FOREIGN_KEY_CHECKS = 1;

其核心思想就是通过反射获取表中启动的任务记录，通过Scheduler操作该类

码上有戏

不多说，先上代码

如图所示：通过start模块为启动类，启动加载job模块下CronScheduleJob（从数据库读取记录和反射获取并添加相应job类)，bpArticleJob为具体业务类,BaseJob为实现job接口的类，业务job只要实现该方法即可扩展

读取任务

@Component
@Slf4j
public class CronScheduleJob {
    @Autowired
    private ISysJobDetailService jobService;

    public void scheduleJobsRun() throws SchedulerException {
        List<SysJobDetail> dwTdJobDetails = jobService.findInitJob();
        dwTdJobDetails.forEach(dwTdJobDetail -> {
            try {
                jobService.addJob(dwTdJobDetail, false);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("初始化定时失败！{}", e.getMessage());
            }
        });
    }

}

最核心的就是就是addJob方法了

@Override
    public void addJob(SysJobDetail dwTdJobDetailModel, boolean isCheck) throws SchedulerException, ClassNotFoundException {
        scheduler.start();
        System.out.println(dwTdJobDetailModel.toString());
        JobDetail jobDetail = JobBuilder
                .newJob(ClassUtil.getJobClass(dwTdJobDetailModel.getJobClassName()))
                .withIdentity(dwTdJobDetailModel.getJobClassName(), dwTdJobDetailModel.getJobGroup())
                .build();
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder
                .cronSchedule(dwTdJobDetailModel.getJobCron());
        CronTrigger cronTrigger = TriggerBuilder
                .newTrigger()
                .withIdentity(dwTdJobDetailModel.getJobClassName(), dwTdJobDetailModel.getJobGroup())
                .withSchedule(scheduleBuilder)
                .build();
        if (isCheck) {
            if (scheduler.getJobGroupNames().contains(dwTdJobDetailModel.getJobGroup()) ||
                    !jobDetailHandle(dwTdJobDetailModel.getJobClassName(),
                            dwTdJobDetailModel.getJobGroup(), "addJob")) {
                jobExistsException();
            }
        }
        scheduler.scheduleJob(jobDetail, cronTrigger);
        log.info("定时任务" + dwTdJobDetailModel.getJobName() + "开始");
    }

原理分析

在分析add方法之前，首先需要了解Quzrtz的几个核心对象

Scheduler   -- 核心调度器
Job         -- 任务
JobDetail   -- 任务描述
Trigger     -- 触发器

I 调度器 Scheduler 通过SchedulerFactory工厂模式创建，是实际执行任务调度的控制器
II Job位于org.quartz包下，任何一个基于Quartz都必须实现该接口，即execute（）方法
III 触发器 Trigger 用于定义任务调度的时间规则，有SimpleTrigger,CronTrigger,DateIntervalTrigger等
IV jobdetail： 记录job的一些信息（如key，class等用于唯一定位一个job任务）

其相应关系如下图所示

springboot项目启动时会执行实现了CommandLineRunner接口的类StartupRunner，然后从数据库读取到 List《SysJobDetail》，然后依次遍历，启动scheduler，初始化JobDetail和Trigger，通过scheduler.scheduleJob(jobDetail, cronTrigger)唤起job
，而其中通过jobKey区分每一个任务

jobDetail

JobDetail jobDetail = JobBuilder
                .newJob(ClassUtil.getJobClass(dwTdJobDetailModel.getJobClassName()))
                .withIdentity(dwTdJobDetailModel.getJobClassName(), dwTdJobDetailModel.getJobGroup())
                .build();

通过build模式，将反射后的类初始化给jobDetail的Jobclass，同时classname与group组合保证唯一key赋给jobKey

CronTrigger

CronScheduleBuilder scheduleBuilder = CronScheduleBuilder
                .cronSchedule(dwTdJobDetailModel.getJobCron());
        CronTrigger cronTrigger = TriggerBuilder
                .newTrigger()
                .withIdentity(dwTdJobDetailModel.getJobClassName(), dwTdJobDetailModel.getJobGroup())
                .withSchedule(scheduleBuilder)
                .build();

同样方式保证CronTrigger的key唯一，
最后唤起相应线程 scheduler.scheduleJob(jobDetail, cronTrigger);

简单说明

I 可在bpArticleJob中写自己的业务方法，或者如果需要扩展多个业务，只需表中配置下和新增一个xxxjob即可

II 通过Scheduler提供的api操作job进行任务的停止，暂停和重启等

源码地址

代码地址