Annotation Support for Scheduling and Asynchronous Execution

In the previous post Task Execution and Scheduling in Spring, I explained basic interfaces for task execution and scheduling. In this post I shall demonstrate an example for the same using annotations @Scheduled and @Async. Let us have working Eclipse IDE in place and follow the steps to create a scheduled Spring application:

1. Create a project: Create a project with a name SpringScheduler and create a package com.javabeat under the src directory in the created project.
2. Add Libraries: Add required Spring libraries using Add External JARs option as explained in the article Customizing callback methods. Along with these libraries also add aopalliance-1.0.jar to the build path.
3. Create source files: Create Java classes SchedulerSample,TaskSample and MainApp under the com.javabeat package.
4. Create configuration file: Create XML based configuration file Beans.xml under src directory.

follow us on @twitter and @facebook

• Spring Framework Books
• Spring Tutorials ( Collection for Spring reference tutorials)
• Spring Framework Interview Questions
• Introduction to Spring LDAP
• How to write Custom Spring Callback Methods?

The content of SchedulerSample.java file are:

[java]
package com.javabeat;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class SchedulerSample {

@Autowired
private TaskSample task;

@Scheduled(fixedDelay = 3000)
public void processScheduledJob() {
task.execute();
}

public TaskSample getTask() {
return task;
}

public void setTask(TaskSample task) {
this.task = task;
}
}
[/java]

Here you can note that we have scheduled the task for a time of 3000 milliseconds.

The content of TaskSample.java file are:

[java]
package com.javabeat;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class TaskSample {
@Async
public void execute() {
System.out
.println("Executing asynchronous task for every fixedDelay of 3000millisecond.");
}
}
[/java]

The execute() method will be called every 3000 milliseconds.

The content of Beans.xml file are:

[java]
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">

<context:component-scan base-package="com.javabeat" />

<task:annotation-driven executor="executor" scheduler="scheduler" />

<task:executor id="executor" pool-size="5" />

<task:scheduler id="scheduler" pool-size="5" />

</beans>
[/java]

Here we need to note few things:

• To enable the annotation driven scheduling we have added the annotation-driven element from the task namespace.
• Schema http://www.springframework.org/schema/task, http://www.springframework.org/schema/task/spring-task-3.0.xsd, are added to the above file.
• task:executor – creates an instance of ThreadPoolTaskExecutor.
• task:scheduler – creates an instance of ThreadPoolTaskScheduler.

To execute the application the MainApp.java is as follows:

[java]
package com.javabeat;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
public static void main(String[] args) {
new ClassPathXmlApplicationContext("Beans.xml");
}
}
[/java]

Execute the code

The final step is run the application. Once all the above code is ready execute and the below output appears on the console:

[java]
Executing asynchronous task for every fixedDelay of 3000millisecond.
Executing asynchronous task for every fixedDelay of 3000millisecond.
[/java]

As you can see the message is printed at a delay of 3000millisecond. You need to stop the application to stop the printing of message.

Summary

In this section I demonstrated an example of scheduling the Spring application using the annotation.If you are interested in receiving the future articles, please subscribe here. follow us on @twitter and @facebook