1.BeanFactory概述 Spring的本质是一个bean工厂(beanFactory)或者说bean容器，它按照我们的要求，生产我们需要的各种各样的bean，提供给我们使用。只是在生产bean的过程中，需要解决bean之间的依赖问题，才引入了依赖注入(DI)这种技术。也就是说依赖注入是beanFactory生产bean时为了解决bean之间的依赖的一种技术而已。那么我们为什么需要Spring框架来给我们提供这个beanFactory的功能呢？第一个原因是，我们可以将原来硬编码的对象依赖通过Spring这个beanFactory这个工厂来注入依赖，也就是说原来只有依赖方和被依赖方，现在我们引入了第三方spring这个beanFactory，由它来解决bean之间的依赖问题，达到了对象间松耦合的效果；还有一个更加重要的原因：在没有spring这个beanFactory之前，我们都是直接通过new来实例化各种对象，现在各种对象bean的生产都是通过beanFactory来实例化的，这样的话，spring这个beanFactory就可以在实例化bean的过程中，做一些小动作——在实例化bean的各个阶段进行一些额外的处理，也就是说beanFactory会在bean的生命周期的各个阶段中对bean进行各种管理，并且spring将这些阶段通过各种接口暴露给我们，让我们可以对bean进行各种处理，我们只要让bean实现对应的接口，那么spring就会在bean的生命周期调用我们实现的接口来处理该bean。下面我们看是如何实现这一点的。
- bean容器的启动—bean在实例化之前，必须是在bean容器启动之后。所以就有了两个阶段：
- bean容器的启动阶段；
- 容器中bean的实例化阶段；
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor implements BeanDefinition, Cloneable { private volatile Object beanClass; private String scope = SCOPE_DEFAULT; private boolean abstractFlag = false; private boolean lazyInit = false; private int autowireMode = AUTOWIRE_NO; private int dependencyCheck = DEPENDENCY_CHECK_NONE; private String[] dependsOn; private ConstructorArgumentValues constructorArgumentValues; private MutablePropertyValues propertyValues; private String factoryBeanName; private String factoryMethodName; private String initMethodName; private String destroyMethodName;
beanClass保存bean的class属性，scop保存bean是否单例，abstractFlag保存该bean是否抽象，lazyInit保存是否延迟初始化，autowireMode保存是否自动装配，dependencyCheck保存是否坚持依赖，dependsOn保存该bean依赖于哪些bean(这些bean必须提取初始化)，constructorArgumentValues保存通过构造函数注入的依赖，propertyValues保存通过setter方法注入的依赖，factoryBeanName和factoryMethodName用于factorybean，也就是工厂类型的bean，initMethodName和destroyMethodName分别对应bean的init-method和destory-method属性，比如：
读完配置文件之后，得到了很多的BeanDefinition对象，2> 然后通过BeanDefinitionRegistry将这些bean注册到beanFactory中：
public interface BeanDefinitionRegistry extends AliasRegistry { void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException; void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; boolean containsBeanDefinition(String beanName); String[] getBeanDefinitionNames(); int getBeanDefinitionCount(); boolean isBeanNameInUse(String beanName); }
BeanFactory的实现类，需要实现BeanDefinitionRegistry 接口：
@SuppressWarnings("serial") public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable { /** Map of bean definition objects, keyed by bean name */ private final Map beanDefinitionMap = new ConcurrentHashMap(64); @Override public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException { // ... ... this.beanDefinitionMap.put(beanName, beanDefinition); // ... ... }
我们看到BeanDefinition被注册到了 DefaultListableBeanFactory， 保存在它的一个ConcurrentHashMap中。将BeanDefinition注册到了beanFactory之后，在这里Spring为我们提供了一个扩展的切口，允许我们通过实现接口BeanFactoryPostProcessor 在此处来插入我们定义的代码：
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; }
典型的例子就是：PropertyPlaceholderConfigurer，我们一般在配置数据库的dataSource时使用到的占位符的值，就是它注入进去的：
【Java|深入理解BeanFactory】
文章图片
public abstract class PropertyResourceConfigurer extends PropertiesLoaderSupport implements BeanFactoryPostProcessor, PriorityOrdered { @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { try { Properties mergedProps = mergeProperties(); // Convert the merged properties, if necessary. convertProperties(mergedProps); // Let the subclass process the properties. processProperties(beanFactory, mergedProps); } catch (IOException ex) { throw new BeanInitializationException("Could not load properties", ex); } }
processProperties(beanFactory, mergedProps); 在子类中实现的，功能就是将
${jdbc_username}等等这些替换成实际值。
bean的实例化阶段。实例化阶段主要是通过反射或者CGLIB对bean进行实例化，在这个阶段Spring又给我们暴露了很多的扩展点：1> 各种的Aware接口，比如 BeanFactoryAware，MessageSourceAware，ApplicationContextAware对于实现了这些Aware接口的bean，在实例化bean时Spring会帮我们注入对应的：BeanFactory， MessageSource，ApplicationContext的实例：
public interface BeanFactoryAware extends Aware { /** * Callback that supplies the owning factory to a bean instance. * Invoked after the population of normal bean properties * but before an initialization callback such as * {@link InitializingBean#afterPropertiesSet()} or a custom init-method. * @param beanFactory owning BeanFactory (never {@code null}). * The bean can immediately call methods on the factory. * @throws BeansException in case of initialization errors * @see BeanInitializationException */ void setBeanFactory(BeanFactory beanFactory) throws BeansException; }
public interface ApplicationContextAware extends Aware { /** * Set the ApplicationContext that this object runs in. * Normally this call will be used to initialize the object. * Invoked after population of normal bean properties but before an init callback such * as {@link org.springframework.beans.factory.InitializingBean#afterPropertiesSet()} * or a custom init-method. Invoked after {@link ResourceLoaderAware#setResourceLoader}, * {@link ApplicationEventPublisherAware#setApplicationEventPublisher} and * {@link MessageSourceAware}, if applicable. * @param applicationContext the ApplicationContext object to be used by this object * @throws ApplicationContextException in case of context initialization errors * @throws BeansException if thrown by application context methods * @see org.springframework.beans.factory.BeanInitializationException */ void setApplicationContext(ApplicationContext applicationContext) throws BeansException; }
public interface MessageSourceAware extends Aware { /** * Set the MessageSource that this object runs in. * Invoked after population of normal bean properties but before an init * callback like InitializingBean's afterPropertiesSet or a custom init-method. * Invoked before ApplicationContextAware's setApplicationContext. * @param messageSource message sourceto be used by this object */ void setMessageSource(MessageSource messageSource); }
2> BeanPostProcessor接口：实现了BeanPostProcessor接口的bean，在实例化bean时Spring会帮我们调用接口中的方法：
public interface BeanPostProcessor { /** * Apply this BeanPostProcessor to the given new bean instance before 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.*/ Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException; /** * Apply this BeanPostProcessor to the given new bean instance after 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.*/ Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException; }
从注释中可以知道 postProcessBeforeInitialization方法在 InitializingBean接口的 afterPropertiesSet方法之前执行，而postProcessAfterInitialization方法在 InitializingBean接口的afterPropertiesSet方法之后执行。3> InitializingBean接口实现了InitializingBean接口的bean，在实例化bean时Spring会帮我们调用接口中的方法：
public interface InitializingBean { /** * Invoked by a BeanFactory after it has set all bean properties supplied * (and satisfied BeanFactoryAware and ApplicationContextAware). * This method allows the bean instance to perform initialization only * possible when all bean properties have been set and to throw an * exception in the event of misconfiguration. * @throws Exception in the event of misconfiguration (such * as failure to set an essential property) or if initialization fails. */ void afterPropertiesSet() throws Exception; }
4> DisposableBean接口：实现了BeanPostProcessor接口的bean，在该bean死亡时Spring会帮我们调用接口中的方法：
public interface DisposableBean { /** * Invoked by a BeanFactory on destruction of a singleton. * @throws Exception in case of shutdown errors. * Exceptions will get logged but not rethrown to allow * other beans to release their resources too. */ void destroy() throws Exception; }
InitializingBean接口 和 DisposableBean接口对应于
public void init() throws SQLException { // ... ...try { lock.lockInterruptibly(); } catch (InterruptedException e) { throw new SQLException("interrupt", e); } boolean init = false; try { connections = new DruidConnectionHolder[maxActive]; SQLException connectError = null; try { for (int i = 0, size = getInitialSize(); i < size; ++i) { Connection conn = createPhysicalConnection(); DruidConnectionHolder holder = new DruidConnectionHolder(this, conn); connections[poolingCount++] = holder; } if (poolingCount > 0) { poolingPeak = poolingCount; poolingPeakTime = System.currentTimeMillis(); } } catch (SQLException ex) { LOG.error("init datasource error", ex); connectError = ex; } } catch (SQLException e) { LOG.error("dataSource init error", e); throw e; } catch (InterruptedException e) { throw new SQLException(e.getMessage(), e); } finally { inited = true; lock.unlock(); } }
基本就是初始化数据库连接池。
在dataSource 这个bean死亡时会调用 DruidDataSource.close()方法:
public void close() { lock.lock(); try { for (int i = 0; i < poolingCount; ++i) { try { DruidConnectionHolder connHolder = connections[i]; for (PreparedStatementHolder stmtHolder : connHolder.getStatementPool().getMap().values()) { connHolder.getStatementPool().closeRemovedStatement(stmtHolder); } connHolder.getStatementPool().getMap().clear(); Connection physicalConnection = connHolder.getConnection(); physicalConnection.close(); connections[i] = null; destroyCount.incrementAndGet(); } catch (Exception ex) { LOG.warn("close connection error", ex); } } } finally { lock.unlock(); } }
基本就是关闭连接池中的连接。另外注解 @PostConstruct 和 @PreDestroy 也能达到 InitializingBean接口和DisposableBean接口的效果。
2. 总结 spring容器接管了bean的实例化，不仅仅是通过依赖注入达到了松耦合的效果，同时给我们提供了各种的扩展接口，来在bean的生命周期的各个时期插入我们自己的代码：
- BeanFactoryPostProcessor接口(在容器启动阶段)
- 各种的Aware接口
- BeanPostProcessor接口
- InitializingBean接口(@PostConstruct， init-method)
- DisposableBean接口(@PreDestroy, destory-method)
public interface FactoryBean{ T getObject() throws Exception; Class getObjectType(); boolean isSingleton(); }
典型的例子有spring与mybatis的结合：
我们看上面该bean，因为实现了FactoryBean接口，所以返回的不是 SqlSessionFactoryBean 的实例，而是她的 SqlSessionFactoryBean.getObject() 的返回值：
public class SqlSessionFactoryBean implements FactoryBean, InitializingBean, ApplicationListener {private static final Log logger = LogFactory.getLog(SqlSessionFactoryBean.class); private Resource configLocation; private Resource[] mapperLocations; private DataSource dataSource; public SqlSessionFactory getObject() throws Exception { if (this.sqlSessionFactory == null) { afterPropertiesSet(); }return this.sqlSessionFactory; }
其实他是一个专门生产 sqlSessionFactory 的工厂，所以才叫 SqlSessionFactoryBean。 而SqlSessionFactory又是生产SqlSession的工厂。还有spring与ibatis的结合：
public class SqlMapClientFactoryBean implements FactoryBean, InitializingBean { private Resource[] configLocations; private Resource[] mappingLocations; private Properties sqlMapClientProperties; private DataSource dataSource; private boolean useTransactionAwareDataSource = true; private Class transactionConfigClass = ExternalTransactionConfig.class; private Properties transactionConfigProperties; private LobHandler lobHandler; private SqlMapClient sqlMapClient; public SqlMapClient getObject() { return this.sqlMapClient; }
SqlMapClientFactoryBean返回的是getObject()中返回的sqlMapClient,而不是SqlMapClientFactoryBean自己的实例。
4. 依赖注入(DI) 1）依赖注入的方式分为接口注入、构造函数注入和setter方法注入：
构造函数注入使用：
setter方法注入使用 name="username" value="https://www.it610.com/article/xxx"/>, 非简单类型属性使用ref name="xxbean" ref="xxx"/>
2）集合等复杂类型的注入：
administrator@example.orgsupport@example.orgdevelopment@example.org just some string
也很简单，list属性就是
- 里面包含