MyBatis+Spring在注解@Autowried后通过反射的方式调用方法获取注入的Service或DAO对象为空

        最近在做一个定时读取数据的功能，我的想法是能够动态的添加定时任务而不用重启系统，在网上也借阅了很多文章，但是都不够完整，因此通过网上的借鉴我自己整理了一份代码，系统采用的是Spring Boot+MyBatis。

      通过Spring实现定时任务有2种方式：

一、通过注解@Scheduled，如@Scheduled(fixedRate = 1000 * 30)表示30秒执行一次，具体用法可以在网上搜索。

二、通过quartz定时配置，我这里主要是使用的注解，反射等方式实现，可能会不受Spring容器的控制

      maven配置如下(主要部分)：

Xml代码  

1. <dependency>  
2.             <groupId>org.springframework.boot</groupId>  
3.             <artifactId>spring-boot-starter-web</artifactId>  
4.         </dependency>  
5.         <dependency>  
6.             <groupId>org.quartz-scheduler</groupId>  
7.             <artifactId>quartz</artifactId>  
8.             <version>2.2.1</version>  
9.         </dependency>  
10.         <dependency>  
11.             <groupId>org.quartz-scheduler</groupId>  
12.             <artifactId>quartz-jobs</artifactId>  
13.             <version>2.2.1</version>  
14.         </dependency>  
15.   
16.         <dependency>  
17.             <groupId>org.springframework</groupId>  
18.             <artifactId>spring-context-support</artifactId>  
19.         </dependency>  
20.   
21.         <dependency>  
22.             <groupId>com.alibaba</groupId>  
23.             <artifactId>druid</artifactId>  
24.             <version>1.0.11</version>  
25.         </dependency>  
26.   
27.         <dependency>  
28.             <groupId>mysql</groupId>  
29.             <artifactId>mysql-connector-java</artifactId>  
30.         </dependency>  
31.   
32.         <dependency>  
33.             <groupId>org.mybatis.spring.boot</groupId>  
34.             <artifactId>mybatis-spring-boot-starter</artifactId>  
35.             <version>1.0.1</version>  
36.         </dependency>  
37.   
38.         <dependency>  
39.             <groupId>commons-lang</groupId>  
40.             <artifactId>commons-lang</artifactId>  
41.             <version>2.6</version>  
42.         </dependency>  
43.         <dependency>  
44.             <groupId>org.apache.commons</groupId>  
45.             <artifactId>commons-lang3</artifactId>  
46.             <version>3.0</version>  
47.         </dependency>  
48.   
49.         <dependency>  
50.             <groupId>org.springframework.boot</groupId>  
51.             <artifactId>spring-boot-starter-log4j</artifactId>  
52.         </dependency>  
53.   
54. <build>  
55.         <plugins>  
56.             <plugin>  
57.                 <groupId>org.springframework.boot</groupId>  
58.                 <artifactId>spring-boot-maven-plugin</artifactId>  
59.             </plugin>  
60.         </plugins>  
61.     </build>  

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.11</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.0.1</version>
        </dependency>

        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j</artifactId>
        </dependency>

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    数据库的链接方式如下，  配置的application.properties和mybatis.xml文件(这里不清楚为什么如果只是配置xml文件连接数据库启动时会报错，配置在properties文件里就不会，xml也要配置是因为后面通过反射方式读取时需要用到xml配置里的数据库)：

  application.properties：

mybatis.config=classpath:config/mybatis.xml

spring.datasource.name=pump_valve
spring.datasource.url=jdbc:mysql://localhost:3306/pump_valve
spring.datasource.username=root
spring.datasource.password=

# 使用druid数据源
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.filters=stat
spring.datasource.maxActive=20
spring.datasource.initialSize=1
spring.datasource.maxWait=60000
spring.datasource.minIdle=1
spring.datasource.timeBetweenEvictionRunsMillis=60000
spring.datasource.minEvictableIdleTimeMillis=30000
spring.datasource.validationQuery=select 'x'
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
spring.datasource.poolPreparedStatements=true
spring.datasource.maxOpenPreparedStatements=20

mybatis.xml：

Xml代码  

1. <?xml version=“1.0” encoding=“UTF-8”?>  
2. <!DOCTYPE configuration  PUBLIC ”-//ibatis.apache.org//DTD Config 3.1//EN”  
3.         “http://ibatis.apache.org/dtd/ibatis-3-config.dtd”>  
4. <configuration>  
5.     <typeAliases>  
6.         <typeAlias alias=“scheduleJob” type=“com.chinamobile.pumpValve.entity.ScheduleJob”/>  
7.         <typeAlias alias=“equipmentInfo” type=“com.chinamobile.pumpValve.entity.EquipmentInfo” />  
8.         <typeAlias alias=“project” type=“com.chinamobile.pumpValve.entity.Project” />  
9.         <typeAlias alias=“equipmentStatusInfo” type=“com.chinamobile.pumpValve.entity.EquipmentStatusInfo” />  
10.     </typeAliases>  
11.     <environments default=“development”>  
12.     <!– 开发环境数据  –>  
13.         <environment id=“development”>  
14.             <transactionManager type=“jdbc”></transactionManager>  
15.             <dataSource type=“pooled”>  
16.                 <property name=“driver” value=“com.mysql.jdbc.Driver”/>  
17.                 <property name=“url”  
18.                           value=“jdbc:mysql://localhost:3306/pump_valve?useSSL=false&amp;characterEncoding=utf-8”/>  
19.                 <property name=“username” value=“root”/>  
20.                 <property name=“password” value=“”/>  
21.             </dataSource>  
22.         </environment>  
23.     </environments>  
24.   
25.     <mappers>  
26.         <mapper resource=“mapper/scheduleJob.xml”/>  
27.         <mapper resource=“mapper/equipmentInfo.xml” />  
28.         <mapper resource=“mapper/project.xml” />  
29.         <mapper resource=“mapper/equipmentStatusInfo.xml” />  
30.     </mappers>  
31. </configuration>  

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration  PUBLIC "-//ibatis.apache.org//DTD Config 3.1//EN"
        "http://ibatis.apache.org/dtd/ibatis-3-config.dtd">
