Spring IoC实现解析

public interface BeanFactory {
  // 用来引用一个实例，或把它和工厂生产的Bean区分开，如果一个FactoryBean的名字为a，那么&a会得到那个Factory
    String FACTORY_BEAN_PREFIX = "&";
//四种不同形式的getBean方法获取实例
    Object getBean(String var1) throws BeansException;

    Object getBean(String var1, Class var2) throws BeansException;

    Object getBean(String var1, Object[] var2) throws BeansException;

    boolean containsBean(String var1); //是否存在
// 是否是单例
    boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;
// 是否为原型
    boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;
// 名称、类型是否匹配
    boolean isTypeMatch(String var1, Class var2) throws NoSuchBeanDefinitionException;
// 获取类型
    Class getType(String var1) throws NoSuchBeanDefinitionException;
// 根据实例的名字获取实例的别名
    String[] getAliases(String var1);
}

public interface FactoryBean {
  // 返回由FactoryBean创建的Bean实例，如果isSingleton()返回true，则该实例会放到Spring容器中单例缓存池中
    Object getObject() throws Exception;
// 类型
    Class getObjectType();
// 作用域是单例还是原型
    boolean isSingleton();
}

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor implements BeanDefinition, Cloneable {
 private volatile Object beanClass;
    private String scope;//默认scope为“”，相当于单例 
    private boolean singleton;//bean默认为单例的
    private boolean prototype;//bean默认不是原型的  
    private boolean abstractFlag;//bean默认不是抽象的 
    private boolean lazyInit;//bean默认不开启延迟初始化
    private int autowireMode;//bean默认自动装配功能是关闭的
    private int dependencyCheck;//bean的默认依赖检查方式 
    private String[] dependsOn;//这个bean要初始化依赖的bean名称数组 
    private boolean autowireCandidate;//自动装配候选者  
    private boolean primary;//默认不是主要候选者
    private final Map<String, AutowireCandidateQualifier> qualifiers;//用于记录Qualifier，对应子元素qualifier
    private boolean nonPublicAccessAllowed;//允许访问非公开的构造器和方法
    private boolean lenientConstructorResolution;//是否以一种宽松的模式解析构造函数，默认true
    private ConstructorArgumentValues constructorArgumentValues;//记录构造函数注入属性，对应bean属性constructor-arg
    private MutablePropertyValues propertyValues;//普通属性集合
    private MethodOverrides methodOverrides;//方法重写持有者
    private String factoryBeanName;// 对应bean属性: factory-bean
    private String factoryMethodName;//对应bean属性: factory-method
    private String initMethodName;//初始化方法，对应bean属性: init-method
    private String destroyMethodName;// 销毁方法，对应destory-method
    private boolean enforceInitMethod;// 是否执行init-method
    private boolean enforceDestroyMethod;//是否执行destory-method
    private boolean synthetic;//是否是用户定义的而不是应用程序本身定义的
    private int role;//定义这个bean的应用
    private String description;// bean的描述
    private Resource resource; //bean定义的资源
}

public interface BeanDefinitionReader {
    BeanDefinitionRegistry getRegistry();
    ResourceLoader getResourceLoader();
    ClassLoader getBeanClassLoader();
    BeanNameGenerator getBeanNameGenerator();
    int loadBeanDefinitions(Resource var1) throws BeanDefinitionStoreException;
    int loadBeanDefinitions(Resource... var1) throws BeanDefinitionStoreException;
    int loadBeanDefinitions(String var1) throws BeanDefinitionStoreException;
    int loadBeanDefinitions(String... var1) throws BeanDefinitionStoreException;
}

public void refresh() throws BeansException, IllegalStateException { 
    synchronized (this.startupShutdownMonitor) { 
        // Prepare this context for refreshing. 
        prepareRefresh(); 
        // 在子类中启动refreshBeanFactory 
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 
        // Prepare the bean factory for use in this context. 
        prepareBeanFactory(beanFactory); 
        try { 
            // 设置BeanFactory的后置处理 
            postProcessBeanFactory(beanFactory); 
            // 调用BeanFactory的后处理器，这些后处理器是在Bean定义中向容器注册的 
            invokeBeanFactoryPostProcessors(beanFactory); 
            // 注册Bean的后处理器，在Bean创建过程中调用
            registerBeanPostProcessors(beanFactory); 
            // 对上下文的消息源进行初始化
            initMessageSource(); 
            // 初始化上下文中的事件机制
            initApplicationEventMulticaster(); 
            // 初始化其他的特殊Bean 
            onRefresh(); 
            // 检查坚挺Bean并且将这些Bean向容器注册
            registerListeners(); 
            // 实例化所有(non-lazy-init)单件 
            finishBeanFactoryInitialization(beanFactory); 
            // 发布容器事件，结束Refresh过程 
            finishRefresh(); 
        } 
        catch (BeansException ex) { 
            // Destroy already created singletons to avoid dangling resources. 
            destroyBeans(); 
            // Reset 'active' flag. 
            cancelRefresh(ex); 
            // Propagate exception to caller. 
            throw ex; 
        } 
    } 
}

