quartz页面配置任务job

最新推荐文章于 2025-06-04 09:20:47 发布

爱吃鱼油

最新推荐文章于 2025-06-04 09:20:47 发布

阅读量2.3k

点赞数

CC 4.0 BY-SA版权

分类专栏： quartz 定时任务文章标签： quartz spring java反射回调函数

本文链接：https://blog.youkuaiyun.com/u010081710/article/details/50844407

定时任务同时被 2 个专栏收录

5 篇文章

订阅专栏

quartz

4 篇文章

订阅专栏

本文介绍了一个使用Quartz框架实现的任务调度系统，重点阐述了业务类如何通过回调接口接收任务执行结果，并进行相应处理的过程。其中包括了任务执行状态的判断、日志记录、业务方法的执行以及回调方法的实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

接口‘IScheduleJobListener提供回调方法，业务类中回调方法通知执行结果

public interface IScheduleJobListener {

	/**
	 * call back when job has done.
	 * 业务回调方法，表明业务处理完成
	 * 
	 * @param flag 取值: 
	 * ScheConstant.java中定义：成功: EXE_STATE_SUCCESS = "1"、异常: EXE_STATE_EXCEPTION ="2";
	 * @param message log-message: 获取详细异常信息：JobManager.getFullExceptionStackTrace(Exception ex);
	 */
	public void onJobDone(String stateFlag, String message);
	
	public void updateJobProcess(float processing);
}

JobWrapper单任务处理类封装类

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.HashMap;
import java.util.Map;

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.apache.log4j.Logger;

import com.schedule.ScheConstant;
import com.schedule.framework.dto.ScheduleJobBatchLogDTO;
import com.schedule.framework.integration.dao.SingleJobBatchLogDao;
import com.schedule.framework.integration.dao.impl.SingleJobBatchLogDaoImpl;
import com.schedule.framework.service.JobWrapperService;
import com.schedule.framework.service.impl.JobWrapperServiceImpl;
import com.schedule.framework.util.JdbcTool;
public class JobWrapper implements Job, IScheduleJobListener{

	private static final Logger log=Logger.getLogger(JobWrapper.class);
	public  static final String USER_NAME="username";
	private String Singlejob_batch_id="";
	private JobWrapperService jobWrapperService;
	
	@Override
	public void execute(JobExecutionContext jobcontext) throws JobExecutionException {
				
		//获得单任务的jobname job_group
		JobDetail jobDetail = jobcontext.getJobDetail();
		String job_name = jobDetail.getName();
		String job_group = jobDetail.getGroup();
		
		//任务是否添加例外情况，如果例外情况下的任务则返回。
		if(!JobManager.isAvailableTime(job_name, false)){//判断是否为例外情况，如果是例外情况也需要记录完整日志，再返回
			log.info( "job_name==="+job_name+" 任务未执行：该任务不在执行有效期内或目标机器上！");
			return ;
		}
		
		//批次号
		Singlejob_batch_id=java.util.UUID.randomUUID().toString().replaceAll("-", "");
		Map<String,Object> BusinessJobparam=new HashMap<String,Object>();//传递批次号参数
		
		//获得重跑的单任务参数
		JobDataMap dataMap = jobcontext.getMergedJobDataMap();
		Map<String,Object> restartJobparam=(Map<String,Object>) dataMap.get("immediaSingleJobparam");

		String usename="ScheduleJob";
		if(restartJobparam!=null){
			//获得单任务重跑时的系统用户，用户姓名username存在调用者传递的参数map中通过key获得。
			usename=(String) restartJobparam.get(JobWrapper.USER_NAME);			
		}else{
			//非重跑状态时，默认的调用这为字符串ScheduleJob
			restartJobparam=new HashMap<String,Object>();
			restartJobparam.put(JobWrapper.USER_NAME,usename);
		}	
		//记录单任务运行日志
		SingleJobBatchLogDao singlejobbatchlogdao =new SingleJobBatchLogDaoImpl();
		ScheduleJobBatchLogDTO singlejobbatchlog=new ScheduleJobBatchLogDTO();
		jobWrapperService=new JobWrapperServiceImpl();
		
		singlejobbatchlog.setSinglejob_batch_id(Singlejob_batch_id);
		singlejobbatchlog.setJob_id(job_name);
		singlejobbatchlog.setExecute_log("");
		singlejobbatchlog.setExecutor(usename);
		singlejobbatchlog.setStatus("0");
		
		/***记录单任务运行日志*****/
		singlejobbatchlogdao.insertSingleJobLog(singlejobbatchlog);
		/****更新任务状态运行中****/
		jobWrapperService.updateJobStatusByJobID(job_name, "1");
		
		//获得单任务包路径和入口
		Map<String,String> paramMap= this.querySchedulejob(job_name, job_group);
		String JOB_METHOD_NAME=paramMap.get("JOB_METHOD_NAME");
		String JOB_CLASS_NAME=paramMap.get("JOB_CLASS_NAME");

		try {
			
			JobManager.startBusinessMethod(JOB_METHOD_NAME, JOB_CLASS_NAME, restartJobparam, this);
		
		//	JobManager.startBusinessMethod(JOB_METHOD_NAME, JOB_CLASS_NAME, BusinessJobparam, this);
			
		} catch( Exception e){
			onJobDone(ScheConstant.EXE_STATE_EXCEPTION, JobManager.getFullExceptionStackTrace(e) );
		}
	}

