org.quartz.spi.JobFactory Java Examples

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

@Inject
public QuartzSchedulerProvider(final NodeAccess nodeAccess,
                               final Provider<JobStore> jobStore,
                               final JobFactory jobFactory,
                               @Named("${nexus.quartz.poolSize:-20}") final int threadPoolSize,
                               @Named("${nexus.quartz.taskThreadPriority:-5}") final int threadPriority)
{
  this.nodeAccess = checkNotNull(nodeAccess);
  this.jobStore = checkNotNull(jobStore);
  this.jobFactory = checkNotNull(jobFactory);
  checkArgument(threadPoolSize > 0, "Invalid thread-pool size: %s", threadPoolSize);
  this.threadPoolSize = threadPoolSize;
  this.threadPriority = threadPriority;
  log.info("Thread-pool size: {}, Thread-pool priority: {}", threadPoolSize, threadPriority);
}
 

@Bean
public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource, JobFactory jobFactory) throws IOException {
	SchedulerFactoryBean factory = new SchedulerFactoryBean();
	factory.setOverwriteExistingJobs(true);
	factory.setDataSource(dataSource);
	factory.setJobFactory(jobFactory);
	factory.setQuartzProperties(quartzProperties());

	// Here we will set all the trigger beans we have defined.
	if (!NotificationUtil.isObjectEmpty(listOfTrigger)) {
		factory.setTriggers(listOfTrigger.toArray(new Trigger[listOfTrigger.size()]));
	}

	return factory;
}
 

@Bean
public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource,
                                                 JobFactory jobFactory) {
    SchedulerFactoryBean factory = new SchedulerFactoryBean();
    factory.setOverwriteExistingJobs(true);
    factory.setDataSource(dataSource);
    factory.setJobFactory(jobFactory);
    factory.setQuartzProperties(quartzConf);
    return factory;
}
 

@Bean(name = "scheduler")
public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory,
		@Qualifier("jobTrigger") Trigger sampleJobTrigger) throws IOException {
	SchedulerFactoryBean factory = new SchedulerFactoryBean();
	factory.setJobFactory(jobFactory);
	factory.setQuartzProperties(quartzProperties());
	factory.setTriggers(sampleJobTrigger);
	factory.setAutoStartup(false);
	return factory;
}
 

@Override
protected void configure() {
    Names.bindProperties(binder(), config.toProperties());
    
    bind(JobFactory.class).to(SchedulerFactory.class);
    bind(Cache.class).toProvider(CacheProvider.class);
    bind(MangooAuthorizationService.class).to(AuthorizationService.class);
}
 

@Bean(name = QUARTZ_JOB_FACTORY_BEAN_NAME)
@ConditionalOnMissingBean(name = QUARTZ_JOB_FACTORY_BEAN_NAME)
   public JobFactory autoJobFactory(ApplicationContext applicationContext,
   		@Autowired(required=false) QuartzSchedulerProperties properties) {
	if (null == properties) {
		LOGGER.warn("no QuartzSchedulerProperties found, consider to set quartz.enabled=true in properties");
		return null;
	}
       AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
       jobFactory.setApplicationContext(applicationContext);
       return jobFactory;
   }
 

@Bean
public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource, JobFactory jobFactory, @Qualifier("sampleJobTrigger") Trigger sampleJobTrigger) throws IOException {
    SchedulerFactoryBean factory = new SchedulerFactoryBean();
    factory.setOverwriteExistingJobs(true);
    factory.setDataSource(dataSource);
    factory.setJobFactory(jobFactory);
    PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
    propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
    propertiesFactoryBean.afterPropertiesSet();
    factory.setQuartzProperties(propertiesFactoryBean.getObject());
    return factory;
}
 

