Java SchedulerFactoryBean.setTriggers方法代码示例

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
public SchedulerFactoryBean build() throws Exception {
	SchedulerFactoryBean bean = new SchedulerFactoryBean();
	PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
	propertiesFactoryBean.setLocation(new ClassPathResource(config));
	propertiesFactoryBean.afterPropertiesSet();
	Properties props = propertiesFactoryBean.getObject();
	List<Trigger> triggers = Lists.newArrayList();
	List<JobModel> jobList = getJobs(props);
	for (JobModel job : jobList) {
		if (!job.isEnable()) {
			continue;
		}
		JobDetailFactoryBean detail = createJobDetail(job.getName(), Class.forName(job.getJob()));
		CronTriggerFactoryBean trigger = createCronTrigger(job.getName(), detail.getObject(), job.getCorn());
		CronTrigger t = trigger.getObject();
		triggers.add(t);
	}
	bean.setTriggers(triggers.toArray(new Trigger[0]));
	//bean.afterPropertiesSet();
	return bean;

}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
/**
 * 创建调度服务
 * 每一个批次启动后，创建一个调度服务
 */
public SchedulerFactoryBean createSchedulerFactoryBean(BatchRunConfDto conf, ResourceManagement drm) throws Exception {
    this.conf = conf;
    this.jobKeyStatusService = drm.getJobKeyStatusService();
    this.argumentService = drm.getArgumentService();

    getAllTaskForMap();
    initGroupTaskMap(drm.getJobKeyList());

    SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
    // 配置DataSource后,将会出现异常
    // JobLauncher实例化对象无法序列化
    // schedulerFactoryBean.setDataSource(dataSource);
    schedulerFactoryBean.setSchedulerName(conf.getBatchId());
    schedulerFactoryBean.setWaitForJobsToCompleteOnShutdown(true);
    schedulerFactoryBean.setAutoStartup(false);

    // 获取指定批次的所有任务Job
    ArrayList<SimpleTrigger> arrayList = new ArrayList<SimpleTrigger>();
    for (String jobId : jobKeyStatusService.getAllJob().keySet()) {
        SimpleTrigger simpleTrigger = createSimpleTrigger(jobId);
        schedulerFactoryBean.setTriggers(simpleTrigger);
        arrayList.add(simpleTrigger);
    }

    SimpleTrigger[] simpleTriggers = new SimpleTrigger[arrayList.size()];
    for (int i = 0; i < arrayList.size(); i++) {
        simpleTriggers[i] = arrayList.get(i);
    }
    schedulerFactoryBean.setTriggers(simpleTriggers);
    schedulerFactoryBean.afterPropertiesSet();
    schedulerFactoryBean.getScheduler().pauseAll();
    schedulerFactoryBean.start();
    return schedulerFactoryBean;
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
/** 
 * attention: 
 * Details：定义quartz调度工厂 
 */  
@Bean(name = "scheduler")  
public SchedulerFactoryBean schedulerFactory(Trigger cronJobTrigger) {  
    SchedulerFactoryBean bean = new SchedulerFactoryBean();  
    // 用于quartz集群,QuartzScheduler 启动时更新己存在的Job  
    bean.setOverwriteExistingJobs(true);  
    // 延时启动，应用启动1秒后  
    bean.setStartupDelay(1);  
    // 注册触发器  
    bean.setTriggers(cronJobTrigger);  
    return bean;  
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
@Bean
public SchedulerFactoryBean getEventHealthMonitorBean(){
	SchedulerFactoryBean bean = new SchedulerFactoryBean();
	bean.setBeanName("EventHealthMonitorThread");
	bean.setTriggers(new Trigger [] {getMonitorJobTrigger().getObject()});
	Properties prop = new Properties();
	prop.setProperty("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
	prop.setProperty("org.quartz.threadPool.threadCount", "1");
	bean.setQuartzProperties(prop);
	return bean;
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
@Bean
public SchedulerFactoryBean getEventJobBean(){
	SchedulerFactoryBean bean = new SchedulerFactoryBean();
	bean.setBeanName("EligibleEventProcessorThread");
	bean.setTriggers(new Trigger [] {getEventJobTrigger().getObject()});
	Properties prop = new Properties();
	prop.setProperty("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
	prop.setProperty("org.quartz.threadPool.threadCount", "1");
	bean.setQuartzProperties(prop);
	return bean;
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
/**
 * Gets the scheduler factory bean.
 *
 * @param appStatsTrigger the app stats trigger
 * @param clusterStatsTrigger the cluster stats trigger
 * @param connectorStatsTrigger the connector stats trigger
 * @param datasourceStatsTrigger the datasource stats trigger
 * @param memoryStatsTrigger the memory stats trigger
 * @param runtimeStatsTrigger the runtime stats trigger
 * @param statsSerializerTrigger the stats serializer trigger
 * @return the scheduler factory bean
 */
@Bean(name = "scheduler")
public SchedulerFactoryBean getSchedulerFactoryBean(@Autowired AppStatsTrigger appStatsTrigger,
    @Autowired ClusterStatsTrigger clusterStatsTrigger,
    @Autowired ConnectorStatsTrigger connectorStatsTrigger,
    @Autowired DatasourceStatsTrigger datasourceStatsTrigger,
    @Autowired MemoryStatsTrigger memoryStatsTrigger,
    @Autowired RuntimeStatsTrigger runtimeStatsTrigger,
    @Autowired StatsSerializerTrigger statsSerializerTrigger) {

  logger.debug("Instantiated scheduler");
  SchedulerFactoryBean bean = new SchedulerFactoryBean();

  // Add Triggers
  bean.setTriggers(appStatsTrigger.getObject(), clusterStatsTrigger.getObject(),
      connectorStatsTrigger.getObject(), datasourceStatsTrigger.getObject(),
      memoryStatsTrigger.getObject(), runtimeStatsTrigger.getObject(),
      statsSerializerTrigger.getObject());

  // Add Properties
  Properties properties = new Properties();
  properties.setProperty("org.quartz.scheduler.instanceName", "ProbeScheduler");
  properties.setProperty("org.quartz.threadPool.threadCount", "5");
  properties.setProperty("org.quartz.threadPool.threadNamePrefix", "Probe_Quartz");
  bean.setQuartzProperties(properties);

  return bean;
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
@Bean
public Scheduler scheduler() throws Exception {
	SchedulerFactoryBean factory = new SchedulerFactoryBean();
	factory.setTriggers(new Trigger[] { jobDetailTrigger() });
	factory.setJobFactory(new SpringBeanJobFactory());
	factory.setDataSource(dataSource());
	factory.setSchedulerContextAsMap(new HashMap<String, Object>() {{
		put("job", job());
		put("jobLauncher", jobLauncher);
	}});
	factory.afterPropertiesSet();

	return factory.getObject();
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
@Bean(name = QUARTZ_SCHEDULER_FACTORY_BEAN_NAME)
@ConditionalOnMissingBean(name = QUARTZ_SCHEDULER_FACTORY_BEAN_NAME)
public SchedulerFactoryBean autoSchedulerFactory(ApplicationContext applicationContext, JobFactory jobFactory,
		QuartzSchedulerProperties properties, @Qualifier(QUARTZ_PROPERTIES_BEAN_NAME) Properties quartzProperties) {
	
	LOGGER.debug("creating SchedulerFactory");
	
	SchedulerFactoryBean factory = BeanUtils.instantiateClass(SchedulerFactoryBean.class);
	
       factory.setApplicationContext(applicationContext);
       factory.setJobFactory(jobFactory);
       
       Persistence persistenceSettings = properties.getPersistence();
       if (persistenceSettings.isPersisted()) {
       	factory.setDataSource(getDataSource(applicationContext, persistenceSettings));
       	if (persistenceSettings.isUsePlatformTxManager()) {
       		PlatformTransactionManager txManager = getTransactionManager(applicationContext);
           	if (null != txManager) {
               	factory.setTransactionManager(txManager);
               }
       	}
       }
       
       SchedulerFactory factorySettings = properties.getSchedulerFactory();
       factory.setSchedulerName(factorySettings.getSchedulerName());
       factory.setPhase(factorySettings.getPhase());
       factory.setStartupDelay(factorySettings.getStartupDelay());
       factory.setAutoStartup(factorySettings.isAutoStartup());
       factory.setWaitForJobsToCompleteOnShutdown(factorySettings.isWaitForJobsToCompleteOnShutdown());
       factory.setOverwriteExistingJobs(factorySettings.isOverwriteExistingJobs());
       factory.setExposeSchedulerInRepository(factorySettings.isExposeSchedulerInRepository());
       
       factory.setQuartzProperties(quartzProperties);
       
       Collection<Trigger> triggers = getTriggers(applicationContext);
       if (null != triggers && !triggers.isEmpty()) {
       	factory.setTriggers(triggers.toArray(new Trigger[triggers.size()]));
       	LOGGER.info("staring scheduler factory with " + triggers.size() + " job triggers");
       } else {
       	LOGGER.info("staring scheduler factory with 0 job triggers");
       }
       
       QuartzSchedulerFactoryOverrideHook hook = getQuartzSchedulerFactoryOverrideHook(applicationContext);
       if (null != hook) {
       	factory = hook.override(factory, properties, quartzProperties);
       }
       
	return factory;
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
public void start() throws Exception {
	LOG.info("start crontab");
	
	if (application.getCrontab() != null && application.getCrontab().getCrons() != null) {
		
		Trigger[] triggers = new Trigger[application.getCrontab().getCrons().size()];
		for (int i = 0; i < triggers.length; i ++) {
			
			Cron cron = application.getCrontab().getCrons().get(i);
			String desc = cron.getDescription();
			String exp = cron.getSchedule();
			String script = cron.getScript();
			
			MethodInvokingJobDetailFactoryBean jobDetailFactory = new MethodInvokingJobDetailFactoryBean();
			jobDetailFactory.setBeanName("jobDetail" + script);
			jobDetailFactory.setName("jobDetail" + script);
			jobDetailFactory.setTargetObject(this);
			jobDetailFactory.setTargetMethod("execute");
			jobDetailFactory.setArguments(new Object[]{script, exp, desc});
			jobDetailFactory.setConcurrent(application.getCrontab().isConcurrent());
			jobDetailFactory.afterPropertiesSet();
			
			JobDetail jobDetail = jobDetailFactory.getObject();

			CronTriggerBean trigger = new CronTriggerBean();
			trigger.setBeanName("trigger" + script);
			trigger.setName("trigger" + script);
			trigger.setJobDetail(jobDetail);
			trigger.setCronExpression(exp);
			trigger.afterPropertiesSet();
			
			triggers[i] = trigger;
		}

		Properties properties = new Properties();
		properties.setProperty("org.quartz.scheduler.skipUpdateCheck", "true");
		
		schedulerFactory = new SchedulerFactoryBean();
		schedulerFactory.setBeanName("schedulerFactory");
		schedulerFactory.setTriggers(triggers);
		schedulerFactory.setQuartzProperties(properties);
		//schedulerFactory.setAutoStartup(true);
		schedulerFactory.afterPropertiesSet();
		schedulerFactory.start();
	}
}