Spring的IoC容器之BeanFactory

Spring IoC 容器之 BeanFactory

首先，Spring 提供了两种容器类型：BeanFactory 和 ApplicationContext。

BeanFactory：基础容器类型，提供了完整的 IoC 服务支持。默认采用延迟初始化策略（lazy-load）。只有当客户端对象需要访问容器中某个对象的时候，猜对该对象进行初始化以及依赖注入操作。适用于资源有限、功能要求不多的场景。
ApplicationContext：在 BeanFactory 的基础上构建，提供了其他高级功能，如事件发布、国际化支持等。在该类型容器启动后，所管理的对象默认全部初始化并完成依赖注入。适用于资源充足、要求功能完善的场景。

本文主要介绍 BeanFactory。

public interface BeanFactory {

	String FACTORY_BEAN_PREFIX = "&";

	Object getBean(String name) throws BeansException;

	<T> T getBean(String name, Class<T> requiredType) throws BeansException;

	Object getBean(String name, Object... args) throws BeansException;

	<T> T getBean(Class<T> requiredType) throws BeansException;

	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);

	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

	boolean containsBean(String name);

	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;

	@Nullable
	Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;

	String[] getAliases(String name);
}

BeanFactory 的对象注册

BeanFactory 只是一个接口，我们需要一个实现来管理对象。DefaultListableBeanFactory 间接实现了 BeanFactory，且实现了 BeanDefinitionFactory。该接口担任着 Bean 的注册管理的角色。

每一个受管控的 bean，在容器中都会有一个 BeanDefinition 的实例与之对应，该 BeanDefinition 的实例负责保存对象的所有必要信息，包括对象的 class 类型、是否是抽象类、构造方法参数以及其他属性等。当客户端向 BeanFactory 请求相应对象时，BeanFactory 会通过这些信息给客户端返回一个完备可用的对象实例。RootBeanDefinition 和 ChildBeanDefinition 是两个主要实现类。

实例如下：

public class BeanFactoryTest {
    public static void main(String[] args) {
        DefaultListableBeanFactory beanRegistry = new DefaultListableBeanFactory();
        BeanFactory beanFactory = bind(beanRegistry);
        FXNewsProvider fxNewsProvider1 = beanFactory.getBean(FXNewsProvider.class);
        FXNewsProvider fxNewsProvider2 = beanFactory.getBean(FXNewsProvider.class);
        System.out.println(fxNewsProvider1 == fxNewsProvider2);  // true

    }

    public static BeanFactory bind(BeanDefinitionRegistry registry) {
        AbstractBeanDefinition fxNewsProvider = new RootBeanDefinition(FXNewsProvider.class);
        AbstractBeanDefinition dowJonesNewsListener = new RootBeanDefinition(DowJonesNewsListener.class);
        AbstractBeanDefinition dowJonesNewsPersister = new RootBeanDefinition(DowJonesNewsPersister.class);

        // 将 bean 定义注册到容器中
        registry.registerBeanDefinition("fxNewsProvider", fxNewsProvider);
        registry.registerBeanDefinition("dowJonesNewsListener", dowJonesNewsListener);
        registry.registerBeanDefinition("dowJonesNewsPersister", dowJonesNewsPersister);

        // 通过构造方法注入
        // ConstructorArgumentValues arguments = new ConstructorArgumentValues();
        // arguments.addIndexedArgumentValue(0, dowJonesNewsListener);
        // arguments.addIndexedArgumentValue(1, dowJonesNewsPersister);
        // fxNewsProvider.setConstructorArgumentValues(arguments);

        // 通过 setter 注入
        MutablePropertyValues mutablePropertyValues = new MutablePropertyValues();
        mutablePropertyValues.addPropertyValue(new PropertyValue("dowJonesNewsListener", dowJonesNewsListener));
        mutablePropertyValues.addPropertyValue(new PropertyValue("dowJonesNewsPersister", dowJonesNewsPersister));
        fxNewsProvider.setPropertyValues(mutablePropertyValues);

        return (BeanFactory) registry;
    }
}

bean 的 scope

