Scheduling in Spring.

 

Pure annotation based approach.

Let us use pure Java based configuration. No web.xml. No Spring configuration xml.

I am going to use maven to create a project for me eclipse.

Here are my dependencies from pom.xml

      <dependencies>

                   <dependency>

                             <groupId>org.springframework</groupId>

                             <artifactId>spring-webmvc</artifactId>

                             <version>4.3.7.RELEASE</version>

                   </dependency>

                   <dependency>

                             <groupId>javax.servlet</groupId>

                             <artifactId>javax.servlet-api</artifactId>

                             <version>3.1.0</version>

                   </dependency>

                   <dependency>

                             <groupId>junit</groupId>

                             <artifactId>junit</artifactId>

                             <version>3.8.1</version>

                             <scope>test</scope>

                   </dependency>

          </dependencies>

Set the packaging as war

          <packaging>war</packaging>

Since there is going to be no web.xml, we need to tell this to maven, so that maven generates the war file for us regardless of the present of deployment descriptor file. So set <failOnMissingWebXml> to false in maven-war-plugin configuration.

      <build>

                   <finalName>springscheduler</finalName>

                   <plugins>

                             <plugin>

                                      <groupId>org.apache.maven.plugins</groupId>

                                      <artifactId>maven-war-plugin</artifactId>

                                      <version>2.5</version>

                                      <configuration>

                                                <failOnMissingWebXml>false</failOnMissingWebXml>

                                      </configuration>

                             </plugin>

                     </plugins>

          </build>

@Configuration

@ComponentScan(basePackages="com.rizwan.test")

@EnableScheduling

public class AppConfig {

}

@EnableScheduling annotation enables Spring's scheduled task execution capability, similar to functionality found in Spring's <task:*> XML namespace. To be used on @Configuration classes. Without @EnableScheduling @Schedule annotation would have no effect. It is the xml equivalent of <task:annotation-driven />. Just as without <task:annotationdriven /> scheduling wont happen, similarly without @EnableScheduling scheduling won’t happen.

The Java configuration class decorated with @Configuration annotation. This class eliminates the need for spring configuration.

Taken straight from Javadoc of @Configuration annotation: @Configuration Indicates that a class declares one or more @Bean methods and may be processed by the Spring container to generate bean definitions and service requests for those beans at runtime.

The AppConfig class here is empty. Note the presence of @ComponentScan annotation. It configures component scanning for use with @Configuration. Thus for classes annotated with @Service, @Controller, @Component, @RESTController, @Repository, etc, a bean will be created automatically and registered in the spring application context.

public interface Work {

          public void work();

}

@Component("synch")

public class SynchWorker implements Work {

          public void work() {

                   System.out.println("Doing some work");

          }

}

Work interface and its implementation represents a Spring component for doing any work.

@Service

public interface RefreshTokenService {

          public void refreshToken();

}

@Service

public class RefreshTokenServiceImpl implements RefreshTokenService {

          @Autowired

          @Qualifier("synch")

          private SynchWorker worker;

          public SynchWorker getWorker() {

                   return worker;

          }

          public void setWorker(SynchWorker worker) {

                   this.worker = worker;

          }

          /*

             * fixedDelay - Execute the annotated method with a fixed period in

             * milliseconds between the end of the last invocation and the start of the

             * next.

             *

             * fixedRate - Execute the annotated method with a fixed period in

             * milliseconds between invocations.

             *

             * initialDelay - Number of milliseconds

             * to delay before the first execution of a fixedRate() or fixedDelay()

             * task.

             */

          @Scheduled(fixedDelay = 1000, initialDelay = 1000)

          public void refreshToken() {

                  

                   worker.work();

          }

}

Note that method decorated with @Scheduled annotation must return void and must not accept any arguments.

Here the scheduling is happening synchronously. This means unless the previous task is completed, next run of the task won’t start. It will simply wait for the previous task to complete.

In the asynchronous scheduling next task will start irrespective of whether previous task has finished. Next task will be typically started in a new thread.

For asynchronous scheduling, use the @Async annotation.

        @Scheduled(fixedDelay = 1000, initialDelay = 1000)

        @Async

          public void refreshToken() {

                  

                   worker.work();

          }

@Scheduled and @Async annotations can be applied on both refreshToken method of Service class as well as work method of the Worker component.