spring boot加载第三方jar包的配置文件的方法

前言

今天收到一封邮件，大概内容如下：spring boot鼓励去配置化，那么怎么将第三方jar包中的xml去配置化了？

其实，这个问题，在前面的文章中也有提到，

下面，我们就以quartz定时任务为例，单独对这个问题来进行说明，如何实现去配置化。

如果不使用spring boot，我们配置一个简单的定时任务时，需要引入以下配置文件：

<!-- 配置需要定时执行的任务类以及方法 --> 
 <bean id="dojob" 
  class="org.springframework.scheduling.quartz.methodinvokingjobdetailfactorybean"> 
  <!-- 指定任务类 --> 
  <property name="targetobject" ref="schedulertask" /> 
  <!-- 指定任务执行的方法 --> 
  <property name="targetmethod" value="dotask" /> 
  <property name="concurrent" value="false"></property> 
 </bean> 
  
 <!-- 配置触发器 --> 
 <bean id="jobtrigger" 
  class="org.springframework.scheduling.quartz.crontriggerfactorybean"> 
  <property name="jobdetail" ref="dojob" /> 
  <!-- 每5秒运行一次 --> 
  <property name="cronexpression" value="0/5 * * * * ?" /> 
 </bean> 
 
 <!-- 触发定时任务 --> 
 <bean id="schedulerfactorybean" class="org.springframework.scheduling.quartz.schedulerfactorybean"> 
  <property name="triggers"> 
   <list> 
    <ref bean="jobtrigger" /><!-- 此处可以配置多个触发器 --> 
   </list> 
  </property> 
  <property name="applicationcontextschedulercontextkey" value="applicationcontextkey" /> 
  <property name="waitforjobstocompleteonshutdown" value="true"></property> 
 </bean> 

接下来的任务，就是如何将上面的xml配置文件，去配置化。

从上面的配置文件中，可以得出，我们需要配置3个实例，分别是jobdetail，jobtrigger和scheduler。

1、首先抽取出需要在application.properties配置文件中配置的属性项，从上面的配置文件中，可以得出如下需要配置的属性项，对应的vo如下：

package com.chhliu.springboot.quartz.config; 
 
import org.springframework.boot.context.properties.configurationproperties; 
 
@configurationproperties(prefix="quartz.config") 
public class quartzconfigproperties { 
 private string targetobject; 
  
 private string targetmethod; 
  
 private boolean concurrent; 
  
 private string cronexpression; 
  
 private string applicationcontextschedulercontextkey; 
  
 private boolean waitforjobstocompleteonshutdown; 
   
  ……省略getter、setter方法…… 
} 

2、在application.properties配置文件中，加入如下配置

quartz.config.targetobject=taskjob ## 待执行对象的名字 
quartz.config.targetmethod=dojob ## 待执行的方法的名字 
quartz.config.concurrent=false ## 是否并发，如果上一个定时任务还没有执行完，又被触发了，如果配置为false，则需等待上个任务执行完，才触发 
quartz.config.cronexpression=0/5 * * * * ? ## 任务触发表达式 
quartz.config.applicationcontextschedulercontextkey=applicationcontextkey ## 通过该key可以获取spring上下文 
quartz.config.waitforjobstocompleteonshutdown=true ## 是否等待任务完全执行完后，再销毁线程池 

3、分别实例化jobdetail，jobtrigger和scheduler 

package com.chhliu.springboot.quartz.entity; 
 
import org.quartz.trigger; 
import org.springframework.beans.factory.annotation.autowired; 
import org.springframework.context.annotation.bean; 
import org.springframework.context.annotation.configuration; 
import org.springframework.scheduling.quartz.crontriggerfactorybean; 
import org.springframework.scheduling.quartz.methodinvokingjobdetailfactorybean; 
import org.springframework.scheduling.quartz.schedulerfactorybean; 
 
import com.chhliu.springboot.quartz.config.quartzconfigproperties; 
 
/** 
 * 描述：将quartz的xml配置文件去配置化 
 * @author chhliu 
 * 创建时间：2017年4月11日 下午7:41:21 
 * @version 1.2.0 
 */ 
@configuration 
public class quartzconfig { 
  
 @autowired 
 private quartzconfigproperties properties; // 注入属性配置文件对应的类实例 
  
