Spring XML配置文件详解

2023-05-16

spring配置文件是用于指导Spring工厂进行Bean生产、依赖关系注入（装配）及Bean实例分发的"图纸"。Spring框架的配置文件是基于xml的，Spring强大的功能依赖于类型繁多的配置项，这些配置项纷繁复杂难以记忆，下面将常用的配置项示例记录下来，以备后续查看使用。

一、Spring配置文件示例

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
	
	<!-- 注解包扫描 -->
	<context:component-scan base-package="com.test.fx.service"></context:component-scan>
	<!-- 引入DB配置文件 -->
	<context:property-placeholder location="classpath:oracleDriver.properties"/>	
	<!-- 配置数据源 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="${driver}"></property>
		<property name="url" value="${url}"></property>
		<property name="username" value="${name}"></property>
		<property name="password" value="${password}"></property>
	</bean>
	<!-- 创建SqlSessionFactory -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource"></property>
		<property name="mapperLocations" value="classpath:com/baizhi/fx/dao/*DaoImpl.xml"></property>
	</bean>
	<!-- 扫描Mapper文件并生成dao对象 -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
		<property name="basePackage" value="com.test.fx.dao"></property>
	</bean>
	<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 事务管理器注解 -->	
	<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

二、配置文件详解

上面给出了Spring最基本的配置文件示例，下面就其标签元素进行详细说明

1.XML结构体概述

这是一个最基本的Spring XML配置文件结构体,这些格式基本都是固定的，可以直接复用

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" <!-- 默认bean命名空间 -->
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" <!-- xml约束命名空间定义 -->
xmlns:aop="http://www.springframework.org/schema/aop"<!-- AOP命名空间的scheme约束 -->
xmlns:context="http://www.springframework.org/schema/context" <!-- context命名空间的scheme约束 -->

xsi:schemaLocation=" <!-- 上面各个scheme的location信息(网络地址) -->
　　　　 http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd ">

</beans>

2.<Bean>标签

<!-- 一个最基本的bean标签 -->
<bean id="bean名称" class="bean的类全名(类全限定路径)" scope="作用域">

上面bean配置了3条最常见的属性,实际上bean的属性有以下内容：

属性	说明
id	bean的名称,可以随便起名但在spring定义中,一般为类名的驼峰命名。例如<bean id=“userServiceImpl”>
class	bean的完全限定名，就是类的全路径名。<bean class=“com.test.demo.UserServiceImpl”>
scope	bean的作用域，或者叫声明周期。可选值有singleton(单例)，prototype(多例，又叫原型)，request，session，global session
lazy-init	lazy-init 属性表明了bean是否为延迟加载。false为立即加载，表示在spring启动时，立刻进行实例化。为true时将不会在ApplicationContext启动时提前被实例化，而是第一次向容器通过getBean索取bean时实例化才会加载。
init-method	用于在bean初始化时指定执行方法。只有一个类完整的实例被创建出来后，才能走初始化方法
destroy-method	用于容器在销毁bean之前调用的方法。注意spring容器在销毁bean时会先执行对应的destroy方法后销毁该bean
abstract	是否为抽象Bean，spring对于抽象bean不产生实例，主要用于继承
parent	父Bean的名称，会继承父Bean的属性，与Java的Class无任何关系,也就是说定义了一个抽象类，这个抽象类被作为父类，其他子类可以继承父类的属性。这个父类在spring的配置文件中定义时，无需指定class属性
factory-bean	创建该bean时使用的工厂类(名字)
factory-method	要调用的工厂类方法
depends-on	依赖对象,这个Bean在初始化时依赖的对象，这个对象会在这个Bean初始化之前创建。
dependency-check	依赖检查它用来确保Bean组件通过JavaBean描述的所以依赖关系都得到满足。在与自动装配功能一起使用时，它特别有用。可选值：none(不进行依赖检查)，objects(只做对象间依赖的检查)，simple(只做原始类型和String类型依赖的检查)，all(对所有类型的依赖进行检查。它包括了前面的objects和simple)
autowire	自动装配，它定义了Bean的自动装载方式。可选值：no(不使用自动装配功能)，byName(通过Bean的属性名实现自动装配)，byType(通过Bean的类型实现自动装配)，constructor(构造函数的参数的自动组装)，autodetect通过bean类的自省机制（introspection）来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式

lazy-init属性需要注意的是：
- 如果一个设置了立即加载的bean1，引用了一个延时加载的bean2，那么bean1在容器启动时被实例化，而bean2由于被bean1引用，所以也被实例化，这种情况也符合延时加载的bean在第一次调用时才被实例化的规则。
- 在容器层次中通过在<beans/>元素上使用’default-lazy-init’属性来控制延时初始化也是可能的。如下面配置：
```
<beans default-lazy-init="true"></beans>
```
- 如果一个bean的scope属性为scope="pototype"时，即使设置了lazy-init=“false”,容器启动时不实例化bean，而是调用getBean方法实例化的

