Spring Integrated Quartz

Catalogue [-]

• One, Spring creates jobdetail two ways
• Ii. Integration Method An example step
• 1. Import the spring core jar packages, Quartz.jar, and Spring-context-support.jar into the classpath.
• 2, write the Job class Punchjob (the class must inherit Quartzjobbean)
• 3. Write Quartz.xml configuration file
• 4. Let the container load Quartz.xml
• 5, configure the Quartz environment: Quartz.properties file (placed under the classpath)
• Third, the matters needing attention

One, Spring creates jobdetail two ways

Timing task two ways, Spring good package use quartz details, the first way is to use the Spring package Quartz class for the implementation of specific methods, the second is through the transparent use of quartz to achieve the purpose of timing task development, generally speaking the second kind of developers more convenient!

Configuring spring's task Scheduling abstraction layer simplifies task scheduling and provides better scheduling objects on a quartz basis. Spring uses the quartz framework to complete task scheduling and create Quartz's job bean (Jobdetail) in two ways:

1: Use Jobdetailbean to wrap an instance of the Quartzjobbean subclass (that is, the job class).

2: Use the Methodinvokingjobdetailfactorybean factory bean to wrap generic Java objects (that is, the job class).

Description

1: Use the first method to create the job class, you must inherit Quartzjobbean, implement Executeinternal (Jobexecutioncontext
Jobexecutioncontext) method, which is the executing body of the scheduled task, and then configures the instance of the job class directly into the Jobdetailbean. This method is the same as in normal quartz programming.

2: Use the second method to create the job class, without inheriting the parent class, directly configure the Methodinvokingjobdetailfactorybean. But you need to specify two properties:

TargetObject: Specifies the bean instance that contains the task execution body.

Targetmethod: Specifies that the method of the specified bean instance is wrapped into the execution body of the task.

Ii. Integration Method An example step 1. Import the spring core jar packages, Quartz.jar, and Spring-context-support.jar into the classpath.

Do not forget to import Spring-context-support-3.2.0.m2.jar: This is because this approach is implemented using the spring-encapsulated quartz class for a specific method.

The two JobDetail:org.springframework.scheduling.quartz.JobDetailBean we used. and Org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;

Trigger: Org.springframework.scheduling.quartz.CronTriggerBean The Scheduler: Org.springframework.scheduling.quartz.SchedulerFactoryBean is sourced from this jar package.

2, write the Job class Punchjob (the class must inherit Quartzjobbean)

[Java] View plain copy

2. Package org.crazyit.hrsystem.schedule;
6. Import Java.util.Date;
8. Import Org.springframework.scheduling.quartz.QuartzJobBean;
10. Import Org.quartz.JobExecutionContext;
12. Import org.quartz.JobExecutionException;
16. Import Org.crazyit.hrsystem.service.EmpManager;
20. public class Punchjob
22. Extends Quartzjobbean
24. {
26. Flag that determines whether the job is executed
28. Private Boolean isrunning = false;
30. The business logic component on which the job class depends
32. Private Empmanager empmgr;
34. public void Setempmgr (Empmanager empmgr)
36. {
38. This.empmgr = Empmgr;
40. }
42. Define task Execution Body
44. public void Executeinternal (Jobexecutioncontext ctx)
46. Throws Jobexecutionexception
48. {
50. if (!isrunning)
52. {
54. System.out.println ("Start automatic clock-out");
56. IsRunning = true;
58. Invoking the business logic method
60. Empmgr.autopunch ();
62. IsRunning = false;
64. }
66. }
68. }

3. Write Quartz.xml configuration file

[HTML] View plain copy