Spring 容器最初只有 singleton 和 prototype 两种 scope 类型，后面又引入了三种：request、session 和 global session。

singleton：在容器中只存在一个实例，所有对该对象的引用都将共享这个实例。该实例从容器启动，并在第一次初始化之后，将一直存活到容器退出。
prototype：容器在接到该类型对象的请求的时候，会每次都重新生成一个新的对象实例返回。虽然这种类型的对象的实例化和属性设置等工作是由容器负责的，但是主要对象返回后，容器不再拥有该对象的引用，即不再管理该对象。

容器启动的一些细节

Spring 的 IoC 容器，会以某种方式加载 Configuration Metadata（各种配置信息），然后根据这些信息绑定整个系统的对象，最终组装成一个可用的基于轻量级容器的应用系统。

Spring 的 IoC 容器可以分成两个阶段，容器启动阶段和 bean 的实例化阶段。

容器的启动阶段

容器启动伊始，首先会通过某种途径加载 Configuration Metadata。在大部分情况下，容器需要依赖某些工具类（BeanDefinitionReader）对加载的 Configuration Metadata 进行解析和分析，并将分析后的信息编组为相应的 BeanDefinition，待注册到相应的 BeanDefinitionRegistry，这样容器启动的主要工作就结束了。

该阶段主要侧重于对象管理信息的收集，一些验证性或者辅助性的工作也可以在这个阶段完成。

bean 的实例化阶段

在第一阶段中，bean 的定义信息都已经注册到 BeanDefinitionRegistry 中。当某个请求通过容器的 getBean 方法明确请求到某个对象或者因依赖关系容器需要隐式调用 getBean 方法时，就会触发 bean 的实例化。

在该阶段，容器首先会检查所请求的对象之前是否已经初始化。如果没有，则会根据注册的 BeanDefinition 所提供的信息实例化被请求对象，并为其注入依赖。如果该对象实现了某些回调接口，也会根据回调接口的要求来装配它。当对象转配完毕之后，容器会立即返回该对象。

插手容器的启动

BeanFactoryPostProcessor

Spring 提供了 BeanFactoryPostProcessor 的机制，可以允许在容器实例化相应的对象之前，对注册到容器的 BeanDefinition 所保存的信息进行修改。

@FunctionalInterface
public interface BeanFactoryPostProcessor {

	/**
	 * Modify the application context's internal bean factory after its standard
	 * initialization. All bean definitions will have been loaded, but no beans
	 * will have been instantiated yet. This allows for overriding or adding
	 * properties even to eager-initializing beans.
	 * @param beanFactory the bean factory used by the application context
	 * @throws org.springframework.beans.BeansException in case of errors
	 */
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

简单看一下 Spring 内置的几个常见的 BeanFactoryPostProcessor。

PropertySourcesPlaceholderConfigurer

通常情况下，我们会将例如数据库连接、服务器连接信息等放在一个 properties 文件中，这样，当系统资源变动的话，只需要修改相应的 properties 文件即可。PropertySourcesPlaceholderConfigurer 允许我们在 XML 或者在 Bean 中使用占位符（PlaceHolder，形如 ${property}）。

简单来说，当 BeanFactory 在第一阶段加载完成所有的配置信息时，BeanFactory 中保存的对象的属性还是以占位符的形式存在，如 ${jdbc.url}。当 PropertySourcesPlaceholderConfigurer 作为 BeanFactoryPostProcessor 被应用时，它会使用 properties 文件中配置信息替换相应的 BeanDefinition 中占位符所表示的属性值。这样，当进入容器实现的第二阶段实例化 bean 时，bean 定义的属性值就是最终替换完成的了。

bean 的生命周期

BeanFactory 的源码注释中描述了 bean 的生命周期：

实例化 bean：

BeanNameAware's setBeanName
BeanClassLoaderAware's setBeanClassLoader
BeanFactoryAware's setBeanFactory
EnvironmentAware's setEnvironment
EmbeddedValueResolverAware's setEmbeddedValueResolver
ResourceLoaderAware's setResourceLoader (only applicable when running in an application context)
ApplicationEventPublisherAware's setApplicationEventPublisher (only applicable when running in an application context)
MessageSourceAware's setMessageSource (only applicable when running in an application context)
ApplicationContextAware's setApplicationContext (only applicable when running in an application context)
ServletContextAware's setServletContext (only applicable when running in a web application context)
postProcessBeforeInitialization methods of BeanPostProcessors
InitializingBean's afterPropertiesSet
a custom init-method definition
postProcessAfterInitialization methods of BeanPostProcessors

销毁 bean：

postProcessBeforeDestruction methods of DestructionAwareBeanPostProcessors
DisposableBean's destroy
a custom destroy-method definition

bean 的实例化和 BeanWrapper

容器内部实例化的时候，采用策略模式来决定采用何种方式进行初始化。通常，可以通过反射或者CGLIB动态字节码生成来初始化相应的 bean 的实例或者动态生成其子类。

org.springframework.beans.factory.support.InstantiationStrategy 是实例化策略的抽象接口，其子类 SimpleInstantiationStrategy 实现了简单的对象实例化功能，通过反射来实例化对象实例，但不支持方法注入方式的对象实例化。CglibSubclassingInstantiationStrategy 继承了 SimpleInstantiationStrategy 以反射方式实例化对象的功能，并且通过 CGLIB 的动态字节码生成功能，满足方法注入所需的对象实例化需求。容器默认采用 CglibSubclassingInstantiationStrategy。

public interface InstantiationStrategy {

