定时任务之--Quartz

1.在一个系统中,定时任务是最常见的,这个定时任务是支持动态的修改和手动触发

应为定时任务项目里或多或少都会用到

2.首先添加依赖:

<dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.0</version>
</dependency>

3.创建定时任务数据库:定时任务记录表,定时任务记录表,

CREATE TABLE `cl_quartz_info` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `name` varchar(32) NOT NULL DEFAULT '' COMMENT '定时任务名称',
  `code` varchar(64) NOT NULL DEFAULT '' COMMENT '定时任务code标识',
  `cycle` varchar(32) NOT NULL DEFAULT '' COMMENT '定时任务执行周期',
  `class_name` varchar(64) NOT NULL DEFAULT '' COMMENT '定时任务执行类',
  `succeed` int(11) NOT NULL DEFAULT '0' COMMENT '成功执行次数',
  `fail` int(11) NOT NULL DEFAULT '0' COMMENT '失败执行次数',
  `state` varchar(2) NOT NULL DEFAULT '' COMMENT '是否启用 10-启用 20-禁用',
  `create_time` datetime NOT NULL COMMENT '创建时间',
  PRIMARY KEY (`id`),
  KEY `name` (`name`)
) ENGINE=InnoDB AUTO_INCREMENT=16 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='定时任务信息表';


CREATE TABLE `cl_quartz_log` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `quartz_id` bigint(20) DEFAULT '0' COMMENT '定时任务id',
  `start_time` datetime DEFAULT NULL COMMENT '启动时间',
  `time` int(11) DEFAULT '0' COMMENT '任务用时',
  `result` varchar(2) DEFAULT '20' COMMENT '执行是否成功 10-成功 20-失败',
  `remark` varchar(128) DEFAULT '' COMMENT '备注信息',
  PRIMARY KEY (`id`),
  KEY `quartz_id` (`quartz_id`)
) ENGINE=InnoDB AUTO_INCREMENT=708 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='定时任务执行记录表';

4.创建两个表的实体类