<configuration>
    <typeAliases>
        <typeAlias alias="scheduleJob" type="com.chinamobile.pumpValve.entity.ScheduleJob"/>
        <typeAlias alias="equipmentInfo" type="com.chinamobile.pumpValve.entity.EquipmentInfo" />
        <typeAlias alias="project" type="com.chinamobile.pumpValve.entity.Project" />
        <typeAlias alias="equipmentStatusInfo" type="com.chinamobile.pumpValve.entity.EquipmentStatusInfo" />
    </typeAliases>
    <environments default="development">
    <!-- 开发环境数据  -->
        <environment id="development">
            <transactionManager type="jdbc"></transactionManager>
            <dataSource type="pooled">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url"
                          value="jdbc:mysql://localhost:3306/pump_valve?useSSL=false&amp;characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value=""/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="mapper/scheduleJob.xml"/>
        <mapper resource="mapper/equipmentInfo.xml" />
        <mapper resource="mapper/project.xml" />
        <mapper resource="mapper/equipmentStatusInfo.xml" />
    </mappers>
</configuration>

   

 

创建一个schedule_job定时任务表，其对应的实体类如下(省略了get/set方法)：

Java代码  

1. public static final String STATUS_RUNNING = “1”;  
2.     public static final String STATUS_NOT_RUNNING = “0”;  
3.     public static final String CONCURRENT_IS = “1”;  
4.     public static final String CONCURRENT_NOT = “0”;  
5.   
6.     private Integer scheduleJobId = null;  
7.     //任务名称  
8.     private String jobName = “”;  
9.     //任务分组  
10.     private String jobGroup = “”;  
11.     //任务状态 是否启动任务  
12.     private String jobStatus = “”;  
13.     //cron表达式,定时任务运行时间  
14.     private String cronExpression = “”;  
15.     //描述  
16.     private String description = “”;  
17.     //任务执行时调用哪个类的方法 包名+类名  
18.     private String beanClass = “”;  
19.     //任务是否有状态  
20.     private String concurrentStatus = “”;  
21.     //spring bean  
22.     private String springId = “”;  
23.     //任务调用的方法名  
24.     private String methodName = “”;  
25.     //定时任务是否有效  
26.     private String enableFlag = “”;  

public static final String STATUS_RUNNING = "1";
    public static final String STATUS_NOT_RUNNING = "0";
    public static final String CONCURRENT_IS = "1";
    public static final String CONCURRENT_NOT = "0";

    private Integer scheduleJobId = null;
    //任务名称
    private String jobName = "";
    //任务分组
    private String jobGroup = "";
    //任务状态 是否启动任务
    private String jobStatus = "";
    //cron表达式,定时任务运行时间
    private String cronExpression = "";
    //描述
    private String description = "";
    //任务执行时调用哪个类的方法 包名+类名
    private String beanClass = "";
    //任务是否有状态
    private String concurrentStatus = "";
    //spring bean
    private String springId = "";
    //任务调用的方法名
    private String methodName = "";
    //定时任务是否有效
    private String enableFlag = "";

  jobName 和jobGroup 组成唯一的组合，cronExpression形式如0 0/2 * * * ? ，表示每2分钟运行一次，具体可参考网上，其他表对应的实体类就不在上传表示。

 

mybatis对应的scheduleJob.xml(这里只是列举了部分)：

Xml代码  

1. <?xml version=“1.0” encoding=“UTF-8”?>  
2. <!DOCTYPE mapper PUBLIC ”-//mybatis.org//DTD Mapper 3.0//EN” “http://mybatis.org/dtd/mybatis-3-mapper.dtd”>  
3. <mapper namespace=“com.chinamobile.pumpValve.dao.ScheduleJobDAO”>  
4.      <select id=“getAll” resultType=“scheduleJob”>  
5.          SELECT  
6.             SCHEDULE_JOB_ID scheduleJobId,  
7.             JOB_NAME jobName,  
8.             JOB_GROUP jobGroup,  
9.             JOB_STATUS jobStatus,  
10.             CRON_EXPRESSION cronExpression,  
11.             DESCRIPTION description,  
12.             BEAN_CLASS beanClass,  
13.             CONCURRENT_STATUS concurrentStatus,  
14.             SPRING_ID springId,  
15.             METHOD_NAME methodName,  
16.             ENABLE_FLAG enableFlag,  
17.             CREATED_BY createdBy,  
18.             CREATION_DATE creationDate,  
19.             LAST_UPDATED_BY lastUpdatedBy,  
20.             LAST_UPDATE_DATE lastUpdateDate  
21.           FROM  
22.             schedule_job  
23.           WHERE  
24.             ENABLE_FLAG = ‘Y’  
25.      </select>  
26. </mapper>  

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.chinamobile.pumpValve.dao.ScheduleJobDAO">
     <select id="getAll" resultType="scheduleJob">
         SELECT
            SCHEDULE_JOB_ID scheduleJobId,
            JOB_NAME jobName,
            JOB_GROUP jobGroup,
            JOB_STATUS jobStatus,
            CRON_EXPRESSION cronExpression,
            DESCRIPTION description,
            BEAN_CLASS beanClass,
            CONCURRENT_STATUS concurrentStatus,
            SPRING_ID springId,
            METHOD_NAME methodName,
            ENABLE_FLAG enableFlag,
            CREATED_BY createdBy,
            CREATION_DATE creationDate,
            LAST_UPDATED_BY lastUpdatedBy,
            LAST_UPDATE_DATE lastUpdateDate
          FROM
            schedule_job
          WHERE
            ENABLE_FLAG = 'Y'
     </select>
</mapper>

   其他的配置也不再展示。

   创建DAO接口类ScheduleJobDAO，因为mybatis只需要接口就可以了，代码如下：

Java代码  

