深入Spring配置項問題，全面決議

<!-- 配置SqlSessionFactoryBean -->
<bean id="thirdPartySqlSessionFactory"
      
      depends-on="myDataSource">
    <!-- datasource為自定義資料源 -->
    <property name="dataSource" ref="myDataSource"/>
    <property name="mapperLocations" value="https://www.cnblogs.com/88223100/archive/2023/05/19/classpath:mybatis/third-party/*.xml"/>
</bean>

<!-- 配置MapperScannerConfigurer -->
<bean id="thirdPartyMapperScannerConfigurer"
      
      depends-on="thirdPartySqlSessionFactory">
    <property name="basePackage" value="https://www.cnblogs.com/88223100/archive/2023/05/19/com.alibaba.thirdparty.dao"/>
    <property name="sqlSessionFactoryBeanName" value="https://www.cnblogs.com/88223100/archive/2023/05/19/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"  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" 
      factory-method="getResourceAsStream">
    <constructor-arg value="https://www.cnblogs.com/88223100/archive/2023/05/19/org/mybatis/example/mybatis-config.xml"/>
</bean>

<bean id="mySqlSessionFactoryBuilder" />

<bean id="mySqlSessionFactory" 
      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;
}