We Keep Coding

How to always start a new job instance for each run when using spring batch with spring boot?

While using spring batch with spring boot, we will get a fat jar which contains all of my spring batch jobs, I want to be able to trigger a specific job from the command line by specifying the job name, the problem is that spring batch detects the job completed, so it will only run the job once, with spring boot, we can specify the name using --spring.batch.job.names=jobToRun, the problem is how can I make it always start a new instance and still be able to use this mechanism to pass a job name to run.
I didn't configure a JobLauncher, so I guess it's using the default JobLauncherCommandLineRunner, All I currently configured is:
#SpringBootApplication
#EnableBatchProcessing
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
With this configuration, I can run the job from the command line:
java -jar batch.jar --spring.batch.job.names=job1ToRun
How can I start a new instance for every run with a similiar mechanism? I need to specify a job name from the command line to choose a job to run.

From the spring-batch documentation
The CommandLineJobRunner
Because the script launching the job must kick off a Java Virtual Machine, there needs to be a class with a main method to act as the primary entry point. Spring Batch provides an implementation that serves just this purpose: CommandLineJobRunner. It's important to note that this is just one way to bootstrap your application, but there are many ways to launch a Java process, and this class should in no way be viewed as definitive. The CommandLineJobRunner performs four tasks:
Load the appropriate ApplicationContext
Parse command line arguments into JobParameters
Locate the appropriate job based on arguments
Use the JobLauncher provided in the application context to launch the job.
A very basic example of how you could do this:
public static void main(String[] args) throws Exception {
ConfigurableApplicationContext ctx = SpringApplication.run(Application.class, args);
JobLauncher jobLauncher = ctx.getBean(JobLauncher.class);
String jobName = args[0] // assuming args[0] is the jobName
JobParameters jobParameters = createJobParameters(args)
Job jobInstance = ctx.getBean(jobName, Job.class);
jobLauncher.run(jobInstance, jobParameters);
}
private static JobParameters createJobParameters(String[] args) {
// TODO: Create & return the needed parameters
}

java scheduler spring vs quartz

