Spring之依赖注入（IOC、DI）详解---配置Bean

Spring是什么

• 轻量级：Spring 是非侵入性的 - 基于 Spring 开发的应用中的对象可以不依赖于 Spring 的 API
• 依赖注入(DI — dependency injection、IOC)
• 面向切面编程(AOP — aspect oriented programming)
• 容器: Spring 是一个容器, 因为它包含并且管理应用对象的生命周期
• 框架: Spring 实现了使用简单的组件配置组合成一个复杂的应用. 在 Spring 中可以使用 XML 和 Java 注解组合这些对象
• 一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库 （实际上 Spring 自身也提供了展现层的 SpringMVC 和 持久层的 Spring JDBC）

IOC & DI 概述

推荐一个知乎帖子，从概念上形象的说明了IOC的思想：https://www.zhihu.com/question/23277575

IOC(Inversion of Control)：其思想是反转资源获取的方向. 传统的资源查找方式要求组件向容器发起请求查找资源. 作为回应, 容器适时的返回资源. 而应用了 IOC 之后, 则是容器主动地将资源推送给它所管理的组件, 组件所要做的仅是选择一种合适的方式来接受资源. 这种行为也被称为查找的被动形式

**DI(Dependency Injection) **：IOC 的另一种表述方式：即组件以一些预先定义好的方式(例如: setter 方法)接受来自如容器的资源注入. 相对于 IOC 而言，这种表述更直接

需求：从容器中获取 B 对象，并使 B 对象的 a 属性被赋值为容器中 A 对象的引用

传统方式：

class A{}

class B{

	private A a;
	public void setA(A a){
		this.a = a;
	}
}

IOC：

B b = getB();

注：本篇博客中使用的类，出于简洁，大部分不提供其实现，都是最基本的bean

Spring容器

在 Spring IOC 容器读取 Bean 配置创建 Bean 实例之前, 必须对它进行实例化. 只有在容器实例化后, 才可以从 IOC 容器里获取 Bean 实例并使用.

Spring 提供了两种类型的 IOC 容器实现：

• BeanFactory: IOC 容器的基本实现
• ApplicationContext: 提供了更多的高级特性. 是 BeanFactory 的子接口.

BeanFactory 是 Spring 框架的基础设施，面向 Spring 本身；ApplicationContext 面向使用 Spring 框架的开发者，几乎所有的应用场合都直接使用 ApplicationContext 而非底层的 BeanFactory.无论使用何种方式, 配置文件时相同的.

ApplicationContext 的主要实现类：

• ClassPathXmlApplicationContext：从 类路径下加载配置文件
• FileSystemXmlApplicationContext: 从文件系统中加载配置文件

ApplicationContext 在初始化上下文时就实例化所有单例的 Bean。通过ApplicationContext中的getBean()方法来从IOC容器中获取Bean。

依赖注入的方式 （Bean 的配置方式）

基于 XML 文件的方式

通过全类名（反射）

属性注入

• 属性注入即通过 setter 方法（即对应的属性在类中要有对应的set方法）注入Bean 的属性值或依赖的对象
• 属性注入使用<property>元素, 使用 name 属性指定 Bean 的属性名称，value 属性或 <value>子节点指定属性值
• 属性注入是实际应用中最常用的注入方式

<bean id="helloWorld" class="com.atguigu.spring.helloworld.HelloWorld">
		<!-- 为属性赋值，对应的属性需要有对应的set方法赋值才会成功，例如此处在HelloWorld类中需要有setName（）方法 -->
		<property name="user" value="Jerry"></property>
</bean>

构造器注入