	/**
	 * Return an instance of the bean with the given name in this factory.
	 */
	Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner)
			throws BeansException;

	/**
	 * Return an instance of the bean with the given name in this factory,
	 * creating it via the given constructor.
	 */
	Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
			Constructor<?> ctor, Object... args) throws BeansException;

	/**
	 * Return an instance of the bean with the given name in this factory,
	 * creating it via the given factory method.
	 */
	Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
			@Nullable Object factoryBean, Method factoryMethod, Object... args)
			throws BeansException;

}

容器根据 RootBeanDefinition 结合 CglibSubclassingInstantiationStrategy 以及不同的 bean 定义类型，就可以返回实例化完成的对象实例。但是，不是直接返回构造完成的对象实例，而是以 BeanWrapper 对构造完成的对象实例进行包裹。

至此，实例化对象的步骤结束。

BeanWrapper 接口有个实现类 BeanWrapperImpl，设置 bean 的相应属性值。BeanWrapper 定义继承了 PropertyAccessor 接口，可以以统一的方式对对象属性进行访问；另外，同时继承了 PropertyEditorRegistry 和 TypeConverter 接口，提供属性设值的类型转换等功能。

示例：

public class BeanWrapperTest {
    public static void main(String[] args) throws Exception {
        final Object fxNewsProvider = Class.forName("com.stm.spring.ioc.bean.FXNewsProvider").newInstance();
        final Object dowJonesNewsListener = Class.forName("com.stm.spring.ioc.bean.DowJonesNewsListener").newInstance();
        final Object dowJonesNewsPersister = Class.forName("com.stm.spring.ioc.bean.DowJonesNewsPersister").newInstance();

        BeanWrapper newsProvider = new BeanWrapperImpl(fxNewsProvider);
        newsProvider.setPropertyValue("dowJonesNewsListener", dowJonesNewsListener);
        newsProvider.setPropertyValue("dowJonesNewsPersister", dowJonesNewsPersister);

        System.out.println(newsProvider.getWrappedInstance() instanceof FXNewsProvider); // true
        System.out.println(dowJonesNewsListener == newsProvider.getPropertyValue("dowJonesNewsListener")); // true
        System.out.println(dowJonesNewsPersister == newsProvider.getPropertyValue("dowJonesNewsPersister")); // true
    }
}

至此，完成了对象属性赋值的步骤。

各种 Aware 接口的处理

当对象实例化完成并且相关属性以及依赖设置完成之后，spring 容器会检查当前对象实例是否实现了一系列以 Aware 命名结尾的接口定义。如果是，则将这些 Aware 接口定义中规定的依赖注入给当前对象实例。

BeanPostProcessor