 /** 
  * attention: 
  * details：初始化jobdetail 
  * @author chhliu 
  * 创建时间：2017年4月11日 下午6:17:06 
  * @param task 
  * @return 
  * methodinvokingjobdetailfactorybean 
  * @throws classnotfoundexception 
  * @throws illegalaccessexception 
  * @throws instantiationexception 
  */ 
 @bean(name = "jobdetail") 
 public methodinvokingjobdetailfactorybean detailfactorybean() throws classnotfoundexception, instantiationexception, illegalaccessexception {// scheduletask为需要执行的任务 
  methodinvokingjobdetailfactorybean jobdetail = new methodinvokingjobdetailfactorybean(); 
  /* 
   * 是否并发执行 
   * 例如每5s执行一次任务，但是当前任务还没有执行完，就已经过了5s了， 
   * 如果此处为true，则下一个任务会执行，如果此处为false，则下一个任务会等待上一个任务执行完后，再开始执行 
   */ 
  jobdetail.setconcurrent(properties.isconcurrent()); 
   
  /* 
   * 为需要执行的实体类对应的对象 
   */ 
  string targetobject = properties.gettargetobject(); 
  jobdetail.settargetbeanname(targetobject); 
   
  /* 
   * 通过这几个配置，告诉jobdetailfactorybean我们需要定时执行targetobject类中的properties.gettargetmethod()方法 
   */ 
  jobdetail.settargetmethod(properties.gettargetmethod()); 
  return jobdetail; 
 } 
  
 /** 
  * attention: 
  * details：实例化jobtrigger 
  * @author chhliu 
  * 创建时间：2017年4月11日 下午7:39:14 
  * @param jobdetail 
  * @return 
  * crontriggerfactorybean 
  */ 
 @bean(name = "jobtrigger") 
 public crontriggerfactorybean cronjobtrigger(methodinvokingjobdetailfactorybean jobdetail) { 
  crontriggerfactorybean tigger = new crontriggerfactorybean(); 
  tigger.setjobdetail(jobdetail.getobject()); 
  tigger.setcronexpression(properties.getcronexpression()); 
  return tigger; 
 
 } 
  
 /** 
  * attention: 
  * details：实例化scheduler 
  * @author chhliu 
  * 创建时间：2017年4月11日 下午7:39:35 
  * @param cronjobtrigger 
  * @return 
  * schedulerfactorybean 
  */ 
 @bean(name = "scheduler") 
 public schedulerfactorybean schedulerfactory(trigger cronjobtrigger) { 
  schedulerfactorybean bean = new schedulerfactorybean(); 
  // 注册触发器 
  bean.settriggers(cronjobtrigger); 
  // 通过applicationcontextschedulercontextkey属性配置获取spring上下文 
  bean.setapplicationcontextschedulercontextkey(properties.getapplicationcontextschedulercontextkey()); 
  // 关闭任务的时候，是否等待任务执行完毕 
  bean.setwaitforjobstocompleteonshutdown(properties.iswaitforjobstocompleteonshutdown()); 
  return bean; 
 } 
} 

4、编写需要执行的方法 

package com.chhliu.springboot.quartz.job; 
 
import org.slf4j.logger; 
import org.slf4j.loggerfactory; 
import org.springframework.stereotype.service; 
 
@service("taskjob") 
public class taskjob { 
 private static final logger logger = loggerfactory.getlogger(taskjob.class); 
 public void dojob(){ 
  logger.info("hello spring boot, i'm the king of the world!!!"); 
 } 
} 

5、测试

package com.chhliu.springboot.quartz; 
 
import org.springframework.boot.springapplication; 
import org.springframework.boot.autoconfigure.springbootapplication; 
import org.springframework.boot.context.properties.enableconfigurationproperties; 
 
import com.chhliu.springboot.quartz.config.quartzconfigproperties; 
 
@springbootapplication 
@enableconfigurationproperties({quartzconfigproperties.class} ) // 开启配置属性支持 
public class springbootquartzapplication { 
 
 public static void main(string[] args) { 
  springapplication.run(springbootquartzapplication.class, args); 
 } 
} 

6、测试结果如下 

2017-04-11 19:09:35.017 info 7500 --- [eduler_worker-1] c.chhliu.springboot.quartz.job.taskjob : hello spring boot, i'm the king of the world!!! 
2017-04-11 19:09:40.004 info 7500 --- [eduler_worker-2] c.chhliu.springboot.quartz.job.taskjob : hello spring boot, i'm the king of the world!!! 
2017-04-11 19:09:45.004 info 7500 --- [eduler_worker-3] c.chhliu.springboot.quartz.job.taskjob : hello spring boot, i'm the king of the world!!! 
2017-04-11 19:09:50.004 info 7500 --- [eduler_worker-4] c.chhliu.springboot.quartz.job.taskjob : hello spring boot, i'm the king of the world!!! 
2017-04-11 19:09:55.001 info 7500 --- [eduler_worker-5] c.chhliu.springboot.quartz.job.taskjob : hello spring boot, i'm the king of the world!!! 
2017-04-11 19:10:00.002 info 7500 --- [eduler_worker-6] c.chhliu.springboot.quartz.job.taskjob : hello spring boot, i'm the king of the world!!! 
2017-04-11 19:10:05.001 info 7500 --- [eduler_worker-7] c.chhliu.springboot.quartz.job.taskjob : hello spring boot, i'm the king of the world!!! 

从上面的测试结果可以看出，任务被触发了，也得到了正确的结果。

上面的这个示例，只是一个简单的例子，但是生产上复杂的需求，原理也是类似的。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。