1. public interface ScheduleJobDAO {  
2.   
3.     /** 
4.      * 获取所有的job 
5.      * @return 
6.      */  
7.     public  List<ScheduleJob> getAll();  
8.   
9.     /** 
10.      * 获取特定job 
11.      * @param scheduleJob 
12.      * @return 
13.      */  
14.     public ScheduleJob getJobByNameAndGroup(ScheduleJob scheduleJob);  
15.   
16.     /** 
17.      * 插入job 
18.      * @param scheduleJob 
19.      */  
20.     public void addEntity(ScheduleJob scheduleJob);  
21.   
22.     /** 
23.      * 更新job的corn_expression字段 
24.      * @param scheduleJob 
25.      */  
26.     public void updateExpreByNameAndGroup(ScheduleJob scheduleJob);  
27. }  

public interface ScheduleJobDAO {

    /**
     * 获取所有的job
     * @return
     */
    public  List<ScheduleJob> getAll();

    /**
     * 获取特定job
     * @param scheduleJob
     * @return
     */
    public ScheduleJob getJobByNameAndGroup(ScheduleJob scheduleJob);

    /**
     * 插入job
     * @param scheduleJob
     */
    public void addEntity(ScheduleJob scheduleJob);

    /**
     * 更新job的corn_expression字段
     * @param scheduleJob
     */
    public void updateExpreByNameAndGroup(ScheduleJob scheduleJob);
}

   ScheduleJobService类：

 

  

Java代码  

