AliasRegistry：定义了对别名的简单增删改操作

public interface AliasRegistry {
    void registerAlias(String var1, String var2);

    void removeAlias(String var1);

    boolean isAlias(String var1);

    String[] getAliases(String var1);
}

SimpleAliasRegistry：使用ConcurrentHashMap实现了AliasRegistry接口：

public class SimpleAliasRegistry implements AliasRegistry {
    private final Map<String, String> aliasMap = new ConcurrentHashMap(16);

    public SimpleAliasRegistry() {
    }
    ...
  }

SingletonBeanRegistry ：定义对单例的注册及获取

public interface SingletonBeanRegistry {
    void registerSingleton(String var1, Object var2);

    Object getSingleton(String var1);

    boolean containsSingleton(String var1);

    String[] getSingletonNames();

    int getSingletonCount();
}

DefaultSingletonBeanRegistry：对SingletonBeanRegistry 接口的实现，同时继承了SimpleAliasRegistry 类。

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
 protected static final Object NULL_OBJECT = new Object();//静态不可变对象Object，因为ConcurrentHashMap不能保存null值。
    private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap(16));//根据map生成对应结构的set，保存正在创建的单例beanName的set
     private final Map<String, Object> singletonObjects = new ConcurrentHashMap(64);//保存单例的map
      private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);//保存单例bean
              private final Map<String, Object> earlySingletonObjects = new HashMap(16);//缓存从ObjectFactory中获取的bean
                  private final Set<String> registeredSingletons = new LinkedHashSet(64);//保存已经注册的beanName，
     private boolean singletonsCurrentlyInDestruction = false;//目前是否在销毁单例
         private final Map<String, Object> disposableBeans = new LinkedHashMap();//保存只使用一次的bean
    private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap(16);//bean的包含关系
    private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap(64);//bean的依赖关系
    private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap(64);//bean的依赖关系
    //单例注册的实现
      public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
        Assert.notNull(beanName, "\'beanName\' must not be null");
        Map var3 = this.singletonObjects;
        synchronized(this.singletonObjects) {//对保存单例的map加锁
            Object oldObject = this.singletonObjects.get(beanName);//查看对应名字的单例是否存在
            if(oldObject != null) {//已经存在，抛出异常
                throw new IllegalStateException("Could not register object [" + singletonObject + "] under bean name \'" + beanName + "\': there is already object [" + oldObject + "] bound");
            } else {//不存在，增加这个单例对象
                this.addSingleton(beanName, singletonObject);
            }
        }
    }
    //往singletonObjects里面增加单例
       protected void addSingleton(String beanName, Object singletonObject) {
        Map var3 = this.singletonObjects;
        synchronized(this.singletonObjects) {//加锁
            this.singletonObjects.put(beanName, singletonObject != null?singletonObject:NULL_OBJECT);//待增加的singletonObject 为null则增加静态不可变类NULL_OBJECT
            this.singletonFactories.remove(beanName);//从ObjectFactory中移除beanName
            this.earlySingletonObjects.remove(beanName);//从earlySingletonObjects中移除beanName
            this.registeredSingletons.add(beanName);//将beanName保存到保存已经注册的set中
        }
    }
//增加对象工厂（工厂bean）
    protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(singletonFactory, "Singleton factory must not be null");
        Map var3 = this.singletonObjects;
        synchronized(this.singletonObjects) {//加锁
        //判断singletonObjects是否包含这个beanName
            if(!this.singletonObjects.containsKey(beanName)) {
                this.singletonFactories.put(beanName, singletonFactory);
                this.earlySingletonObjects.remove(beanName);
                this.registeredSingletons.add(beanName);//保存beanName到set中
            }

        }
    }
//获取单例，
    public Object getSingleton(String beanName) {
    //获取单例，允许从ObjectFactory中获取
        return this.getSingleton(beanName, true);
    }
//先从保存bean对map中获取，没有获取到，则从缓存ObjectFactory获取的bean的map中获取，没有获取到，则从工厂bean获取
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        //保存单例的map中没有获取到单例， 
         if(singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
            Map var4 = this.singletonObjects;
            //对单例map进行加锁
            synchronized(this.singletonObjects) {
            //从缓存ObjectFactory获取的bean的map中获取
                            singletonObject = this.earlySingletonObjects.get(beanName);
                //从ObjectFactory获取
                                if(singletonObject == null && allowEarlyReference) {
                    ObjectFactory singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                    if(singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);//将正在创建的bean放到早期引用map中
                        this.singletonFactories.remove(beanName);//从保存共产bean的map中移除这个beanName

                    }
                }
            }
        }

        return singletonObject != NULL_OBJECT?singletonObject:null;
    }
}

