Quartz集群原理以及配置应用的方法详解

<bean id="jobtask" class="org.springframework.scheduling.quartz. MethodInvokingJobDetailFactoryBean ">
　　<property name="targetObject">
　　　　<ref bean="quartzJob"/>
　　</property>
　　<property name="targetMethod">
　　　　<value>execute</value>
　　</property>
</bean>

package org.lxh.mvc.jobbean;
import java.lang.reflect.Method;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.quartz.QuartzJobBean;
public class MyDetailQuartzJobBean extends QuartzJobBean {
 protected final Log logger = LogFactory.getLog(getClass());
 private String targetObject;
 private String targetMethod;
 private ApplicationContext ctx;
 protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
  try {
   logger.info("execute [" + targetObject + "] at once>>>>>>");
   Object otargetObject = ctx.getBean(targetObject);
   Method m = null;
   try {
    m = otargetObject.getClass().getMethod(targetMethod, new Class[] {});
    m.invoke(otargetObject, new Object[] {});
   } catch (SecurityException e) {
    logger.error(e);
   } catch (NoSuchMethodException e) {
    logger.error(e);
   }
  } catch (Exception e) {
   throw new JobExecutionException(e);
  }
 }

 public void setApplicationContext(ApplicationContext applicationContext){
  this.ctx=applicationContext;
 }

 public void setTargetObject(String targetObject) {
  this.targetObject = targetObject;
 }

 public void setTargetMethod(String targetMethod) {
  this.targetMethod = targetMethod;
 }
}

package org.lxh.mvc.job;
import java.io.Serializable;
import java.util.Date;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class Test implements Serializable{
 private Log logger = LogFactory.getLog(Test.class);
 private static final long serialVersionUID = -2073310586499744415L; 
 public void execute () {
  Date date=new Date(); 
  System.out.println(date.toLocaleString()); 
 }
}

<bean id="Test" class="org.lxh.mvc.job.Test" scope="prototype">
 </bean>

 <bean id="TestjobTask" class="org.springframework.scheduling.quartz.JobDetailBean">
  <property name="jobClass">
<value>org.lxh.mvc.jobbean.MyDetailQuartzJobBean</value>
  </property>
  <property name="jobDataAsMap">
   <map>
    <entry key="targetObject" value="Test" />
    <entry key="targetMethod" value="execute" />
    </map>
   </property> 
  </bean>
 
 <bean name="TestTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"> 
  <property name="jobDetail" ref="TestjobTask" />
  <property name="cronExpression" value="0/1 * * * * ?" />
 </bean> 
<bean id="quartzScheduler"
 class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
  <property name="configLocation" value="classpath:quartz.properties"/>
  <property name="triggers">
   <list>
    <ref bean="TestTrigger" />
   </list>
  </property>
  <property name="applicationContextSchedulerContextKey" value="applicationContext" />
 </bean>

#============================================================== 
#Configure Main Scheduler Properties 
#============================================================== 
org.quartz.scheduler.instanceName = quartzScheduler
org.quartz.scheduler.instanceId = AUTO

#============================================================== 
#Configure JobStore 
#============================================================== 
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.isClustered = true
org.quartz.jobStore.clusterCheckinInterval = 10000 
org.quartz.jobStore.dataSource = myDS
 
#============================================================== 
#Configure DataSource 
#============================================================== 
org.quartz.dataSource.myDS.driver = com.mysql.jdbc.Driver
org.quartz.dataSource.myDS.URL = jdbc:mysql://192.168.31.18:3306/test?useUnicode=true&characterEncoding=UTF-8
org.quartz.dataSource.myDS.user = root
org.quartz.dataSource.myDS.password = 123456
org.quartz.dataSource.myDS.maxConnections = 30

#============================================================== 
#Configure ThreadPool 
#============================================================== 
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 5
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

package cluster;
import java.util.Date;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleTrigger;
import org.quartz.impl.StdSchedulerFactory;
public class ClusterExample {
 