	/**
	 * 只有在业务回调此方法的时候，表明该任务完成！
	 */
	@Override
	public void onJobDone(String stateFlag, String message) {
		
		log.info("onJobDone: "+stateFlag+" - "+message);
		SingleJobBatchLogDao singlejobbatchlogdao =new SingleJobBatchLogDaoImpl();
		ScheduleJobBatchLogDTO singlejobbatchlog=new ScheduleJobBatchLogDTO();
		singlejobbatchlog=singlejobbatchlogdao.querySingleJobLogByBatchId(Singlejob_batch_id);
		//System.err.println("singlejobbatchlog===="+singlejobbatchlog.toString());
		try {
			java.util.Date utildate=new java.util.Date();
			SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd H:m:s");
			String end_time=sdf.format(utildate);
			singlejobbatchlog.setEnd_time(sdf.parse(end_time));
			singlejobbatchlog.setStatus(stateFlag);
			singlejobbatchlog.setExecute_log(message);
			singlejobbatchlogdao.updateStatuSingleJobLog(singlejobbatchlog);
			jobWrapperService.updateJobStatusByJobBatchID(Singlejob_batch_id, "0");
		} catch (ParseException e) {
			e.printStackTrace();
		}		
	}

	@Override
	public void updateJobProcess(float processing) {
		// TODO Auto-generated method stub
		
	}

	/****
	 * 
	 * @param job_name
	 * @param job_group
	 * @return 	通过查询数据库获得
	 * 			JOB_METHOD_NAME方法名
	 * 			JOB_CLASS_NAME类路径或者时BeanID(spring容器中的beanid)
	 */
	private static Map<String,String> querySchedulejob(String job_name,String job_group ){
		
		Map<String,String> paramMap=new HashMap<String,String>();
		
		String sql="SELECT * FROM SCHEDULE_JOB WHERE 1=1 AND job_name='"+job_name+"'and job_group='"+job_group+"'";
//		Connection conn=JdbcTool.getConnByJdbc();
		Connection conn=null;
		PreparedStatement ps;
		ResultSet rs=null;
		try {
			conn = JdbcTool.getconn(JdbcTool.JNDI_NAME);
			ps = conn.prepareStatement(sql);
			rs=ps.executeQuery();
			while(rs.next()){
				String JOB_CLASS_NAME=rs.getString("job_class_name");
				String JOB_METHOD_NAME=rs.getString("JOB_METHOD_NAME");
				paramMap.put("JOB_CLASS_NAME", JOB_CLASS_NAME);
				paramMap.put("JOB_METHOD_NAME", JOB_METHOD_NAME);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			JdbcTool.closeConnection(conn);
		}
		return paramMap;		
	}
	
}

quartz工具类只保留了反射调用业务方法

//通过反射回调业务方法

//业务代码和quartz的代码松耦合

//可以通过页面配置任何业务类的任何方法，无需修改已经开发完成的业务类。

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;
import org.apache.log4j.Logger;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.context.ApplicationContext;
import com.util.ScheduleMethodInvokingJobDetailFactoryBean;

public class JobManager {
	