总结bean的增加和获取：
把bean增加到singletonObjects中，从singletonFactories中移除，从earlySingletonObjects中移除，再保存到registeredSingletons中。
BeanFactory：bean的获取和bean的各种属性

public interface BeanFactory {
    String FACTORY_BEAN_PREFIX = "&";

    Object getBean(String var1) throws BeansException;

    <T> T getBean(String var1, Class<T> var2) throws BeansException;

    <T> T getBean(Class<T> var1) throws BeansException;

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

    <T> T getBean(Class<T> 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);
}

HierarchicalBeanFactory ：在BeanFactory 的基础上增加工厂层次关系，

public interface HierarchicalBeanFactory extends BeanFactory {
    BeanFactory getParentBeanFactory();

    boolean containsLocalBean(String var1);
}

BeanDefinitionRegistry ：对BeanDefinition的增删改操作

public interface BeanDefinitionRegistry extends AliasRegistry {
    void registerBeanDefinition(String var1, BeanDefinition var2) throws BeanDefinitionStoreException;

    void removeBeanDefinition(String var1) throws NoSuchBeanDefinitionException;

    BeanDefinition getBeanDefinition(String var1) throws NoSuchBeanDefinitionException;

    boolean containsBeanDefinition(String var1);

    String[] getBeanDefinitionNames();

    int getBeanDefinitionCount();

    boolean isBeanNameInUse(String var1);
}

FactoryBeanRegistrySupport ：增加对FactoryBean的操作

public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry { 
private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap(16);//缓存从工厂bean中获取的对象

}

ConfigurableBeanFactory ：提供配置Factory的各种方法

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
//bean的属性
   String SCOPE_SINGLETON = "singleton";
    String SCOPE_PROTOTYPE = "prototype";
      void setParentBeanFactory(BeanFactory var1) throws IllegalStateException;//设置父工厂
      void setBeanClassLoader(ClassLoader var1);//设置bean的类加载器
      void setBeanExpressionResolver(BeanExpressionResolver var1);//设置bean表达式解析器
      void setConversionService(ConversionService var1);//设置类型转换器
      void addPropertyEditorRegistrar(PropertyEditorRegistrar var1);// 用一个属性编辑注册器(PropertyEditorRegistry)注册一个自定义的属性编辑器(PropertyEditor)的策略接口。
      void setTypeConverter(TypeConverter var1);//设置类型转换器
      void addBeanPostProcessor(BeanPostProcessor var1);//增加bean后处理器
      ...
}

ListableBeanFactory ：根据各种条件获取bean

public interface ListableBeanFactory extends BeanFactory {
<T> Map<String, T> getBeansOfType(Class<T> var1) throws BeansException;//根据类型获取bean
    ...
}

AbstractBeanFactory ：继承了FactoryBeanRegistrySupport ，同时实现ConfigurableBeanFactory 接口的方法

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
     private BeanFactory parentBeanFactory;//父beanFactory
    private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();//获取类加载器，首选当前线程的类加载器
    private ClassLoader tempClassLoader;//临时类加载器
    private boolean cacheBeanMetadata = true;
    private BeanExpressionResolver beanExpressionResolver;
    private ConversionService conversionService;
    private final Set<PropertyEditorRegistrar> propertyEditorRegistrars = new LinkedHashSet(4);
    private TypeConverter typeConverter;
    private final Map<Class<?>, Class<? extends PropertyEditor>> customEditors = new HashMap(4);
    private final List<StringValueResolver> embeddedValueResolvers = new LinkedList();
    private final List<BeanPostProcessor> beanPostProcessors = new ArrayList();//bean后处理器
    private boolean hasInstantiationAwareBeanPostProcessors;
    private boolean hasDestructionAwareBeanPostProcessors;
    private final Map<String, Scope> scopes = new HashMap(8);
    private SecurityContextProvider securityContextProvider;
    private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap(64);
    private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap(64));
    private final ThreadLocal<Object> prototypesCurrentlyInCreation = new NamedThreadLocal("Prototype beans currently in creation");
//构造方法设置父BeanFactory 
public AbstractBeanFactory(BeanFactory parentBeanFactory) {
        this.parentBeanFactory = parentBeanFactory;
    }
     public Object getBean(String name) throws BeansException {
        return this.doGetBean(name, (Class)null, (Object[])null, false);
    }

    public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
        return this.doGetBean(name, requiredType, (Object[])null, false);
    }