 public void cleanUp(Scheduler inScheduler) throws Exception {
  System.out.println("***** Deleting existing jobs/triggers *****");
  // unschedule jobs
  String[] groups = inScheduler.getTriggerGroupNames();
  for (int i = 0; i < groups.length; i++) {
   String[] names = inScheduler.getTriggerNames(groups[i]);
   for (int j = 0; j < names.length; j++) {
    inScheduler.unscheduleJob(names[j], groups[i]);
   }
  }
  // delete jobs
  groups = inScheduler.getJobGroupNames();
  for (int i = 0; i < groups.length; i++) {
   String[] names = inScheduler.getJobNames(groups[i]);
   for (int j = 0; j < names.length; j++) {
    inScheduler.deleteJob(names[j], groups[i]);
   }
  }
 }
  
 public void run(boolean inClearJobs, boolean inScheduleJobs) 
  throws Exception {
  // First we must get a reference to a scheduler
  SchedulerFactory sf = new StdSchedulerFactory();
  Scheduler sched = sf.getScheduler();
  
  if (inClearJobs) {
   cleanUp(sched);
  }
  System.out.println("------- Initialization Complete -----------");
  if (inScheduleJobs) {
   System.out.println("------- Scheduling Jobs ------------------");
   String schedId = sched.getSchedulerInstanceId();
   int count = 1;
   JobDetail job = new JobDetail("job_" + count, schedId, SimpleRecoveryJob.class);
   // ask scheduler to re-execute this job if it was in progress when
   // the scheduler went down...
   job.setRequestsRecovery(true);
   SimpleTrigger trigger = 
    new SimpleTrigger("triger_" + count, schedId, 200, 1000L);
   trigger.setStartTime(new Date(System.currentTimeMillis() + 1000L));
   System.out.println(job.getFullName() +
     " will run at: " + trigger.getNextFireTime() + 
     " and repeat: " + trigger.getRepeatCount() + 
     " times, every " + trigger.getRepeatInterval() / 1000 + " seconds");
   sched.scheduleJob(job, trigger);
   count++;
   job = new JobDetail("job_" + count, schedId, 
     SimpleRecoveryStatefulJob.class);
   // ask scheduler to re-execute this job if it was in progress when
   // the scheduler went down...
   job.setRequestsRecovery(false);
   trigger = new SimpleTrigger("trig_" + count, schedId, 100, 2000L);
   trigger.setStartTime(new Date(System.currentTimeMillis() + 2000L));
   System.out.println(job.getFullName() +
     " will run at: " + trigger.getNextFireTime() + 
     " and repeat: " + trigger.getRepeatCount() + 
     " times, every " + trigger.getRepeatInterval() / 1000 + " seconds");
   sched.scheduleJob(job, trigger);
  }
  // jobs don't start firing until start() has been called...
  System.out.println("------- Starting Scheduler ---------------");
  sched.start();
  System.out.println("------- Started Scheduler ----------------");
  System.out.println("------- Waiting for one hour... ----------");
  try {
   Thread.sleep(3600L * 1000L);
  } catch (Exception e) {
  }
  System.out.println("------- Shutting Down --------------------");
  sched.shutdown();
  System.out.println("------- Shutdown Complete ----------------");
  }
 
 public static void main(String[] args) throws Exception {
  boolean clearJobs = true;
  boolean scheduleJobs = true;
  for (int i = 0; i < args.length; i++) {
   if (args[i].equalsIgnoreCase("clearJobs")) {
    clearJobs = true;    
   } else if (args[i].equalsIgnoreCase("dontScheduleJobs")) {
    scheduleJobs = false;
   }
  }
  ClusterExample example = new ClusterExample();
  example.run(clearJobs, scheduleJobs);
 }
}

package cluster;

import java.io.Serializable;
import java.util.Date;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
//如果有想反复执行的动作，作业，任务就把相关的代码写在execute这个方法里，前提：实现Job这个接口
//至于SimpleJob这个类什么时候实例化，execute这个方法何时被调用，我们不用关注，交给Quartz
public class SimpleRecoveryJob implements Job, Serializable {
 private static Log _log = LogFactory.getLog(SimpleRecoveryJob.class);
 public SimpleRecoveryJob() {
 }
 public void execute(JobExecutionContext context)
  throws JobExecutionException {
  //这个作业只是简单的打印出作业名字和此作业运行的时间
  String jobName = context.getJobDetail().getFullName();
  System.out.println("JOB 1111111111111111111 SimpleRecoveryJob says: " + jobName + " executing at " + new Date());
 }
}