@Test
public void testBindings() {
       //given
	Injector guice = Application.getInjector();
	
       //when
	Binding<Stage> stage = guice.getBinding(Stage.class);
	Binding<Injector> injector = guice.getBinding(Injector.class);
	Binding<Logger> logger = guice.getBinding(Logger.class);
	Binding<Config> config = guice.getBinding(Config.class);
	Binding<JobFactory> jobFactory = guice.getBinding(JobFactory.class);
	Binding<Cache> cache = guice.getBinding(Cache.class);
	Binding<TemplateEngine> templateEngine = guice.getBinding(TemplateEngine.class);		
	Binding<OncePerRequestFilter> mangooRequestFilter = guice.getBinding(OncePerRequestFilter.class);
	Binding<MangooBootstrap> mangooBootstrap = guice.getBinding(MangooBootstrap.class);
	
	//then
	assertThat(stage.getKey().getTypeLiteral().getType().getTypeName(), equalTo("com.google.inject.Stage"));
	assertThat(injector.getKey().getTypeLiteral().getType().getTypeName(), equalTo("com.google.inject.Injector"));
	assertThat(logger.getKey().getTypeLiteral().getType().getTypeName(), equalTo("java.util.logging.Logger"));
	assertThat(config.getKey().getTypeLiteral().getType().getTypeName(), equalTo("io.mangoo.core.Config"));
	assertThat(jobFactory.getKey().getTypeLiteral().getType().getTypeName(), equalTo("org.quartz.spi.JobFactory"));
	assertThat(cache.getKey().getTypeLiteral().getType().getTypeName(), equalTo("io.mangoo.cache.Cache"));
	assertThat(templateEngine.getKey().getTypeLiteral().getType().getTypeName(), equalTo("io.mangoo.templating.TemplateEngine"));
	assertThat(mangooRequestFilter.getKey().getTypeLiteral().getType().getTypeName(), equalTo("io.mangoo.interfaces.filters.OncePerRequestFilter"));
	assertThat(mangooBootstrap.getKey().getTypeLiteral().getType().getTypeName(), equalTo("io.mangoo.interfaces.MangooBootstrap"));
}
 

/**
 * @see org.quartz.Scheduler#setJobFactory(org.quartz.spi.JobFactory)
 */
public void setJobFactory(JobFactory factory) throws SchedulerException {
    sched.setJobFactory(factory);
}
 

public void init(@Nullable final Integer poolSize, @Nullable final JobFactory factory) throws Exception {
  eventManager = new SimpleEventManager();
  applicationDirectories = mock(ApplicationDirectories.class);
  baseUrlManager = mock(BaseUrlManager.class);
  nodeAccess = mock(NodeAccess.class);
  lastShutdownTimeService = mock(LastShutdownTimeService.class);
  statusDelayedExecutor = mock(DatabaseStatusDelayedExecutor.class);

  Module module = binder -> {
    Properties properties = new Properties();
    properties.put("basedir", util.getBaseDir());
    if (poolSize != null) {
      properties.put("nexus.quartz.poolSize", poolSize);
    }
    binder.bind(ParameterKeys.PROPERTIES)
        .toInstance(properties);

    binder.bind(EventManager.class).toInstance(eventManager);

    File workDir = util.createTempDir(util.getTargetDir(), "workdir");
    when(applicationDirectories.getWorkDirectory(anyString())).thenReturn(workDir);
    binder.bind(ApplicationDirectories.class)
        .toInstance(applicationDirectories);

    binder.bind(BaseUrlManager.class)
        .toInstance(baseUrlManager);

    binder.bind(DatabaseInstance.class)
        .annotatedWith(Names.named("config"))
        .toInstance(databaseInstance);

    doAnswer(i  -> {
      ((Runnable) i.getArguments()[0]).run();
      return null;
    }).when(statusDelayedExecutor).execute(notNull(Runnable.class));
    binder.bind(DatabaseStatusDelayedExecutor.class)
        .toInstance(statusDelayedExecutor);

    when(nodeAccess.getId()).thenReturn("test-12345");
    when(nodeAccess.getMemberIds()).thenReturn(ImmutableSet.of("test-12345"));
    binder.bind(NodeAccess.class)
        .toInstance(nodeAccess);
    if (factory != null) {
      binder.bind(JobFactory.class).toInstance(factory);
    }

    binder.bind(LastShutdownTimeService.class).toInstance(lastShutdownTimeService);
    when(lastShutdownTimeService.estimateLastShutdownTime()).thenReturn(Optional.empty());

    // filtering by feature flag is not supported here yet
    binder.bind(JobStore.class).to(JobStoreImpl.class);
  };

  this.injector = Guice.createInjector(new WireModule(
      module, new StateGuardModule(),
      new SpaceModule(new URLClassSpace(TaskSchedulerHelper.class.getClassLoader()), BeanScanning.INDEX)
  ));
  injector.injectMembers(this);
}
 