注意：BeanPostProcessor 用于 bean 的实例化阶段，BeanFactoryPostProcessor 用于容器启动阶段。BeanPostProcessor 会处理容器内所有符合条件的实例化后的对象实例。该接口定义如下：

public interface BeanPostProcessor {

	/**
	 * Apply this {@code BeanPostProcessor} to the given new bean instance <i>before</i> any bean
	 * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
	 * or a custom init-method). The bean will already be populated with property values.
	 * The returned bean instance may be a wrapper around the original.
	 * <p>The default implementation returns the given {@code bean} as-is.
	 */
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	/**
	 * Apply this {@code BeanPostProcessor} to the given new bean instance <i>after</i> any bean
	 * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
	 * or a custom init-method). The bean will already be populated with property values.
	 * The returned bean instance may be a wrapper around the original.
	 * <p>In case of a FactoryBean, this callback will be invoked for both the FactoryBean
	 * instance and the objects created by the FactoryBean (as of Spring 2.0). The
	 * post-processor can decide whether to apply to either the FactoryBean or created
	 * objects or both through corresponding {@code bean instanceof FactoryBean} checks.
	 * <p>This callback will also be invoked after a short-circuiting triggered by a
	 * {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation} method,
	 * in contrast to all other {@code BeanPostProcessor} callbacks.
	 * <p>The default implementation returns the given {@code bean} as-is.
	 */
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

常见的使用 BeanPostProcessor 的场景，是处理标记接口实现类，或者为当前对象提供代理实现。例如，ApplicationContext 中的 Aware 接口就是通过 BeanPostProcessor 实现的。参考 ApplicationContextAwareProcessor 源码：

class ApplicationContextAwareProcessor implements BeanPostProcessor {

	private final ConfigurableApplicationContext applicationContext;

	private final StringValueResolver embeddedValueResolver;


	/**
	 * Create a new ApplicationContextAwareProcessor for the given context.
	 */
	public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
		this.applicationContext = applicationContext;
		this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
	}


	@Override
	@Nullable
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
				bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
				bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
			return bean;
		}

		AccessControlContext acc = null;

		if (System.getSecurityManager() != null) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareInterfaces(bean);
				return null;
			}, acc);
		}
		else {
			invokeAwareInterfaces(bean);
		}

		return bean;
	}

	private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof EnvironmentAware) {
			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}

}

另外，在 CommonAnnotationBeanPostProcessor 类中提供了对 PostConstruct 和 PreDestroy 的支持。

InitializingBean 和 init-method

这两种方式都是在 BeanPostProcessor 的前置处理之后调用。比如在某些情况下，某个业务对象实例化完成后，还不能处于可以使用的状态，这个时候可以让业务对象实现 InitializingBean，在 afterPropertiesSet 方法中完善对该业务对象的处理。

public interface InitializingBean {

	/**
	 * Invoked by the containing {@code BeanFactory} after it has set all bean properties
	 * and satisfied {@link BeanFactoryAware}, {@code ApplicationContextAware} etc.
	 * <p>This method allows the bean instance to perform validation of its overall
	 * configuration and final initialization when all bean properties have been set.
	 */
	void afterPropertiesSet() throws Exception;

}

另外，可以指定 init-method，完成类似功能。

DisposableBean 和 destroy-method

两种方式都是为了当 singleton 对象在容器销毁时，提供一个用于对象销毁的回调。

public interface DisposableBean {

	/**
	 * Invoked by the containing {@code BeanFactory} on destruction of a bean.
	 * @throws Exception in case of shutdown errors. Exceptions will get logged
	 * but not rethrown to allow other beans to release their resources as well.
	 */
	void destroy() throws Exception;

}

总结

BeanFactory 作为 spring 提供的基础 IoC 容器，支持对象的注册以及依赖关系绑定。除了 BeanFactory，spring 还提供了 ApplicationContext 容器，其构建于 BeanFactory 之上，提供了更多丰富的功能。

posted @ 2022-11-07 23:04 天山琴子阅读(104) 评论(0) 收藏举报

刷新页面返回顶部

Loading

天山琴子