1. import org.quartz.*;  
2. import org.quartz.impl.matchers.GroupMatcher;  
3. import org.springframework.beans.factory.annotation.Autowired;  
4. import org.springframework.context.annotation.ImportResource;  
5. import org.springframework.scheduling.quartz.SchedulerFactoryBean;  
6. import org.springframework.web.bind.annotation.PathVariable;  
7. import org.springframework.web.bind.annotation.RequestMapping;  
8. import org.springframework.web.bind.annotation.RequestMethod;  
9. import org.springframework.web.bind.annotation.RestController;  
10.   
11. import javax.annotation.PostConstruct;  
12. import java.util.ArrayList;  
13. import java.util.List;  
14. import java.util.Set;  
15.   
16. /** 
17.   * @DESCRIPTION 定时任务Service类 
18.  */  
19. @RestController  
20. @ImportResource(“config/spring.xml”)  
21. public class ScheduleJobService {  
22.   
23.     public final static Logger log = Logger.getLogger(ScheduleJobService.class);  
24.   
25.     @Autowired  
26.     private SchedulerFactoryBean schedulerFactoryBean = null;  
27.     @Autowired  
28.     private ScheduleJobDAO scheduleJobDAO = null;  
29.   
30.     @PostConstruct  
31.     public void addJobBegin() throws SchedulerException {  
32.         Scheduler scheduler = schedulerFactoryBean.getScheduler();  
33.          // 这里从数据库中获取任务信息数据  
34.         List<ScheduleJob> jobList = scheduleJobDAO.getAll();  
35.         for (ScheduleJob job : jobList) {  
36.             addTimeJob(job);  
37.          }  
38.   
39.     }  
40.   
41.     /** 
42.      * 添加任务 
43.      * @param job 
44.      * @throws SchedulerException 
45.      */  
46.     public void addTimeJob(ScheduleJob job) throws SchedulerException {  
47.         /*if(job == null || ScheduleJob.STATUS_RUNNING.equals(job.getJobStatus())){ 
48.             return; 
49.         }*/  
50.         if(job == null){  
51.             return;  
52.         }  
53.         log.info(”开始添加任务–>”+job.getJobGroup()+“.”+job.getJobName()+“.”+job.getMethodName());  
54.         Scheduler scheduler = schedulerFactoryBean.getScheduler();  
55.         //根据任务名称和任务组组成唯一的triggerKey  
56.         TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(),job.getJobGroup());  
57.         CronTrigger cronTrigger = (CronTrigger)scheduler.getTrigger(triggerKey);  
58.         //查看是否已经存在该任务  
59.         if(cronTrigger == null){  
60.             Class clazz = ScheduleJob.CONCURRENT_IS.equals(job.getConcurrentStatus()) ? QuartzJobFactory.class:QuartzJobFactoryDisallowConcurrentExecution.class;  
61.             JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(job.getJobName(),job.getJobGroup()).build();  
62.             jobDetail.getJobDataMap().put(”scheduleJob”,job);  
63.             CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());  
64.             cronTrigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(),job.getJobGroup()).withSchedule(cronScheduleBuilder).build();  
65.             scheduler.scheduleJob(jobDetail,cronTrigger);  
66.         }else {  
67.             // Trigger已存在，那么更新相应的定时设置  
68.             CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());  
69.             // 按新的cronExpression表达式重新构建trigger  
70.             cronTrigger = cronTrigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();  
71.             // 按新的trigger重新设置job执行  
72.            scheduler.rescheduleJob(triggerKey, cronTrigger);  
73.         }  
74.         log.info(”结束添加任务–>”+job.getJobGroup()+“.”+job.getJobName()+“.”+job.getMethodName());  
75.     }  
76.   
77.     /** 
78.      * 获取所有计划中的任务列表 
79.      * @return 
80.      * @throws SchedulerException 
81.      */  
82.     @RequestMapping(value = “/pumpValve/getAllJob”,method = RequestMethod.GET)  
83.     public List<ScheduleJob> getAllJob() throws SchedulerException {  
84.         Scheduler scheduler = schedulerFactoryBean.getScheduler();  
85.         GroupMatcher<JobKey> groupMatcher = GroupMatcher.anyJobGroup();  
86.         Set<JobKey> jobKeys = scheduler.getJobKeys(groupMatcher);  
87.         List<ScheduleJob> ScheduleJobs = new ArrayList<ScheduleJob>();  
88.         for(JobKey jobKey : jobKeys){  
89.             List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);  
90.             for(Trigger trigger : triggers){  
91.                 ScheduleJob jobForm = new ScheduleJob();  
92.                 jobForm.setJobName(jobKey.getName());  
93.                 jobForm.setJobGroup(jobKey.getGroup());  
94.                 jobForm.setDescription(”触发器:”+trigger.getKey());  
95.                 Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());  
96.                 jobForm.setJobStatus(triggerState.name());  
97.                 if(trigger instanceof CronTrigger){  
98.                     CronTrigger cronTrigger = (CronTrigger)trigger;  
99.                     String cronExpression = cronTrigger.getCronExpression();  
100.                     jobForm.setCronExpression(cronExpression);  
101.                 }  
102.                 ScheduleJobs.add(jobForm);  
103.             }  
104.         }  
105.         return ScheduleJobs;  
106.     }  
107.   
108.     /** 
109.      * 所有正在运行的job 
110.      * @return 
111.      * @throws SchedulerException 
112.      */  
113.     public List<ScheduleJob> getRunningJob() throws SchedulerException {  
114.         Scheduler scheduler = schedulerFactoryBean.getScheduler();  
115.         List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();  
116.         List<ScheduleJob> jobList = new ArrayList<ScheduleJob>(executingJobs.size());  
117.         for (JobExecutionContext executingJob : executingJobs) {  
118.             ScheduleJob job = new ScheduleJob();  
119.             JobDetail jobDetail = executingJob.getJobDetail();  
120.             JobKey jobKey = jobDetail.getKey();  
121.             Trigger trigger = executingJob.getTrigger();  
122.             job.setJobName(jobKey.getName());  
123.             job.setJobGroup(jobKey.getGroup());  
124.             job.setDescription(”触发器:” + trigger.getKey());  
125.             Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());  
126.             job.setJobStatus(triggerState.name());  
127.             if (trigger instanceof CronTrigger) {  
128.                 CronTrigger cronTrigger = (CronTrigger) trigger;  
129.                 String cronExpression = cronTrigger.getCronExpression();  
130.                 job.setCronExpression(cronExpression);  
131.             }  
132.             jobList.add(job);  
133.         }  
134.         return jobList;  
135.     }  
136.   
137.     /** 
138.      * 暂停一个job 
139.      * @param scheduleJob 
140.      * @throws SchedulerException 
141.      */  
142.     public void pauseJob(ScheduleJob scheduleJob) throws SchedulerException {  
143.         Scheduler scheduler = schedulerFactoryBean.getScheduler();  
144.         JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());  
145.         scheduler.pauseJob(jobKey);  
146.     }  
147.   
148.     /* 恢复一个job 
149.     * @param scheduleJob 
150.     * @throws SchedulerException 
151.     */  
152.     public void resumeJob(ScheduleJob scheduleJob) throws SchedulerException {  
153.         Scheduler scheduler = schedulerFactoryBean.getScheduler();  
154.         JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());  
155.         scheduler.resumeJob(jobKey);  
156.     }  
157.   
158.     /** 
159.      * 删除一个job 
160.      * @param scheduleJob 
161.      * @throws SchedulerException 
162.      */  
163.     public void deleteJob(ScheduleJob scheduleJob) throws SchedulerException {  
164.         Scheduler scheduler = schedulerFactoryBean.getScheduler();  
165.         JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());  
166.         scheduler.deleteJob(jobKey);  
167.     }  
168.   
169.     /** 
170.      * 立即执行job 
171.      * @param scheduleJob 
172.      * @throws SchedulerException 
173.      */  
174.     public void runAJobNow(ScheduleJob scheduleJob) throws SchedulerException {  
175.         Scheduler scheduler = schedulerFactoryBean.getScheduler();  
176.         JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());  
177.         scheduler.triggerJob(jobKey);  
178.     }  
179.   
180.     /** 
181.      * 更新job时间表达式 
182.      * @param scheduleJob 
183.      * @throws SchedulerException 
184.      */  
185.     public void updateJobCron(ScheduleJob scheduleJob) throws SchedulerException {  
186.         Scheduler scheduler = schedulerFactoryBean.getScheduler();  
187.         TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());  
188.         CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);  
189.         //判断时间表达式是否正确  
190.         CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());  
191.         trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();  
192.         scheduler.rescheduleJob(triggerKey, trigger);  
193.         //更新表中的表达式  
194.         scheduleJobDAO.updateExpreByNameAndGroup(scheduleJob);  
195.     }  
196.   
197.     @RequestMapping(value = “/pumpValve/addExecuteJob/{jobName}/{jobGroup}”)  
198.     public void addExecuteJob(@PathVariable(“jobName”) String jobName, @PathVariable(“jobGroup”) String jobGroup) throws SchedulerException {  
199.         ScheduleJob scheduleJobForm = new ScheduleJob();  
200.         scheduleJobForm.setJobName(jobName);  
201.         scheduleJobForm.setJobGroup(jobGroup);  
202.         scheduleJobForm = scheduleJobDAO.getJobByNameAndGroup(scheduleJobForm);  
203.         addTimeJob(scheduleJobForm);  
204.     }  
205.   
206.     public void addJob(ScheduleJob scheduleJob){  
207.         scheduleJobDAO.addEntity(scheduleJob);  
208.     }  

import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ImportResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

/**
  * @DESCRIPTION 定时任务Service类
 */
@RestController
@ImportResource("config/spring.xml")
public class ScheduleJobService {

    public final static Logger log = Logger.getLogger(ScheduleJobService.class);

    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean = null;
    @Autowired
    private ScheduleJobDAO scheduleJobDAO = null;

