深入Spring配置项问题，全面解析

<!-- 配置SqlSessionFactoryBean -->
<bean id="thirdPartySqlSessionFactory"
      class="org.mybatis.spring.SqlSessionFactoryBean"
      depends-on="myDataSource">
    <!-- datasource为自定义数据源 -->
    <property name="dataSource" ref="myDataSource"/>
    <property name="mapperLocations" value="classpath:mybatis/third-party/*.xml"/>
</bean>

<!-- 配置MapperScannerConfigurer -->
<bean id="thirdPartyMapperScannerConfigurer"
      class="org.mybatis.spring.mapper.MapperScannerConfigurer"
      depends-on="thirdPartySqlSessionFactory">
    <property name="basePackage" value="com.alibaba.thirdparty.dao"/>
    <property name="sqlSessionFactoryBeanName" value="thirdPartySqlSessionFactory"/>
</bean>

@Configuration
@EnableTransactionManagement(proxyTargetClass = true)
// 引入上述XML文件
@ImportResource("classpath*:/mybatis-third-party-config.xml")
public class MyDataSourceConfiguration {

    // 声明自定义数据源
    @Bean(name = "myDataSource")
    public DataSource createMyDataSource(Environment env) {
        // 返回数据源实例，具体代码略
    }
    
}

<!-- 项目中一个原有的bean声明 -->
<bean id="myHsfClient" class="com.taobao.hsf.app.spring.util.HSFSpringConsumerBean" init-method="init">
    <property name="interfaceName">
        <value>com.taobao.custom.MyHsfClient</value>
    </property>
    <!-- version属性值为待解析的配置项占位符 -->
    <property name="version">
        <value>${hsf.client.version}</value>
    </property>
</bean>

<!-- 其余bean声明省略 -->

// 改写后的Java注解声明方式
@Configuration
public class MyHsfConfig {

    @HSFConsumer(serviceVersion = "${hsf.client.version}")
    private MyHsfClient myHsfClient;

    // 其余代码省略
}

// 处理属性值
protected void doProcessProperties(ConfigurableListableBeanFactory beanFactoryToProcess,
        StringValueResolver valueResolver) {

    BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver);

    String[] beanNames = beanFactoryToProcess.getBeanDefinitionNames();
    // 遍历bean工厂中的bean名称集合
    for (String curName : beanNames) {
      // 跳过对自身的处理
        if (!(curName.equals(this.beanName) && beanFactoryToProcess.equals(this.beanFactory))) {
            // 通过bean的名称获取bean的定义
            BeanDefinition bd = beanFactoryToProcess.getBeanDefinition(curName);
            try {
                // 访问bean的定义，解析并替换其中的配置项占位符
                visitor.visitBeanDefinition(bd);
            }
            catch (Exception ex) {
                throw new BeanDefinitionStoreException(bd.getResourceDescription(), curName, ex.getMessage(), ex);
            }
        }
    }

    // 将配置项解析器注册添加至bean工厂，供基于注解的配置项解析处理器使用（后文将详细介绍）
    // New in Spring 3.0: resolve placeholders in embedded values such as annotation attributes.
    beanFactoryToProcess.addEmbeddedValueResolver(valueResolver);
    // 其余代码省略
}

public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    // 部分代码省略
    
    // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
    boolean reiterate = true;
    while (reiterate) {
        reiterate = false;
        // 从bean工厂中找出bean定义注册表后置处理器
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            // 如果当前处理器尚未被触发过
            if (!processedBeans.contains(ppName)) {
                // 初始化处理器，并加入到本次需要触发的处理器集合中
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                // 标记处理器为已被处理
                processedBeans.add(ppName);
                // 继续循环，因为当前集合中的处理器被触发后，可能会引入新的bean定义，其中可能包含新的bean定义注册表后置处理器需要被触发
                reiterate = true;
            }
        }
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        // 触发集合中的处理器的bean定义注册表后置处理动作
        // * 本文案例中，我们在第三方XML文件中引入的MapperScannerConfigurer，便是在此时被触发的
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        currentRegistryProcessors.clear();
    }
    
}