/**
 * 定时任务详情实体
 */
 public class QuartzInfo implements Serializable {

    private static final long serialVersionUID = 1L;

	/**
	 * 主键Id
	 */
	private Long id;

	/**
	 * 定时任务名称
	 */
	private String name;

	/**
	 * 定时任务标识
	 */
	private String code;

	/**
	 * 定时任务执行周期
	 */
	private String cycle;

	/**
	 * 定时任务执行类
	 */
	private String className;

	/**
	 * 成功执行次数
	 */
	private Integer succeed;

	/**
	 * 失败执行次数
	 */
	private Integer fail;

	/**
	 * 是否启用 10-启用 20-禁用
	 */
	private String state;

	/**
	 * 创建时间
	 */
	private Date createTime;

	/**
	 * 获取主键Id
	 *
	 * @return id
	 */
	public Long getId() {
		return id;
	}

	/**
	 * 设置主键Id
	 * 
	 * @param
	 */
	public void setId(Long id) {
		this.id = id;
	}

	/**
	 * 获取定时任务名称
	 *
	 * @return 定时任务名称
	 */
	public String getName() {
		return name;
	}

	/**
	 * 设置定时任务名称
	 * 
	 * @param name
	 *            要设置的定时任务名称
	 */
	public void setName(String name) {
		this.name = name;
	}

	/**
	 * 获取定时任务标识
	 * 
	 * @return code
	 */
	public String getCode() {
		return code;
	}

	/**
	 * 设置定时任务标识
	 * 
	 * @param code
	 */
	public void setCode(String code) {
		this.code = code;
	}

	/**
	 * 获取定时任务执行周期
	 *
	 * @return 定时任务执行周期
	 */
	public String getCycle() {
		return cycle;
	}

	/**
	 * 设置定时任务执行周期
	 * 
	 * @param cycle
	 *            要设置的定时任务执行周期
	 */
	public void setCycle(String cycle) {
		this.cycle = cycle;
	}

	/**
	 * 获取定时任务执行类
	 *
	 * @return 定时任务执行类
	 */
	public String getClassName() {
		return className;
	}

	/**
	 * 设置定时任务执行类
	 * 
	 * @param className 要设置的定时任务执行类
	 */
	public void setClassName(String className) {
		this.className = className;
	}

	/**
	 * 获取成功执行次数
	 *
	 * @return 成功执行次数
	 */
	public Integer getSucceed() {
		return succeed;
	}

	/**
	 * 设置成功执行次数
	 * 
	 * @param succeed
	 *            要设置的成功执行次数
	 */
	public void setSucceed(Integer succeed) {
		this.succeed = succeed;
	}

	/**
	 * 获取失败执行次数
	 *
	 * @return 失败执行次数
	 */
	public Integer getFail() {
		return fail;
	}

	/**
	 * 设置失败执行次数
	 * 
	 * @param fail
	 *            要设置的失败执行次数
	 */
	public void setFail(Integer fail) {
		this.fail = fail;
	}

	/**
	 * 获取是否启用 10-启用 20-禁用
	 *
	 * @return 是否启用 10-启用 20-禁用
	 */
	public String getState() {
		return state;
	}

	/**
	 * 设置是否启用 10-启用 20-禁用
	 * 
	 * @param state
	 *            要设置的是否启用 10-启用 20-禁用
	 */
	public void setState(String state) {
		this.state = state;
	}

	/**
	 * 获取创建时间
	 *
	 * @return 创建时间
	 */
	public Date getCreateTime() {
		return createTime;
	}

	/**
	 * 设置创建时间
	 * 
	 * @param createTime
	 *            要设置的创建时间
	 */
	public void setCreateTime(Date createTime) {
		this.createTime = createTime;
	}

5.定时任务记录表实体类

/**
 * 定时任务记录实体
 */
 public class QuartzLog implements Serializable {

    private static final long serialVersionUID = 1L;

	/**
	 * 主键Id
	 */
	private Long id;

	/**
	 * 定时任务id
	 */
	private Long quartzId;

	/**
	 * 启动时间
	 */
	private Date startTime;

	/**
	 * 任务用时
	 */
	private long time;

	/**
	 * 执行是否成功 10-成功 20-失败
	 */
	private String result;
	
	/**
	 * 备注信息
	 */
	private String remark;

	/**
	 * 获取主键Id
	 *
	 * @return id
	 */
	public Long getId() {
		return id;
	}

	/**
	 * 设置主键Id
	 * 
	 * @param 要设置的主键Id
	 */
	public void setId(Long id) {
		this.id = id;
	}

	/**
	 * 获取定时任务id
	 *
	 * @return 定时任务id
	 */
	public Long getQuartzId() {
		return quartzId;
	}

	/**
	 * 设置定时任务id
	 * 
	 * @param quartzId
	 *            要设置的定时任务id
	 */
	public void setQuartzId(Long quartzId) {
		this.quartzId = quartzId;
	}

	/**
	 * 获取启动时间
	 *
	 * @return 启动时间
	 */
	public Date getStartTime() {
		return startTime;
	}

	/**
	 * 设置启动时间
	 * 
	 * @param startTime
	 *            要设置的启动时间
	 */
	public void setStartTime(Date startTime) {
		this.startTime = startTime;
	}

	/**
	 * 获取任务用时
	 *
	 * @return 任务用时
	 */
	public long getTime() {
		return time;
	}

	/**
	 * 设置任务用时
	 * 
	 * @param time
	 *            要设置的任务用时
	 */
	public void setTime(long time) {
		this.time = time;
	}

	/**
	 * 获取执行是否成功 10-成功 20-失败
	 *
	 * @return 执行是否成功 10-成功 20-失败
	 */
	public String getResult() {
		return result;
	}

	/**
	 * 设置执行是否成功 10-成功 20-失败
	 * 
	 * @param result
	 *            要设置的执行是否成功 10-成功 20-失败
	 */
	public void setResult(String result) {
		this.result = result;
	}

	/**
	 * @return the remark
	 */
	public String getRemark() {
		return remark;
	}

	/**
	 * @param remark the remark to set
	 */
	public void setRemark(String remark) {
		this.remark = remark;
	}

6.定时任务接口

/**
 * 定时任务详情Service
 */
public interface QuartzInfoService{


	/**
	 * 保存定时任务数据
	 * @param qi
	 */
	boolean save(QuartzInfo qi);

	/**
	 * 修改定时任务
	 * @param search
	 * @return
	 */
	boolean update(Map<String, Object> search);

	/**
	 * 查询所有任务
	 * @param result
	 * @return
	 */
	List<QuartzInfo> list(Map<String, Object> result);

	/**
	 * 定时任务分页查询
	 * @param searchMap
	 * @param current
	 * @param pageSize
	 * @return
	 */
	Page<QuartzInfoModel> page(Map<String, Object> searchMap, int current,
							   int pageSize);
	
	/**
	 * 据任务标识查询任务
	 * @param paramMap
	 * @return
	 */
	QuartzInfo findByCode(String code);
	
	/**
	 * 据条件查询定时任务详情
	 * @param paramMap
	 * @return
	 */
	QuartzInfo findSelective(Map<String, Object> paramMap);

7.实现类

import com.github.pagehelper.Page;
import com.itcorey.domain.QuartzLog;
import com.itcorey.model.QuartzLogModel;

import java.util.Map;

/**
 * 定时任务记录Service
 */
public interface QuartzLogService {

	/**
	 * 保存日志
	 */
	int save(QuartzLog ql);

	Page<QuartzLogModel> page(Map<String, Object> searchMap, int current,
							  int pageSize);

}

8.两个Model类,定时任务记录Model

import com.itcorey.domain.QuartzLog;

/**
 * 定时任务记录Model
 */
public class QuartzLogModel extends QuartzLog {

	private static final long serialVersionUID = 1L;

	/** 执行结果 - 成功 */
	public static final String RESULT_SUCCESS = "10";
	/** 执行结果 - 失败 */
	public static final String RESULT_FAIL = "20";

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

	/**
	 * 任务执行结果中文描述
	 */
	private String resultStr;

	/**
	 * 获取任务名称
	 *
	 * @return name
	 */
	public String getName() {
		return name;
	}

	/**
	 * 设置任务名称
	 *
	 * @param name
	 */
	public void setName(String name) {
		this.name = name;
	}

	/**
	 * 获取任务执行结果中文描述
	 *
	 * @return resultStr
	 */
	public String getResultStr() {
		this.resultStr = convertResult(this.getResult());
		return resultStr;
	}

	/**
	 * 设置任务执行结果中文描述
	 *
	 * @param resultStr
	 */
	public void setResultStr(String resultStr) {
		this.resultStr = resultStr;
	}

	/**
	 * 执行结果中文描述转换
	 * @param result
	 * @return
	 */
	public static String convertResult(String result) {
		String resultStr = " - ";
		if (QuartzLogModel.RESULT_SUCCESS.equals(result)) {
			resultStr = "执行成功";
		} else if (QuartzLogModel.RESULT_FAIL.equals(result)) {
			resultStr = "执行失败";
		}
		return resultStr;
	}
}

定时任务详情Model

import com.itcorey.domain.QuartzInfo;

import java.util.Date;

/**
 *  定时任务详情Model
 */
public class QuartzInfoModel extends QuartzInfo {
	
	private static final long serialVersionUID = 1L;
	
	/** 状态 - 启用 */
	public static final String STATE_ENABLE = "10";

	/** 状态 - 禁用 */
	public static final String STATE_DISABLE = "20";
	/**
     * 状态中文转换
     * 
     * @param state
     * @return
     */
    public static String stateConvert(String state) {
        String stateStr;
        if (ChannelModel.STATE_DISABLE.equals(state)) {
            stateStr = "禁用";
        } else {
            stateStr = "启用";
        }
        return stateStr;
    }
    
	
	/**
	 * 任务状态描述
	 */
	private String stateStr;
	
	/**
	 * 上次执行时间
	 */
	private Date lastStartTime;

	/**
	 * 获取任务状态描述
	 * @return stateStr
	 */
	public String getStateStr() {
		this.stateStr = stateConvert(this.getState());
		return stateStr;
	}

	/**
	 * 设置任务状态描述
	 * @param stateStr
	 */
	public void setStateStr(String stateStr) {
		this.stateStr = stateStr;
	}

	/**
	 * 获取上次执行时间
	 * 
	 * @return lastStartTime
	 */
	public Date getLastStartTime() {
		return lastStartTime;
	}

	/**
	 * 设置上次执行时间
	 * 
	 * @param lastStartTime
	 */
	public void setLastStartTime(Date lastStartTime) {
		this.lastStartTime = lastStartTime;
	}
	
}

9.定时任务业务代码类:

/**
 * Created by ：Corey
 * 17:37 2019/2/22
 * 定时任务
 */
public class QuartzInform implements Job {

    private static final Logger logger = Logger.getLogger(QuartzInform.class);

    /**
     * 查询用户
     * @throws ServiceException
     */
    public String repayInform() throws ServiceException {
        IUserService userService = (IUserService) BeanUtil.getBean("IUserService");
        logger.info("进入定时任务......");
        String quartzRemark = null;
        int succeed = 0;
        int fail = 0;
        int total = 0;
        //查询所有用户
        List<User> list = userService.getAllUser();
        if (!list.isEmpty()) {
            for (User user : list) {
                System.out.println("user"+user.getUserName());
            }
        }
        logger.info("查询所有用户信息结束......");
        quartzRemark = "执行总次数"+total+",成功"+succeed+"次,失败"+fail+"次";
        return quartzRemark;
    }

    @Override
    public void execute(JobExecutionContext arg0) throws JobExecutionException {
        QuartzInfoService quartzInfoService = (QuartzInfoService)BeanUtil.getBean("quartzInfoService");
        QuartzLogService quartzLogService = (QuartzLogService)BeanUtil.getBean("quartzLogService");
        QuartzLog ql = new QuartzLog();
        Map<String,Object> qiData = new HashMap<>();
        QuartzInfo qi = quartzInfoService.findByCode("doRepayInform");
        try {
            qiData.put("id", qi.getId());
            ql.setQuartzId(qi.getId());
            ql.setStartTime(DateUtil.getNow());

            String remark = repayInform();

            ql.setTime(DateUtil.getNow().getTime()-ql.getStartTime().getTime());
            ql.setResult("10");
            ql.setRemark(remark);
            qiData.put("succeed", qi.getSucceed()+1);

        }catch (Exception e) {
            ql.setResult("20");
            qiData.put("fail", qi.getFail()+1);
            logger.error(e.getMessage(),e);
        }finally{
            logger.info("保存定时任务日志");
            quartzLogService.save(ql);
            quartzInfoService.update(qiData);
        }
    }

}

代码提交到:https://github.com/coreyxuy/SSM