    @PostConstruct
    public void addJobBegin() throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
         // 这里从数据库中获取任务信息数据
        List<ScheduleJob> jobList = scheduleJobDAO.getAll();
        for (ScheduleJob job : jobList) {
            addTimeJob(job);
         }

    }

    /**
     * 添加任务
     * @param job
     * @throws SchedulerException
     */
    public void addTimeJob(ScheduleJob job) throws SchedulerException {
        /*if(job == null || ScheduleJob.STATUS_RUNNING.equals(job.getJobStatus())){
            return;
        }*/
        if(job == null){
            return;
        }
        log.info("开始添加任务-->"+job.getJobGroup()+"."+job.getJobName()+"."+job.getMethodName());
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        //根据任务名称和任务组组成唯一的triggerKey
        TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(),job.getJobGroup());
        CronTrigger cronTrigger = (CronTrigger)scheduler.getTrigger(triggerKey);
        //查看是否已经存在该任务
        if(cronTrigger == null){
            Class clazz = ScheduleJob.CONCURRENT_IS.equals(job.getConcurrentStatus()) ? QuartzJobFactory.class:QuartzJobFactoryDisallowConcurrentExecution.class;
            JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(job.getJobName(),job.getJobGroup()).build();
            jobDetail.getJobDataMap().put("scheduleJob",job);
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
            cronTrigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(),job.getJobGroup()).withSchedule(cronScheduleBuilder).build();
            scheduler.scheduleJob(jobDetail,cronTrigger);
        }else {
            // Trigger已存在，那么更新相应的定时设置
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
            // 按新的cronExpression表达式重新构建trigger
            cronTrigger = cronTrigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
            // 按新的trigger重新设置job执行
           scheduler.rescheduleJob(triggerKey, cronTrigger);
        }
        log.info("结束添加任务-->"+job.getJobGroup()+"."+job.getJobName()+"."+job.getMethodName());
    }

    /**
     * 获取所有计划中的任务列表
     * @return
     * @throws SchedulerException
     */
    @RequestMapping(value = "/pumpValve/getAllJob",method = RequestMethod.GET)
    public List<ScheduleJob> getAllJob() throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        GroupMatcher<JobKey> groupMatcher = GroupMatcher.anyJobGroup();
        Set<JobKey> jobKeys = scheduler.getJobKeys(groupMatcher);
        List<ScheduleJob> ScheduleJobs = new ArrayList<ScheduleJob>();
        for(JobKey jobKey : jobKeys){
            List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
            for(Trigger trigger : triggers){
                ScheduleJob jobForm = new ScheduleJob();
                jobForm.setJobName(jobKey.getName());
                jobForm.setJobGroup(jobKey.getGroup());
                jobForm.setDescription("触发器:"+trigger.getKey());
                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                jobForm.setJobStatus(triggerState.name());
                if(trigger instanceof CronTrigger){
                    CronTrigger cronTrigger = (CronTrigger)trigger;
                    String cronExpression = cronTrigger.getCronExpression();
                    jobForm.setCronExpression(cronExpression);
                }
                ScheduleJobs.add(jobForm);
            }
        }
        return ScheduleJobs;
    }

    /**
     * 所有正在运行的job
     * @return
     * @throws SchedulerException
     */
    public List<ScheduleJob> getRunningJob() throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
        List<ScheduleJob> jobList = new ArrayList<ScheduleJob>(executingJobs.size());
        for (JobExecutionContext executingJob : executingJobs) {
            ScheduleJob job = new ScheduleJob();
            JobDetail jobDetail = executingJob.getJobDetail();
            JobKey jobKey = jobDetail.getKey();
            Trigger trigger = executingJob.getTrigger();
            job.setJobName(jobKey.getName());
            job.setJobGroup(jobKey.getGroup());
            job.setDescription("触发器:" + trigger.getKey());
            Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
            job.setJobStatus(triggerState.name());
            if (trigger instanceof CronTrigger) {
                CronTrigger cronTrigger = (CronTrigger) trigger;
                String cronExpression = cronTrigger.getCronExpression();
                job.setCronExpression(cronExpression);
            }
            jobList.add(job);
        }
        return jobList;
    }

    /**
     * 暂停一个job
     * @param scheduleJob
     * @throws SchedulerException
     */
    public void pauseJob(ScheduleJob scheduleJob) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
        scheduler.pauseJob(jobKey);
    }

    /* 恢复一个job
    * @param scheduleJob
    * @throws SchedulerException
    */
    public void resumeJob(ScheduleJob scheduleJob) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
        scheduler.resumeJob(jobKey);
    }

    /**
     * 删除一个job
     * @param scheduleJob
     * @throws SchedulerException
     */
    public void deleteJob(ScheduleJob scheduleJob) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
        scheduler.deleteJob(jobKey);
    }

    /**
     * 立即执行job
     * @param scheduleJob
     * @throws SchedulerException
     */
    public void runAJobNow(ScheduleJob scheduleJob) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
        scheduler.triggerJob(jobKey);
    }

    /**
     * 更新job时间表达式
     * @param scheduleJob
     * @throws SchedulerException
     */
    public void updateJobCron(ScheduleJob scheduleJob) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        //判断时间表达式是否正确
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());
        trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
        scheduler.rescheduleJob(triggerKey, trigger);
        //更新表中的表达式
        scheduleJobDAO.updateExpreByNameAndGroup(scheduleJob);
    }

    @RequestMapping(value = "/pumpValve/addExecuteJob/{jobName}/{jobGroup}")
    public void addExecuteJob(@PathVariable("jobName") String jobName, @PathVariable("jobGroup") String jobGroup) throws SchedulerException {
        ScheduleJob scheduleJobForm = new ScheduleJob();
        scheduleJobForm.setJobName(jobName);
        scheduleJobForm.setJobGroup(jobGroup);
        scheduleJobForm = scheduleJobDAO.getJobByNameAndGroup(scheduleJobForm);
        addTimeJob(scheduleJobForm);
    }

    public void addJob(ScheduleJob scheduleJob){
        scheduleJobDAO.addEntity(scheduleJob);
    }

 这里通过注解@ImportResource导入了一个spring配置文件，内容如下：

 

Xml代码  

