A Quick Note on Job Configuration
Before we show the API that you use for Quartz and Obsidian, first I’ll mention that using an API typically isn’t the best approach to scheduling a job. Quartz provides a mechanism to configure jobs via XML, and Obsidian provides a full administration and monitoring web application for you to schedule jobs.
However, some use cases definitely suggest API integration, so lets move forward with that.
Let’s see what scheduling a job to run every half hour looks like in Quartz.
// First, create the scheduler SchedulerFactory sf = new StdSchedulerFactory(); Scheduler scheduler = sf.getScheduler(); // Build up the job detail JobDetail job = JobBuilder.newJob(HelloWorld.class) .withIdentity("HelloWorldJob", "HelloWorldGroup") .build(); // Add some configuration job.getJobDataMap().put("planet", "Earth"); // Create the scheduler CronScheduleBuilder schedule = CronScheduleBuilder.cronSchedule("* 0/30 * * * ?"); // Create the trigger CronTrigger trigger = TriggerBuilder.newTrigger() .withIdentity("HelloWorldTrigger", "HelloWorldGroup") .withSchedule(schedule) .build(); // Schedule the job with the created trigger. scheduler.scheduleJob(job, trigger); scheduler.start(); // This is how you start the scheduler itself if you need to // Later, we can shut down the scheduler scheduler.shutdown();
As you can see, first you have to get a handle on the scheduler instance (or create it), then you create the
CronTrigger, and then you can finally schedule the job itself.
There are a few seemingly superfluous steps here, and some extraneous properties like job identities, trigger names, trigger groups, etc. that you have to provide, but this is the basic template you’d use.
Now let’s see how it’s done in Obsidian. We are using the same job class (let’s assume it satisfies both Quartz and Obsidian’s job interfaces), and we’ll use the same every-half-hour schedule.
// Create our configuration parameters List<ConfigurationParameter> parameters = Arrays.asList( new ConfigurationParameter().withName("planet") .withType(ParameterType.STRING) .withValue("Earth") ); // Set up the job configuration JobCreationRequest request = new JobCreationRequest() .withNickname("HelloWorld") .withJobClass(HelloWorld.class.getName()) .withState(JobStatus.ENABLED) .withSchedule("* 0/30 * * *") .withRecoveryType(JobRecoveryType.LAST) // how to recover failed jobs .withParameters(parameters); // Now actually save this configurations, which becomes active on all schedulers. JobDetail addedJob = new JobManager().addJob(request, "Audit User"); System.out.println("Added new job: " + addedJob ); // If you need to start an embedded scheduler, use this line to initialize it. SchedulerStarter scheduler = SchedulerStarter.get(SchedulerMode.EMBEDDED); // Later, we can gracefully shut down the scheduler scheduler.shutDown();
As you can see, Obsidian keeps things simple and does away with extraneous properties which don’t help you develop and manage your jobs. You simply create a
JobCreationRequest with the required fields above, including any
ConfigurationParameters, and call
JobManager.addJob() with the job configuration and an optional audit user, which is used to track changes.
This API call saves your configuration to the Obsidian database, so it is instantly propagated to all schedulers in your cluster, and it outlives restarts. Many of our users take advantage of this API to perform one-time initialization of job schedules, after which they use our powerful web application to make changes as they are required.
This API was carefully designed to expose the powerful features our users demand, while still remaining simple to use. This sample will give you the basic template for how to schedule a job in Obsidian, but if you need more detail or want to use other extended features, you can check out our full Embedded API documentation.