**分为按索引匹配入参和按类型匹配入参两种：** ```

<!-- 若一个 bean 有多个构造器, 如何通过构造器来为 bean 的属性赋值 -->
<!-- 可以根据 index 和 value 进行更加精确的定位. 可以通过index与type混合使用，不标明index则默认依次的顺序 -->
<bean id="car" class="com.atguigu.spring.helloworld.Car">
	<!-- 构造器的参数是String，String，int -->
	<!-- 使用构造器注入属性可以指定参数的位置和参数的类型 ，以区分重载的构造器-->
	<constructor-arg value="KUGA" index="1"></constructor-arg>
	<constructor-arg value="ChangAnFord" index="0"></constructor-arg>
	<constructor-arg value="250000" type="float"></constructor-arg>
</bean>

<bean id="car2" class="com.atguigu.spring.helloworld.Car">
	<constructor-arg value="ChangAnMazda" type="java.lang.String"></constructor-arg>
	<!-- 若字面值中包含特殊字符, 则可以使用 CDATA 来进行赋值.例如如下包含“<>”的情况 (了解) -->
	<constructor-arg>
		<value><![CDATA[<ATARZA>]]></value>
	</constructor-arg>
	<!-- 使用如下value子结点的方式注入属性也是可以的 -->
	<constructor-arg  type="int">
		<value>250</value>
	</constructor-arg>
</bean>

引用其它Bean

组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能. 要使 Bean 能够相互访问, 就必须在 Bean 配置文件中指定对 Bean 的引用。在 Bean 的配置文件中, 可以通过 <ref> 元素或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用，也可以在属性或构造器里包含 Bean 的声明, 这样的 Bean 称为内部 Bean。

内部Bean：

	<!-- 声明使用内部 bean -->
	<bean id="service2" class="com.atguigu.spring.ref.Service">
		<property name="dao">
			<!-- 内部 bean, 类似于匿名内部类对象. 不能被外部的 bean 来引用, 也没有必要设置 id 属性 -->
			<bean class="com.atguigu.spring.ref.Dao">
				<property name="dataSource" value="c3p0"></property>
			</bean>
		</property>
	</bean>

集合属性等复合形式

在 Spring中可以通过一组内置的 xml 标签(例如: <list>, <set> 或 <map>) 来配置集合属性.配置 java.util.List 类型的属性, 需要指定 <list> 标签, 在标签里包含一些元素. 这些标签可以通过<value> 指定简单的常量值, 通过<ref> 指定对其他 Bean 的引用. 通过<bean> 指定内置 Bean 定义. 通过<null/> 指定空元素. 甚至可以内嵌其他集合.

	<!-- 装配集合属性 ，例如一个user会有多量车-->
	<bean id="user" class="com.atguigu.spring.helloworld.User">
		<property name="userName" value="Jack"></property>
		<property name="cars">
			<!-- 使用 list 元素来装配集合属性 ，同理需要存在对应的set方法setCars(List<Car> cars)-->
			<list>
				<ref bean="car"/>
				<ref bean="car2"/>
			</list>
		</property>
	</bean>

注：如上通过ref引用的car和car2是在之前都已经配置好的Bean

	<!-- 声明集合类型的 bean,需要导入util命名空间 -->
	<util:list id="cars">
		<ref bean="car"/>
		<ref bean="car2"/>
	</util:list>
	
	<bean id="user2" class="com.atguigu.spring.helloworld.User">
		<property name="userName" value="Rose"></property>
		<!-- 引用外部声明的 list -->
		<property name="cars" ref="cars"></property>
	</bean>

使用p命名空间与继承、依赖关系的配置

p命名空间
为了简化 XML 文件的配置，越来越多的 XML 文件采用属性而非子元素配置信息。Spring 从 2.5 版本开始引入了一个新的 p 命名空间，可以通过 元素属性的方式配置 Bean 的属性。使用 p 命名空间后，基于 XML 的配置方式将进一步简化（使用p命名空间，则不必再使用<property>标签）：

	<bean id="user3" class="com.atguigu.spring.helloworld.User"
		p:cars-ref="cars" p:userName="Titannic">
	</bean>
		

继承Bean配置

• Spring 允许继承 bean 的配置, 被继承的 bean 称为父 bean. 继承这个父 Bean 的 Bean 称为子 Bean
• 子 Bean 从父 Bean 中继承配置, 包括 Bean 的属性配置
• 子 Bean 也可以覆盖从父 Bean 继承过来的配置
• 父 Bean 可以作为配置模板, 也可以作为 Bean 实例. 若只想把父 Bean 作为模板, 可以设置<bean>的abstract 属性为 true, 这样 Spring 将不会实例化这个 Bean，只能被继承
• 并不是 <bean>元素里的所有属性都会被继承. 比如: autowire, abstract 等.
• 若一个bean的class属性没有指定，则该bean必须是一个抽象bean
• 也可以忽略父 Bean 的 class 属性, 让子 Bean 指定自己的类, 而共享相同的属性配置. 但此时 abstract 必须设为 true

	<!-- bean 的配置能够继承吗 ? 使用 parent 来完成继承，子bean也可以覆盖父Bean的属性，例如此处覆盖userName属性 -->	
	<bean id="user4" parent="user" p:userName="Bob"></bean>
	
	<bean id="user6" parent="user" p:userName="维多利亚"></bean>

依赖Bean配置

依赖Bean配置：Spring 允许用户通过 depends-on 属性设定 Bean 前置依赖的Bean，前置依赖的 Bean 会在本 Bean 实例化之前创建好。如果前置依赖于多个 Bean，则可以通过逗号，空格或的方式配置 Bean 的名称。

	<!-- bean之间的依赖关系 -->
	<!-- 测试 depents-on -->	
	<bean id="user5" parent="user" p:userName="Backham" depends-on="user6"></bean>

XML配置里的自动装配

Spring IOC 容器可以自动装配 Bean. 需要做的仅仅是在<bean>的 autowire 属性里指定自动装配的模式：

• byType(根据类型自动装配): 若 IOC 容器中有多个与目标 Bean 类型一致的 Bean. 在这种情况下, Spring 将无法判定哪个 Bean 最合适该属性, 所以不能执行自动装配.
• byName(根据名称自动装配): 必须将目标 Bean 的名称和属性名设置的完全相同.
• constructor(通过构造器自动装配): 当 Bean 中存在多个构造器时, 此种自动装配方式将会很复杂. 不推荐使用

	<!--  
		prototype: 原型的. 每次调用 getBean 方法都会返回一个新的 bean. 且在第一次调用 getBean 方法时才创建实例
		singleton: 单例的. 每次调用 getBean 方法都会返回同一个 bean. 且在 IOC 容器初始化时即创建 bean 的实例. 默认值 
	-->
	<bean id="dao2" class="com.atguigu.spring.ref.Dao" scope="prototype"></bean>
	
	<bean id="service" class="com.atguigu.spring.ref.Service" autowire="byName"></bean>
	
	<bean id="action" class="com.atguigu.spring.ref.Action" autowire="byType"></bean>

在 Bean 配置文件里设置 autowire 属性进行自动装配将会装配 Bean 的所有属性. 然而, 若只希望装配个别属性时, autowire 属性就不够灵活了. autowire 属性要么根据类型自动装配, 要么根据名称自动装配, 不能两者兼而有之.一般情况下，在实际的项目中很少使用自动装配功能，因为和自动装配功能所带来的好处比起来，明确清晰的配置文档更有说服力一些.

SpEL：字面量

Spring 表达式语言（简称SpEL）：是一个支持运行时查询和操作对象图的强大的表达式语言。语法类似于 EL：SpEL 使用 #{…} 作为定界符，所有在大框号中的字符都将被认为是 SpEL。SpEL 为 bean 的属性进行动态赋值提供了便利，其实现了：

• 通过 bean 的 id 对 bean 进行引用
• 调用方法以及引用对象中的属性
• 计算表达式的值
• 正则表达式的匹配

	<!-- 测试 SpEL: 可以为属性进行动态的赋值(了解) -->
	<bean id="girl" class="com.atguigu.spring.helloworld.User">
		<property name="userName" value="周迅"></property>
	</bean>
	<bean id="car" class="com.atguigu.spring.helloworld.Car">
		<constructor-arg value="Aodi"></constructor-arg>
		<constructor-arg value="Ford"></constructor-arg>
		<!-- 使用spel引用类的静态属性 -->
		<constructor-arg value="#{(java.lang.Math).PI*80}" ></constructor-arg>
	</bean>
	<bean id="boy" class="com.atguigu.spring.helloworld.User" init-method="init" destroy-method="destroy">
		<!-- 使用spel为属性赋一个字面值 -->
		<property name="userName" value="#{'LiMing'}"></property>
		<!-- 使用spel来引用其他的bean的属性 -->
		<property name="wifeName" value="#{girl.userName}"></property>
		<!-- 在spel中使用运算符，并且此处是动态赋值，由car对象的price属性来决定info的取值 -->
		<property name="info" value="#{car.price > 20000 ? '金领' ：‘白领’}"></property>
	</bean>
	

使用外部属性文件

在配置文件里配置 Bean 时, 有时需要在 Bean 的配置里混入系统部署的细节信息(例如: 文件路径, 数据源配置信息等). 而这些部署细节实际上需要和 Bean 配置相分离.

Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器, 这个处理器允许用户将 Bean 配置的部分内容外移到属性文件中. 可以在 Bean 配置文件里使用形式为 ${var} 的变量, PropertyPlaceholderConfigurer 从属性文件里加载属性, 并使用这些属性来替换变量.

Spring 2.5 之后: 可通过<context:property-placeholder>元素简化:

	<!-- 导入外部的资源文件，例如外部有存储信息的properties文件 -->
	<context:property-placeholder location="classpath:db.properties"/>

通过工厂方法（静态工厂方法 & 实例工厂方法）

• 调用静态工厂方法创建 Bean是将对象创建的过程封装到静态方法中. 当客户端需要对象时, 只需要简单地调用静态方法, 而不同关心创建对象的细节.
• 要声明通过静态方法创建的 Bean, 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称. 最后, 使用 <constrctor-arg> 元素为该方法传递方法参数.

静态工厂方法

/**
 * 静态工厂方法：直接调用某一个类的静态方法就可以返回Bean的实例
 */
public class StaticCarFactory {
	private static Map<String,Car> cars = new HashMap<String,Car>();
	
	static{
		cars.put("audi",new Car("audi","Tom",300000));
		cars.put("ford",new Car("ford","Jerry",343444));
	}
	
	//静态工厂方法
	public static Car getCar(String name){
		return cars.get(name);
	}
}

配置Bean：

	<!-- 通过静态工厂方法来配置bean，注意：不是配置静态工厂方法实例，而是配置bean实例 -->
	<!-- 
	class属性：指向静态工厂方法的名字
	factory-method：指向静态工厂方法的名字
	constructor-arg：如果工厂方法需要传入参数，则使用constructor-arg来配置参数
	 -->
	 <!-- 如下的配置创建的bean实例为 ("audi","Tom",300000)的Car对象-->
	<bean id="car1"
	class="com.atguigu.spring.beans.factory.StaticCarFactory" factory-method="getCar">
	<constructor-arg value="audi"></constructor-arg>
	</bean>

实例工厂方法

• 实例工厂方法: 将对象的创建过程封装到另外一个对象实例的方法里. 当客户端需要请求对象时, 只需要简单的调用该实例方法而不需要关心对象的创建细节.
• 要声明通过实例工厂方法创建的 Bean：
  在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean
  在 factory-method 属性里指定该工厂方法的名称
  使用 construtor-arg 元素为工厂方法传递方法参数

/**
 * 实例工厂方法：实例工厂的方法，即先需要创建工厂本身，再调用工厂的实例方法来返回bean的实例
 * 
 *
 */
public class InstanceCarFactory {
	
	private static Map<String,Car> cars = null;
	
	public InstanceCarFactory(){
		cars = new HashMap<String,Car>();
		cars.put("audi",new Car("audi","audi",300000));
		cars.put("ford",new Car("ford","ford",343444));
	}
	
	public static Car getCar(String brand){
		return cars.get(brand);
	}
	
}

配置Bean：

	<!-- 配置工厂的实例 -->
	<bean id="carFactory" class="com.atguigu.spring.beans.factory.InstanceCarFactory"></bean>
	<!-- 通过实例工厂方法来配置bean -->
	<!-- 
	factory-bean属性：指向实例工厂方法的bean
	factory-method：指向静态工厂方法的名字
	constructor-arg：如果工厂方法需要传入参数，则使用constructor-arg来配置参数
	 -->
	<bean id="car2" factory-bean="carFactory" factory-method="getCar">
		<constructor-arg value="ford"></constructor-arg>
	</bean>

两种方法的调用

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans-factory.xml");
		Car car1 = (Car) ctx.getBean("car1");
		System.out.println(car1);
		Car car2 = (Car) ctx.getBean("car2");
		System.out.println(car2);
	}

}

FactoryBean

• Spring 中有两种类型的 Bean, 一种是普通Bean, 另一种是工厂Bean, 即FactoryBean.
• 工厂 Bean 跟普通Bean不同, 其返回的对象不是指定类的一个实例, 其返回的是该工厂 Bean 的 getObject 方法所返回的对象

如下实例，最终返回一个brand属性值为BMW的Car对象：

FacrotyBean：

//自定义FactoryBean需要实现FactoryBean 接口
public class CarFactoryBean implements FactoryBean<Car>{
	
	
	private String brand;
	
	public void setBrand(String brand){
		this.brand = brand;
	}
	//返回bean对象
	@Override
	public Car getObject() throws Exception {
		// TODO Auto-generated method stub
		return new Car("brand",345456);
	}
	
	/**
	 * 返回bean的类型
	 */
	@Override
	public Class<?> getObjectType() {
		// TODO Auto-generated method stub
		return Car.class;
	}
	//是否是单实例的
	@Override
	public boolean isSingleton() {
		// TODO Auto-generated method stub
		return true;
	}

}

	<!-- 
		通过FactoryBean来配置bean的实例
		class：指向FactoryBean的全类名
		property：配置FactoryBean的属性，但是实际返回的实例却是FactoryBean的getObject（）方法返回的实例
	 -->
	<bean id="car" class="com.atguigu.spring.beans.factorybean.CarFactoryBean">
		<property name="brand" value="BMW"></property>
	</bean>

基于注解的方式

• 组件扫描(component scanning): Spring 能够从 classpath 下自动扫描, 侦测和实例化具有特定注解的组件.
• 特定组件包括:
  @Component: 基本注解, 标识了一个受 Spring 管理的组件
  @Respository: 标识持久层组件
  @Service: 标识服务层(业务层)组件
  @Controller: 标识表现层组件
• 对于扫描到的组件, Spring 有默认的命名策略: 使用非限定类名, 第一个字母小写. 也可以在注解中通过 value 属性值标识组件的名称
• 当在组件类上使用了特定的注解之后, 还需要在 Spring 的配置文件中声明 <context:component-scan>：
  ·base-package 属性指定一个需要扫描的基类包，Spring 容器将会扫描这个·基类包里及其子包中的所有类.
  ·当需要扫描多个包时, 可以使用逗号分隔.
  ·如果仅希望扫描特定的类而非基包下的所有类，可使用 resource-pattern 属性过滤特定的类，示例：<context:component-scan base-package="com.spring.beans" resource-pattern="autowire/*.class">
  -<context:include-filter> 子节点表示要包含的目标类
• <context:exclude-filter> 子节点表示要排除在外的目标类
• <context:component-scan>下可以拥有若干个 <context:include-filter> 和 <context:exclude-filter>子节点
• 使用@Autowired进行自动装配

为了模拟持久层、业务层与表现层，实例的结构如下：

import org.springframework.stereotype.Component;

@Component
public class TestObject {

}

/**
 * 模拟表现层
 * @author Megustas
 *
 */
@Controller
public class UserController {
	
	//建立关联关系
	@Autowired 
	private UserService userService;
	
	public void execute(){
		System.out.println("UserController execute...");
		//调用方法
		userService.add();
	}
}

public interface UserRepository {
	
	void save();
}

/**
 * 模拟持久层
 * @author Megustas
 *
 */
@Repository("userRepository")
public class UserRepositoryImpl implements UserRepository {

	@Override
	public void save() {
		// TODO Auto-generated method stub
		System.out.println("UserRepository Save ...");
	}

}

/**
 * 模拟业务层
 * @author Megustas
 *
 */
@Service
public class UserService {
	
	//建立关联关系
	@Autowired 
	public UserRepository userRepository;

	public void add(){
		System.out.println("UserService add...");
		userRepository.save();
	}
}

Bean配置：

	<!-- 指定Spring IOC容器扫描的包 -->
	<!-- 配置自动扫描的包: 将扫描 base-package这个包及其子包下的所有标识注解的bean，都将交给IOC容器进行管理-->
	
	<context:component-scan base-package="com.atguigu.spring.annotation"></context:component-scan>

	<!-- 可以通过resource-pattern来指定扫描的资源 -->
	<!-- 
	<context:component-scan base-package="com.atguigu.spring.annotation"
	resource-pattern="repository/*.class"></context:component-scan>
	 -->

主函数Main（获取各个目标Bean）：

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-annotation.xml");
		
		TestObject to = (TestObject) ctx.getBean("testObject");
		System.out.println(to);
		
		UserController uesrController = (UserController) ctx.getBean("userController");
		System.out.println(uesrController);
			
		UserRepository userRepository = (UserRepository) ctx.getBean("userRepository");
		System.out.println(userRepository);
		
		UserService userService = (UserService) ctx.getBean("userService");
		System.out.println(userRepository);
		
	}

}

IOC容器中bean的生命周期

IOC 容器中 Bean 的生命周期方法

Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务.

Spring IOC 容器对 Bean 的生命周期进行管理的过程:

• 通过构造器或工厂方法创建 Bean 实例
• 为 Bean 的属性设置值和对其他 Bean 的引用
• 调用 Bean 的初始化方法
• Bean 可以使用了
• 当容器关闭时, 调用 Bean 的销毁方法

在 Bean 的声明里设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法.

在进行Bean的配置时：

	<!-- 通过实例说明bean的生命周期 -->
	<bean id="Car" class="com.atguigu.spring.beans.cycle.Car"
		init-method="initcar"
		destroy-method="destroycar">
		<property name="brand" value="Audi"></property>
	</bean>

创建 Bean 后置处理器

其实我们可以更细腻的定制初始化方法：

• Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理.
• Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例. 其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.
• 对Bean 后置处理器而言, 需要实现Interface BeanPostProcessor接口. 在初始化方法被调用前后, Spring 将把每个 Bean 实例分别传递给上述接口的以下两个方法:（在IOC容器中进行配置时，不需要加上id，IOC容器会自动识别）
• Object postProcessAfterInitialization(Object bean,String beanName)
• Object postProcessBeforeInitialization(Object bean,String beanName)

接下来是一个演示完整的Bean生命周期的实例：

Bean的定义，定义一个Car：

public class Car {

	private String brand;

	public void setBrand(String brand) {
		System.out.println("setBrand...");
		this.brand = brand;
	}

	public Car(){
		System.out.println("Car's Contructor...");
	}

	public void initcar(){
		System.out.println("init method...");
	}
	
	public void destroycar(){
		System.out.println("destroy method...");
	}
}

处理器：

public class MyBeanPostProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("postProcessBeforeInitialization"+beanName+","+beanName);
		return bean;
	}
	
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("postProcessAfterInitialization"+beanName+","+beanName);
		return bean;
	}

}

配置：

	<!-- 通过实例说明bean的声明周期 -->
	<bean id="car" class="com.atguigu.spring.beans.cycle.Car" 
	init-method="initcar" destroy-method="destroycar">
		<property name="brand" value="Audi"></property>
	</bean>
	
	<!-- 配置bean的后置处理器，无需id，IOC自动识别 -->
	<bean class="com.atguigu.spring.beans.cycle.MyBeanPostProcessor"></bean>

Main方法：

public class Main {
	
	public static void main(String[] args) {
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans-cycle.xml");
		Car car = (Car) ctx.getBean("car");
		System.out.println(car);
		
		//关闭IOC容器
		ctx.close();
	}
	
}

结果：

添加 Bean 后置处理器后 Bean 的生命周期：

• 通过构造器或工厂方法创建 Bean 实例
• 为 Bean 的属性设置值和对其他 Bean 的引用
• 将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法
• 调用 Bean 的初始化方法
• 将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization方法
• Bean 可以使用了
• 当容器关闭时, 调用 Bean 的销毁方法

通过后置处理器还可以实现“偷梁换柱”与过滤等功能，只需要在后置处理器中加入对应语句就可以。例如：

public class MyBeanPostProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("postProcessBeforeInitialization"+beanName+","+beanName);
		//对beanName是car的bean进行如下操作，实现过滤操作
		if("car".equals(beanName)){
			
		}		
		return bean;		
	}
	
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("postProcessAfterInitialization"+beanName+","+beanName);
		Car car = new Car();
		car.setBrand("Ford");
		return bean;
	}

}

泛型依赖注入

Spring 4.x 中可以为子类注入子类对应的泛型类型的成员变量的引用，如图：

整合多个配置文件：

• Spring 允许通过 <import>将多个配置文件引入到一个文件中，进行配置文件的集成。这样在启动 Spring 容器时，仅需要指定这个合并好的配置文件就可以。
• import 元素的 resource 属性支持 Spring 的标准的路径资源