Spring配置文件

spring配置文件各个属性详解分类：spring 2012-08-09 11:25 9316人阅读评论(2) 收藏举报springaophibernateattributesxhtmlwebsphere目录(?)[+]一、引用外部属性文件<bean id="propertyConfigurer"class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="locations"><list><value>classpath:mail.properties</value><value>classpath:jdbc.properties</value></list></property></bean>我们定义了一个PropertyPlaceholderConfigurer类的实例，并将其位置属性设置为我们的属性文件。

该类被实现为Bean工厂的后处理器，并将使用定义在文件中的属性来代替所有的占位符（${...}value）。

注意：而在spring2.5的版本中提供了一种更简便的方式，如：1.<context:property-placeholderlocation="classpath:config/jdbc.properties"/>这样以后要使用属性文件中的资源时，可以使用${属性名}来获得。

二、常用数据源的配置第一种是：DBCP数据源，（需要加入2个jar文件，在spring中的lib下jakarta-commons/commons-dbcp.jar和commons-pools.jar）主要配置如下：<!-- Mysql版--><bean id="dataSource"class="mons.dbcp.BasicDataSource"><property name="driverClassName"value="com.mysql.jdbc.Driver"></property><property name="url"value="${jdbc.url}"></property><property name="username" value="${ername}"></property><property name="password" value="${jdbc.password}"></property></bean>第二种是：c3p0数据源，跟第一种一个类型，需加入c3p0.jar包。

Spring配置定时器（注解+xml）⽅式—整理⼀、注解⽅式1. 在Spring的配置⽂件ApplicationContext.xml，⾸先添加命名空间1 xmlns:task="/schema/task"2 /schema/task3 /schema /task/springtask3.1.xsd42. 最后是我们的task任务扫描注解1<task:annotation-driven/>3. spring扫描位置1<context:annotation-config/>2<context:component-scan base-package="com.test"/>4.写⾃⼰的定时任务1 @Component //import ponent;2public class MyTestServiceImpl implements IMyTestService {3 @Scheduled(cron="0/5 * * * * ? ") //每5秒执⾏⼀次4public void myTest(){5 System.out.println("进⼊测试");6 }7 }♦注意：定时器的任务⽅法不能有返回值（如果有返回值，spring初始化的时候会告诉你有个错误、需要设定⼀个proxytargetclass的某个值为true）⼆、XML⽅式1.在spring配置⽂件中创建bean，创建schedule1<bean id="schedule"class="org.springframework.scheduling.quartz.SchedulerFactoryBean">3<property name="triggers">4<list>5<ref bean="testTrigger"/>6</list>7</property>8</bean>2. 在spring配置⽂件中创建bean，创建你的triggers1<bean id="testTrigger"class="org.springframework.scheduling.quartz.CronTriggerBean">3<property name="jobDetail" ref="testJobDetail"/>4<property name="cronExpression" value="0 1/5 * * * ?"/>5</bean>3. 在spring配置⽂件中创建bean，指定定时器作⽤在那个类那个⽅法上⾯1<bean id="testJobDetail"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">3<property name="targetObject" ref="targetTestService"/>4<property name="targetMethod" value="timerTest"/>5</bean>♦注明：把定时器作⽤在targetTestService对象中的timerTest⽅法上⾯4. 当然还得把你作⽤的对象交Spring来管理，所以在spring配置⽂件中创建作⽤类的 bean1<bean id="targetTestService" class=".service.TargetTestService" scope="prototype"></bean>♦这是时间的设置规则org.springframework.scheduling.quartz.CronTriggerBean允许你更精确地控制任务的运⾏时间，只需要设置其cronExpression属性。

spring是一个开源的控制反转（inversion of control）和面向切面（AOP）的容器框架，她主要设计目标是简化开发。

如：public class UserService {private UserDAO userDAO = new UserDAO();public void addUser(User user) {userDAO.add(user);}}userDAO是在应用内部创建和维护，控制反转是应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护由外部容器负责，这种控制权由应用转移到外部容器就称为反转。

当把这种控制权力交给外部容器处理之后代码可以改为public class UserService {private UserDAO userDAO;public void addUser(User user) {userDAO.add(user);}}针对这个属性可以提供构造方法中传递参数或者提供setter方法进行注入。