/*
* BeanDefinitionRegistries are called early in application startup, before
* BeanFactoryPostProcessors. This means that PropertyResourceConfigurers will not have been
* loaded and any property substitution of this class' properties will fail. To avoid this, find
* any PropertyResourceConfigurers defined in the context and run them on this class' bean
* definition. Then update the values.
*/
// 上面这段英文注释体现了作者的考虑，即文中描述的情况
private void processPropertyPlaceHolders() {
    // 获取配置项处理器实例，即PropertySourcesPlaceholderConfigurer处理器
  Map<String, PropertyResourceConfigurer> prcs = applicationContext.getBeansOfType(PropertyResourceConfigurer.class);

    if (!prcs.isEmpty() && applicationContext instanceof ConfigurableApplicationContext) {
        BeanDefinition mapperScannerBean = ((ConfigurableApplicationContext) applicationContext)
          .getBeanFactory().getBeanDefinition(beanName);
        
        // 构造一个新的bean工厂
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        // 将自身的bean定义注册到这个bean工厂中
        factory.registerBeanDefinition(beanName, mapperScannerBean);
        // * 对这个bean工厂执行配置项后置处理操作
        for (PropertyResourceConfigurer prc : prcs.values()) {
          prc.postProcessBeanFactory(factory);
        }
        
        PropertyValues values = mapperScannerBean.getPropertyValues();
        // 使用被解析处理过的值更新原有的值
        this.basePackage = updatePropertyValue("basePackage", values);
        this.sqlSessionFactoryBeanName = updatePropertyValue("sqlSessionFactoryBeanName", values);
        this.sqlSessionTemplateBeanName = updatePropertyValue("sqlSessionTemplateBeanName", values);
    }
}

public class ConfigurationBeanFactoryMetaData implements BeanFactoryPostProcessor {
    
    private Map<String, MetaData> beans = new HashMap<String, MetaData>();
    
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        // 遍历bean工厂中的bean定义
        for (String name : beanFactory.getBeanDefinitionNames()) {
            BeanDefinition definition = beanFactory.getBeanDefinition(name);
            String method = definition.getFactoryMethodName();
            String bean = definition.getFactoryBeanName();
            // 如果存在工厂方法元数据（如通过@Bean注解声明的bean），则将相关信息记录下来
            if (method != null && bean != null) {
                this.beans.put(name, new MetaData(bean, method));
            }
        }
    }
}

// MyBatis配置文件路径。配置文件包含数据源、映射器等信息
String resource = "org/mybatis/example/mybatis-config.xml";
// 创建配置文件输入流
InputStream inputStream = Resources.getResourceAsStream(resource);
// 创建SqlSessionFactory实例
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
// 创建SqlSession实例
try (SqlSession session = sqlSessionFactory.openSession()) {
  // 获取BlogMapper映射器
    BlogMapper mapper = session.getMapper(BlogMapper.class);
    // 执行查询语句
    Blog blog = mapper.selectBlog(101);
}

<bean id="myInputStream" class="org.apache.ibatis.io.Resources"
      factory-method="getResourceAsStream">
    <constructor-arg value="org/mybatis/example/mybatis-config.xml"/>
</bean>

<bean id="mySqlSessionFactoryBuilder" class="org.apache.ibatis.session.SqlSessionFactoryBuilder"/>

<bean id="mySqlSessionFactory" class="org.apache.ibatis.session.SqlSessionFactory"
      factory-bean="mySqlSessionFactoryBuilder"
      factory-method="build">
    <constructor-arg ref="myInputStream"/>
</bean>

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {

    // 映射器接口类型
    private Class<T> mapperInterface;

    // 通过该方法获取我们实际需要的映射器实例
    @Override
    public T getObject() throws Exception {
        return getSqlSession().getMapper(this.mapperInterface);
    }

    // 获取实际的bean的类型，即映射器接口类型
    @Override
    public Class<T> getObjectType() {
      return this.mapperInterface;
    }
    
}

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    ConfigurationProperties annotation = AnnotationUtils.findAnnotation(bean.getClass(),
            ConfigurationProperties.class);
    if (annotation != null) {
        postProcessBeforeInitialization(bean, beanName, annotation);
    }
    // 处理方法级别的@ConfigurationProperties注解
    // 这里的this.beans即为ConfigurationBeanFactoryMetaData实例
    annotation = this.beans.findFactoryAnnotation(beanName, ConfigurationProperties.class);
    if (annotation != null) {
        postProcessBeforeInitialization(bean, beanName, annotation);
    }
    return bean;
}