Spring 核心方法 refresh 刷新流程简要概述及相关源码扩展实现（二）（下）

public interface Converter<S, T> {
  /**
   * S 类型转换成 T 类型
   */
  @Nullable
  T convert(S source);
}

public interface ConverterFactory<S, R> {
  /**
   * 获取转换器
   */
  <T extends R> Converter<S, T> getConverter(Class<T> targetType);
}

public interface GenericConverter {
  /**
   * 返回转换器集合可以转换源和目标类型
   */
  @Nullable
  Set<ConvertiblePair> getConvertibleTypes();
  /**
   *  转换源对象到目标类型的描述
   *  源 TypeDescriptor 提供对保存正在转换的值的源字段的访问
   *  目标 TypeDescriptor 提供对要设置转换值的目标字段的访问
   */
  @Nullable
  Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType);
}
// 组建一个源到目的的组合
final class ConvertiblePair {
    private final Class<?> sourceType;
    private final Class<?> targetType;
    /**
      * 创建一个新的源-目标组合
      */
    public ConvertiblePair(Class<?> sourceType, Class<?> targetType) {
        Assert.notNull(sourceType, "Source type must not be null");
        Assert.notNull(targetType, "Target type must not be null");
        this.sourceType = sourceType;
        this.targetType = targetType;
    }
  public Class<?> getSourceType() {
        return this.sourceType;
    }
    public Class<?> getTargetType() {
        return this.targetType;
    }
}

public interface ConditionalConverter {
    /**
     * 判断是否匹配能够从源类型转换为目标类型
     */
    boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType);
} 

public interface ConversionService {
  /**
   * 判断能否进行类型转换
   */
  boolean canConvert(@Nullable Class<?> sourceType, Class<?> targetType);
  boolean canConvert(@Nullable TypeDescriptor sourceType, TypeDescriptor targetType);
  /**
   * 类型转换，获取合适的转换器进行类型的转换，默认是 DefaultConversionService，也可以是自定义的
   */
  @Nullable
  <T> T convert(@Nullable Object source, Class<T> targetType);
  @Nullable
  Object convert(@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType);
}

public class StudentConverter implements Converter<String,Student> {
    @Override
    public Student convert(String source) {
        System.out.println("-----");
        Student s  = new Student();
        String[] splits = source.split("_");
        s.setId(Integer.parseInt(splits[0]));
        s.setName(splits[1]);
        return s;
    }
}

<!-- xml 方式配置 -->
<bean id="studentConverter" class="com.mashibing.selfConverter.StudentConverter"/>
<bean id ="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <set>
            <ref bean="studentConverter"/>
        </set>
    </property>
</bean>

// 注解方式配置
@Configuration
public class AppConfig {
    @Bean
    public ConversionService conversionService() {
        DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService();
        conversionService.addConverter(new MyCustomConverter());
        return conversionService;
    }
}

<context:property-placeholder location="classpath:db.properties"/>

// 尽早初始化 loadTimeWeaverAware bean，以便尽早注册它们的转换器
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
   getBean(weaverAwareName);
}
// 禁止使用临时类加载器进行类型匹配
beanFactory.setTempClassLoader(null);
// 冻结所有 bean 定义，说明注册 bean 定义将不被修改或任何进一步的处理
beanFactory.freezeConfiguration();
// 实例化剩下的单例对象
beanFactory.preInstantiateSingletons();

protected void finishRefresh() {
  // 清除上下文级别的资源缓存(如扫描的 ASM 元数据)
  // 清空在资源加载器中的所有资源缓存
  clearResourceCaches();
  // 为这个上下文初始化生命周期处理器
  // 初始化 LifecycleProcessor：如果上下文中找到'lifecycleProcessor' 的 LifecycleProcessor Bean 对象，则使用 DefaultLifecycleProcessor
  initLifecycleProcessor();
  // 首先将刷新传播到生命周期处理器
  // 上下文刷新的通知，例如自动启动的组件
  getLifecycleProcessor().onRefresh();
  // 发布最终事件
  // 新建 ContextRefreshedEvent 事件对象，将其发布给所有监听器
  publishEvent(new ContextRefreshedEvent(this));
  // 参与 LiveBeansView MBean，如果是活动的
  // LiveBeansView：Spring 用于支持JMX 服务的类
  // 注册当前上下文到 LiveBeansView，以支持 JMX 服务
  LiveBeansView.registerApplicationContext(this);
}

protected void finishRefresh() {
    //调用父类 finishRefresh 方法
  super.finishRefresh();
    // 启动 webServer
  WebServer webServer = startWebServer();
  if (webServer != null) {
        // 发布 webServer 初始化完成事件
    publishEvent(new ServletWebServerInitializedEvent(webServer, this));
  }
}

protected void resetCommonCaches() {
  // 清除方法、属性缓存
  ReflectionUtils.clearCache();
  AnnotationUtils.clearCache();
  // 清除对象映射、序列化包装对象缓存
  ResolvableType.clearCache();
  CachedIntrospectionResults.clearClassLoader(getClassLoader());
}