	private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
	private static final Logger logger=Logger.getLogger(JobManager.class);
	
	//单一任务
	public static String JOB_GROUP_SIN = "MHIS_DEFAULT_JOBGROUP";
	public static String TRIGGER_NAME_SIN="TRIGGER_NAME";
	public static String TRIGGER_GROUP_SIN="MHIS_DEFAULT_TRIGGERGROUP";
	
	//任务组任务
	public static String JOB_GROUP_GRO="JOB_GROUP";
	public static String TRIGGER_NAME_GRO="TRIGGER_NAME";
	public static String TRIGGER_GROUP_GRO="TRIGGER_GROUP";
	
	
	/**
	 * 单一任务
	 * JOB_NAME=UUID
	 * JOB_GROUP_SIN = "MHIS_DEFAULT_JOBGROUP"
	 * TRIGGER_NAME="TRIGGER_NAME"+UUID
	 * TRIGGER_GROUP_SIN="MHIS_DEFAULT_TRIGGERGROUP"
	 * 
	 * 任务组任务
	 * String JOB_NAME=UUID;
	 * String JOB_GROUP="JOB_GROUP"+UUID;(根job的UUID作为这个任务组的job_group)
	 * String TRIGGER_NAME="TRIGGER_NAME"+UUID;
	 * String TRIGGER_GROUP="TRIGGER_GROUP"+UUID;(根job的UUID作为这个任务组的job_group)
	 */

	/*****
	    * 
	    * @param JOB_METHOD_NAME
	    * @param JOB_CLASS_NAME
	    * @param paramMap 业务方法的参数
	    * @param listener 传this对象
	    * @throws InvocationTargetException
	    * @throws IllegalAccessException
	    * @throws IllegalArgumentException
	    * @throws NoSuchMethodException
	    * @throws SecurityException
	    */
	   public  static void startBusinessMethod (String JOB_METHOD_NAME,String JOB_CLASS_NAME, Map<String ,Object> paramMap, IScheduleJobListener listener) throws Exception{
			
			ApplicationContext context = ScheduleMethodInvokingJobDetailFactoryBean.getApplicationContext();
			Object obj = context.getBean(JOB_CLASS_NAME);
			if(obj!=null){
				Class<?> cls = obj.getClass();
				Method m= cls.getDeclaredMethod(JOB_METHOD_NAME, Map.class, IScheduleJobListener.class);
				if(m!=null){
					m.invoke(obj, paramMap, listener);
					
				}
			}
		}
}

业务类代码

import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.IScheduleJobListener;


@Component("testServiceAImpl")
public class TestServiceAImpl implements ServiceA {

	public static Log log = LogFactory.getLog(TestServiceAImpl.class);


	@Autowired
	private ServiceB serviceB;
	
	@Override
	public void testMethodA(Map<String, Object> params,IScheduleJobListener listener)  throws Exception {
		
		try {
			log.info("进行业务处理......");
			Thread.sleep(5000l);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}		
		/**** 
		 * 回调IScheduleJobListener类中onJobDone方法
		 * 通知调用者调用业务方法的执行结果
		 * ScheConstant.EXE_STATE_SUCCESS为类中自定义的字符串常量
		 */
		listener.onJobDone(ScheConstant.EXE_STATE_SUCCESS, "");//1成功 2执行异常
	}
	
	
}