protected final void refreshBeanFactory() throws BeansException { 
    if (hasBeanFactory()) { 
        destroyBeans(); 
        closeBeanFactory(); 
    } 
    try { 
        DefaultListableBeanFactory beanFactory = createBeanFactory(); 
        beanFactory.setSerializationId(getId()); 
        customizeBeanFactory(beanFactory); 
        loadBeanDefinitions(beanFactory); 
        synchronized (this.beanFactoryMonitor) { 
            this.beanFactory = beanFactory; 
        } 
    } 
    catch (IOException ex) { 
        throw new ApplicationContextException(
			"I/O error parsing bean definition source for " 
			+ getDisplayName(), ex); 
    } 
}

void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 
    throws BeansException;

public interface BeanPostProcessor {
    Object postProcessBeforeInitialization(Object var1, String var2) throws BeansException;

    Object postProcessAfterInitialization(Object var1, String var2) throws BeansException;
}

protected void finishBeanFactoryInitialization(
	ConfigurableListableBeanFactory beanFactory) { 

    // Stop using the temporary ClassLoader for type matching. 
    beanFactory.setTempClassLoader(null); 
    // Allow for caching all bean definition metadata, not expecting further changes.
    beanFactory.freezeConfiguration(); 
    // Instantiate all remaining (non-lazy-init) singletons. 
    beanFactory.preInstantiateSingletons(); 
}

public void preInstantiateSingletons() throws BeansException { 
    if (this.logger.isInfoEnabled()) { 
        this.logger.info("Pre-instantiating singletons in " + this); 
    } 
    synchronized (this.beanDefinitionMap) { 
        for (String beanName : this.beanDefinitionNames) { 
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); 
            if (!bd.isAbstract() && bd.isSingleton() 
                && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) { 
                    final FactoryBean factory = 
                        (FactoryBean) getBean(FACTORY_BEAN_PREFIX+ beanName); 
                    boolean isEagerInit; 
                    if (System.getSecurityManager() != null 
                        && factory instanceof SmartFactoryBean) { 
                        isEagerInit = AccessController.doPrivileged(
                            new PrivilegedAction<Boolean>() { 
                            public Boolean run() { 
                                return ((SmartFactoryBean) factory).isEagerInit(); 
                            } 
                        }, getAccessControlContext()); 
                    } 
                    else { 
                        isEagerInit = factory instanceof SmartFactoryBean 
                            && ((SmartFactoryBean) factory).isEagerInit(); 
                    } 
                    if (isEagerInit) { 
                        getBean(beanName); 
                    } 
                } 
                else { 
                    getBean(beanName); 
                } 
            } 
        } 
    } 
}

public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory var1) throws BeansException;
}

public interface BeanPostProcessor {
    Object postProcessBeforeInitialization(Object var1, String var2) throws BeansException;

    Object postProcessAfterInitialization(Object var1, String var2) throws BeansException;
}

@Component
public class SqlClientReplacer implements BeanFactoryPostProcessor, PriorityOrdered{
   
   private static boolean hasProcessd;
   private DefaultListableBeanFactory listableBeanFactory = null;

   @Override
   public int getOrder() {
      return Ordered.LOWEST_PRECEDENCE - 2;
   }

   @Override
   public void postProcessBeanFactory(
         ConfigurableListableBeanFactory beanFactory) throws BeansException {
      if (hasProcessd) {
         return;
      }
      hasProcessd = true;

      listableBeanFactory = (DefaultListableBeanFactory) beanFactory;
      String[] beanDefinitionNames = listableBeanFactory.getBeanNamesForType(BaseDAO.class);
      
      for (String definitionName : beanDefinitionNames) {
         try {
            AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) listableBeanFactory
                  .getBeanDefinition(definitionName);
            Class<?> beanClazz = beanDefinition.resolveBeanClass(ClassUtils.getDefaultClassLoader());
            if (beanClazz != null && BaseDAO.class.isAssignableFrom(beanClazz)) {
               BeanDefinition definition = listableBeanFactory.getBeanDefinition(definitionName);
               
               Slave slave = beanClazz.getAnnotation(Slave.class);
               if(slave != null){
                  definition.getPropertyValues().addPropertyValue("sqlMapClient", new RuntimeBeanReference("bookingSlaveSqlMapClient"));
               }else{
                  definition.getPropertyValues().addPropertyValue("sqlMapClient", new RuntimeBeanReference("bookingMasterSqlMapClient"));
               }
            }
         } catch (ClassNotFoundException e) {
            throw new RuntimeException("postProcessBeanFactory failed", e);
         }
      }
   }

}

public class SpringConfig extends InitializeConfig ;
<bean name="placeholder" lazy-init="false" class="com.dianping.lion.client.SpringConfig">
		<property name="propertiesPath" value="config/applicationContext.properties" />
	</bean>
  // 具体实现，看父类InitializeConfig，将${}中的字符串替换成配置
  public class InitializeConfig implements BeanFactoryPostProcessor, PriorityOrdered, BeanNameAware, BeanFactoryAware {
    private static Logger logger;
    public static final String DEFAULT_PLACEHOLDER_PREFIX = "${";
    public static final String DEFAULT_PLACEHOLDER_SUFFIX = "}";
    private String placeholderPrefix = "${";
    private String placeholderSuffix = "}";
    private int order = 2147483647;
    private BeanFactory beanFactory;
    private String beanName;
    private String nullValue = "";
    protected String address;
    private String environment;
    private String propertiesPath;
    private boolean includeLocalProps;
    private Properties localProps;
    private Map<String, List<BeanData>> propertyMap = new HashMap();
  }