public DynamicJobFactory(JobFactory defaultFactory) {
    this.defaultFactory = defaultFactory;
}
 

@Bean
public JobFactory jobFactory() {
    return new DynamicJobFactory(new AdaptableJobFactory());
}
 

@Bean(name = QUARTZ_SCHEDULER_FACTORY_BEAN_NAME)
@ConditionalOnMissingBean
public SchedulerFactoryBean autoSchedulerFactory(ApplicationContext applicationContext, JobFactory jobFactory,
		@Autowired(required=false) QuartzSchedulerProperties properties,
		@Qualifier(QUARTZ_PROPERTIES_BEAN_NAME) Properties quartzProperties,
		@Autowired(required=false) List<TriggerListener> triggerListeners,
		@Autowired(required=false) List<JobListener> jobListeners,
		@Autowired(required=false) List<SchedulerListener> schedulerListeners) {
	
	if (null == properties) {
		LOGGER.warn("no QuartzSchedulerProperties found, consider to set quartz.enabled=true in properties");
		return null;
	}
	
	LOGGER.debug("creating SchedulerFactory");
	 
       SchedulerFactory factorySettings = properties.getSchedulerFactory();
	SchedulerRepository schedulerRepo = SchedulerRepository.getInstance();
	if (schedulerRepo.remove(QUARTZ_SCHEDULER_FACTORY_BEAN_NAME)) {
		LOGGER.debug("removed scheduler from SchedulerRepository with name: " + QUARTZ_SCHEDULER_FACTORY_BEAN_NAME);
	}
	if (null != factorySettings.getSchedulerName() && schedulerRepo.remove(factorySettings.getSchedulerName())) {
		LOGGER.debug("removed scheduler from SchedulerRepository with name: " + factorySettings.getSchedulerName());
	}
	
	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, persistenceSettings.getPlatformTxManagerBeanName());
           	if (null != txManager) {
               	factory.setTransactionManager(txManager);
               }
       	}
       }
       
       if (!StringUtils.isEmpty(factorySettings.getSchedulerName())) {
       	factory.setSchedulerName(factorySettings.getSchedulerName());
       } else {
       	LOGGER.debug("no SchedulerName configured, using bean name: " + QUARTZ_SCHEDULER_FACTORY_BEAN_NAME);
       }
       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);
       
       if (!CollectionUtils.isEmpty(jobListeners)) {
       	LOGGER.info("configuring " + jobListeners.size() + " job listeners");
       	factory.setGlobalJobListeners(jobListeners.toArray(new JobListener[]{}));
       }
       if (!CollectionUtils.isEmpty(triggerListeners)) {
       	LOGGER.info("configuring " + triggerListeners.size() + " trigger listeners");
       	factory.setGlobalTriggerListeners(triggerListeners.toArray(new TriggerListener[]{}));
       }
       if (!CollectionUtils.isEmpty(schedulerListeners)) {
       	LOGGER.info("configuring " + schedulerListeners.size() + " scheduler listeners");
       	factory.setSchedulerListeners(schedulerListeners.toArray(new SchedulerListener[]{}));
       }
       
       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;
}
 

public JobFactory getJobFactory()  {
    return jobFactory;
}
 

/**
 * @see org.quartz.Scheduler#setJobFactory(org.quartz.spi.JobFactory)
 */
