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:

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

开始使用

新建JobBean

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工具类

Cron4jPlugin:

package utils;

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;

import com.jfinal.plugin.IPlugin;

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;
	}

}

新建定时任务类

Testjob:

package utils;

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=*/1 * * * *
task1.enable=true
task1.name=task1

# 多个任务
#task2.job=utils.Testjob2
#task2.cron=*/2 * * * *
#task2.enable=true
#task2.name=task2

JFinal 核心类配置

    public void configPlugin(Plugins me) {

    	me.add(new Cron4jPlugin());
        
    }

停止任务

Cron4jPlugin.stopJob("task1");

调度模式（scheduling pattern）

scheduling pattern是一个 UNIX 的类定时任务模式，由一个以空格分隔为五个部分的字符串组成。从左到右依次为分、时、天、月、周。精确到秒则需要quartz。

字段	规则
分	从 0 到 59
时	从 0 到 23
天	从 1 到 31，字母 L 可以表示月的最后一天
月	从 1 到 12，可以别名：jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov" and "dec"
周	从 0 到 6，0 表示周日，6 表示周六，可以使用别名： "sun", "mon", "tue", "wed", "thu", "fri" and "sat"

字符	用法
n	表示一个具体的时间点，例如 5 * * * * 表示 5 分这个时间点时执行
,	表示指定多个数值，例如 3,5 * * * * 表示 3 和 5 分这两个时间点执行
-	表示范围，例如 1-3 * * * * 表示 1 分、2 分再到 3 分这三个时间点执行
*	表示每一个时间点，例如 * * * * * 表示每分钟执行
/	表示指定一个值的增加幅度，例如 */5表示每隔5分钟执行一次

常用的：

含义	价格
每分钟执行依次	* * * * *
每个小时执行一次	0 */1 * * *
每天23:59执行一次	59 23 * * *
每月最后一天的23:59执行一次	59 23 L * *
每天9点到晚上9点，每个小时执行一次	0 9-21/1 * * *
每天8点、10点、12点、14点、16点、18点各执行依次	0 8,10,12,14,16,18 * * *
每个周六23:59执行一次	59 23 * * 6 59 23 * * sat
一月份的每个周六23:59执行一次	59 23 * 1 6 59 23 * jan sat