关于Jfinal自带Cron4j的定时器使用实例

cron4j是Java平台的一个调度器,使用cron4j你只需要制定一些简单的规则，就可以在规定好的时间内执行你所指定的任务。本篇我们主要介绍cron4j在JFinal中的使用。

cron4j基本概念

主要步骤：

cron4j的主要对象为scheduler（调度器）。

1. 我们在使用的时候需要先new一个scheduler实例。

2. 通过schedule方法添加实现了java.lang.Runnable接口的实例对象作为要调度的任务（或是用cron4j提供的it.sauronsoftware.con4j.Task类来实例一个对象）。

3. 用一个时间字符串来代表指定的scheduling pattern（调度模式）指定任务在何时执行（或是使用一个it.sauronsoftware.cron4j.SchedulingPattern类的实例）。

4. 最后启动scheduler。

• 调度器可以安排任意数量的任务。
• 可以在调度器运行的过程中，添加新的任务或是对已经在运行的任务进行修改、移除。\
• 调度器可以开启或停止任意次。

 MAVEN配置（pom.xml）

<dependency>
    <groupId>it.sauronsoftware.cron4j</groupId>
    <artifactId>cron4j</artifactId>
    <version>2.2.5</version>
    <scope>provided</scope>
</dependency>

新建JobBean

package utils;

public class JobBean {

    /** id */
    private String jobId;

    /** 类名 */
    private String jobClass;

    /** 时间表达式 */
    private String cronExpression;

    /** 任务名称 */
    private String jobName;

    public String getJobId() {
        return jobId;
    }

    public void setJobId(String jobId) {
        this.jobId = jobId;
    }

    public String getJobClass() {
        return jobClass;
    }

    public void setJobClass(String jobClass) {
        this.jobClass = jobClass;
    }

    public String getCronExpression() {
        return cronExpression;
    }

    public void setCronExpression(String cronExpression) {
        this.cronExpression = cronExpression;
    }

    public String getJobName() {
        return jobName;
    }

    public void setJobName(String jobName) {
        this.jobName = jobName;
    }

    public JobBean(String jobId, String jobClass, String cronExpression, String jobName) {
        this.jobId = jobId;
        this.jobClass = jobClass;
        this.cronExpression = cronExpression;
        this.jobName = jobName;
    }

    public JobBean() {
        super();
    }
}

新建Cron4jPlugin工具类

package utils;

import com.jfinal.plugin.IPlugin;
import it.sauronsoftware.cron4j.InvalidPatternException;
import it.sauronsoftware.cron4j.Scheduler;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;

public class Cron4jPlugin implements IPlugin {

    // 任务调度器
    private static Scheduler scheduler = null;

    // 任务
    private static List<JobBean> jobs = new ArrayList<JobBean>();

    // 任务配置文件
    private String config = "job.properties";
    private Properties properties;

    public Cron4jPlugin(String config) {
        this.config = config;
    }

    public Cron4jPlugin() {

    }

    /**
     * 启动任务调度器
     */
    public boolean start() {
        scheduler = new Scheduler();
        // 加载配置文件
        loadProperties();
        Enumeration enums = properties.keys();

        // 解析配置文件
        while (enums.hasMoreElements()) {
            String key = enums.nextElement() + "";
            if (!key.endsWith("job")) {
                continue;
            }
            String cronKey = key.substring(0, key.indexOf("job")) + "cron";
            String enable = key.substring(0, key.indexOf("job")) + "enable";
            String name = key.substring(0, key.indexOf("job")) + "name";
            // 判断是否自启动
            if (isDisableJob(enable)) {
                continue;
            }
            String jobClassName = properties.get(key) + "";
            String jobCronExp = properties.getProperty(cronKey) + "";
            String jobName = properties.getProperty(name) + "";
            Class clazz;
            try {
                clazz = Class.forName(jobClassName);
            } catch (ClassNotFoundException e) {
                throw new RuntimeException(e);
            }
            try {
                // 添加一个调度任务;任务创建成功后会返回一个String类型的id,后续可以通过这个id操作这个任务
                String jobId = scheduler.schedule(jobCronExp, (Runnable) clazz.newInstance());
                jobs.add(createJob(jobId,jobClassName,jobCronExp,jobName));
            } catch (InvalidPatternException e) {
                throw new RuntimeException(e);
            } catch (InstantiationException e) {
                throw new RuntimeException(e);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }

        // 启动调度器
        scheduler.start();

        return true;
    }

    private void loadProperties() {
        properties = new Properties();
        InputStream is = Cron4jPlugin.class.getClassLoader().getResourceAsStream(config);
        try {
            properties.load(is);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private boolean isDisableJob(String enable) {
        return Boolean.valueOf(properties.get(enable) + "") == false;
    }

    /**
     * 创建job
     * @param id id
     * @param className 类名
     * @param cron 时间表达式
     * @param name 任务
     * @return
     */
    private JobBean createJob(String id,String className,String cron,String name){
        JobBean job = new JobBean();
        job.setJobId(id);
        job.setJobClass(className);
        job.setCronExpression(cron);
        job.setJobName(name);
        return job;
    }


    /**
     * 停止任务
     * @param name 任务名
     * @return
     */
    public static boolean stopJob(String name) {

        for (JobBean job : jobs) {
            if(name.equals(job.getJobName())){
                scheduler.deschedule(job.getJobId());
                return true;
            }
        }
        return false;
    }

    /**
     * 停止任务调度器
     */
    public boolean stop() {
        scheduler.stop();
        return true;
    }
}

新建定时任务类test(Testjob.java)

package utils;

import com.jfinal.config.Plugins;

import java.util.Date;

public class Testjob implements Runnable {

    public void run() {
        System.out.println("Current system time: " + new Date());
        System.out.println("Another minute ticked away...");
    }

}

properties配置文件(job.properties)

#job:任务类
#cron:执行的时间表达式
#enable:是否自启动
#name:任务名

task1.job=utils.Testjob
# 间隔时间
task1.cron=*/5 * * * * 
task1.enable=true
task1.name=task1

注意：job.properties 文件需要放在classpath下。

JFinal 核心类配置

JfinalConfigApiRun.java

@Override
public void configPlugin(final Plugins plugins) {
  log.info("测试定时器----------------------------------------------------------");
  plugins.add(new Cron4jPlugin());

}

全都配置完之后就可以用了，我的例子是每五分钟执行一次。