Java SchedulerFactoryBean.setJobFactory方法代码示例

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
@Bean
public SchedulerFactoryBean schedulerFactory(JobFactory jobFactory) {
    SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
    schedulerFactoryBean.setApplicationContext(applicationContext);
    schedulerFactoryBean.setAutoStartup(schedulerProperties.isAutoStartup());
    schedulerFactoryBean.setDataSource(dataSource);
    schedulerFactoryBean.setTransactionManager(platformTransactionManager);
    schedulerFactoryBean.setOverwriteExistingJobs(schedulerProperties.isOverwriteExistingJobs());
    schedulerFactoryBean.setSchedulerFactoryClass(StdSchedulerFactory.class);
    schedulerFactoryBean.setBeanName(schedulerProperties.getBeanName());
    schedulerFactoryBean.setJobFactory(jobFactory);
    schedulerFactoryBean.setWaitForJobsToCompleteOnShutdown(schedulerProperties.isWaitOnShutdown());
    schedulerFactoryBean.setQuartzProperties(schedulerProperties.getProperties());
    schedulerFactoryBean.setStartupDelay(schedulerProperties.getStartupDelay());
    schedulerFactoryBean.setCalendars(calendarMap);
    schedulerFactoryBean.setSchedulerListeners(schedulerListeners);
    return schedulerFactoryBean;
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
/**
 * create scheduler
 */
@Bean
public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
 
    SchedulerFactoryBean factory = new SchedulerFactoryBean();
    factory.setOverwriteExistingJobs(true);
    factory.setDataSource(dataSource);
    factory.setQuartzProperties(quartzProperties());
    
    //Register listeners to get notification on Trigger misfire etc
    factory.setGlobalTriggerListeners(triggerListner);
    factory.setGlobalJobListeners(jobsListener);
    
    AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
    jobFactory.setApplicationContext(applicationContext);
    factory.setJobFactory(jobFactory);
    
    return factory;
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
@Bean(name = "batch")
    public SchedulerFactoryBean schedulerFactoryBean(
    		DataSource dataSource, 
    		JobFactory jobFactory) {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setOverwriteExistingJobs(true);
        factory.setDataSource(dataSource);
        factory.setJobFactory(jobFactory);
        
        Properties props = new Properties();
        props.setProperty(StdSchedulerFactory.PROP_SCHED_INSTANCE_NAME, "batch");
        props.setProperty(StdSchedulerFactory.PROP_SCHED_INSTANCE_ID, "auto");
        props.setProperty("org.quartz.jobStore.driverDelegateClass", "org.quartz.impl.jdbcjobstore.HSQLDBDelegate");
        props.setProperty("org.quartz.scheduler.skipUpdateCheck", "true");
//        factory.setQuartzProperties(props);
//        factory.setTriggers(sampleJobTrigger);

        return factory;
    }
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
@Bean
public SchedulerFactoryBean schedulerFactoryBean(
        DataSource dataSource, PlatformTransactionManager transactionManager, JobFactory jobFactory) {

    final SchedulerFactoryBean factory = new SchedulerFactoryBean();
    factory.setOverwriteExistingJobs(true);
    factory.setTaskExecutor(commonTaskScheduler.getScheduledExecutor());
    factory.setDataSource(dataSource);
    factory.setTransactionManager(transactionManager);
    factory.setJobFactory(jobFactory);
    factory.setQuartzProperties(quartzProperties);
    factory.setSchedulerName(SCHEDULER_NAME);
    factory.setAutoStartup(true);
    factory.setWaitForJobsToCompleteOnShutdown(true);

    // Delay added to avoid errors caused by updating registered tasks and reduce load on startup
    factory.setStartupDelay(30);

    return factory;
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
@Bean
public SchedulerFactoryBean schedulerFactory(JobFactory jobFactory) throws IOException {
    SchedulerFactoryBean factory = new SchedulerFactoryBean();
    factory.setSchedulerName("Sentry");
    factory.setJobFactory(jobFactory);
    factory.setQuartzProperties(quartzProperties());
    // this allows to update triggers in DB when updating settings in config file:
    factory.setOverwriteExistingJobs(true);
    return factory;
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
@Bean
public SchedulerFactoryBean schedulerFactoryBean(ApplicationContext applicationContext, DataSource dataSource,
		JobFactory jobFactory)
{
	SchedulerFactoryBean schedulerFactory = new SchedulerFactoryBean();
	schedulerFactory.setConfigLocation(new ClassPathResource("quartz.properties"));
	schedulerFactory.setAutoStartup(true);
	schedulerFactory.setDataSource(dataSource);
	schedulerFactory.setJobFactory(jobFactory);
	return schedulerFactory;
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
@Bean
public SchedulerFactoryBean schedulerFactory(ApplicationContext applicationContext) {
	SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
	AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
	jobFactory.setApplicationContext(applicationContext);
	
	factoryBean.setJobFactory(jobFactory);
	factoryBean.setApplicationContextSchedulerContextKey("applicationContext");
	return factoryBean;
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
@Bean(name = "mainScheduler")
public SchedulerFactoryBean mainScheduler(DelegatingQuartzJobFactory jobFactory,
                                            @Qualifier("quartzProperties") Properties quartzProperties,
                                            @Value("#{'${cronyx.passive}'=='true'}") boolean passive,
                                            @Qualifier("cronyxDataSource") DataSource dataSource){
    SchedulerFactoryBean factory = new SchedulerFactoryBean();
    factory.setJobFactory(jobFactory);
    factory.setQuartzProperties(quartzProperties);
    factory.setDataSource(dataSource);
    factory.setAutoStartup(!passive);
    factory.setSchedulerName(quartzProperties.getProperty(PROP_SCHED_INSTANCE_NAME));
    return factory;
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
@Bean
public SchedulerFactoryBean schedulerFactoryBean() {
    SchedulerFactoryBean scheduler = new SchedulerFactoryBean();
    scheduler.setTaskExecutor(getAsyncExecutor());
    scheduler.setAutoStartup(true);
    scheduler.setJobFactory(new SimpleJobFactory());
    return scheduler;
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
@Bean
public SchedulerFactoryBean schedulerFactoryBean()
{
	SchedulerFactoryBean quartzScheduler = new SchedulerFactoryBean();
	AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
	jobFactory.setApplicationContext(applicationContext);
	quartzScheduler.setJobFactory(jobFactory);
	return quartzScheduler;
}
 

import org.springframework.scheduling.quartz.SchedulerFactoryBean; //导入方法依赖的package包/类
@Bean
public Scheduler quartzScheduler(ApplicationContext context) throws Exception {
    SchedulerFactoryBean factory = new SchedulerFactoryBean();

    factory.setApplicationContext(context);
    factory.setExposeSchedulerInRepository(true);
    factory.setApplicationContextSchedulerContextKey(APPLICATION_CONTEXT_KEY);
    factory.setJobFactory(glassJobFactory);

    Properties properties = new Properties();
    properties.setProperty("org.quartz.scheduler.skipUpdateCheck","true");
    properties.setProperty("org.quartz.threadPool.class", SimpleThreadPool.class.getName());
    properties.setProperty("org.quartz.threadPool.threadCount", "15");
    properties.setProperty("org.quartz.threadPool.threadPriority", "4");

    if (configuration().isInMemory()) {
        properties.setProperty("org.quartz.jobStore.class", RAMJobStore.class.getName());
    } else {
        factory.setDataSource(dataSource());

        properties.setProperty("org.quartz.jobStore.tablePrefix", configuration().getTablePrefix());
        properties.setProperty("org.quartz.jobStore.isClustered", "false");
        properties.setProperty("org.quartz.jobStore.driverDelegateClass", configuration().getDriverDelegateClass());
    }

    factory.setQuartzProperties(properties);

    factory.afterPropertiesSet();

    Scheduler scheduler = factory.getObject();

    scheduler.getListenerManager().addJobListener(glassJobListener);
    scheduler.getListenerManager().addSchedulerListener(glassSchedulerListener);

    scheduler.start();

    return scheduler;
}
 

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;
}