init-method属性说明:

此属性用于替代的是 InitializingBean接口。InitializingBean接口为bean提供了初始化方法的方式，它只有afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候会执行该方法

// 示例
import org.springframework.beans.factory.InitializingBean;
public class TestInitializingBean implements InitializingBean{
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("TestInitializingBean "); 
    } 
}

<!-- 配置文件 -->
<bean id="testInitializingBean" class="com.TestInitializingBean" ></bean>

// 测试类如下
public class Main {
    public static void main(String[] args){
        ApplicationContext context = 
            new FileSystemXmlApplicationContext("/src/main/java/com/beans.xml");
    }
}
// 打印结果为：TestInitializingBean

如果在配置文件中指明了bean的init-method方法，则不用实现InitializingBean接口。示例如下

public class TestInitMethod{
    public void testInit(){
        System.out.println("test init-method");        
    }
}

<bean id="testInitMethod" class="com.TestInitMethod" init-method="testInit"></bean>

public class Main {
    public static void main(String[] args){
        ClassPathXmlApplicationContext context1 = 
            new ClassPathXmlApplicationContext("spring.xml");
　　}
}
// 打印结果为：test init-method

destroy-method属性：
- 与之init初始化方法类似的是，此属性替代的是DisposableBean接口中的destroy()方法
- 当bean的作用域scope = "prototype"时，该属性将失效，因为在spring中，如果一个bean为多例的，那么该bean被创建后，spring将不再去管理了

关于abstract和praent属性：

// 这里有一个类叫做XiaoMing
public class XiaoMing{
    private String id;
    private String loginName;
    private String loginPwd;
    private String sex;
}

// 又有另一个类叫XiaoHong
public class XiaoHong{
    private String id;
    private String loginName;
    private String loginPwd;
    private String sex;
}

此时，我们发现，这两个类有公用的字段属性，此后不管叫小刚，李四，王五也好，他们都会有共同的属性

,假设他们拥有同一个登录帐号，那么我们可以将登录字段属性设置为一个抽象类,其他子类可以继承

<bean id="loginAbstract" abstract="true">
	<property name="loginName" value="admin"/>
    <property name="loginPwd" value="admin"/>
</bean>

<!-- 其他子类继承了父类中的通用属性 -->
<bean id="xiaoMing" class="com.test.demo.XiaoMing" parent="loginAbstract">
	<property name="id" value="001" />
    <property name="sex" value="man" />
</bean>

<bean id="xiaoHong" class="com.test.demo.XiaoHong" parent="loginAbstract">
	<property name="id" value="002" />
    <property name="sex" value="woman" />
</bean>

factory-bean & factory-method说明

这两个属性可以同时出现，也可以只指定factory-method，下面进行详细说明。

情况一：同时使用factory-bean 和 factory-method
```
// 汽车生产工厂类
public class CarFactory {
   // 非静态方法
   public Car createCar(){
       Car car = new Car();
       car.setBrand("BMW");
       return car;
   }
}
```
```


<bean id="carFactory" class="com.factory.demo.CarFactory"/>

<bean id="car1" factory-bean="carFactory" factory-method="createCar">
</bean>
```
我们在一个bean 元素上同时配置 factory-bean 和 factory-method，那么意思就是说，这个bean 的创建就使用工厂模式，即由CarFactory工厂类创建car对象。factory-method属性指向了工厂类中的具体产生car对象的方法。此处的方法必须是非静态的（如果是静态的则会抛出异常）。至于原因你也一定能想到，static方法可以直接通过类调用而无需实例化，何必再去多此一举实例化工厂类呢

情况二：只配置了factory-method属性

public class CarFactory {
   // 静态方法
   public static Car createStaticCar(){
       Car car = new Car();
       return car;
   }
}

<!-- 指定该bean的class类型为该bean的工厂类 -->
<bean id="car2" class="com.bean.demo.CarFactory" factory-method="createStaticCar"></bean>

这里该bean的class类型为产生该bean的工厂类，factory-method指向该工厂类的非静态方法。

另外工厂方法是可以有参数的，如果有参数，那么我们可以通过 constructor-arg 进行配置，原理跟普通的构造方法注入是一样的

public class CarFactory {
   // 静态方法
   public static Car createStaticCar(String brand){
       Car car = new Car();
       car.setBrand(brand);
       return car;
   }
}

<bean id="car2" class="com.bean.demo.CarFactory" factory-method="createStaticCar">
	<constructor-arg name="brand" value="GTR" />