public void setJobFactory(JobFactory factory) throws SchedulerException {
    throw new SchedulerException(
            "Operation not supported for remote schedulers.",
            SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}
 

/**
 * @see org.quartz.Scheduler#setJobFactory(org.quartz.spi.JobFactory)
 */
public void setJobFactory(JobFactory factory) throws SchedulerException {
    throw new SchedulerException(
            "Operation not supported for remote schedulers.",
            SchedulerException.ERR_UNSUPPORTED_FUNCTION_IN_THIS_CONFIGURATION);
}
 

public JobFactory getJobFactory()  {
    return jobFactory;
}
 

public void setJobFactory(JobFactory factory) throws SchedulerException {
	scheduler.setJobFactory(factory);
}
 

/**
 * @see org.quartz.Scheduler#setJobFactory(org.quartz.spi.JobFactory)
 */
public void setJobFactory(JobFactory factory) throws SchedulerException {
    throw new SchedulerException(
            "Operation not supported for remote schedulers.");
}
 

/**
 * @see org.quartz.Scheduler#setJobFactory(org.quartz.spi.JobFactory)
 */
public void setJobFactory(JobFactory factory) throws SchedulerException {
    sched.setJobFactory(factory);
}
 

/**
 * @see org.quartz.Scheduler#setJobFactory(org.quartz.spi.JobFactory)
 */
public void setJobFactory(JobFactory factory) throws SchedulerException {
    throw new SchedulerException("Operation not supported for remote schedulers.");
}
 

@Override
public void setJobFactory(JobFactory factory) throws SchedulerException {
    throw new UnsupportedOperationException();
}
 

@Bean
public Scheduler scheduler(JobFactory jobFactory) {
    return schedulerFactoryBean(jobFactory).getScheduler();
}
 

public CdiAwareJobFactory()
{
    String defaultJobFactoryName = SchedulerBaseConfig.JobCustomization.DEFAULT_JOB_FACTORY_CLASS_NAME;

    defaultFactory = ClassUtils.tryToInstantiateClassForName(defaultJobFactoryName, JobFactory.class);
}
 

public void setJobFactory(JobFactory factory) throws SchedulerException {

        if(factory == null) {
            throw new IllegalArgumentException("JobFactory cannot be set to null!");
        }

        getLog().info("JobFactory set to: " + factory);

        this.jobFactory = factory;
    }
 

public void setJobFactory(JobFactory factory) throws SchedulerException {

        if(factory == null) {
            throw new IllegalArgumentException("JobFactory cannot be set to null!");
        }

        getLog().info("JobFactory set to: " + factory);

        this.jobFactory = factory;
    }
 

/**
 * <p>
 * Set the <code>JobFactory</code> that will be responsible for producing 
 * instances of <code>Job</code> classes.
 * </p>
 * 
 * <p>
 * JobFactories may be of use to those wishing to have their application
 * produce <code>Job</code> instances via some special mechanism, such as to
 * give the opportunity for dependency injection.
 * </p>
 * 
 * @see org.quartz.spi.JobFactory
 */
void setJobFactory(JobFactory factory) throws SchedulerException;
 

/**
 * Set the Quartz JobFactory to use for this Scheduler.
 * <p>Default is Spring's {@link AdaptableJobFactory}, which supports
 * {@link java.lang.Runnable} objects as well as standard Quartz
 * {@link org.quartz.Job} instances. Note that this default only applies
 * to a <i>local</i> Scheduler, not to a RemoteScheduler (where setting
 * a custom JobFactory is not supported by Quartz).
 * <p>Specify an instance of Spring's {@link SpringBeanJobFactory} here
 * (typically as an inner bean definition) to automatically populate a job's
 * bean properties from the specified job data map and scheduler context.
 * @see AdaptableJobFactory
 * @see SpringBeanJobFactory
 */
public void setJobFactory(JobFactory jobFactory) {
	this.jobFactory = jobFactory;
	this.jobFactorySet = true;
}
 

/**
 * Set the Quartz {@link JobFactory} to use for this Scheduler.
 * <p>Default is Spring's {@link AdaptableJobFactory}, which supports
 * {@link java.lang.Runnable} objects as well as standard Quartz
 * {@link org.quartz.Job} instances. Note that this default only applies
 * to a <i>local</i> Scheduler, not to a RemoteScheduler (where setting
 * a custom JobFactory is not supported by Quartz).
 * <p>Specify an instance of Spring's {@link SpringBeanJobFactory} here
 * (typically as an inner bean definition) to automatically populate a job's
 * bean properties from the specified job data map and scheduler context.
 * @since 2.0
 * @see AdaptableJobFactory
 * @see SpringBeanJobFactory
 */
public void setJobFactory(JobFactory jobFactory) {
	this.jobFactory = jobFactory;
	this.jobFactorySet = true;
}