uw.task.TaskCroner Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of uw-task Show documentation
uw-task包是一个分布式任务框架，通过uw-task可以快速构建基于docker的分布式任务体系，同时支持基于influx的任务运维监控。
There is a newer version: 1.1.17
package uw.task;

import java.util.Date;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronTrigger;

import uw.task.api.TaskAPI;
import uw.task.entity.TaskCronerLog;
import uw.task.util.GlobalSequenceManager;
import uw.task.util.LeaderVote;
import uw.task.util.Utils;

/**
 * 定时任务类。 使用Cron表达式来运行定时任务。
 * 
 * @author axeon
 *
 */
@EnableScheduling
public abstract class TaskCroner implements SchedulingConfigurer {

	private static final Logger log = LoggerFactory.getLogger(TaskCroner.class);

	/**
	 * 直接运行模式。
	 */
	public static final int RUN_TYPE_ANYWAY = 0;

	/**
	 * 运行在全局单例模式下。
	 */
	public static final int RUN_TYPE_SINGLETON = 1;

	/**
	 * 选举
	 */
	@Autowired
	private LeaderVote leaderVote;

	/**
	 * 服务端API
	 */
	@Autowired
	private TaskAPI taskAPI;

	/**
	 * 全局序列发生器。
	 */
	@Autowired
	private GlobalSequenceManager sequence;

	/**
	 * CronTrigger调度器，默认是每秒触发。
	 */
	private CronTrigger trigger = new CronTrigger("*/1 * * * * ?");

	/**
	 * 是否是全局性任务？
	 */
	private int runType = 0;

	/**
	 * 运行主机。
	 */
	private String runTarget;

	/**
	 * 任务日志
	 */
	private TaskCronerLog taskCronerLog = null;

	/**
	 * 是否启动
	 */
	private boolean isStart = false;

	/**
	 * 启动，一般不要调用。
	 */
	public void start() {
		isStart = true;
	}

	/**
	 * 停止，一般不要调用。
	 */
	public void stop() {
		isStart = false;
	}

	/**
	 * @return the runType
	 */
	public int getRunType() {
		return runType;
	}

	/**
	 * @param runType
	 *            the runType to set
	 */
	public void setRunType(int runType) {
		this.runType = runType;
	}

	/**
	 * @return the runTarget
	 */
	public String getRunTarget() {
		return runTarget;
	}

	/**
	 * @param runTarget
	 *            the runTarget to set
	 */
	public void setRunTarget(String targetHost) {
		this.runTarget = targetHost;
	}

	/**
	 * 获得当前Cron表达式
	 * 
	 * @return
	 */
	public String getCronExpression() {
		return trigger.getExpression();
	}

	/**
	 * 设置新的Cron表达式
	 * 
	 * @param expression
	 */
	public void setCronExpression(String expression) {
		if (!trigger.getExpression().equalsIgnoreCase(expression)) {
			trigger = new CronTrigger(expression);
		}
	}

	/**
	 * 配置任务
	 * 
	 * @param taskRegistrar
	 */
	@Override
	public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {

		taskRegistrar.addTriggerTask(new Runnable() {
			@Override
			public void run() {
				// 判断是否启动
				if (!isStart) {
					return;
				}
				// 判断是否是可运行的主机
				if (runTarget != null && runTarget.length() > 0 && taskAPI.getHostConfig() != null
						&& !taskAPI.getHostConfig().contains(runTarget)) {
					return;
				}
				// 判断全局唯一条件
				if (runType == RUN_TYPE_SINGLETON && !leaderVote.isLeader(this.getClass().getName())) {
					return;
				}
				// 任务逻辑
				taskCronerLog = new TaskCronerLog();
				taskCronerLog.setId(sequence.nextId("task_croner_log"));
				taskCronerLog.setTaskClass(TaskCroner.this.getClass().getName());
				taskCronerLog.setTaskCron(trigger.getExpression());
				taskCronerLog.setRunType(runType);
				taskCronerLog.setRunTarget(runTarget);
				taskCronerLog.setHostIp(taskAPI.getHostIp());
				taskCronerLog.setHostId(LeaderVote.UUID);
				String data = "";
				try {
					data = runTask();
					taskCronerLog.setStatus(TaskData.STATUS_SUCCESS);
				} catch (TaskException e) {
					// 出现TaskException，说明是合作方的错误。
					taskCronerLog.setStatus(TaskData.STATUS_FAIL_PARTNER);
					data = Utils.exceptionToString(e);
					log.error(e.getMessage(), e);
				} catch (Exception e) {
					data = Utils.exceptionToString(e);
					taskCronerLog.setStatus(TaskData.STATUS_FAIL_PROGRAM);
					log.error(e.getMessage(), e);
				}
				taskCronerLog.setResultData(data);
			}
		}, new Trigger() {
			@Override
			public Date nextExecutionTime(TriggerContext triggerContext) {
				// 任务触发，可修改任务的执行周期
				Date nextExec = trigger.nextExecutionTime(triggerContext);
				// 在此处写入本次执行的信息
				if (isStart && taskCronerLog != null && taskCronerLog.getId() > 0) {
					if (triggerContext.lastScheduledExecutionTime() != null
							&& triggerContext.lastActualExecutionTime() != null
							&& triggerContext.lastCompletionTime() != null) {
						taskCronerLog.setScheduleDate(triggerContext.lastScheduledExecutionTime());
						taskCronerLog.setRunDate(triggerContext.lastActualExecutionTime());
						taskCronerLog.setFinishDate(triggerContext.lastCompletionTime());
						// 写入下次计划执行日期。
						taskCronerLog.setNextDate(nextExec);
						// 入库
						taskAPI.sendTaskCronerLog(taskCronerLog);
					}
				}
				return nextExec;
			}
		});
	}

	/**
	 * 运行任务
	 */
	public abstract String runTask() throws TaskException;

	/**
	 * 初始化的Cron表达式。
	 */
	public abstract String initCronExpression();

	/**
	 * 初始化运行模式
	 * 
	 * @return
	 */
	public abstract int initRunType();

	/**
	 * 初始化运行主机
	 * 
	 * @return
	 */
	public abstract String initRunTarget();

}