依赖注入（Dependency Injection）：由容器动态地将依赖对象注入到组件中。

Spring带来的好处1、降低组件之间的耦合度，实现软件各层之间的解耦。

Action →service →DAO2、可以使用容器提供相关服务，如：事务管理服务等，使用spring管理服务之后不再需要手工控制事务。

（hibernate或者是jdbc的事务相关操作代码都可以去掉）Spring的声明式事务管理可以实现复杂的事务操作。

3、容器提供单例模式，开发人员不再编写单例代码。

4、容器提供AOP技术，利用它很容易实现权限拦截、监控、日志等功能。

5、容器提供很多辅助类，利用这些类能够加快应用的开发，如：JdbcTemplate、HibernateTemplate等6、spring对于一些主流的框架提供了集成支持，如hibernate、struts、ibatis等搭建spring开发环境使用spring需要的jar在官网上下载spring的安装包dist\spring.jarlib\jakarta-commons\commons-logging.jar如果使用aop还需要Lib\aspectj\aspectjweaver.jar、aspectjrt.jarLib\cglib\cglib-nodep-2.1.3.jar如果使用JSR-250中的注解还需要使用lib\j2ee\common-annotations.jarspring配置文件，规范参考文档手册实例化spring容器方法一、在类路径下寻找配置文件来实例化容器ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{“beans.xml”,”user.xml”});方法二、在文件系统路径下需找配置文件来实例化容器ApplicationContext ctx = new FileSystemXmlApplicationContext(new String[]{“c:\\beans.xml”}); 注意：spring配置文件可以有多个，这时通过string数组传入。

项目中一个需求就是所有的功能都是插件的形式装入系统，这就需要利用Spring去动态加载某一位置下的配置文件，就总结了下Spring中加载xml配置文件的方式, xml是最常见的spring 应用系统配置源。

Spring中的几种容器都支持使用xml装配bean，包括：XmlBeanFactory,ClassPathXmlApplicationContext,FileSystemXmlApplicationContext,XmlWebApplicationContext,.....一: XmlBeanFactory 引用资源1.Resource cr = new ClassPathResource("applicationContext.xml");BeanFactory bf=new XmlBeanFactory(cr);UserDao userDao = (UserDao)bf.getBean("userDao");二: ClassPathXmlApplicationContext 编译路径使用ClassPathXmlApplicationContext对象获取，必须把applicationContext.xml放置到类的加载路径中，也就是Src下面1.ApplicationContext factory=new ClassPathXmlApplicationContext("classpath:appcontext.xml");// src目录下的2.ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserDao userDao = (UserDao)context.getBean("userDao");3.ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext-oracle.xml","applicationContext.xml"});UserDao userDao = (UserDao)context.getBean("userDao");// src/conf 目录下的4.ApplicationContext factory=new ClassPathXmlApplicationContext("conf/appcontext.xml");5.ApplicationContext factory=new ClassPathXmlApplicationContext("file:G:/Test/src/appcontext.xml");三: FileSystemXmlApplicationContext用文件系统的路径必须把applicationContext.xml放置到工程目录下面，也就是项目路径的下面1.ApplicationContext factory=newFileSystemXmlApplicationContext("src/appcontext.xml");//使用了classpath: 前缀,作为标志, 这样,FileSystemXmlApplicationContext 也能够读入classpath下的相对路径没有classpath的话就是从当前的工作目录2.ApplicationContext factory=newFileSystemXmlApplicationContext("classpath:appcontext.xml");3.ApplicationContext factory=newFileSystemXmlApplicationContext("file:G:/Test/src/appcontext.xml");4.ApplicationContext factory=newFileSystemXmlApplicationContext("G:/Test/src/appcontext.xml");四: XmlWebApplicationContext是专为Web工程定制的。