Currently I am building a spring standalone program in order to learn new methods and architectures.
The last few days I tried to learn scheduler. I never used them before so I read some articles handling the different possible methods. Two of them are especially interesting: The spring nativ #Scheduler and Quartz.
From what I read, Spring is a little bit smaller then Quartz and much more basic. And quartz is not easy to use with spring (because of the autowired and components).
My problem now is, that there is one thing I do not understand:
From my understanding, both methods are creating parallel Threads in order to asynchronously run the jobs. But what if I now have a spring #Service in my main Application, that is holding a HashMap with some information. The data is updated and changed with user interaction. Parallel there are the scheduler. And a scheduler now whants to use this HashMap from the main application as well. Is this even possible?
Or do I understand something wrong? Because there is also the #Async annotation and I did not understand the difference. Because a scheduler itself is already parallel to the main corpus, isn't it?
(summing up, two questions:
can a job that is executed every five seconds, implemented with a scheduler, use a HashMap out of a service inside the main program? (in spring #Scheduler and/or in Quartz?)
Why is there a #Async annotation. Isn't a scheduler already parallel to the main process?
)

I have to make a few assumptions about which version of Spring you're using but as you're in the process of learning, I would assume that you're using spring-boot or a fairly new version, so please excuse if the annotations don't match your version of Spring. This said, to answer your two questions the best I can:
can a job that is executed every five seconds, implemented with a scheduler, use a HashMap out of a service inside the main program? (in spring #Scheduler and/or in Quartz?)
Yes, absolutely! The easiest way is to make sure that the hashmap in question is declared as static. To access the hashmap from the scheduled job, simply either autowire your service class or create a static get function for the hashmap.
Here is an example of a recent Vaadin project where I needed a scheduled message sent to a set of subscribers.
SchedulerConfig.class
#Configuration
#EnableAsync
#EnableScheduling
public class SchedulerConfig {
#Scheduled(fixedDelay=5000)
public void refreshVaadinUIs() {
Broadcaster.broadcast(
new BroadcastMessage(
BroadcastMessageType.AUTO_REFRESH_LIST
)
);
}
}
Broadcaster.class
public class Broadcaster implements Serializable {
private static final long serialVersionUID = 3540459607283346649L;
private static ExecutorService executorService = Executors.newSingleThreadExecutor();
private static LinkedList<BroadcastListener> listeners = new LinkedList<BroadcastListener>();
public interface BroadcastListener {
void receiveBroadcast(BroadcastMessage message);
}
public static synchronized void register(BroadcastListener listener) {
listeners.add(listener);
}
public static synchronized void unregister(BroadcastListener listener) {
listeners.remove(listener);
}
public static synchronized void broadcast(final BroadcastMessage message) {
for (final BroadcastListener listener: listeners)
executorService.execute(new Runnable() {
#Override
public void run() {
listener.receiveBroadcast(message);
}
});
}
}
Why is there a #Async annotation. Isn't a scheduler already parallel to the main process?
Yes, the scheduler is running in its own thread but what occurs to the scheduler on long running tasks (ie: doing a SOAP call to a remote server that takes a very long time to complete)?
The #Async annotation isn't required for scheduling but if you have a long running function being invoked by the scheduler, it becomes quite important.
This annotation is used to take a specific task and request to Spring's TaskExecutor to execute it on its own thread instead of the current thread. The #Async annotation causes the function to immediately return but execution will be later made by the TaskExecutor.
This said, without the #EnableAsync or #Async annotation, the functions you call will hold up the TaskScheduler as they will be executed on the same thread. On a long running operation, this would cause the scheduler to be held up and unable to execute any other scheduled functions until it returns.
I would suggest a read of Spring's Documentation about Task Execution and Scheduling It provides a great explanation of the TaskScheduler and TaskExecutor in Spring

how to suspend job in quartz scheduler?

Hi i am creating an application that executes the method of a class based on a cron expression. For that i am using spring quartz in which i have to configure all these stuffs in my spring-file it works fine and jobs are executing based on the cron expression, But now i want to suspend the next execution of particular job in java class based on the choice of a user from UI. Then is there any way to do this ??
can i get the details of all running job it the context ? if so then i can filter the jobs and try to suspend that job for next execution.

Inject your SchedulerFactoryBean. Use it's getScheduler method to obtain a quartz Scheduler and use rescheduleJob or other methods from quartz API to perform your task.

I got it work by use of following code
stdScheduler is a scheduleFactoryBean
String groupnames[] = stdScheduler.getJobGroupNames();
for (String groupName : groupnames) {
String[] jobNames = stdScheduler.getJobNames(groupName);
for (String jobName : jobNames) {
if (jobName.equals("jobName")) {
stdScheduler.pauseJob(jobName, groupName);
}
}
}

We can use the stdScheduler.pauseJob(JobKey jobKey) method to reduce the number of loops mentioned in the code above

If you got hold of the SchedulerFactoryBean by injection or somehow else there are the convenience methods:
schedulerFactoryBean.getScheduler().standby();
schedulerFactoryBean.getScheduler().start();
When using Quartz directly also this works:
#Autowired
private Scheduler scheduler;
...
scheduler.standby();
...
scheduler.start();

Using Hibernate session with quartz

I've a web application which uses framework like Struts and Hibernate. Currently I'm developing a scheduler for this application using Quartz. While coding I realized that the use of Hibernate session is not possible with the threads of Quartz.
Anybody have a solution for using hibernate sessions from quartz job class?

One approach is to use a HibernateUtil class which builds the SessionFactory in a static initializer and makes it available via a public static getter. Your Quartz job can create a Session as HibernateUtil.getSessionFactory().getCurrentSession() and use it.

I know this is an old question, but I did a quick Google search, and this was the first hit.
In the quartz job, add this line at the start of the method:
public void execute(JobExecutionContext context) throws JobExecutionException
{
SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this); //<-- this line
//...your code here...
}
I apologize if this doesn't fix your specific issue, but I suspect it will catch someone in the future.

Searching for "Quartz Hibernate" returned this. Coming to a different solution (and using Tapestry), I thought I'd share it.
when scheduling the Job:
…
Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
JobDataMap myJobDataMap = new JobDataMap();
myJobDataMap.put("HibernateSessionManager", hibernateSessionManager);
myJobDataMap.put("PerthreadManager", perThreadManager);
JobDetail job = JobBuilder.newJob(SomeJob.class).withIdentity(
"SomeJob", "someGroup").setJobData(
myJobDataMap).build();
Trigger trigger = TriggerBuilder.newTrigger().withIdentity(
"Some Trigger", "someGroup").startNow().withSchedule(
SimpleScheduleBuilder.repeatSecondlyForever(30)).build();
scheduler.scheduleJob(job, trigger);
scheduler.start();
…
and in the Job
public void execute(JobExecutionContext context)
throws JobExecutionException
{
JobDataMap jdm = context.getMergedJobDataMap();
HibernateSessionManager hibernateSessionManager = (HibernateSessionManager) jdm.get("HibernateSessionManager");
PerthreadManager perThreadManager = (PerthreadManager) jdm.get("PerthreadManager");
Session session = hibernateSessionManager.getSession();
//do stuff with session …
//now clean up, otherwise I ended up with <IDLE> in transactions
perThreadManager.cleanUp();
}
Hope somebody can use this.

You can look at the below link to see if it gives you a direction to follow. Since you are not using Spring, it might be hard to apply this directly
http://forum.springsource.org/showthread.php?t=12117

Timing quartz task execution duration

Is there a standard way of logging the time Quartz takes to execute a task? I'm open to Spring based solutions as well, as I'm using both.

You can use a general purpose timing library, such as ERMA. It integrates very nicely with spring.

You could implement a JobListener and add it as a global job listener to the scheduler.
This will give you some hooks on when a job is about to be executed and when it has finished executing. You should be able to do something with these hooks to record the start and end times of the jobs, and then log the run time.

You can use a JobListener for that. The execution time of a job is even provided by the context. The Listener need to be added to the used Scheduler:
public class GlobalJobRuntimeListener implements JobListener {
//... other methods to overwrite
#Override
public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
System.out.println("Job with key " + context.getJobDetail().getKey().toString()
+ " finished in " + context.getJobRunTime() + " ms.");
}
}
-
Scheduler scheduler = schedulerFactory.getScheduler();
scheduler.getListenerManager().addJobListener(new GlobalJobRuntimeListener());
scheduler.start();