Spring IOC 三大高级特性（简述）

一、lazy-init 延迟加载

延迟加载主要是指Bean对象的延迟创建。ApplicationContext 容器的默认行为是在容器启动时将所有的single bean 提前实例化。提前实例化意味着初始化过程的一部分，ApplicationContext 实力会创建并配置所有的singleton bean。

属性：

• lazy-init=“false”，false表示立即加载，true表示延迟加载，默认是false。立即加载表示spring启动时立即加载，延迟加载则在ApplicationContext 启动时不会立即实例化，而是在第一次向容器getBean索取bean时才会实例化。
• default-lazy-init=“false”，在容器层次中通过在元素上使用"default-lazy-init" 属性来控制延时初始化。

使用：

<bean id="testBean" calss="com.LazyBean" lazy-init="true" />

<beans default-lazy-init="true">
	<!-- no beans will be eagerly pre-instantiated... -->
</beans>

注：如果⼀个 bean 的 scope 属性为 scope=“pototype” （多例）时，即使设置了 lazy-init=“false”，容器启动时也不会实例化bean，⽽是调⽤ getBean ⽅法实例化的。

应用场景：

• 使用延迟加载一定程度上提高容器启动和运转性能；
• 对于不常使用的bean设置延迟加载，这样不必从一开始就占用资源。

二、FactoryBean 和 BeanFactory

BeanFactory：接口是容器的顶级接口，定义了容器的一些基础行为，是负责生产和管理bean的一个工厂，具体使用它下面的子接口类型，例如：ApplicationContext。

FactoryBean:
spring中的bean分为两种，一种是普通bean，一种是工厂bean（FactoryBean）,FactoryBean可以生成某个类型的bean实例返回给我们，因此我们可以借助它自定义bean的创建过程。

源代码：

// 可以让我们⾃定义Bean的创建过程（完成复杂Bean的定义）
public interface FactoryBean<T> {
	@Nullable
	// 返回FactoryBean创建的Bean实例，如果isSingleton返回true，则该实例会放到Spring容器的单例对象缓存池中Map
	T getObject() throws Exception;
	@Nullable
	// 返回FactoryBean创建的Bean类型
	Class<?> getObjectType();

	// 返回作⽤域是否单例
	default boolean isSingleton() { 
		return true;
	}
}

使用实例：
实体：

@Data
public class Company {
	private String name;
	private String address;
	private int scale;
}

实现FactoryBean接口：

public class CompanyFactoryBean implements FactoryBean<Company> {
	private String companyInfo; // 公司名称,地址,规模
	
	public void setCompanyInfo(String companyInfo) {
		this.companyInfo = companyInfo;
	}
	
	@Override
	public Company getObject() throws Exception {
		// 模拟创建复杂对象Company
		Company company = new Company();
		String[] strings = companyInfo.split(",");
		company.setName(strings[0]);
		company.setAddress(strings[1]);
		company.setScale(Integer.parseInt(strings[2]));
		return company ;
	}

	@Override
	public Class<?> getObjectType() { 
		return Company.class;
	}

	@Override
	public boolean isSingleton() { 
		return true;
	}
}

xml配置：

<bean id="companyBean" class="com.edu.factory.CompanyFactoryBean">
	<property name="companyInfo" value="xx,中关村,500"/>
</bean>

测试：

Object companyBean = applicationContext.getBean("companyBean");
System.out.println("bean:" + companyBean);

//获取FanctoryBean
Object companyBean = applicationContext.getBean("&companyBean"); System.out.println("bean:" + companyBean);

结果如下：

bean:Company{name='xx', address='中关村', scale=500}

bean:com.edu.factory.CompanyFactoryBean@53f6fd09

三、后置处理器

Spring提供了两种后处理bean的扩展接⼝，分别为 BeanPostProcessor 和BeanFactoryPostProcessor。

BeanFactoryPostProcessor：
在BeanFactory初始化之后可以使⽤BeanFactoryPostProcessor进⾏后置处理做⼀些事情。BeanFactory级别的处理，是针对整个Bean的⼯⼚进⾏处理。

典型应⽤:PropertyPlaceholderConfigurer

此接⼝只提供了⼀个⽅法，⽅法参数为 ConfigurableListableBeanFactory ，该参数类型定义了⼀些⽅法，其中有个⽅法名为 getBeanDefinition 的⽅法，我们可以根据此⽅法，找到我们定义bean的 BeanDefinition 对象，然后我们可以对定义的属性进⾏修改，⽅法名字类似我们bean标签的属性， setBeanClassName 对应bean标签中的class属性，以下是 BeanDefinition 中的⽅法：

BeanDefinition对象：我们在 XML 中定义的 bean标签，Spring 解析 bean 标签成为⼀个 JavaBean，这个JavaBean 就是 BeanDefinition。

注意：调⽤ BeanFactoryPostProcessor ⽅法时，这时候bean还没有实例化，此时 bean 刚被解析成BeanDefinition对象。

BeanPostProcessor：在Bean对象实例化（并不是Bean的整个⽣命周期完成）之后可以使⽤BeanPostProcessor进⾏后置处理做⼀些事情。是针对Bean级别的处理，可以针对某个具体的Bean。

该接⼝提供了两个⽅法，分别在 Bean 的初始化⽅法前和初始化⽅法后执⾏，这个初始化⽅法类似我们在定义bean时，定义了 init-method 所指定的⽅法。

使用：
定义⼀个类实现了 BeanPostProcessor，默认是会对整个Spring容器中所有的bean进⾏处理。如果要对具体的某个bean处理，可以通过⽅法参数判断，两个类型参数分别为Object和String，第⼀个参数是每个bean的实例，第⼆个参数是每个bean的name或者id属性的值。所以我们可以通过第⼆个参数，来判断我们将要处理的具体的bean。

注：处理是发⽣在Spring容器的实例化和依赖注⼊之后。

springBean的生命周期

图如下：

Bean 生命周期的整个执行过程描述如下。

1）根据配置情况调用 Bean 构造方法或工厂方法实例化 Bean。

2）利用依赖注入完成 Bean 中所有属性值的配置注入。

3）如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。

4）如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。

5）如果 Bean 实现了 ApplicationContextAware 接口，则 Spring 调用 setApplicationContext() 方法传入当前 ApplicationContext 实例的引用。

6）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的预初始化方法 postProcessBeforeInitialzation() 对 Bean 进行加工操作，此处非常重要，Spring 的 AOP 就是利用它实现的。

7）如果 Bean 实现了 InitializingBean 接口，则 Spring 将调用 afterPropertiesSet() 方法。

8）如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法。

9）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的初始化方法 postProcessAfterInitialization()。此时，Bean 已经可以被应用系统使用了。

10）如果在 < bean > 中指定了该 Bean 的作用范围为 scope=“singleton”，则将该 Bean 放入 Spring IoC 的缓存池中，将触发 Spring 对该 Bean 的生命周期管理；如果在 < bean > 中指定了该 Bean 的作用范围为 scope=“prototype”，则将该 Bean 交给调用者，调用者管理该 Bean 的生命周期，Spring 不再管理该 Bean。

11）如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方法将 Spring 中的 Bean 销毁；如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁。

Spring 为 Bean 提供了细致全面的生命周期过程，通过实现特定的接口或 < bean > 的属性设置，都可以对 Bean 的生命周期过程产生影响。虽然可以随意配置 < bean > 的属性，但是建议不要过多地使用 Bean 实现接口，因为这样会导致代码和 Spring 的聚合过于紧密。