<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="/schema/beans"
xmlns:xsi="/2001/XMLSchema-instance"
xsi:schemaLocation="/schema/beans
传统J2EE应用的开发效率低，应用服务器厂商对各种技术的支持并没有真正统一，导致J2EE的应用没有真正实现Write Once及Run Anywhere的承诺。Spring作为开源的中间件，独立于各种应用服务器，甚至无须应用服务器的支持，也能提供应用服务器的功能，如声明式事务、事务处理等。
Spring致力于J2EE应用的各层的解决方案，而不是仅仅专注于某一层的方案。可以说Spring是企业应用开发的“一站式”选择，并贯穿表现层、业务层及持久层。然而，Spring并不想取代那些已有的框架，而是与它们无缝地整合。
}
publicvoidrecharge(){
System.out.println("您好"+user.getAccount()+"用户,你的账户充值成功！");
System.out.println("充值金额为:"+user.getMoney());
}
publicvoidread(){
try(BufferedReader reader =newBufferedReader(
（三）Spring由哪些模块组成？它们分别有些什么作用？
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图所示：

spring注解注⼊properties配置⽂件早期，如果需要通过spring读取properties⽂件中的配置信息，都需要在XML⽂件中配置⽂件读取⽅式。

基于XML的读取⽅式：1<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">2<property name="locations">3<list>4<value>classpath:properties/thread-pool.properties</value>5</list>6</property>7</bean>当然，这种⽅式可以统⼀管理properties配置⽂件，也能实现代码的松耦合。

但为了⽅便开发，提⾼开发效率，spring官⽅后来提供了基于注解的配置读取⽅式。

两种⽅式各有优势，可以基于对项⽬的考虑选择最合适的⽅式。

接下来就介绍如何通过注解注⼊properties的配置信息。

⾸先，准备配置⽂件：1 core.pool.size=22 max.pool.size=33 keep.alive.time=14 task.queue.size=35 await.termination.time=5定义配置类：1package org.cellphone.config;23import com.google.gson.Gson;4import org.springframework.beans.factory.annotation.Value;5import org.springframework.context.annotation.Bean;6import org.springframework.context.annotation.PropertySource;7import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;8import ponent;910/**11 *12*/13 @Component14 @PropertySource("classpath:properties/thread-pool.properties")15public class ThreadPoolConfig {16/**17 * 核⼼线程个数18*/19 @Value("${core.pool.size}")20private int corePoolSize;21/**22 * 最⼤线程个数23*/24 @Value("${max.pool.size}")25private int maxPoolSize;26/**27 * 保持⼼跳时间28*/29 @Value("${keep.alive.time}")30private int keeAliveTime;31/**32 * 任务队列长度33*/34 @Value("${task.queue.size}")35private int taskQueueSize;36/**37 * 等待任务结束的时间38*/39 @Value("${await.termination.time}")40private int awaitTerminationTime;4142/**43 * 使⽤@value注解注⼊properties中的属性44 * 1. 在类名上⾯使⽤ @PropertySource("classpath:*") 注解,*代表属性⽂件路径,可以指向多个配置⽂件路径45 * 如果是多个配置⽂件,则是 @PropertySource({"classpath:*","classpath:*"....})46 * 2. 在字段上直接使⽤@value注解47 * 3. 注解内使⽤${core.pool.size} core.pool.size 代表属性⽂件⾥⾯的key48 * 5. 需要新增 PropertySourcesPlaceholderConfigurer 的 bean49 * 6. 在 PropertySourcesPlaceholderConfigurer 增加@bean注解,申明返回的是⼀个bean,否则会注⼊失败50 *51*/525355 @Bean56public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {57return new PropertySourcesPlaceholderConfigurer();58 }5960public int getCorePoolSize() {61return corePoolSize;62 }6364public void setCorePoolSize(int corePoolSize) {65this.corePoolSize = corePoolSize;66 }6768public int getMaxPoolSize() {69return maxPoolSize;70 }7172public void setMaxPoolSize(int maxPoolSize) {73this.maxPoolSize = maxPoolSize;74 }7576public int getKeeAliveTime() {77return keeAliveTime;78 }7980public void setKeeAliveTime(int keeAliveTime) {81this.keeAliveTime = keeAliveTime;82 }8384public int getTaskQueueSize() {85return taskQueueSize;86 }8788public void setTaskQueueSize(int taskQueueSize) {89this.taskQueueSize = taskQueueSize;90 }9192public int getAwaitTerminationTime() {93return awaitTerminationTime;94 }9596public void setAwaitTerminationTime(int awaitTerminationTime) {97this.awaitTerminationTime = awaitTerminationTime;98 }99100 @Override101public String toString() {102return new Gson().toJson(this);103 }104 }这⾥注⼊了⼀个 PropertySourcesPlaceholderConfigurer bean，spring是通过 PropertySourcesPlaceholderConfigurer 的 locations 来查找属性⽂件，然后再根据注解将匹配的属性set进去，下⾯通过源码来了解注解可以进⾏⼀些什么操作。

spring.factories配置⽂件的⼯⼚模式在springboot的各个依赖包下，我们经常看到META-INF/spring.factories这个⽂件。

spring.factories⽂件的内容基本上都是这样的格式：1 # Initializers2 org.springframework.context.ApplicationContextInitializer=\3 org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\4 org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener我们看到，这个⽂件配置了⼀个key:value格式的数据1）key是：org.springframework.context.ApplicationContextInitializer2）value是：org.springframework.context.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,org.springframework.context.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener key声明的是⼀个接⼝，value则是这个接⼝对应的实现类，如果有多个则以","符号分割。

简单来说，spring.factories⽂件包含了⼀些接⼝相对应的实现类的配置，我们通过这些配置就可以知道接⼝有哪些可选的实现类，并通过反射获取对应的实例对象。

就像是简单⼯⼚模式⼀样，也因此spring将这个⽂件定义为spring.factories这个名字。

springlog4j2.xml配置⽂件详解⼀、log4j2介绍 log4j 2.x版本不再⽀持像1.x中的.properties后缀的⽂件配置⽅式，2.x版本配置⽂件后缀名只能为".xml",".json"或者".jsn"。

配置⽂件的格式：log2j配置⽂件可以是xml格式的，也可以是json格式的。

配置⽂件的位置：log4j2默认会在classpath⽬录下寻找log4j2.xml、log4j.json、log4j.jsn等名称的⽂件。

系统选择配置⽂件的优先级(从先到后)如下： (1).classpath下的名为log4j2-test.json 或者log4j2-test.jsn的⽂件. (2).classpath下的名为log4j2-test.xml的⽂件. (3).classpath下名为log4j2.json 或者log4j2.jsn的⽂件. (4).classpath下名为log4j2.xml的⽂件. 我们⼀般默认使⽤log4j2.xml进⾏命名。

⼆、配置⽂件节点解析 (1).根节点Configuration有两个属性:status和monitorinterval,有两个⼦节点:Appenders和Loggers(表明可以定义多个Appender和Logger)。

status⽤来指定log4j本⾝的打印⽇志的级别。

monitorinterval⽤于指定log4j⾃动重新配置的监测间隔时间，单位是s,最⼩是5s。

(2).Appenders节点，常见的有三种⼦节点:Console、RollingFile、File。

Console节点⽤来定义输出到控制台的Appender。

name:指定Appender的名字. target:SYSTEM_OUT 或 SYSTEM_ERR,⼀般只设置默认:SYSTEM_OUT。

PatternLayout:输出格式，不设置默认为:%m%n。

springboot目录结构和配置文件详解Spring Boot是一个用于创建独立的、基于生产级别的Spring应用程序的框架。

它具备了自动配置、内嵌服务器和依赖管理等特性，使得开发人员可以更加便捷地创建和部署Spring应用程序。

在使用Spring Boot开发应用程序时，了解其目录结构和配置文件是非常重要的。

本文将详细介绍Spring Boot的目录结构和配置文件。

一、目录结构Spring Boot的项目目录结构与传统的Java Web项目有些不同，主要包括以下几个目录：1. src/main/java：该目录用于存放项目的源代码文件。

2. src/main/resources：该目录用于存放项目的资源文件，如配置文件、静态资源文件等。

3. src/test/java：该目录用于存放项目的测试用例代码文件。

4. src/test/resources：该目录用于存放项目的测试用例的资源文件。

除了以上几个目录外，还有一些重要的文件如下：1. pom.xml：该文件是项目的依赖管理文件，用于配置项目所需的依赖库。

2. application.properties/application.yml：这是Spring Boot 的配置文件，用于配置应用程序的参数。

二、配置文件在Spring Boot中，配置文件主要包括两种形式：properties和yml。

1. application.properties：application.properties是以key=value的形式配置的文本文件。

其中，key为配置项的名称，value为配置项的值。

以下是一个示例的application.properties文件：```#数据库连接配置#服务器端口配置server.port=8080#日志级别配置.springframework=INFO```在上述示例中，配置了数据库连接URL、用户名和密码，服务器端口和日志级别等配置项。

Spring使⽤@Value注解与@PropertySource注解加载配置⽂件操作1、@Value注解简介Spring框架提供的@Value注解可以将外部的值动态注⼊到Bean中，@Value注解使⽤在字段、构造器参数和⽅法参数上。

@Value可以指定属性取值的表达式，⽀持通过#{}使⽤SpringEL来取值，也⽀持使⽤${}来将属性来源中（Properties⽂件、本地环境变量、系统属性等）的值注⼊到Bean的属性中。

此注解值的注⼊发⽣在AutowiredAnnotationBeanPostProcessor类中。

@Value注解实现以下⼏种情况：（1）注⼊普通字符；（2）注⼊操作系统属性；（3）注⼊表达式运算结果；（4）注⼊其他Bean的属性；（5）注⼊⽂件内容；（6）注⼊⽹址内容；（7）注⼊属性⽂件。

2、@PropertySource注解简介@PropertySource注解可以加载指定的属性⽂件（*.properties）到 Spring 的 Environment 中。

可以配合 @Value 和@ConfigurationProperties 使⽤。

语法格式如下：@PropertySource(value = "classpath:com/pjb/el/user.properties",encoding = "UTF-8")public class UserInfo{}【实例】使⽤@Value注解与@PropertySource注解加载配置⽂件。

（1）创建⽤户信息属性⽂件（user.properties）erId=1erName=pan_junbiao的博客user.blogUrl=https:///pan_junbiaouser.remark=您好，欢迎访问 pan_junbiao的博客（2）创建⽤户信息实体类（UserInfo.java）使⽤@PropertySource注解加载配置⽂件信息，然后使⽤@Value注解注⼊属性值。

Springboot常⽤注解及配置⽂件加载顺序详解Springboot常⽤注解及底层实现1、@SpringBootApplication：这个注解标识了⼀个SpringBoot⼯程，她实际上是另外三个注解的组合，分别是：@SpringBootConfiguration：源码可以看到，这个注解除了元注解外，实际就只有⼀个@Configuration，把该类变成⼀个配置类，表⽰启动类也是⼀个配置类；@EnableAutoConfiguration：是开启⾃动配置的功能，向Spring容器中导⼊了⼀个Selector，⽤来加载ClassPath下SpringFactories中所定义的⾃动配置类，将这些⾃动加载为配置Bean;由@AutoConfigurationPackage和@Import组成，前者表⽰让包中的类能够被⾃动扫描到spring容器中；使⽤import是往Spring容器中导⼊⼀个组件，将主配置类的所在包及⼦包所有组件扫描加载到Spring容器；Springboot在启动的时候，从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为⾃动配置类导⼊到容器中，⾃动配置类就⽣效，帮我们进⾏⾃动配置⼯作。

以前需要我们⾃⼰配置的东西，⾃动配置类都帮我们完成了。

@ComponentScan：标识扫描路径，因为默认是没有配置实际扫描路径的，所以SpringBoot扫描的路径是启动类所在的当前⽬录；2、@Bean注解：⽤来定义Bean，类似于XML中的<bean>标签，Spring在启动时，会对加了@Bean注解的⽅法进⾏解析，将⽅法的名字作为beanName，并通过执⾏⽅法得到bean对象；3、@Controller、@Service、@ResponseBody、@AutowiredSpringboot中配置⽂件的加载顺序优先级从⾼到低，⾼优先级的配置覆盖低优先级的配置，所有配置会形成互补配置；1、命令⾏参数。

spring配置详解1.前⾔公司⽼项⽬的后台，均是基于spring框架搭建，其中还⽤到了log4j.jar等开源架包。

在新项⽬中，则是spring和hibernate框架均有使⽤，利⽤了hibernate框架，来实现持久化，简化sql操作等。

Hibernate配置⽂件可以有两种格式，⼀种是 hibernate.properties，另⼀种是hibernate.cfg.xml。

后者稍微⽅便⼀些，当增加hbm映射⽂件的时候，可以直接在 hibernate.cfg.xml ⾥⾯增加，不必像 hibernate.properties 必须在初始化代码中加⼊。

我们新项⽬中使⽤的是hibernate.cfg.xml格式。

不过在本⽂中不将细述，后续有机会再补上。

公司项⽬中，中间件主要有tomcat，webshpere，WebLogic。

以下，将对项⽬中spring基本配置，log4j的配置，还有中间件的相关参数配置做⼀个初步的介绍。

2.spring配置——以⽼GIS项⽬为例⼦GISV13中的配置涉及到了SpringMVC,IOC,AOP, Quartz⽅⾯的配置。

配置的实现是通过注记配置和XML配置来合作实现。

这⾥，我将按照Spring的配置流程，将其他⼏个⽅⾯的配置融合其中，来进⾏全⾯解析。

2.1SpringMVC的配置2.1.1.web.xml的配置Web程序中，当中间件启动时，中间件会⾸先读取web.xml中的配置。

在web.xml中可以配置监听器，过滤器，servlet映射等等。

在Spring 框架中，我们主要需配置容器初始化时读取的spring容器配置⽂件的路径以及springMVC中的分发器DispatcherServlet。

在GISV13的web.xml中，我们定义了如下内容：InitGISConfigServlet定义了容器启动时，⾸先要运⾏这个⽅法。

然后servletname为MVC的这部分便是定义了springMVC的分发器以及此servlet所对应的加载配置⽂件的路径。

如何使用多个Spring的xml配置文件(多模块配置)在用Struts Spring Hibernate进行项目团队开发的时候，我们每个开发人员可能都会用到spring的配置文件，如果我们每个开放人员都用同一个的话，这样会给项目开发带来一定的影响，不过大家不用急，Spring为我们提供了很好的方法，我们可以写多个xml文件，然后将每个文件引入进来就行了，话不多说了，马上开始！！方法一、在web.xml中定义 contextConfigLocation参数.spring会使用这个参数加载.所有”逗号”分割的xml.如果没有这个参数,spring默认加载WEB-INF/applicationContext.xml文件(我们现在将Spring配置文件都放在WEB-INF下面)<context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:conf/spring/applicationContext_core*.xml,classpath*:conf/spring/applicationContext_dict*.xml,classpath*:conf/spring/applicationContext_hibernate.xml,classpath*:conf/spring/applicationContext_staff*.xml,classpath*:conf/spring/applicationContext_security.xmlclasspath*:conf/spring/applicationContext_modules*.xmlclasspath*:conf/spring/applicationContext_cti*.xmlclasspath*:conf/spring/applicationContext_apm*.xml</param-value></context-param>contextConfigLocation 参数定义了要装入的 Spring 配置文件。

读取xml文件/*** 利用XmlBeanFactory(Resource resource)* 这里Resource必须是xml格式* Resource包括：AbstractResource, ClassPathResource, FileSystemResource, * InputStreamResource, ServletContextResource, UrlResource*//** 利用InputStreamResource(InputStream inputStream)* 要将applicationContext.xml放在项目根目录下*/InputStream is = null;try {is = new FileInputStream("applicationContext.xml");} catch (FileNotFoundException e) {e.printStackTrace();}Resource resource = new InputStreamResource(is);BeanFactory factory = new XmlBeanFactory(resource);UserDao userDao = (UserDao)factory.getBean("userDao");/** 利用Properties* 要将bean.properties放在类路径－－源文件夹（src）目录下*/具体见1.利用ClassPathXmlApplicationContext可以从classpath中读取XML文件(1) ApplicationContext context = newClassPathXmlApplicationContext("applicationContext.xml");UserDao userDao = (UserDao)context.getBean("userDao");(2) ClassPathXmlApplicationContext resource = new ClassPathXmlApplicationContext(new String[]{"applicationContext-ibatis-oracle.xml","applicationC ontext.xml","applicationContext-data-oracle.xml"});BeanFactory factory = resource;UserDao userDao = (UserDao) factory.getBean("userDao");2. 利用ClassPathResource可以从classpath中读取XML文件Resource cr = new ClassPathResource("applicationContext.xml");BeanFactory bf=new XmlBeanFactory(cr);UserDao userDao = (UserDao)bf.getBean("userDao");加载一个xml文件org.spring framewonfig.PropertyPlaceholderConfigurer不起作用3．利用XmlWebApplicationContext读取从Web应用程序的文件架构中，指定相对位置来读取定义文件。

web.xml的配置web.xml应该是整个项目最重要的配置文件了，不过servlet3.0中已经支持注解配置方式了。

在servlet3.0以前每个servlet必须要在web.xml中配置servlet及其映射关系。

但是在spring框架中就不用了，因为Spring中是依赖注入（Dependency Injection）的也叫控制反转（Inversion of Control）。

但是也要配置一个重要的servlet，就是前端控制器（DispatcherServlet）。

配置方式与普通的servlet基本相似。

配置内容如下：<!-- 配置前端控制器--><servlet><servlet-name>spring</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><!-- ContextconfigLocation配置springmvc加载的配置文件适配器、处理映射器等--><param-name>contextConfigLocation</param-name><param-value>WEB-INF/classes/spring/springmvc.xml</param-value></init-param></servlet><servlet-mapping><servlet-name>spring</servlet-name><!-- 1、.action访问以.action结尾的由DispatcherServlet进行解析2、/,所有访问都由DispatcherServlet进行解析--><url-pattern>/</url-pattern></servlet-mapping>这里需要注意，springmvc.xml是spring配置文件，将在后面讨论。

SpringMVC的配置⽂件⼀、root标签跟spring配置⼀样，root标签是beans，毕竟springmvc是spring的⼀个模块在springmvc⾥，⾃动扫描主要是配置controller：⼆、⾃动扫描：⼆、⾃动扫描：在<context:component-scan base-package="com.xxx.controller"/>三、解析器Resolver：解析器有很多种，⽐较重要的是ViewResolverViewResolver也有很多种，其中⽐较重要和常⽤的是InternalResourceViewResolver（内部资源视图解析器）代码：<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"><property name="prefix" value="/WEB-INF/jsp/" /><property name="suffix" value=".jsp" /></bean>如果没有视图解析器，我们在controller⾥⾯的代码是这样的：@Controllerpublic class LoginActionController {@RequestMapping("/index")public String toIndex(HttpServletRequest request, ModelMap map, HttpSession session) {return "/WEB-INF/jsp/index.jsp";}⽽使⽤了视图解析器，我们的代码是这样的：@Controllerpublic class LoginActionController {@RequestMapping("/index")public String toIndex(HttpServletRequest request, ModelMap map, HttpSession session) {return "index";}区别在最后⼀句，我们不需要给出⽬标视图的全路径了。

SpringBoot获取配置⽂件的简单实现⽅法前⾔在讲SpringBoot 获取配置⽂件之前我们需要对SpringBoot 的项⽬有⼀个整体的了解，如何创建SpringBoot 项⽬，项⽬结构等等知识点，我在这⾥就不⼀⼀讲述了，没有学过的⼩伙伴可以⾃⼰在⽹上找⼀些资料进⾏学习，很简单的。

下⾯让我们开始今天的内容讲解吧。

⼀、SpringBoot 全局配置⽂件的加载顺序在SpringBoot 当中，全局配置⽂件有两种不同的格式，⼀个是我们常见的properties, ⼀种是yml.这两种格式的⽂件其实也没什么太⼤的区别，使⽤的时候按照个⼈的习惯来就⾏，下⾯我们⽤的是yml⽂件。

⾸先，当我们创建SpringBoot 的项⽬时，默认在resources⽬录下创建⼀个application.properties⽂件，这时我们可以在这个⽂件当中对项⽬进⾏配置即可。

但是在SpringBoot 中application.properties可以存放在以下⼏个位置：file:./config/ 项⽬根⽬录下的config⽂件夹下file:./ 项⽬根⽬录下classpath:/config/ 类路径下的config⽂件夹下classpath:/ 类路径下⽂件的加载顺序：即根⽬录下的config⽬录下，然后是根⽬录下，然后是classpath路径下的config⽬录下，最后是classpath路径下。

优先级由⾼到低，⾼优先级的配置会覆盖低优先级的配置。

假如：根⽬录下的config⽬录下定义端⼝为8084，根⽬录下定义端⼝为8083 ，classpath路径下的config⽬录定义端⼝为8082，classpath路径下定义端⼝为8081，最后启动，启动的端⼝为8084 ，⾼优先级会覆盖低优先级。

注意：并不是⾼优先级的被加载了，低优先级的就不会再加载，实际上是SpringBoot会从这四个位置全部加载主配置⽂件，并且还能产⽣互相配置的效果。