Example of implementation of Spring+quartz

There is a problem in my friend’s project. His side is based on Spring architecture and has a relatively simple task that requires scheduled execution. After understanding his needs, he proposed a relatively simple Spring+quartz implementation.

Note that this article only discusses how to complete the simplest scheduled tasks under the completed Spring project.

The first step is to know the Spring architecture, which is very interesting and interesting. The effect of freely plugging and unplugging functional modules can be achieved. The project is based on MAVEN package dependency management, so list the required dependency package references this time:

 1 <!-- 定时器依赖 开始 --> 2 <dependency> 3 <groupid>org.springframework</groupid> 4 <artifactid>spring-context-support</artifactid> 5 <version>4.0.2.RELEASE</version> 6 </dependency> 7  8   9 10 <dependency>11 <groupid>org.quartz-scheduler</groupid>12 <artifactid>quartz</artifactid>13 <version>2.2.1</version>14 </dependency>15 <!-- 定时器依赖 结束 -->

Of course, this must match the corresponding Spring version. . Our project here is 4.0.2. The previous package spring-context-support is mainly used as a component for communication and management between Spring and quartz. If it is commented out, an error like this will be reported

Configure in MAVEN After completing the packages that need to be added (other packages will not be discussed here for the time being, this article only discusses the configuration under the complete Spring project), we can start to add functional modules for scheduled tasks to this project.

The second step is to start from the origin of the web project and make changes in web.xml. Since the Spring configuration file of the original project was Spring-mvc.xml, I changed the configuration file of the scheduled task to spring-time.xml. In this way, the same scan configuration can be read at startup. The specific code is as follows:

1 <context-param>2         <param-name>contextConfigLocation</param-name>3         <param-value>classpath:spring-*.xml</param-value>4     </context-param>

Then to show you my engineering structure:

#qi You will know how to call it. After achieving this step, we can continue to move forward;

The third step is to complete the core configuration of spring-timer.xml, a scheduled task. In this file configuration, we mainly complete three things:

1. Configure startup settings, regarding lazy loading (to put it simply, for example, initializing a certain variable to null is also a kind of lazy loading, That is, after the service is started, it will only be instantiated when it is actually called. Otherwise, it will not exist in the memory. It can only save logical space, but it may also cause the problem to be discovered after a long delay. , will not be explained in detail here), and the configuration of the trigger;

2. The configuration of quartz-2.x includes the name of the job to be called after the scheduled task is triggered, and the corn expression (i.e. the scheduled Expression controls the reason why the program is executed repeatedly. This time, I will add the content about cron expression later);

3. Configure the content of the job and the specific class corresponding to the job.

Okay, now that the explanation of the logical process is complete, here’s the code:

 1 <?xml  version="1.0" encoding="UTF-8"?>   2 <beans>   7    8         <!-- 启动触发器的配置开始 -->   9     <bean>  11         <property>  12             <list>  13                 <ref></ref>  14             </list>  15         </property>  16     </bean>  17     <!-- 启动触发器的配置结束 -->  18   19     <!-- 调度的配置开始 -->  20     <!--  21         quartz-1.8以前的配置   
22     <bean id="myJobTrigger"  
23         class="org.springframework.scheduling.quartz.CronTriggerBean">  
24         <property name="jobDetail">  
25             <ref bean="myJobDetail" />  
26         </property>  
27         <property name="cronExpression">  
28             <value>0/1 * * * * ?</value>  
29         </property>  
30     </bean>  
31     -->  32     <!-- quartz-2.x的配置 -->  33     <bean>  35         <property>  36             <ref></ref>  37         </property>  38         <property>  39         40         <value>0/10 * *  * * ?</value>41           <!--   <value>1 52 * * * ?</value>  --> 42         </property>  43     </bean>  44     <!-- 调度的配置结束 -->  45   46     <!-- job的配置开始 -->  47     <bean>  49         <property>  50             <ref></ref>  51         </property>  52         <property>  53             <value>work</value>  54         </property>  55     </bean>  56     <!-- job的配置结束 -->  57   58     <!-- 工作的bean -->  59     <bean></bean>  60   61 </beans>

After completing the configuration file configuration here, you can start the next step, specifically The business logic is implemented;

The fourth step is to implement the specific business logic.

What should be noted here is the two points in the picture below

The picture above is specific The name of the business implementation class must be the same as the scheduled task configuration in the figure below.

After completing the above, we can start the project to see the actual effect.

##You can see here that the scheduled task is executed every 10 seconds according to the 0/10 * * * * ? we previously configured in the configuration One time it came running.

                                           

It should be noted that in the process of implementing this method, I encountered repeated execution. It was executed twice at the same time. The reason found later was that when configuring web.xml, the scheduled task was repeatedly configured, which caused it to be executed multiple times. If you encounter this situation, you can refer to my solution.

There will be two articles next, one is a simpler implementation method of writing scheduled tasks, and the other explains cron expressions.

The above is the detailed content of Example of implementation of Spring+quartz. For more information, please follow other related articles on the PHP Chinese website!