1. <?xml version=“1.0” encoding=“UTF-8”?>  
2. <beans xmlns=“http://www.springframework.org/schema/beans”  
3.        xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”  
4.        xsi:schemaLocation=”  
5. http://www.springframework.org/schema/beans  
6. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
7. “>  
8.     <bean id=“schedulerFactoryBean” class=“org.springframework.scheduling.quartz.SchedulerFactoryBean” />  
9.  </beans>  

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
">
    <bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" />
 </beans>

 还有就是log4j的配置

log4j.rootLogger=DEBUG,Console,File

log4j.logger.org.springframework=error
log4j.logger.org.mybatis.spring=DEBUG
log4j.logger.base=DEBUG
log4j.logger.org.apache.ibatis=debug
log4j.logger.java.sql=debug
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.Statement=DEBUG

log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.Target=System.out
log4j.appender.Console.Threshold=DEBUG
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=[%p][%l]-%m%n

log4j.appender.File=org.apache.log4j.RollingFileAppender
log4j.appender.File.File=E:/log/quartz-spring_demo.log
log4j.appender.File.MaxBackupIndex=10
log4j.appender.File.MaxFileSize=5MB
log4j.appender.File.Threshold=ALL
log4j.appender.File.layout=org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern=[%p][%d{yyyy-MM-dd HH\:mm\:ss,SSS}][%c]%m%n
log4j.logger.org.quartz=INFO

以及使用了另外两个类，QuartzJobFactory:

Java代码  

1. import org.quartz.Job;  
2. import org.quartz.JobExecutionContext;  
3. import org.quartz.JobExecutionException;  
4.   
5.   
6. public class QuartzJobFactory implements Job {  
7.     @Override  
8.     public void execute(JobExecutionContext context) throws JobExecutionException {  
9.         ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get(”scheduleJob”);  
10.         TaskUtils.invokeMethod(scheduleJob);  
11.     }  
12. }  

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;


public class QuartzJobFactory implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("scheduleJob");
        TaskUtils.invokeMethod(scheduleJob);
    }
}

 QuartzJobFactoryDisallowConcurrentExecution类：

Java代码  

1. import org.quartz.DisallowConcurrentExecution;  
2. import org.quartz.Job;  
3. import org.quartz.JobExecutionContext;  
4. import org.quartz.JobExecutionException;  
5.   
6.   
7. @DisallowConcurrentExecution  
8. public class QuartzJobFactoryDisallowConcurrentExecution implements Job {  
9.     @Override  
10.     public void execute(JobExecutionContext context) throws JobExecutionException {  
11.         ScheduleJob scheduleJob = (ScheduleJob)context.getMergedJobDataMap().get(”scheduleJob”);  
12.         TaskUtils.invokeMethod(scheduleJob);  
13.     }  
14. }  

import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;


@DisallowConcurrentExecution
public class QuartzJobFactoryDisallowConcurrentExecution implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        ScheduleJob scheduleJob = (ScheduleJob)context.getMergedJobDataMap().get("scheduleJob");
        TaskUtils.invokeMethod(scheduleJob);
    }
}

 这两个类中使用了TaskUtils类，代码如下：

Java代码  

1. import org.apache.commons.lang.StringUtils;  
2. import org.apache.log4j.Logger;  
3.   
4. import java.lang.reflect.InvocationTargetException;  
5. import java.lang.reflect.Method;  
6.   
7. /** 
8.  * @Description 用于启动任务 
9.  */  
10. public class TaskUtils {  
11.     public final static Logger log = Logger.getLogger(TaskUtils.class);  
12.     public static void invokeMethod(ScheduleJob scheduleJob){  
13.         Object object = null;  
14.         Class clazz = null;  
15.         if(StringUtils.isBlank(scheduleJob.getSpringId())){  
16.             //根据spirng bean id 获取Java类  
17.             clazz = SpringUtils.getBean(scheduleJob.getSpringId());  
18.         }else if(StringUtils.isNotBlank(scheduleJob.getBeanClass())){  
19.             try {  
20.                 //根据类全路径名获取Java类  
21.                 clazz = Class.forName(scheduleJob.getBeanClass());  
22.                 //实例化类  
23.                 object = clazz.newInstance();  
24.             } catch (ClassNotFoundException e) {  
25.                 e.printStackTrace();  
26.             } catch (InstantiationException e) {  
27.                 e.printStackTrace();  
28.             } catch (IllegalAccessException e) {  
29.                 e.printStackTrace();  
30.             }  
31.         }  
32.   
33.         if(object == null){  
34.             log.error(”任务名称 = [“ + scheduleJob.getJobName() + “]—————未启动成功，请检查是否配置正确！！！”);  
35.             return;  
36.         }  
37.   
38.         clazz = object.getClass();  
39.         Method method = null;  
40.         try {  
41.             //判断特定的方法来反射获取方法  
42.             if(scheduleJob.getMethodName().equals(“testVariableJob”)){  
43.                 method = clazz.getDeclaredMethod(scheduleJob.getMethodName(),String.class);  
44.             }else {  
45.                 method = clazz.getDeclaredMethod(scheduleJob.getMethodName());  
46.             }  
47.         } catch (NoSuchMethodException e) {  
48.             log.error(”任务名称 = [“ + scheduleJob.getJobName() + “]—————未启动成功，方法名设置错误！！！”);  
49.             e.printStackTrace();  
50.         }  
51.         if(method != null){  
52.             try {  
53.                 //判断特定的方法是否传参等，同时启动方法  
54.                 if(scheduleJob.getMethodName().equals(“getAllEquipment”)){  
55.                     EquipmentInfoDAO equipmentInfoDAO = SpringUtils.getBean(”equipmentInfoDAO”);  
56.                     method.invoke(object,equipmentInfoDAO);  
57.                 }else{  
58.                     method.invoke(object);  
59.                 }  
60.             } catch (IllegalAccessException e) {  
61.                 e.printStackTrace();  
62.             } catch (InvocationTargetException e) {  
63.                 e.printStackTrace();  
64.             }  
65.         }  
66.         System.out.println(”任务名称 = [“ + scheduleJob.getJobName() + “]———-启动成功”);  
67.     }  
68. }  

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @Description 用于启动任务
 */
