org.quartz.impl.StdSchedulerFactory#getScheduler ( )源码实例Demo

public DefaultTaskScheduler() {
	StdSchedulerFactory schedFactory = new StdSchedulerFactory();
	Properties props = new Properties();
	props.setProperty("org.quartz.scheduler.instanceName", "DefaultQuartzScheduler");
	props.setProperty("org.quartz.scheduler.rmi.export", "false");
	props.setProperty("org.quartz.scheduler.rmi.proxy", "false");
       props.setProperty("org.quartz.scheduler.wrapJobExecutionInUserTransaction", "false");
       props.setProperty("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
       props.setProperty("org.quartz.threadPool.threadCount", "10");
       props.setProperty("org.quartz.jobStore.misfireThreshold", "60000");
       props.setProperty("org.quartz.jobStore.class", "org.quartz.simpl.RAMJobStore");
	try {
		schedFactory.initialize(props);
		quartz = schedFactory.getScheduler();
	} catch (SchedulerException e) {
		throw new RuntimeException(e);
	}
}
 

public SolrTrackerScheduler(AlfrescoCoreAdminHandler adminHandler)
{
    // TODO: pick scheduler properties from SOLR config or file ...
    try
    {
        StdSchedulerFactory factory = new StdSchedulerFactory();
        Properties properties = new Properties();
        properties.setProperty("org.quartz.scheduler.instanceName", adminHandler.toString());
        properties.setProperty("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
        properties.setProperty("org.quartz.threadPool.threadCount", "40");
        properties.setProperty("org.quartz.threadPool.makeThreadsDaemons", "true");
        properties.setProperty("org.quartz.scheduler.makeSchedulerThreadDaemon", "true");
        properties.setProperty("org.quartz.jobStore.class", "org.quartz.simpl.RAMJobStore");
        properties.setProperty("org.quartz.scheduler.skipUpdateCheck","true");
        factory.initialize(properties);
        scheduler = factory.getScheduler();
        scheduler.start();

    }
    catch (SchedulerException e)
    {
        logError("SolrTrackerScheduler", e);
    }
}
 

@Override
public void init(SourceBean config) {
	StdSchedulerFactory stdSchedFact = new StdSchedulerFactory();
	Properties properties = new Properties();
	try {
		Thread currThread = Thread.currentThread();
		ClassLoader classLoader = currThread.getContextClassLoader();
		InputStream propIs = classLoader.getResourceAsStream("quartz.properties");
		properties.load(propIs);

		String figuredOutValue = null;

		if (properties.containsKey(PROPERTY_DELEGATE_CLASS)) {
			logger.info("Quartz delegate class set to " + properties.get(PROPERTY_DELEGATE_CLASS));
		} else {
			logger.warn("Property " + PROPERTY_DELEGATE_CLASS + " not set! Trying to figure out what delegate class needs to be used...");
			determineDelegateClass(properties);
		}

		stdSchedFact.initialize(properties);
		Scheduler sched = stdSchedFact.getScheduler();
		sched.start();
	} catch (Exception e) {
		SpagoBITracer.major(SpagoBIConstants.NAME_MODULE, this.getClass().getName(), "init", "Error while initializing scheduler " + e);
	}
}
 

public TaskManager(TaskFactory taskFactory) {
    this.taskFactory = taskFactory;
    try {
        StdSchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
        Properties props = new Properties();
        props.put(
                StdSchedulerFactory.PROP_THREAD_POOL_CLASS,
                "org.quartz.simpl.SimpleThreadPool");
        props.put("org.quartz.threadPool.threadCount", "1");
        stdSchedulerFactory.initialize(props);
        scheduler = stdSchedulerFactory.getScheduler();
    } catch (SchedulerException e) {
        logger.error("something wrong with getting scheduler: {}", e.getLocalizedMessage());
    }
}
 

private Scheduler getScheduler() {
    StdSchedulerFactory factory = new StdSchedulerFactory();
    try {
        factory.initialize(getQuartzProperties());
        return factory.getScheduler();
    } catch (final SchedulerException ex) {
        throw new JobSystemException(ex);
    }
}
 

@BeforeEach
void setup() throws SchedulerException {
    initMocks(this);
    stdSchedulerFactory = new StdSchedulerFactory();
    scheduler = stdSchedulerFactory.getScheduler();
    backupScheduler = new BackupScheduler(scheduler, goConfigService, serverHealthService, backupService);
}
 

@Before
public void setUp() throws Exception {
    maintenanceModeService = new MaintenanceModeService(new TimeProvider());
    quartzSchedulerFactory = new StdSchedulerFactory();
    scheduler = quartzSchedulerFactory.getScheduler();
    systemEnvironment = new SystemEnvironment();
    scheduler.start();
}
 

@Override
public void start(String resource) throws Throwable {
	log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
	log.info("timer client component starting, version: " + Version.getVersion());
	log.info("*** Start parsing: " + resource);
	parse(resource);// "config.xml"
	schedulerfactory = new StdSchedulerFactory();
	scheduler = schedulerfactory.getScheduler();
	register();
	scheduler.start();
	log.info("timer client component successfully.");
}
 

public void start() {
    
    StdSchedulerFactory sf = new StdSchedulerFactory();
    try {
        _scheduler = sf.getScheduler();
        _scheduler.start();
        scheduleJobs();
    } catch (SchedulerException e) {
        new RuntimeException("Failed starting job scheduler", e);
    }
}
 

protected void testJobStore(Properties quartzProperties) throws SchedulerException {
    StdSchedulerFactory schedulerFactory = new StdSchedulerFactory();
    schedulerFactory.initialize(quartzProperties);

    Scheduler scheduler = schedulerFactory.getScheduler();
    scheduler.start();

    JobDetail job = getJobDetail("testJob1", "testJobGroup1");
    CronTriggerImpl trigger = getCronTrigger("testTrigger1", "testTriggerGroup1", job.getKey(), "0/5 * * * * ?");

    scheduler.scheduleJob(job, trigger);

    JobDetail retrievedJob = jobStore.retrieveJob(job.getKey());
    assertThat(retrievedJob, not(nullValue()));
    assertThat(retrievedJob.getJobDataMap(), hasKey("timeout"));

    CronTriggerImpl retrievedTrigger = (CronTriggerImpl) jobStore.retrieveTrigger(trigger.getKey());
    assertThat(retrievedTrigger, not(nullValue()));
    assertEquals(trigger.getCronExpression(), retrievedTrigger.getCronExpression());

    scheduler.deleteJob(job.getKey());

    assertThat(jobStore.retrieveJob(job.getKey()), nullValue());
    assertThat(jobStore.retrieveTrigger(trigger.getKey()), nullValue());

    scheduler.shutdown();
}
 

/**
 * 스케줄러 초기화
 * @throws Exception
 * @return void
 */
public void JobInit() throws Exception {
	try {
		if (scheduler != null && scheduler.isStarted())
			return;

		schedulerFactory = new StdSchedulerFactory();
		scheduler = schedulerFactory.getScheduler();
		scheduler.start();
		JobRegist();
	} catch (Exception e) {
		throw e;
	}
}
 

public JobScheduler(BimServer bimServer) {
	try {
		Properties properties = new Properties();
		String instanceName = "UniqueName" + Math.random();
		properties.setProperty("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
		properties.setProperty("org.quartz.threadPool.threadCount", "1");
		properties.setProperty(StdSchedulerFactory.PROP_SCHED_INSTANCE_NAME, instanceName);
		sf = new StdSchedulerFactory(properties);
		sched = sf.getScheduler();
		sched.getContext().put("bimserver", bimServer);
	} catch (SchedulerException e) {
		LOGGER.error("", e);
	}
}
 

public void JobInit() throws Exception {
	try {
		if (scheduler != null && scheduler.isStarted())
			return;

		schedulFactoty = new StdSchedulerFactory();
		scheduler = schedulFactoty.getScheduler();
		scheduler.start();
		JobRegist();
	} catch (Exception e) {
		throw e;
	}
}
 

public Scheduler getScheduler() throws Exception {

		if (scheduler == null) {
			schedulFactoty = new StdSchedulerFactory();
			scheduler = schedulFactoty.getScheduler();
		}
		return scheduler;
	}
 

/**
 * 스케줄러 초기화
 * @throws Exception
 * @return void
 */
public void JobInit() throws Exception {
	try {
		if (scheduler != null && scheduler.isStarted())
			return;

		schedulerFactory = new StdSchedulerFactory();
		scheduler = schedulerFactory.getScheduler();
		scheduler.start();
		JobRegist();
	} catch (Exception e) {
		throw e;
	}
}
 

/**
 * 스케줄러 인스턴스 얻기
 * @throws Exception
 * @return Scheduler
 */
public Scheduler getScheduler() throws Exception {

	if (scheduler == null) {
		schedulerFactory = new StdSchedulerFactory();
		scheduler = schedulerFactory.getScheduler();
	}
	return scheduler;
}
 

public void JobInit() throws Exception {
	try {
		if (scheduler != null && scheduler.isStarted())
			return;

		schedulFactoty = new StdSchedulerFactory();
		scheduler = schedulFactoty.getScheduler();
		scheduler.start();
		JobRegist();
	} catch (Exception e) {
		throw e;
	}
}
 

public Scheduler getScheduler() throws Exception {

		if (scheduler == null) {
			schedulFactoty = new StdSchedulerFactory();
			scheduler = schedulFactoty.getScheduler();
		}
		return scheduler;
	}
 

/** This method will register the quartz scheduler job. */
public void schedule() {
  ProjectLogger.log(
      "SchedulerManager:schedule: Call to start scheduler jobs - org.sunbird.common.quartz.scheduler.SchedulerManager",
      LoggerEnum.INFO.name());

  try {
    Thread.sleep(240000);
    boolean isEmbedded = false;
    Properties configProp = null;
    String embeddVal = System.getenv(JsonKey.SUNBIRD_QUARTZ_MODE);
    if (JsonKey.EMBEDDED.equalsIgnoreCase(embeddVal)) {
      isEmbedded = true;
    } else {
      configProp = setUpClusterMode();
    }
    if (!isEmbedded && configProp != null) {

      StdSchedulerFactory schedulerFactory = new StdSchedulerFactory(configProp);
      ProjectLogger.log("Quartz scheduler is running in cluster mode.", LoggerEnum.INFO.name());
      scheduler = schedulerFactory.getScheduler("MyScheduler");

      if (null == scheduler) {
        Thread.sleep(5000);
        scheduler = schedulerFactory.getScheduler();
      }

      String schedulerName = scheduler.getSchedulerName();
      ProjectLogger.log(
          "Quartz scheduler is running in cluster mode. scheduler Name is: " + schedulerName,
          LoggerEnum.INFO.name());
    } else {
      ProjectLogger.log("Quartz scheduler is running in embedded mode.", LoggerEnum.INFO.name());
      scheduler = new StdSchedulerFactory().getScheduler();
    }
    String identifier = "NetOps-PC1502295457753";

    scheduleBulkUploadJob(identifier);
    scheduleUpdateUserCountJob(identifier);
    scheduleChannelReg(identifier);
    scheduleShadowUser(identifier);

  } catch (Exception e) {
    ProjectLogger.log(
        "SchedulerManager:schedule: Error in starting scheduler jobs - org.sunbird.common.quartz.scheduler.SchedulerManager "
            + e.getMessage(),
        LoggerEnum.ERROR.name());
  } finally {
    registerShutDownHook();
  }
  ProjectLogger.log(
      "SchedulerManager:schedule: started scheduler jobs - org.sunbird.common.quartz.scheduler.SchedulerManager",
      LoggerEnum.INFO.name());
}
 

/**
 * 将会删除通用
 * @param properties
 * @return
 * @throws SchedulerException
 */
public static Scheduler createScheduler(Properties properties) throws SchedulerException {
    StdSchedulerFactory stdSchedulerFactory= new StdSchedulerFactory(properties);
    return stdSchedulerFactory.getScheduler();
}