</bean>

ref引用属性

用于指定属性值为spring容器中的其它bean.两个基本属性是local和bean

local：如果一个bean与被参考引用的bean在同一个xml 文件中而且被引用参考的bean是用id来命名的，那么就可以使用ref的local属性。这样会让项目里解析器更早的在xml文档解析时，验证bean的id

**Bean：**用ref元素的bean属性指定被参考引用的bean是spring中最常见的形式，它允许指向的bean可以在同一个xml，也可以不在同一个xml中。bean属性的值可以与被参考引用的bean的id属性相同，也可以与被参考引用的bean的属性不相同

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    <property name="url" value="jdbc:mysql://localhost:3306/db_ssm" />
    <property name="username" value="hc" />
    <property name="password" value="123456" />
</bean>

<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource">
        <ref local="dataSource"/>
        <!-- 
			<ref bean="dataSource">
		-->
    </property>
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
</bean>

3.<aop>标签

 <!-- 定义切面bean -->
<bean id="切面bean的id" class="类的全限定路径"></bean>

<!-- 目标对象 -->
<bean id="目标对象id" class="目标对象类的全限定路径"></bean>

<!-- 定义切面的配置：注解 -->
<aop:config>
    <aop:aspect id="切面ID" ref="要引用的切面实例名称">
        <!--定义一个切点 -->
        <aop:pointcut id="切入点名称"  expression="切入点表达式" />
        <!-- 定义四类通知-->
        <aop:before method="切面类前置通知方法名" pointcut-ref="引用的切入点名称"/>
        <aop:after method="切面类后置通知方法名" pointcut-ref="引用的切入点名称"/>
        <aop:after-returning method="切面类最终通知方法名" pointcut-ref="引用的切入点名称"/>
        <aop:after-throwing method="切面类异常通知方法名" pointcut-ref="引用的切入点名称"/>
        <!-- 定义环绕通知 -->
        <aop:around method="切面类环绕通知方法名" pointcut-ref="引用的切入点名称"/>
        <!--定义增强类  -->
        <aop:declare-parents types-matching="com.test.CurdServiceImpl(匹配的类型)" 
                             implement-interface="com.test.CurdService(实现的接口)" 
                             default-impl="com.test.CurdServiceImpl(默认实现类)"/>
    </aop:aspect>
</aop:config>

有关AOP的XML配置使用请移步本博客:
AOP XML的配置使用 https://blog.csdn.net/zxcbnm7089/article/details/104359598

4.各种bean的值注入

请移步本博客：

Spring Bean值注入 - 基于XML配置文件 https://blog.csdn.net/zxcbnm7089/article/details/104394070

5.<tx>事务标签

xml配置格式如下

<!-- 配置事务管理器 -->
<bean id="事务管理bean id" class="类的全限定路径">
	<property name="数据源属性名称" ref="引用的数据源实例名称" />
</bean>

<!-- 配置一个事务通知 -->
<tx:advice id="事务通知名称" transaction-manager="事务管理器实例名称">
    <tx:attributes>
        <tx:method name="方法名" read-only="是否只读" propagation="事务类型"/>
        <!-- 其他所有方法，以默认事务运行 -->
        <tx:method name="*" />
    </tx:attributes>
</tx:advice>

<!-- 配置事务切入点 -->
<aop:config>
	<aop:pointcut id="事务切入点id" expression="事务切入点表达式" />
    <aop:advisor advice-ref="事务通知名称" ponitcut-ref="事务切入点id" />
</aop:config>

代码使用示例

<!-- 配置数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="${driver}"></property>
    <property name="url" value="${url}"></property>
    <property name="username" value="${name}"></property>
    <property name="password" value="${password}"></property>
</bean>

<!-- 配置事务管理器 -->
<bean id="transactionManager" 		
      class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 配置事务通知 -->
<!-- 使用<tx:advice>元素声明事务通知，需要指定id属性，以便AOP把通知和切入点关联起来 -->
<!-- 还需要指定transaction-manager属性，其值为Bean配置文件中事务管理器的id属性值 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!-- 在<tx:advice>元素下声明<tx:attributes>元素，用于指定事务属性 -->
    <!-- 在<tx:attributes>元素下可以使用多个<tx:method>元素指定不同方法的不同事务属性 -->
	<tx:attributes>
		<!-- 根据方法名指定事务的属性  -->
		<tx:method name="BookShopXmlService" propagation="REQUIRED"/>
        <!--方法名以get开头的事务属性 -->
		<tx:method name="get*" read-only="true"/>
		<tx:method name="find*" read-only="true"/>
		<tx:method name="*"/>
	</tx:attributes>
</tx:advice>

