`
newchq
  • 浏览: 55030 次
  • 性别: Icon_minigender_1
  • 来自: 上海
文章分类
社区版块
存档分类
最新评论

spring+quartz 动态任务方案

quartzSpring应用服务器log4jEXT 
阅读更多

公司目前有这样的需求，结合spring+quartz开发个后台的WEB管理系统，系统主要包括以下功能：

  1、动态添加、修改和删除数据源，并加入到spring管理。
  2、动态注册、修改和删除任务(需要实现的具体quartz业务类)，并加入到quartz管理。
  3、提供上传第三方包的功能。（主要考虑实现的业务类，需要引入其他的jar包）。
  4、在线日志查询分析。
  。。。

   后台系统的应用领域：

  1、执行多个数据库之间的数据交换服务。
  2、架设系统与银行之间的通讯服务。
  。。。

  以前没搞过这方面应用，比较头疼，经过google、百度，初步方案实现如下：
 
  1、实现个servlet用于启动quartz调度。
  
 
  程序如下：
 

Java代码 复制代码
  1.   public class DispatchJobServlet extends HttpServlet {   
  2.   
  3. private static final long serialVersionUID = -3920177706344758439L;   
  4. private ApplicationContext ctx;   
  5.   
  6. public DispatchJobServlet() {   
  7.     super();   
  8.     //  初始化自定义类加载器，主要用于加载第三方包和服务程序。   
  9.     ServiceStartup manguage = new ServiceStartup();   
  10.     manguage.startUp();   
  11. }   
  12.   
  13. /**  
  14.  * 初始化  
  15.  */  
  16. public void init(ServletConfig config) throws ServletException {   
  17.     super.init(config);   
  18.     ctx = WebApplicationContextUtils   
  19.             .getRequiredWebApplicationContext(config.getServletContext());   
  20.     StartJobService taskStartService = (StartJobService) ctx.getBean("startJobService");   
  21.     //启用个线程开始任务调度   
  22.     ExecutorService exec = Executors.newCachedThreadPool();   
  23.     exec.execute(taskStartService);   
  24. }   
  25.   
  26.    
   public class DispatchJobServlet extends HttpServlet {

	private static final long serialVersionUID = -3920177706344758439L;
	private ApplicationContext ctx;

	public DispatchJobServlet() {
		super();
		//  初始化自定义类加载器，主要用于加载第三方包和服务程序。
		ServiceStartup manguage = new ServiceStartup();
		manguage.startUp();
	}

	/**
	 * 初始化
	 */
	public void init(ServletConfig config) throws ServletException {
		super.init(config);
		ctx = WebApplicationContextUtils
				.getRequiredWebApplicationContext(config.getServletContext());
		StartJobService taskStartService = (StartJobService) ctx.getBean("startJobService");
		//启用个线程开始任务调度
		ExecutorService exec = Executors.newCachedThreadPool();
		exec.execute(taskStartService);
	}
}



   2、到xml文件查询前台添加的任务队列，加入quartz管理并执行。
   
   

Java代码 复制代码
  1. @Service  
  2. public class StartJobService implements Runnable {   
  3.     /**  
  4.      * log4j 记录器  
  5.      */  
  6.     private static final Logger log = Logger.getLogger(StartJobService.class);   
  7.     @Resource  
  8.     private SchedulerService schedulerService;   
  9.   
  10.     public void run() {   
  11.         try {   
  12.             while (true) {   
  13.                 List<JobBo> list = DomParser.findAllJobXml("db.service.xml");   
  14.                 Iterator<JobBo> i = list.iterator();   
  15.                 while (i.hasNext()) {   
  16.                     JobBo job = i.next();   
  17.                     // 如果任务队列不存在则注册并运行   
  18.                     if (!ServiceManager.queryExistsJob(job.getName())) {   
  19.                         try {   
  20.                             schedulerService.schedule(job);   
  21.                             ServiceManager.getJobHolder().put(job.getName(),   
  22.                                     job);   
  23.                         } catch (Exception e) {   
  24.                             log.error("服务【" + job.getName() + "】启动失败!", e);   
  25.                             throw new SummerException("服务【" + job.getName()   
  26.                                     + "】启动失败!");   
  27.                         }   
  28.                     }   
  29.                     Thread.sleep(3000);   
  30.                 }   
  31.             }   
  32.         } catch (SummerException e) {   
  33.             throw e;   
  34.         } catch (Exception e) {   
  35.             log.error("调度任务出现异常!", e);   
  36.         }   
  37.     }   
  38. }  
@Service
public class StartJobService implements Runnable {
	/**
	 * log4j 记录器
	 */
	private static final Logger log = Logger.getLogger(StartJobService.class);
	@Resource
	private SchedulerService schedulerService;

	public void run() {
		try {
			while (true) {
				List<JobBo> list = DomParser.findAllJobXml("db.service.xml");
				Iterator<JobBo> i = list.iterator();
				while (i.hasNext()) {
					JobBo job = i.next();
					// 如果任务队列不存在则注册并运行
					if (!ServiceManager.queryExistsJob(job.getName())) {
						try {
							schedulerService.schedule(job);
							ServiceManager.getJobHolder().put(job.getName(),
									job);
						} catch (Exception e) {
							log.error("服务【" + job.getName() + "】启动失败!", e);
							throw new SummerException("服务【" + job.getName()
									+ "】启动失败!");
						}
					}
					Thread.sleep(3000);
				}
			}
		} catch (SummerException e) {
			throw e;
		} catch (Exception e) {
			log.error("调度任务出现异常!", e);
		}
	}
}


   3、封装SchedulerService实现quartz调度的方法
   封装的出来quartz的接口：
  

Java代码 复制代码
  1. public interface SchedulerService {   
  2.   
  3.     /**  
  4.      * 自定义任务对象并启动任务  
  5.      *   
  6.      * @param job  
  7.      *            任务队列业务对象  
  8.      */  
  9.     void schedule(JobBo job);   
  10.   
  11.     /**  
  12.      * 取得所有调度Triggers  
  13.      *   
  14.      * @return  
  15.      */  
  16.     List<Map<String, Object>> getQrtzTriggers();   
  17.   
  18.     /**  
  19.      * 根据名称和组别暂停Tigger  
  20.      *   
  21.      * @param triggerName  
  22.      * @param group  
  23.      */  
  24.     void pauseTrigger(String triggerName, String group);   
  25.   
  26.     /**  
  27.      * 恢复Trigger  
  28.      *   
  29.      * @param triggerName  
  30.      * @param group  
  31.      */  
  32.     void resumeTrigger(String triggerName, String group);   
  33.   
  34.     /**  
  35.      * 删除Trigger  
  36.      *   
  37.      * @param triggerName  
  38.      * @param group  
  39.      */  
  40.     boolean removeTrigdger(String triggerName, String group);   
  41. }  
public interface SchedulerService {

	/**
	 * 自定义任务对象并启动任务
	 * 
	 * @param job
	 *            任务队列业务对象
	 */
	void schedule(JobBo job);

	/**
	 * 取得所有调度Triggers
	 * 
	 * @return
	 */
	List<Map<String, Object>> getQrtzTriggers();

	/**
	 * 根据名称和组别暂停Tigger
	 * 
	 * @param triggerName
	 * @param group
	 */
	void pauseTrigger(String triggerName, String group);

	/**
	 * 恢复Trigger
	 * 
	 * @param triggerName
	 * @param group
	 */
	void resumeTrigger(String triggerName, String group);

	/**
	 * 删除Trigger
	 * 
	 * @param triggerName
	 * @param group
	 */
	boolean removeTrigdger(String triggerName, String group);
}



   实现类：
 

Java代码 复制代码
  1. public class SchedulerServiceImpl implements SchedulerService {   
  2.   
  3.     private static final Logger log = LoggerFactory   
  4.             .getLogger(SchedulerServiceImpl.class);   
  5.   
  6.     private Scheduler scheduler;   
  7.   
  8.     private JobDetail jobDetail;   
  9.   
  10.     public void setScheduler(Scheduler scheduler) {   
  11.         this.scheduler = scheduler;   
  12.     }   
  13.   
  14.     public void setJobDetail(JobDetail jobDetail) {   
  15.         this.jobDetail = jobDetail;   
  16.     }   
  17.   
  18.     /**  
  19.      * 自定义任务对象并启动任务  
  20.      */  
  21.     public void schedule(JobBo job) {   
  22.         // trigger分类   
  23.         String category = job.getCategory();   
  24.         try {   
  25.             if ("cron".equals(category)) {   
  26.                 scheduleCron(job);   
  27.             } else {   
  28.                 scheduleSimple(job);   
  29.             }   
  30.         } catch (Exception e) {   
  31.             log.error("任务调度过程中出现异常!");   
  32.             throw new SummerException(e);   
  33.         }   
  34.     }   
  35.   
  36.     /**  
  37.      * simple任务触发  
  38.      *   
  39.      * @param job  
  40.      */  
  41.     private void scheduleSimple(JobBo job) {   
  42.         String name = getTriggerName(job.getName());   
  43.         // 实例化SimpleTrigger   
  44.         SimpleTrigger simpleTrigger = new SimpleTrigger();   
  45.   
  46.         // 这些值的设置也可以从外面传入，这里采用默放值   
  47.         simpleTrigger.setJobName(jobDetail.getName());   
  48.         simpleTrigger.setJobGroup(Scheduler.DEFAULT_GROUP);   
  49.         simpleTrigger.setRepeatInterval(1000L);   
  50.         // 设置名称   
  51.         simpleTrigger.setName(name);   
  52.   
  53.         // 设置Trigger分组   
  54.         String group = job.getGroup();   
  55.         if (StringUtils.isEmpty(group)) {   
  56.             group = Scheduler.DEFAULT_GROUP;   
  57.         }   
  58.         simpleTrigger.setGroup(group);   
  59.   
  60.         // 设置开始时间   
  61.         Timestamp startTime = job.getStartTime();   
  62.         if (null != startTime) {   
  63.             simpleTrigger.setStartTime(new Date());   
  64.         }   
  65.   
  66.         // 设置结束时间   
  67.         Timestamp endTime = job.getEndTime();   
  68.         if (null != endTime) {   
  69.             simpleTrigger.setEndTime(endTime);   
  70.         }   
  71.   
  72.         // 设置执行次数   
  73.         int repeatCount = job.getRepeatCount();   
  74.         if (repeatCount > 0) {   
  75.             simpleTrigger.setRepeatCount(repeatCount);   
  76.         }   
  77.   
  78.         // 设置执行时间间隔   
  79.         long repeatInterval = job.getRepeatInterval();   
  80.         if (repeatInterval > 0) {   
  81.             simpleTrigger.setRepeatInterval(repeatInterval * 1000);   
  82.         }   
  83.         try {   
  84.             JobDataMap jobData = new JobDataMap();   
  85.             jobData.put("name", job.getName());   
  86.             jobData.put("desc", job.getDesc());   
  87.             jobDetail.setJobDataMap(jobData);   
  88.             scheduler.addJob(jobDetail, true);   
  89.             scheduler.scheduleJob(simpleTrigger);   
  90.             scheduler.rescheduleJob(simpleTrigger.getName(), simpleTrigger   
  91.                     .getGroup(), simpleTrigger);   
  92.         } catch (SchedulerException e) {   
  93.             log.error("任务调度出现异常!");   
  94.             log.error(LogGenerator.getInstance().generate(e));   
  95.             throw new SummerException("任务调度出现异常!");   
  96.         }   
  97.     }   
  98.   
  99.     /**  
  100.      * cron任务触发  
  101.      *   
  102.      * @param job  
  103.      */  
  104.     private void scheduleCron(JobBo job) {   
  105.         String name = getTriggerName(job.getName());   
  106.         try {   
  107.             JobDataMap jobData = new JobDataMap();   
  108.             jobData.put("name", job.getName());   
  109.             jobData.put("desc", job.getDesc());   
  110.             jobDetail.setJobDataMap(jobData);   
  111.             scheduler.addJob(jobDetail, true);   
  112.             CronTrigger cronTrigger = new CronTrigger(name, job.getGroup(),   
  113.                     jobDetail.getName(), Scheduler.DEFAULT_GROUP);   
  114.             cronTrigger.setCronExpression(job.getCronExpression());   
  115.             scheduler.scheduleJob(cronTrigger);   
  116.             scheduler.rescheduleJob(cronTrigger.getName(), cronTrigger   
  117.                     .getGroup(), cronTrigger);   
  118.         } catch (Exception e) {   
  119.             log.error("执行cron触发器出现异常!", e);   
  120.             throw new SummerException("执行cron触发器出现异常!");   
  121.         }   
  122.     }   
  123.   
  124.     public void schedule(String name, Date startTime, Date endTime,   
  125.             int repeatCount, long repeatInterval, String group) {   
  126.         if (name == null || name.trim().equals("")) {   
  127.             name = UUID.randomUUID().toString();   
  128.         } else {   
  129.             // 在名称后添加UUID，保证名称的唯一性   
  130.             name += "&" + UUID.randomUUID().toString();   
  131.         }   
  132.         try {   
  133.             scheduler.addJob(jobDetail, true);   
  134.             SimpleTrigger SimpleTrigger = new SimpleTrigger(name, group,   
  135.                     jobDetail.getName(), Scheduler.DEFAULT_GROUP, startTime,   
  136.                     endTime, repeatCount, repeatInterval);   
  137.             scheduler.scheduleJob(SimpleTrigger);   
  138.             scheduler.rescheduleJob(SimpleTrigger.getName(), SimpleTrigger   
  139.                     .getGroup(), SimpleTrigger);   
  140.         } catch (SchedulerException e) {   
  141.             throw new RuntimeException(e);   
  142.         }   
  143.     }   
  144.   
  145.     public void pauseTrigger(String triggerName, String group) {   
  146.         try {   
  147.             scheduler.pauseTrigger(triggerName, group);// 停止触发器   
  148.         } catch (SchedulerException e) {   
  149.             throw new SummerException(e);   
  150.         }   
  151.     }   
  152.   
  153.     public void resumeTrigger(String triggerName, String group) {   
  154.         try {   
  155.             scheduler.resumeTrigger(triggerName, group);// 重启触发器   
  156.         } catch (SchedulerException e) {   
  157.             log.error("重启触发器失败!");   
  158.             throw new SummerException(e);   
  159.         }   
  160.     }   
  161.   
  162.     public boolean removeTrigdger(String triggerName, String group) {   
  163.         try {   
  164.             scheduler.pauseTrigger(triggerName, group);// 停止触发器   
  165.             return scheduler.unscheduleJob(triggerName, group);// 移除触发器   
  166.         } catch (SchedulerException e) {   
  167.             throw new SummerException(e);   
  168.         }   
  169.     }   
  170.   
  171.     private Timestamp parseDate(String time) {   
  172.         try {   
  173.             return Timestamp.valueOf(time);   
  174.         } catch (Exception e) {   
  175.             log.error("日期格式错误{}，正确格式为：yyyy-MM-dd HH:mm:ss", time);   
  176.             throw new SummerException(e);   
  177.         }   
  178.     }   
  179.   
  180.     public List<Map<String, Object>> getQrtzTriggers() {   
  181.         // TODO Auto-generated method stub   
  182.         return null;   
  183.     }   
  184.   
  185.     /**  
  186.      * 获取trigger名称  
  187.      *   
  188.      * @param name  
  189.      * @return  
  190.      */  
  191.     private String getTriggerName(String name) {   
  192.         if (StringUtils.isBlank(StringUtils.trim(name))) {   
  193.             name = UUID.randomUUID().toString();   
  194.         } else {   
  195.             name = name.substring(name.lastIndexOf(".") + 1);   
  196.             // 在名称后添加UUID，保证名称的唯一性   
  197.             name += "&" + UUID.randomUUID().toString();   
  198.         }   
  199.         return StringUtils.trim(name);   
  200.     }   
  201. }  
public class SchedulerServiceImpl implements SchedulerService {

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

	private Scheduler scheduler;

	private JobDetail jobDetail;

	public void setScheduler(Scheduler scheduler) {
		this.scheduler = scheduler;
	}

	public void setJobDetail(JobDetail jobDetail) {
		this.jobDetail = jobDetail;
	}

	/**
	 * 自定义任务对象并启动任务
	 */
	public void schedule(JobBo job) {
		// trigger分类
		String category = job.getCategory();
		try {
			if ("cron".equals(category)) {
				scheduleCron(job);
			} else {
				scheduleSimple(job);
			}
		} catch (Exception e) {
			log.error("任务调度过程中出现异常!");
			throw new SummerException(e);
		}
	}

	/**
	 * simple任务触发
	 * 
	 * @param job
	 */
	private void scheduleSimple(JobBo job) {
		String name = getTriggerName(job.getName());
		// 实例化SimpleTrigger
		SimpleTrigger simpleTrigger = new SimpleTrigger();

		// 这些值的设置也可以从外面传入，这里采用默放值
		simpleTrigger.setJobName(jobDetail.getName());
		simpleTrigger.setJobGroup(Scheduler.DEFAULT_GROUP);
		simpleTrigger.setRepeatInterval(1000L);
		// 设置名称
		simpleTrigger.setName(name);

		// 设置Trigger分组
		String group = job.getGroup();
		if (StringUtils.isEmpty(group)) {
			group = Scheduler.DEFAULT_GROUP;
		}
		simpleTrigger.setGroup(group);

		// 设置开始时间
		Timestamp startTime = job.getStartTime();
		if (null != startTime) {
			simpleTrigger.setStartTime(new Date());
		}

		// 设置结束时间
		Timestamp endTime = job.getEndTime();
		if (null != endTime) {
			simpleTrigger.setEndTime(endTime);
		}

		// 设置执行次数
		int repeatCount = job.getRepeatCount();
		if (repeatCount > 0) {
			simpleTrigger.setRepeatCount(repeatCount);
		}

		// 设置执行时间间隔
		long repeatInterval = job.getRepeatInterval();
		if (repeatInterval > 0) {
			simpleTrigger.setRepeatInterval(repeatInterval * 1000);
		}
		try {
			JobDataMap jobData = new JobDataMap();
			jobData.put("name", job.getName());
			jobData.put("desc", job.getDesc());
			jobDetail.setJobDataMap(jobData);
			scheduler.addJob(jobDetail, true);
			scheduler.scheduleJob(simpleTrigger);
			scheduler.rescheduleJob(simpleTrigger.getName(), simpleTrigger
					.getGroup(), simpleTrigger);
		} catch (SchedulerException e) {
			log.error("任务调度出现异常!");
			log.error(LogGenerator.getInstance().generate(e));
			throw new SummerException("任务调度出现异常!");
		}
	}

	/**
	 * cron任务触发
	 * 
	 * @param job
	 */
	private void scheduleCron(JobBo job) {
		String name = getTriggerName(job.getName());
		try {
			JobDataMap jobData = new JobDataMap();
			jobData.put("name", job.getName());
			jobData.put("desc", job.getDesc());
			jobDetail.setJobDataMap(jobData);
			scheduler.addJob(jobDetail, true);
			CronTrigger cronTrigger = new CronTrigger(name, job.getGroup(),
					jobDetail.getName(), Scheduler.DEFAULT_GROUP);
			cronTrigger.setCronExpression(job.getCronExpression());
			scheduler.scheduleJob(cronTrigger);
			scheduler.rescheduleJob(cronTrigger.getName(), cronTrigger
					.getGroup(), cronTrigger);
		} catch (Exception e) {
			log.error("执行cron触发器出现异常!", e);
			throw new SummerException("执行cron触发器出现异常!");
		}
	}

	public void schedule(String name, Date startTime, Date endTime,
			int repeatCount, long repeatInterval, String group) {
		if (name == null || name.trim().equals("")) {
			name = UUID.randomUUID().toString();
		} else {
			// 在名称后添加UUID，保证名称的唯一性
			name += "&" + UUID.randomUUID().toString();
		}
		try {
			scheduler.addJob(jobDetail, true);
			SimpleTrigger SimpleTrigger = new SimpleTrigger(name, group,
					jobDetail.getName(), Scheduler.DEFAULT_GROUP, startTime,
					endTime, repeatCount, repeatInterval);
			scheduler.scheduleJob(SimpleTrigger);
			scheduler.rescheduleJob(SimpleTrigger.getName(), SimpleTrigger
					.getGroup(), SimpleTrigger);
		} catch (SchedulerException e) {
			throw new RuntimeException(e);
		}
	}

	public void pauseTrigger(String triggerName, String group) {
		try {
			scheduler.pauseTrigger(triggerName, group);// 停止触发器
		} catch (SchedulerException e) {
			throw new SummerException(e);
		}
	}

	public void resumeTrigger(String triggerName, String group) {
		try {
			scheduler.resumeTrigger(triggerName, group);// 重启触发器
		} catch (SchedulerException e) {
			log.error("重启触发器失败!");
			throw new SummerException(e);
		}
	}

	public boolean removeTrigdger(String triggerName, String group) {
		try {
			scheduler.pauseTrigger(triggerName, group);// 停止触发器
			return scheduler.unscheduleJob(triggerName, group);// 移除触发器
		} catch (SchedulerException e) {
			throw new SummerException(e);
		}
	}

	private Timestamp parseDate(String time) {
		try {
			return Timestamp.valueOf(time);
		} catch (Exception e) {
			log.error("日期格式错误{}，正确格式为：yyyy-MM-dd HH:mm:ss", time);
			throw new SummerException(e);
		}
	}

	public List<Map<String, Object>> getQrtzTriggers() {
		// TODO Auto-generated method stub
		return null;
	}

	/**
	 * 获取trigger名称
	 * 
	 * @param name
	 * @return
	 */
	private String getTriggerName(String name) {
		if (StringUtils.isBlank(StringUtils.trim(name))) {
			name = UUID.randomUUID().toString();
		} else {
			name = name.substring(name.lastIndexOf(".") + 1);
			// 在名称后添加UUID，保证名称的唯一性
			name += "&" + UUID.randomUUID().toString();
		}
		return StringUtils.trim(name);
	}
}



  4、覆盖QuartzJobBean的executeInternal方法,根据“name”名实现任务的动态分配

Java代码 复制代码
  1. public class EnhanceQuartzJobBean extends QuartzJobBean {   
  2.     /**  
  3.      * log4j 记录器  
  4.      */  
  5.     private static final Logger log = Logger   
  6.             .getLogger(EnhanceQuartzJobBean.class);   
  7.   
  8.     @Override  
  9.     protected void executeInternal(JobExecutionContext context)   
  10.             throws JobExecutionException {   
  11.         try {   
  12.             JobDetail t = context.getJobDetail();   
  13.             JobDataMap map = t.getJobDataMap();   
  14.             String name = map.getString("name");   
  15.             String desc = map.getString("desc");   
  16.             ServiceStartupManguage manguage = new ServiceStartupManguage();   
  17.             manguage.runService(name, desc);   
  18.         } catch (Exception e) {   
  19.             log.error("执行任务出现异常", e);   
  20.         }   
  21.     }   
  22.        
  23.     public class ServiceStartup {   
  24.     /**  
  25.      * log4j 记录器  
  26.      */  
  27.     private static final Logger log = Logger   
  28.             .getLogger(ServiceStartupManguage.class);   
  29.   
  30.     public void startUp() {   
  31.         // 启动动态重新加载类的服务   
  32.         StringBuilder sb = new StringBuilder(1024);   
  33.         sb.append(ServiceManager.getHome() + "work");   
  34.         String jarPath = ServiceManager.getHome() + "ext";   
  35.         // 遍历ext文件夹，寻找jar文件   
  36.         File dir = new File(jarPath);   
  37.         String[] subFiles = dir.list();   
  38.         for (int i = 0; i < subFiles.length; i++) {   
  39.             File file = new File(jarPath + System.getProperty("file.separator")   
  40.                     + subFiles[i]);   
  41.             if (file.isFile() && subFiles[i].endsWith("jar")) {   
  42.                 sb.append(File.pathSeparator + jarPath   
  43.                         + System.getProperty("file.separator") + subFiles[i]);   
  44.             }   
  45.         }   
  46.         ServiceManager.checker = new ClassModifyChecker(ServiceManager.getHome());   
  47.         ServiceManager.loader = new ServiceClassLoad(DispatchJobServlet.class  
  48.                 .getClassLoader(), (String) sb.toString(), ServiceManager.checker);   
  49.         ServiceManager.classPath = sb.toString();   
  50.     }   
  51.   
  52.     /**  
  53.      * 启动后台服务  
  54.      *   
  55.      * @author 任鹤峰 2009-02-03  
  56.      * @param name  
  57.      * @param desc  
  58.      * @throws ClassNotFoundException  
  59.      * @throws NoSuchMethodException  
  60.      * @throws InstantiationException  
  61.      * @throws IllegalAccessException  
  62.      * @throws InvocationTargetException  
  63.      */  
  64.     @SuppressWarnings("unchecked")   
  65.     public void runService(String name, String desc)   
  66.             throws ClassNotFoundException, NoSuchMethodException,   
  67.             InstantiationException, IllegalAccessException,   
  68.             InvocationTargetException {   
  69.         try {   
  70.             Object service;   
  71.             Class cls = null;   
  72.             if (null != ServiceManager.loader) {   
  73.                 cls = ServiceManager.getLoader().loadClass(name);   
  74.             } else {   
  75.                 cls = Class.forName(name);   
  76.             }   
  77.             Class[] par = null;   
  78. 分享到：
    | 人民币写法的大小写转换
    评论
    发表评论

    您还没有登录,请您登录后再发表评论

相关推荐

    Spring mvc + Mybatis + quartz + swagger 定时任务管理[新增、编辑、删除、修改]

    本项目就是基于Spring MVC、Mybatis、Quartz和Swagger实现的一个定时任务管理系统，旨在提供一种灵活且可配置的方式来管理和控制定时任务。下面将详细讲解这个系统的核心组成部分及其工作原理。 首先，Spring MVC是...

    定时框架spring+quartz

    "定时框架spring+quartz"的结合，就是将Quartz的定时功能与Spring的强大集成能力完美融合，为开发者提供了一种高效、灵活的定时任务解决方案。 Spring框架提供了多种方式来管理定时任务，包括使用Spring的`@...

    Spring+Quartz定时任务学习文档+实例+jar包

    Spring和Quartz是Java开发中常用的两个框架，它们在企业级应用中被广泛用于实现定时任务的管理和执行。Spring提供了一个轻量级的容器来管理Bean，而Quartz则是一个强大的作业调度库，能够帮助开发者定义和执行定时...

    spring+mvc+quartz.rar

    Spring框架以其强大的功能和灵活的扩展性，成为Java开发的首选，而Quartz作为一款开源的作业调度库，能够很好地与Spring集成，提供定时任务的解决方案。本教程将详细讲解如何利用Spring 4.3.15、Spring MVC 4.3.15和...

    Spring+Quartz 从数据库中获取定时任务和定时时间，动态实现对定时任务的增删改查

    总之，Spring与Quartz的结合提供了一套强大的定时任务解决方案。通过从数据库中动态加载和管理任务，可以灵活应对不断变化的业务需求。而实际项目中的部署和测试，以及各种异常和性能的考虑，都是确保系统稳定运行的...

    spring3.0+quartz-1.6.0定时

    Spring 3.0 和 Quartz 1.6.0 结合使用是企业级应用中常见的定时任务解决方案。Spring 是一个强大的Java应用程序框架，提供了依赖注入、AOP（面向切面编程）以及众多其他功能，而Quartz则是一个开源的作业调度框架，...

    spring + Quartz 定时任务

    Spring框架和Quartz库结合使用，能够构建出强大且灵活的定时任务解决方案。下面我们将深入探讨这两个技术及其整合的方式。 **Spring框架** Spring是一个广泛使用的Java企业级应用开发框架，它提供了依赖注入...

    spring+quartz定时集群支持

    集群解决方案中，除了Spring+Quartz的配置，还可以采用统一调度Server来协调各个应用server的任务执行。例如，通过IHS（IBM HTTP Server）或者其他负载均衡器，可以实现对应用server的流量控制，确保同一时间只有一...

    11-Spring+Quartz定时任务最简集群版1

    【Spring+Quartz定时任务最简集群版1】是一个基于Spring和Quartz的定时任务解决方案，用于在分布式环境中实现任务的自动调度。本项目作为Dubbo工程的一部分，它依赖于Dubbo的一些公共组件，同时也提供了将定时任务...

    Spring+Quartz集群部署案例

    最近项目中使用了spring+Quartz定时任务、但是项目最近要集群部署、多个APP下如何利用Quartz 协调处理任务。 大家可以思考一下、现在有 A、B、C三个应用同时作为集群服务器对外统一提供服务、每个应用下各有一个...

    Spring任务调度配置及说明(spring+quartz)

    《Spring任务调度配置详解：Spring+...这种灵活的配置方式使得Spring+Quartz成为Java项目中广泛使用的任务调度解决方案。在实际开发中，你还可以利用Spring的AOP特性，进行更复杂的任务处理，如事务管理、异常处理等。

    Spring Boot+Apache Shiro+Spring MVC+MyBatis+Quartz+Druid DEMO

    这个DEMO提供了完整的权限管理和任务调度解决方案，下面是这些技术栈的核心知识点及其应用： 1. **Spring Boot**： - Spring Boot简化了Spring应用的初始搭建以及开发过程，它集成了大量的常用库，如自动配置、...

    Spring+Quartz定时调度

    **Spring+Quartz定时调度详解** 在Java世界中，实现定时任务调度是非常常见...配合提供的文档和示例代码，如`Spring+Quartz任务调度.docx`和解压后的`spring+quartz.rar`文件，开发者可以快速掌握并应用到实际项目中。

    spring4+hibernate5+quartz2+hdfs整合

    "spring4+hibernate5+quartz2+hdfs整合"的主题，就是将四个关键的技术组件整合在一起，以实现高效、可扩展的数据处理和任务调度解决方案。以下是这些技术组件的核心知识点： **Spring 4** Spring 是一个开源的Java...

    spring+quartz定时器

    Spring框架与Quartz库的结合为Java开发者提供了一个强大且灵活的定时任务解决方案。让我们深入探讨一下这个"spring2.0+quartz1.6定时器"的工作原理和实现细节。 首先，Spring框架是一个广泛应用的开源Java框架，它...

    spring+springmvc+shiro+quartz

    总结来说，"spring+springmvc+shiro+quartz"组合代表了一个完整的Java Web应用解决方案，涵盖了从基础架构到安全控制再到任务调度的各个方面。在实际开发中，理解并熟练运用这些框架能显著提高开发效率，同时保证...

    spring3+quartz1.6.4 集群示例

    本示例"spring3+quartz1.6.4 集群示例"是将两者结合，以实现一个能够支持集群的定时任务管理解决方案。 1. **Spring 3.x 框架** Spring 3.x 是Spring框架的一个版本，它引入了许多新特性，包括对Java 5和6的支持，...

    基于spring-boot+quartz的CRUD动态任务管理系统

    总的来说，"基于spring-boot+quartz的CRUD动态任务管理系统"是一个综合性的项目，涉及到后端开发、数据库设计、任务调度、Web界面等多个方面，为中小型企业提供了一个高效、易用的任务管理解决方案。

    Spring+Quartz2.2.0+Demo源码实战演练【精华篇2014】

    - `SpringQuartz`项目中的`pom.xml`文件会列出所有依赖，包括Spring和Quartz的相关库。 - 将项目导入MyEclipse后，运行主类启动应用，然后观察任务是否按预期执行。 7. **注意事项**： - 配置Quartz时，确保...

Magicbox
Global site tag (gtag.js) - Google Analytics