2. <?xml version= "1.0" encoding= "GBK"?>
4. <!--Specify the schema information for the spring configuration file--
6. <beans xmlns= "Http://www.springframework.org/schema/beans"
8. Xmlns:xsi= "Http://www.w3.org/2001/XMLSchema-instance"
10. xmlns:aop= "HTTP://WWW.SPRINGFRAMEWORK.ORG/SCHEMA/AOP"
12. xmlns:p= "http://www.springframework.org/schema/p"
14. xmlns:tx= "Http://www.springframework.org/schema/tx"
16. Xsi:schemalocation= "Http://www.springframework.org/schema/beans
18. Http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
20. Http://www.springframework.org/schema/tx
22. Http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
24. Http://www.springframework.org/schema/aop
26. Http://www.springframework.org/schema/aop/spring-aop-3.0.xsd "
28. Default-lazy-init= "false" >
32. <!--definition <span style= "font-family: ' Courier New ', ' Courier ';" > A </span> business logic component that inherits the template of a business logic component--
34. <bean id= "Empmanager"
36. Class= "Org.crazyit.hrsystem.service.impl.EmpManagerImpl"
38. parent= "Managertemplate"/>
42. <!--define triggers to manage task beans--
44. <bean id= "Crontriggerpunch"
46. class= "Org.springframework.scheduling.quartz.CronTriggerBean" >
48. <property name= "Jobdetail" >
50. <!--define a task bean in a way that uses nested beans--
52. <bean
54. class= "Org.springframework.scheduling.quartz.JobDetailBean" >
56. <!--the implementation class for the specified task bean--
58. <property name= "Jobclass"
60. Value= "Org.crazyit.hrsystem.schedule.PunchJob"/>
62. <!--inject properties into the task bean--
64. <property name= "Jobdataasmap" >
66. <map>
68. <entry key= "Empmgr" value-ref= "Empmanager"/>
70. </map>
72. </property>
74. </bean>
76. </property>
78. <!--specify cron expression: Monday to Friday 7 o'clock, 12-point schedule--
80. <property name= "Cronexpression"
82. Value= "0 0 7,12? * Mon-fri "/>
84. </bean>
86. <!--perform the actual scheduler--
88. <bean
90. class= "Org.springframework.scheduling.quartz.SchedulerFactoryBean" >
92. <property name= "Triggers" >
94. <list>
96. <ref bean= "Crontriggerpunch" ></ref>
98. <!--<ref local= "Crontriggerpunch"/> Both can be used--
100. </list>
102. </property>
104. </bean>
106. </beans>

Job Data Map (JOBDATAASMAP) can be obtained through jobexecutioncontext (execution-time delivery). Jobdetailbean map the properties of the job data map to the job's properties. As the example shows, if the job class Punchjob contains a empmgr attribute, Jobdetailbean is automatically injected into the instance of the job class Punchjob and can be used to pass parameters. If it is not stated, it will be reported
Java.lang.NullPointerException error, mainly because no bean was injected.

In the above configuration we let the trigger and the task nesting, in fact, we can also separate them, shape such as:

<!--define Jobdetail beans--

<bean id= "Saveprojectjob"
class= "Org.springframework.scheduling.quartz.JobDetailBean" >

<!--define the job's bean--

<property name= "Jobclass" >
<value>
Com.gresoft.fileupload.service.ParseFileQuartz
</value>
</property>

<!--define the other beans referenced in the job's bean--

<property name= "Jobdataasmap" >
<map>
<entry key= "Readxmlservice" >
<ref bean= "Readxmlservice"/>
</entry>
</map>
</property>
</bean>

<!--------------------------------------------------------------->

<!--The bean that defines the trigger--

<bean id= "Savecron"
class= "Org.springframework.scheduling.quartz.CronTriggerBean" >

<!--designation Jobdetail --

<property name= "Jobdetail" >

<!--<ref bean= "Saveprojectjob" ></ref> both can be used--

<ref local= "Saveprojectjob"/>
</property>

<!--Specify the time that the task fires--

<property name= "Cronexpression" >
<VALUE>0/30 * * * *?</value>
</property>
</bean>

4. Let the container load Quartz.xml

Add in Web. xml:

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/web-inf/applicationcontext.xml,/web-inf/quartz.xml</param-value>
</context-param>

# # # #其实quartz the contents of the. xml file can be written in applicationcontext.xml, but it will appear cluttered.

5, configure the operating environment of the quartz: quartz.propertiesFile (placed under Classpath)

File name must be called this name, in fact, this file we can also not configure.

[HTML] View plain copy

The
1. #  configures the main scheduler property   
2. Org.quartz.scheduler.instancename = quartzscheduler   
3. org.quartz.scheduler.instanceid  = auto  
4. #  Configuring the thread pool   
5. # quartz thread pool implementation class   
6. org.quartz.threadpool.class =  org.quartz.simpl.simplethreadpool  
7. the number of threads in the #  thread pool   
8. org.quartz.threadpool.threadcount = 1  
9. #  Line constructor thread priority   
10. org.quartz.threadpool.threadpriority = 10  
11. #  Configure job store   
12. org.quartz.jobstore.misfirethreshold = 60000  
13. org.quartz.jobstore.class =  org.quartz.simpl.ramjobstore  

If we do not configure this file, the default is to use the Quartz.properties file in Quartz-2.1.6.jar (under the Org/quartz path of the compressed file), if you need to change its run properties, We can create a quartz.properties file ourselves and place the file under the classpath of the system load, and ClassLoader will automatically load and enable the various properties.

Third, the matters needing attention

Two points to note when you configure and quartz integrated content in spring
1, in <Beans> can not set default-lazy-init= "true", otherwise the scheduled task does not trigger, if not explicitly indicate the value of Default-lazy-init, the default is False.
2, in <Beans> can not set the Default-autowire= "ByName" Properties, Otherwise the org.springframework.beans.factory.BeanCreationException error will be reported in the background, so that it cannot be injected automatically through the bean name and must be injected by explicit reference

Original address: http://blog.csdn.net/yuanlaishini2010/article/details/8874991

Spring Integrated Quartz