<!-- 配置事务切入点,以及把事务切入点和事务属性关联起来 -->
<!-- 在<aop:config>元素下，使用<aop:advisor>元素声明一个增强器，将事务通知和切入点关联起来 -->
<!-- 使用 advice-ref属性指定事务通知，用pointcut-ref属性指定切入点 -->
<aop:config>
	<aop:pointcut expression="execution(* com.sqp.spring.service.*.*(..))"
		id="txPointcut"/>
	<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
</aop:config>

6.<context>标签

**<context:annotaion-config>**注解装配在默认情况下是不开启的，为了使用注解装配，我们必须在Spring配置文件中配置 <context:annotation-config/>元素。也就是说，如果我们想要使用@Autowired、@Resoure等注解时可以通过此标签配置，让Spring隐式的帮我们生成这些Bean。

<!-- 使用@Autowired注解，必须事先在Spring容器中声明AutowiredAnnotationBeanPostProcessor的Bean： -->
<bean class="org.springframework.beans.factory.annotation.
             AutowiredAnnotationBeanPostProcessor "/>

<!-- 使用 @Required注解，就必须声明RequiredAnnotationBeanPostProcessor的Bean -->
<bean class="org.springframework.beans.factory.annotation.
             RequiredAnnotationBeanPostProcessor"/>

<!-- 类似地，使用@Resource、@PostConstruct、@PreDestroy等注解就必须声明 CommonAnnotationBeanPostProcessor；使用@PersistenceContext注解，就必须声明 PersistenceAnnotationBeanPostProcessor的Bean。 -->

<!-- 这样的声明未免太不优雅，而Spring为我们提供了一种极为方便注册这些BeanPostProcessor的方式，即使用<context:annotation- config/>隐式地向 Spring容器注册AutowiredAnnotationBeanPostProcessor、RequiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor以及PersistenceAnnotationBeanPostProcessor这4个BeanPostProcessor。 -->
<context:annotation-config/>

**<context:component-scan>**组件扫描

Spring2.5为我们引入了组件自动扫描机制，它可以在类路径底下寻找标注了@Component、@Service、@Controller、@Repository注解的类，并把这些类纳入进Spring容器中管理。
```

<context:component-scan base-package="com.myapp" />
```
这个配置隐式注册了多个对注解进行解析处理的处理器，包括<context:annotation-config/>该配置注册的处理器，也就是说写了<context:component-scan base-package="" />配置，就不用写<context:annotation-config/>配置了。另外此标签还有一个属性是use-default-filter，默认为true这就意味着会扫描指定包下的全部的标有@Component，@Controller，@Service等等的类，并注册成bean
- 另外，<context:component-scan>标签还有两个子标签，其实就是扫描时的过滤器
```
<context:exclude-filter> 指定的不扫描
<context:include-filter> 指定的扫描
```
```


<context:component-scan base-package="com.sparta.trans" use-default-filters="false">
 <context:include-filter type="annotation"          expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
```

**<context:property-placeholder>**配置文件处理

用来处理用一个proerties文件里面的内容来替换spring配置文件中的${}内容，例如：

<!-- 引入DB配置文件 -->
<context:property-placeholder location="classpath:oracleDriver.properties"/>	
<!-- 配置数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="${driver}"></property>
    <property name="url" value="${url}"></property>
    <property name="username" value="${name}"></property>
    <property name="password" value="${password}"></property>
</bean>

属性	说明
location	表示引入配置文件的位置，多个之间用逗号分隔
file-encoding	指定文件编码,如GBK,UTF-8
ignore-resource-not-found	如果属性文件找不到，是否忽略，默认false，即不忽略，找不到将抛出异常
ignore-unresolvable	是否忽略解析不到的属性，如果不忽略，找不到将抛出异常
properties-ref	配置类的引用，如果在xml中声明了properties bean，那么将引用这个bean的id
local-override	是否本地覆盖模式，即如果true，那么properties-ref的属性将覆盖location加载的属性
system-properties-mode	系统属性模式:ENVIRONMENT(默认)，OVERRIDE，NEVER

ENVIRONMENT：将使用Spring 3.1提供的PropertySourcesPlaceholderConfigurer，其他情况使用Spring 3.1之前的PropertyPlaceholderConfigurer如果是本地覆盖模式：那么查找顺序是：properties-ref、location、environment，否则正好反过来；

OVERRIDE： PropertyPlaceholderConfigurer使用，因为在spring 3.1之前版本是没有Enviroment的，所以OVERRIDE是spring 3.1之前版本的Environment如果是本地覆盖模式：那么查找顺序是：properties-ref、location、System.getProperty(),System.getenv()，否则正好反过来；

NEVER：只查找properties-ref、location；

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)