//一系列最核心的getBean方法。非常重要！
    public Object getBean(String name, Object... args) throws BeansException {
        return this.doGetBean(name, (Class)null, args, false);
    }

    public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
        return this.doGetBean(name, requiredType, args, false);
    }
    //获取bean
    protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
        final String beanName = this.transformedBeanName(name);//装换beanName
        Object sharedInstance = this.getSingleton(beanName);//调用父类方法获取beanName对应单例，尝试直接从缓存获取获取singletonFactories中的ObjectFactory中获取
        Object bean;
        if(sharedInstance != null && args == null) {
            if(this.logger.isDebugEnabled()) {
                if(this.isSingletonCurrentlyInCreation(beanName)) {
                    this.logger.debug("Returning eagerly cached instance of singleton bean \'" + beanName + "\' that is not fully initialized yet - a consequence of a circular reference");
                } else {
                    this.logger.debug("Returning cached instance of singleton bean \'" + beanName + "\'");
                }
            }

            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);//bean的实例化，如果是工厂bean,则获取工厂bean的里面的bean
        } else {
            if(this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            BeanFactory ex = this.getParentBeanFactory();
            if(ex != null && !this.containsBeanDefinition(beanName)) {
                String var24 = this.originalBeanName(name);
                if(args != null) {
                    return ex.getBean(var24, args);
                }

                return ex.getBean(var24, requiredType);
            }

            if(!typeCheckOnly) {
                this.markBeanAsCreated(beanName);
            }

            try {
                final RootBeanDefinition ex1 = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(ex1, beanName, args);
                String[] dependsOn = ex1.getDependsOn();
                String[] scopeName;
                if(dependsOn != null) {
                    scopeName = dependsOn;
                    int scope = dependsOn.length;

                    for(int ex2 = 0; ex2 < scope; ++ex2) {
                        String dependsOnBean = scopeName[ex2];
                        if(this.isDependent(beanName, dependsOnBean)) {
                            throw new BeanCreationException(ex1.getResourceDescription(), beanName, "Circular depends-on relationship between \'" + beanName + "\' and \'" + dependsOnBean + "\'");
                        }

                        this.registerDependentBean(dependsOnBean, beanName);
                        this.getBean(dependsOnBean);
                    }
                }

                if(ex1.isSingleton()) {
                    sharedInstance = this.getSingleton(beanName, new ObjectFactory() {
                        public Object getObject() throws BeansException {
                            try {
                                return AbstractBeanFactory.this.createBean(beanName, ex1, args);
                            } catch (BeansException var2) {
                                AbstractBeanFactory.this.destroySingleton(beanName);
                                throw var2;
                            }
                        }
                    });
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, ex1);
                } else if(ex1.isPrototype()) {
                    scopeName = null;

                    Object var25;
                    try {
                        this.beforePrototypeCreation(beanName);
                        var25 = this.createBean(beanName, ex1, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }

                    bean = this.getObjectForBeanInstance(var25, name, beanName, ex1);
                } else {
                    String var26 = ex1.getScope();
                    Scope var27 = (Scope)this.scopes.get(var26);
                    if(var27 == null) {
                        throw new IllegalStateException("No Scope registered for scope \'" + var26 + "\'");
                    }

                    try {
                        Object var28 = var27.get(beanName, new ObjectFactory() {
                            public Object getObject() throws BeansException {
                                AbstractBeanFactory.this.beforePrototypeCreation(beanName);

                                Object var1;
                                try {
                                    var1 = AbstractBeanFactory.this.createBean(beanName, ex1, args);
                                } finally {
                                    AbstractBeanFactory.this.afterPrototypeCreation(beanName);
                                }

                                return var1;
                            }
                        });
                        bean = this.getObjectForBeanInstance(var28, name, beanName, ex1);
                    } catch (IllegalStateException var21) {
                        throw new BeanCreationException(beanName, "Scope \'" + var26 + "\' is not active for the current thread; " + "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var21);
                    }
                }
            } catch (BeansException var23) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var23;
            }
        }
}

AutowireCapableBeanFactory：提供创建bean，自动注入，初始化以及应用bean的后处理器

public interface AutowireCapableBeanFactory extends BeanFactory {
   <T> T createBean(Class<T> var1) throws BeansException;

    void autowireBean(Object var1) throws BeansException;
    ...
}

AbstractAutowireCapableBeanFactory ：继承AbstractBeanFactory ，实现AutowireCapableBeanFactory 接口

//创建bean的实现
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {   public <T> T createBean(Class<T> beanClass) throws BeansException {
        RootBeanDefinition bd = new RootBeanDefinition(beanClass);
        bd.setScope("prototype");
        bd.allowCaching = ClassUtils.isCacheSafe(beanClass, this.getBeanClassLoader());
        return this.createBean(beanClass.getName(), bd, (Object[])null);
    }

}

DefaultListableBeanFactory：综合上面所有功能，主要是对bean注册后的处理