public class TaskUtils {
    public final static Logger log = Logger.getLogger(TaskUtils.class);
    public static void invokeMethod(ScheduleJob scheduleJob){
        Object object = null;
        Class clazz = null;
        if(StringUtils.isBlank(scheduleJob.getSpringId())){
            //根据spirng bean id 获取Java类
            clazz = SpringUtils.getBean(scheduleJob.getSpringId());
        }else if(StringUtils.isNotBlank(scheduleJob.getBeanClass())){
            try {
                //根据类全路径名获取Java类
                clazz = Class.forName(scheduleJob.getBeanClass());
                //实例化类
                object = clazz.newInstance();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }

        if(object == null){
            log.error("任务名称 = [" + scheduleJob.getJobName() + "]---------------未启动成功，请检查是否配置正确！！！");
            return;
        }

        clazz = object.getClass();
        Method method = null;
        try {
            //判断特定的方法来反射获取方法
            if(scheduleJob.getMethodName().equals("testVariableJob")){
                method = clazz.getDeclaredMethod(scheduleJob.getMethodName(),String.class);
            }else {
                method = clazz.getDeclaredMethod(scheduleJob.getMethodName());
            }
        } catch (NoSuchMethodException e) {
            log.error("任务名称 = [" + scheduleJob.getJobName() + "]---------------未启动成功，方法名设置错误！！！");
            e.printStackTrace();
        }
        if(method != null){
            try {
                //判断特定的方法是否传参等，同时启动方法
                if(scheduleJob.getMethodName().equals("getAllEquipment")){
                    EquipmentInfoDAO equipmentInfoDAO = SpringUtils.getBean("equipmentInfoDAO");
                    method.invoke(object,equipmentInfoDAO);
                }else{
                    method.invoke(object);
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
        System.out.println("任务名称 = [" + scheduleJob.getJobName() + "]----------启动成功");
    }
}

   SpringUtils类：

Java代码  

1. import org.springframework.beans.BeansException;  
2. import org.springframework.beans.factory.NoSuchBeanDefinitionException;  
3. import org.springframework.beans.factory.config.BeanFactoryPostProcessor;  
4. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;  
5.   
6. /** 
7.  * @Description 根据Spring工厂类获取Java实例 
8.  */  
9. public class SpringUtils implements BeanFactoryPostProcessor {  
10.     private static ConfigurableListableBeanFactory beanFactory;  
11.     @Override  
12.     public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {  
13.         SpringUtils.beanFactory = configurableListableBeanFactory;  
14.     }  
15.   
16.     /** 
17.      * 获取对象 
18.      * 
19.      * @param name 
20.      * @return Object 一个以所给名字注册的bean的实例 
21.      * @throws BeansException 
22.      * 
23.      */  
24.     public static <T> T getBean(String name) throws BeansException {  
25.         return (T) beanFactory.getBean(name);  
26.     }  
27.   
28.     /** 
29.      * 获取类型为requiredType的对象 
30.      * 
31.      * @param clz 
32.      * @return 
33.      * @throws BeansException 
34.      * 
35.      */  
36.     public static <T> T getBean(Class<T> clz) throws BeansException {  
37.         T result = (T) beanFactory.getBean(clz);  
38.         return result;  
39.     }  
40.   
41.     /** 
42.      * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true 
43.      * 
44.      * @param name 
45.      * @return boolean 
46.      */  
47.     public static boolean containsBean(String name) {  
48.         return beanFactory.containsBean(name);  
49.     }  
50.   
51.     /** 
52.      * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 
53.      * 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException） 
54.      * 
55.      * @param name 
56.      * @return boolean 
57.      * @throws NoSuchBeanDefinitionException 
58.      * 
59.      */  
60.     public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {  
61.         return beanFactory.isSingleton(name);  
62.     }  
63.   
64.     /** 
65.      * @param name 
66.      * @return Class 注册对象的类型 
67.      * @throws NoSuchBeanDefinitionException 
68.      * 
69.      */  
70.     public static Class<?> getType(String name) throws NoSuchBeanDefinitionException {  
71.         return beanFactory.getType(name);  
72.     }  
73.   
74.     /** 
75.      * 如果给定的bean名字在bean定义中有别名，则返回这些别名 
76.      * 
77.      * @param name 
78.      * @return 
79.      * @throws NoSuchBeanDefinitionException 
80.      * 
81.      */  
82.     public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {  
83.         return beanFactory.getAliases(name);  
84.     }  
85. }  

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

/**
 * @Description 根据Spring工厂类获取Java实例
 */
public class SpringUtils implements BeanFactoryPostProcessor {
    private static ConfigurableListableBeanFactory beanFactory;
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        SpringUtils.beanFactory = configurableListableBeanFactory;
    }

    /**
     * 获取对象
     *
     * @param name
     * @return Object 一个以所给名字注册的bean的实例
     * @throws BeansException
     *
     */
    public static <T> T getBean(String name) throws BeansException {
        return (T) beanFactory.getBean(name);
    }

    /**
     * 获取类型为requiredType的对象
     *
     * @param clz
     * @return
     * @throws BeansException
     *
     */
    public static <T> T getBean(Class<T> clz) throws BeansException {
        T result = (T) beanFactory.getBean(clz);
        return result;
    }

    /**
     * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
     *
     * @param name
     * @return boolean
     */
    public static boolean containsBean(String name) {
        return beanFactory.containsBean(name);
    }

    /**
     * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。
     * 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
     *
     * @param name
     * @return boolean
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
        return beanFactory.isSingleton(name);
    }

    /**
     * @param name
     * @return Class 注册对象的类型
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException {
        return beanFactory.getType(name);
    }

    /**
     * 如果给定的bean名字在bean定义中有别名，则返回这些别名
     *
     * @param name
     * @return
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
        return beanFactory.getAliases(name);
    }
}

 定时任务运行时将会到EquimpentInfoService类中去运行fetchData()方法(在定时任务表中需要运行method_name字段上的名字)，因为mybatis只需要接口就可以使用数据库读取，因为通过反射的方式获取不能通过接口去读取数据库，因此在这里我们就接口类进行了实现，EquimpentInfoDAOImpl代码如下：

Java代码  

1. import org.apache.ibatis.session.SqlSession;  
2. import org.apache.ibatis.session.SqlSessionFactory;  
3.   
4. import java.util.List;  
5.   
6. /** 
7.  * @DESCRIPTION 设备dao实现类，针对反射的时候Spring注入获取不到值 
8.  */  
9. public class EquipmentInfoDAOImpl implements EquipmentInfoDAO {  
10.   
11.     private SqlSessionFactory sqlSessionFactory;  
12.     public EquipmentInfoDAOImpl(SqlSessionFactory sqlSessionFactory){  
13.         this.sqlSessionFactory = sqlSessionFactory;  
14.     }  
15.   
16.   
17.     @Override  
18.     public List<EquipmentInfo> getAllEquipment() {  
19.         SqlSession session = sqlSessionFactory.openSession();  
20.         List<EquipmentInfo> equipmentInfoList = session.selectList(”getAllEquipment”);  
21.         session.close();  
22.         return equipmentInfoList;  
23.     }  
24.   
25.     }  

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import java.util.List;

/**
 * @DESCRIPTION 设备dao实现类，针对反射的时候Spring注入获取不到值
 */
public class EquipmentInfoDAOImpl implements EquipmentInfoDAO {

    private SqlSessionFactory sqlSessionFactory;
    public EquipmentInfoDAOImpl(SqlSessionFactory sqlSessionFactory){
        this.sqlSessionFactory = sqlSessionFactory;
    }


    @Override
    public List<EquipmentInfo> getAllEquipment() {
        SqlSession session = sqlSessionFactory.openSession();
        List<EquipmentInfo> equipmentInfoList = session.selectList("getAllEquipment");
        session.close();
        return equipmentInfoList;
    }

    }

 EquimpentInfoService类实现如下(这里实现通过反射方式就会脱离了spring容器控制)：

Java代码  

1. import org.apache.ibatis.io.Resources;  
2. import org.apache.ibatis.session.SqlSession;  
3. import org.apache.ibatis.session.SqlSessionFactory;  
4. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
5. import org.apache.log4j.Logger;  
6. import org.springframework.beans.factory.annotation.Autowired;  
7. import org.springframework.web.bind.annotation.RestController;  
8.   
9. import java.io.IOException;  
10. import java.io.InputStream;  
11. import java.util.List;  
12.   
13. /** 
14.  * @DESCRIPTION 设备信息Service类 
15.  */  
16. @RestController  
17. public class EquipmentInfoService {  
18.     public final static Logger log = Logger.getLogger(EquipmentInfoService.class);  
19.     @Autowired  
20.     private EquipmentInfoDAO equipmentInfoDAO = null;  
21.     /** 
22.      * 获取所有设备信息 
23.      * @return 
24.      */  
25.     public List<EquipmentInfo> getAllEquipment(){  
26.         List<EquipmentInfo> equipmentInfoList = null;  
27.         if(equipmentInfoDAO == null){  
28.             EquipmentInfoDAOImpl infoDAO = new EquipmentInfoDAOImpl(getSqlSessionFactory());  
29.             equipmentInfoList = infoDAO.getAllEquipment();  
30.         }else {  
31.             equipmentInfoList = equipmentInfoDAO.getAllEquipment();  
32.         }  
33.         return equipmentInfoList;  
34.     }  
35.   
36.     /** 
37.      * 获取SqlSessionFactory 
38.      * @return 
39.      */  
40.     private SqlSessionFactory getSqlSessionFactory(){  
41.         SqlSessionFactory sqlSessionFactory = null;  
42.         SqlSession session = null;  
43.         String resource = ”config/mybatis.xml”;  
44.         InputStream inputStream;  
45.         try {  
46.             inputStream = Resources.getResourceAsStream(resource);  
47.             sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
48.         } catch (IOException e) {  
49.             e.printStackTrace();  
50.         }  
51.         return sqlSessionFactory;  
52.     }  
53.   
54.   
55.   
56.     public void fetchData(){  
57.         List<EquipmentInfo> equipmentInfoList = getAllEquipment();  
58.         for(EquipmentInfo equipmentInfo : equipmentInfoList){  
59.                }  
60. }  

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/**
 * @DESCRIPTION 设备信息Service类
 */
@RestController
public class EquipmentInfoService {
    public final static Logger log = Logger.getLogger(EquipmentInfoService.class);
    @Autowired
    private EquipmentInfoDAO equipmentInfoDAO = null;
    /**
     * 获取所有设备信息
     * @return
     */
    public List<EquipmentInfo> getAllEquipment(){
        List<EquipmentInfo> equipmentInfoList = null;
        if(equipmentInfoDAO == null){
            EquipmentInfoDAOImpl infoDAO = new EquipmentInfoDAOImpl(getSqlSessionFactory());
            equipmentInfoList = infoDAO.getAllEquipment();
        }else {
            equipmentInfoList = equipmentInfoDAO.getAllEquipment();
        }
        return equipmentInfoList;
    }

    /**
     * 获取SqlSessionFactory
     * @return
     */
    private SqlSessionFactory getSqlSessionFactory(){
        SqlSessionFactory sqlSessionFactory = null;
        SqlSession session = null;
        String resource = "config/mybatis.xml";
        InputStream inputStream;
        try {
            inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sqlSessionFactory;
    }



    public void fetchData(){
        List<EquipmentInfo> equipmentInfoList = getAllEquipment();
        for(EquipmentInfo equipmentInfo : equipmentInfoList){
               }
}

 这里就是主要的代码实现了。这里主要是处理了因为反射的原因，不能读取到通过注解@Autowried注入EquipmentInfoDAO 类，换而用EquipmentInfoDAOImpl去读取数据。