还在机械地打代码？只知道如何使用，却不知道做了什么，那么你注定只能是一个码农。Spring 框架几乎集成一半 Javaweb 开发的江山，但是你只知道如何写，不知道为什么要这么写，也不知道要如何优化。
本场 Chat 将让大家了解 Spring 的运行原理、深度解析 IOC 和 AOP、最后你还可以自己写一个小型 Spring 框架！
实录提要：
- 阅读源码的正确姿势/最佳实践是什么？
- Spring 源码哪本书比较好？
- 设计模式应该主要掌握哪几种？
- 如何进行统一加解密使用 Spring（还要考虑到上传文件返回文件数据的请款）？
- 模块化思想是什么？
- Spring 源码那么多的类，类之间调用比较复杂，从哪里开始看比较好？
- 一、说说我自己
- 二、IOC入门篇之概念理解
- 三、深入理解IOC核心类
- 四、IOC体系结构源码剖析
我给大家介绍一下我的学习方法。学习的三种阶段：入门、掌握、精通。
- 入门篇 -- 读文章 对这个知识有一定的了解，了解大概的发展趋势以及使用复杂程度，达到基本可以使用程度。
- 掌握篇 -- 看网上的教程 对这个知识使用并了解一些出现bug解决方案，扩展使用途径。
- 精通篇 -- 对知识体系结构已有完整认知 需要读别人写的书 加上自己亲自打代码时间 完全了解这个知识发展渊源。
我也是和大家一样，大三来北京在一个小公司实习，我还是一个专科生 ，我并不是什么大神，只是在spring方面花费比大家多一些时间而已。
送给所有有梦想的我们一句话 ：相信自己，力量在心中！！
IOC入门篇之概念理解控制反转(IoC)：概念的描述：
Martin Fowler提出，那些方面的控制被反转了？ - 他给出的结论：依赖对象的获取被反转了，基于这个结论他为控制反转创造了一个由两个或多各类批次之间的合作来实现业务逻辑的，这是的每一个对象都需要与其合作的对象（也就是他依赖的对象）的引用。如果这个获取过程要考自身实现，那么如果如你所见，这将导致代码高度耦合难以测试。--《摘自维基百科》
我是这样理解IOC容器：以水桶为例，有大的，小的，有金的，银的，各种各样。IOC容器也如此，每种不同的容器有自己功能，但是他们有一个是不能改变的，那就是装水，我们所学习的IOC容器也一样。
IOC是Inversion of Control的缩写，由于引进了中间位置的第三方，也就是IOC容器使得没有关联关系的类有了一个共同的关系--被ICO容器所管理，所以说IOC容器起到了粘合剂的作用。
DI是Dependency Injection的所写，是指通过引入IOC容器，利用类与类相关的依赖关系，注入的方式，实现代码重用以及对象之间的解耦合。（说到解耦合，三大框架都是为了解耦合，面试时候千万别说解耦合 ，说具体，哈哈。）
IOC的好处，初始化的过程中就不可避免的会写大量的new，只需要维护XML或注解，不需要大量的修改代码，IOC容器是分层的，从最底层BeanFactory网上找（后面源码解读会详细讲解），实现类与类之间的解耦合，可以将代码分离，每个人只需要写自己的部分，利于团队协作。
复合IOC规范的产品: Spring、Guice、Pico Container、Avalon、HiveMind；重量级的有EJB，JBoss，Jdon等等。以上除了Spring别的都没用过，出去面试吹一下也没啥^-^
使用IOC容器的小缺点: 引入第三方工具，对性能，初始化等速度均有影响，需要配置一大堆（springboot简化了好多，推荐大家从基于xml的spring学起），通过反射机制创建对象，效率较低~~~实际没影响。
深入理解IOC核心类BeanFactory的基本类体系结构：
如图所示：BeanFactory是最基础的IOC底层，定义了一些bean的基本属性，XMLBeanFactory算比较高级的IOC容器了，IOC容器是分层的，每一层都有自己需要做的功能，一下将简略展示IOC各个容器的功能。
BeanFactory 负责 获取bean，封装判断bean容器是否包含bean，判断bean是否为单利/指定类型，获取类的别名，类型匹配等。
ListanleBeanFactory 继承自BeanFactory 封装bean的一些基本属性信息，如类的个数，类型，别名等，可以根据条件获取指定bean。
AutowireCapableBeanFactory 继承自BeanFactory 封装提供一系列自动装噢诶bean的策略，自动注入初始化以及bean的前/后处理器，分解依赖等。
HierarchicalBeanFactory 继承自BeanFactory 封装两个方法，一个获取bean工厂的父工厂，另一个判断本地工厂是否包含指定bean。
SinglentonRegistry 定义对单例注册及获取是否包含等判断。
ConfigurableBeanFactory 提供配置Factory的方法。
AliaRegistry 提供对bean的别名的增删改查操作。
BeanDefinitionRegister 使用BeanDefinition修饰bean，提供对BeanDefinition的增删改操作。
ConfigurableBeanFactory 提供配置bean的方法 。
ConfigurableListableBeanFactory 配置清单BeanFactory指定忽略类型，接口等。
AbstractAutowireCapableBeanFactory 综合AbstractBeanFactory，对接自动装配bean。
DefaultListableBeanFactory 综合上面的功能，主要针对bean的注册。
XmlBeanFactory 实现类体系结构:
Spring 5.x 源码下载
你也可以到github上下载gradle构架的Spring 然后把你的eclipse配置gradle 安装插件项目。
SimpleAliasRegistry
public class SimpleAliasRegistry implements AliasRegistry {// 包含别名的map 就我了解 所有包含并发操作的都是用currentHashMap 推荐大家也使用private final Map aliasMap = new ConcurrentHashMap(16);@Overridepublic void registerAlias(String name, String alias) { Assert.hasText(name, "'name' must not be empty"); Assert.hasText(alias, "'alias' must not be empty"); // 若别名和实际bean名字相同，移除别名 if (alias.equals(name)) { this.aliasMap.remove(alias); } else { // 获取bean的真实名 String registeredName = this.aliasMap.get(alias); if (registeredName != null) { if (registeredName.equals(name)) { // An existing alias - no need to re-register return; } if (!allowAliasOverriding()) { throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" + name + "': It is already registered for name '" + registeredName + "'."); } } checkForAliasCircle(name, alias);// 当bean名字与name相同 检查别名是否相同 相同抛出异常 已存在的别名 this.aliasMap.put(alias, name); }}// SO WHAT ? protected boolean allowAliasOverriding() { return true;}// checkForAliasCircle调用的 上文指出public boolean hasAlias(String name, String alias) { for (Map.Entry entry : this.aliasMap.entrySet()) { String registeredName = entry.getValue(); if (registeredName.equals(name)) { String registeredAlias = entry.getKey(); return (registeredAlias.equals(alias) || hasAlias(registeredAlias, alias)); } } return false;}// 移除别名@Overridepublic void removeAlias(String alias) { String name = this.aliasMap.remove(alias); if (name == null) { throw new IllegalStateException("No alias '" + alias + "' registered"); }}// 是否是别名@Overridepublic boolean isAlias(String name) { return this.aliasMap.containsKey(name);}// 获取所有别名@Overridepublic String[] getAliases(String name) { List result = new ArrayList(); synchronized (this.aliasMap) { retrieveAliases(name, result); } return StringUtils.toStringArray(result);}// 找出所有name对应的别名 存入Listprivate void retrieveAliases(String name, List result) { for (Map.Entry entry : this.aliasMap.entrySet()) { String registeredName = entry.getValue(); if (registeredName.equals(name)) { String alias = entry.getKey(); result.add(alias); retrieveAliases(alias, result); } }}// 处理所有的别名，如果处理正确，把原来的用解析后的替换public void resolveAliases(StringValueResolver valueResolver) { Assert.notNull(valueResolver, "StringValueResolver must not be null"); synchronized (this.aliasMap) { Map aliasCopy = new HashMap(this.aliasMap); for (String alias : aliasCopy.keySet()) { String registeredName = aliasCopy.get(alias); String resolvedAlias = valueResolver.resolveStringValue(alias); String resolvedName = valueResolver.resolveStringValue(registeredName); if (resolvedAlias == null || resolvedName == null || resolvedAlias.equals(resolvedName)) { this.aliasMap.remove(alias); } else if (!resolvedAlias.equals(alias)) { String existingName = this.aliasMap.get(resolvedAlias); if (existingName != null) { if (existingName.equals(resolvedName)) { // Pointing to existing alias - just remove placeholder this.aliasMap.remove(alias); break; } throw new IllegalStateException( "Cannot register resolved alias '" + resolvedAlias + "' (original: '" + alias + "') for name '" + resolvedName + "': It is already registered for name '" + registeredName + "'."); } checkForAliasCircle(resolvedName, resolvedAlias); this.aliasMap.remove(alias); this.aliasMap.put(resolvedAlias, resolvedName); } else if (!registeredName.equals(resolvedName)) { this.aliasMap.put(alias, resolvedName); } } }}// 若当前map中存在别名和name相同 抛异常protected void checkForAliasCircle(String name, String alias) { if (hasAlias(alias, name)) { throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" + name + "': Circular reference - '" + name + "' is a direct or indirect alias for '" + alias + "' already"); }}//根据name这个Key，在aliasMap中不断循环的取对应的value，如果取得到，就继续根据这个value取值，不断循环继续。直到取不到，就把这个在aliasMap中无对应值的key返回。public String canonicalName(String name) { String canonicalName = name; // Handle aliasing... String resolvedName; do { resolvedName = this.aliasMap.get(canonicalName); if (resolvedName != null) { canonicalName = resolvedName; } } while (resolvedName != null); return canonicalName; }}DefaultSingletonBeanRegistry
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry { // 看看人家 代码写的多规范 我要学习 protected static final Object NULL_OBJECT = new Object(); // 定义记录log日志 protected final Log logger = LogFactory.getLog(getClass()); // 单例bean缓存 private final Map singletonObjects = new ConcurrentHashMap(256); // 单例工厂缓存 private final Map>(16); // 没注册之前存放单例记录 private final Map earlySingletonObjects = new HashMap(16); // 注册过的单例 private final Set registeredSingletons = new LinkedHashSet(256); // 使用ConcurrentHashMap -- set 底层我看过 那个Boolean属性true 包含 // 这样的Set集合是采用锁分段的机制 对高并发操作优化 // 即将创建的单例类 private final Set singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap(16)); // 正在创建的单例类 private final Set inCreationCheckExclusions = Collections.newSetFromMap(new ConcurrentHashMap(16)); // 异常集合 private Set suppressedExceptions; // 单例类是否真正被销毁 private boolean singletonsCurrentlyInDestruction = false; // disposable接口的实例 private final Map disposableBeans = new LinkedHashMap(); // bean名称和bean所有包含的Bean的名称的map private final Map containedBeanMap = new ConcurrentHashMap(16); // bean名称和所有依赖于Bean的名称的map private final Map dependentBeanMap = new ConcurrentHashMap(64); // bean名称和bean所依赖的所有名称的map private final Map dependenciesForBeanMap = new ConcurrentHashMap(64); // 注册单例类 重复注册抛异常 @Override public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException { Assert.notNull(beanName, "'beanName' must not be null"); synchronized (this.singletonObjects) { 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"); } addSingleton(beanName, singletonObject); } } // 从earlySingletonObjects，singletonFactories移除 // 注册bean以及将bean添加到earlySingletonObjects protected void addSingleton(String beanName, Object singletonObject) { synchronized (this.singletonObjects) { this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT)); this.singletonFactories.remove(beanName);// this.earlySingletonObjects.remove(beanName); this.registeredSingletons.add(beanName); } } // 注册一个单例工厂类，注册后从earlySingletonObjects移除 protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) { Assert.notNull(singletonFactory, "Singleton factory must not be null"); synchronized (this.singletonObjects) { if (!this.singletonObjects.containsKey(beanName)) { this.singletonFactories.put(beanName, singletonFactory); this.earlySingletonObjects.remove(beanName); this.registeredSingletons.add(beanName); } } } @Override public Object getSingleton(String beanName) { return getSingleton(beanName, true); } // 获取单例类 protected Object getSingleton(String beanName, boolean allowEarlyReference) { Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { synchronized (this.singletonObjects) { singletonObject = this.earlySingletonObjects.get(beanName); if (singletonObject == null && allowEarlyReference) {// 不存在且正在创建中 ObjectFactory singletonFactory = this.singletonFactories.get(beanName);// 从缓存工厂获取单例工厂 if (singletonFactory != null) { // 单例工厂创建单例对象 singletonObject = singletonFactory.getObject(); // 压进去 this.earlySingletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName); } } } } return (singletonObject != NULL_OBJECT ? singletonObject : null); } // 获取指定的单例Bean public Object getSingleton(String beanName, ObjectFactory singletonFactory) { Assert.notNull(beanName, "'beanName' must not be null"); synchronized (this.singletonObjects) { Object singletonObject = this.singletonObjects.get(beanName); // 如果从当前的单例缓存中没找到指定bean if (singletonObject == null) { if (this.singletonsCurrentlyInDestruction) {//当前单例正在摧毁 throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction " + "(Do not request a bean from a BeanFactory in a destroy method implementation!)"); } if (logger.isDebugEnabled()) { logger.debug("Creating shared instance of singleton bean '" + beanName + "'"); } beforeSingletonCreation(beanName);// 单例类创建之前执行 boolean newSingleton = false; boolean recordSuppressedExceptions = (this.suppressedExceptions == null); if (recordSuppressedExceptions) { this.suppressedExceptions = new LinkedHashSet(); } try { singletonObject = singletonFactory.getObject(); newSingleton = true; } catch (IllegalStateException ex) { // Has the singleton object implicitly appeared in the meantime -> // if yes, proceed with it since the exception indicates that state. singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { throw ex; } } catch (BeanCreationException ex) { if (recordSuppressedExceptions) { for (Exception suppressedException : this.suppressedExceptions) { ex.addRelatedCause(suppressedException); } } throw ex; } finally { if (recordSuppressedExceptions) { this.suppressedExceptions = null; } afterSingletonCreation(beanName); } if (newSingleton) { addSingleton(beanName, singletonObject); } } return (singletonObject != NULL_OBJECT ? singletonObject : null); } } // 添加异常 protected void onSuppressedException(Exception ex) { synchronized (this.singletonObjects) { if (this.suppressedExceptions != null) { this.suppressedExceptions.add(ex); } } } // 根据名称移除本容器中缓存的对应的单例Bean以及所有关联移除 protected void removeSingleton(String beanName) { synchronized (this.singletonObjects) { this.singletonObjects.remove(beanName); this.singletonFactories.remove(beanName); this.earlySingletonObjects.remove(beanName); this.registeredSingletons.remove(beanName); } } // 判断容器是否包含单例bean @Override public boolean containsSingleton(String beanName) { return this.singletonObjects.containsKey(beanName); } // 获取所有单例类名字 @Override public String[] getSingletonNames() { synchronized (this.singletonObjects) { return StringUtils.toStringArray(this.registeredSingletons); } } // 获取单例类个数 @Override public int getSingletonCount() { synchronized (this.singletonObjects) { return this.registeredSingletons.size(); } } // 设置bean创建状态 public void setCurrentlyInCreation(String beanName, boolean inCreation) { Assert.notNull(beanName, "Bean name must not be null"); if (!inCreation) { this.inCreationCheckExclusions.add(beanName); } else { this.inCreationCheckExclusions.remove(beanName); } } // 当前是否正在被创建 public boolean isCurrentlyInCreation(String beanName) { Assert.notNull(beanName, "Bean name must not be null"); return (!this.inCreationCheckExclusions.contains(beanName) && isActuallyInCreation(beanName)); } // 是否在被创建 protected boolean isActuallyInCreation(String beanName) { return isSingletonCurrentlyInCreation(beanName); } // public boolean isSingletonCurrentlyInCreation(String beanName) { return this.singletonsCurrentlyInCreation.contains(beanName); } // 单例类创建之前调用 protected void beforeSingletonCreation(String beanName) { // 若即将创建的类不在正在创建的集合中，向将要即将创建的类加入 if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } } // 单例类创建之后调用 protected void afterSingletonCreation(String beanName) { // 若即将创建的类正在创建的集合中，向将要即将创建的类移除 if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) { throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation"); } } // 向disposable注册实例 public void registerDisposableBean(String beanName, DisposableBean bean) { synchronized (this.disposableBeans) { this.disposableBeans.put(beanName, bean); } } // 注册一个子类 -> 父类 public void registerContainedBean(String containedBeanName, String containingBeanName) { // A quick check for an existing entry upfront, avoiding synchronization... Set containedBeans = this.containedBeanMap.get(containingBeanName); // 已存在 return if (containedBeans != null && containedBeans.contains(containedBeanName)) { return; } // No entry yet -> fully synchronized manipulation of the containedBeans Set synchronized (this.containedBeanMap) { containedBeans = this.containedBeanMap.get(containingBeanName); if (containedBeans == null) { containedBeans = new LinkedHashSet(8);// 初始化 // containingBeanName 父类 containedBeans 孩子集合 this.containedBeanMap.put(containingBeanName, containedBeans); } containedBeans.add(containedBeanName);// 孩子进窝 } registerDependentBean(containedBeanName, containingBeanName);// 添加依赖关系· } // 给beanName添加dependentBeanName依赖 public void registerDependentBean(String beanName, String dependentBeanName) { // A quick check for an existing entry upfront, avoiding synchronization... String canonicalName = canonicalName(beanName); Set dependentBeans = this.dependentBeanMap.get(canonicalName); // 已存在 ruturn if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) { return; } // 和上面一样 synchronized (this.dependentBeanMap) { dependentBeans = this.dependentBeanMap.get(canonicalName); if (dependentBeans == null) { dependentBeans = new LinkedHashSet(8); this.dependentBeanMap.put(canonicalName, dependentBeans); } dependentBeans.add(dependentBeanName); } synchronized (this.dependenciesForBeanMap) { Set dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName); if (dependenciesForBean == null) { dependenciesForBean = new LinkedHashSet(8); this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean); } dependenciesForBean.add(canonicalName); } } // 是否依赖关系 protected boolean isDependent(String beanName, String dependentBeanName) { return isDependent(beanName, dependentBeanName, null); } private boolean isDependent(String beanName, String dependentBeanName, Set alreadySeen) { if (alreadySeen != null && alreadySeen.contains(beanName)) { return false; } String canonicalName = canonicalName(beanName); Set dependentBeans = this.dependentBeanMap.get(canonicalName); if (dependentBeans == null) { return false; } if (dependentBeans.contains(dependentBeanName)) { return true; } for (String transitiveDependency : dependentBeans) { if (alreadySeen == null) { alreadySeen = new HashSet(); } alreadySeen.add(beanName); if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) { return true; } } return false; } // 是否有依赖bean protected boolean hasDependentBean(String beanName) { return this.dependentBeanMap.containsKey(beanName); } // 根据beanName获取所有依赖bean public String[] getDependentBeans(String beanName) { Set dependentBeans = this.dependentBeanMap.get(beanName); if (dependentBeans == null) { return new String[0]; } return StringUtils.toStringArray(dependentBeans); } // 根据beanName获取所有所依赖 public String[] getDependenciesForBean(String beanName) { Set dependenciesForBean = this.dependenciesForBeanMap.get(beanName); if (dependenciesForBean == null) { return new String[0]; } return dependenciesForBean.toArray(new String[dependenciesForBean.size()]); } // 销毁所有单例 public void destroySingletons() { if (logger.isDebugEnabled()) { logger.debug("Destroying singletons in " + this); } synchronized (this.singletonObjects) { this.singletonsCurrentlyInDestruction = true; } String[] disposableBeanNames; synchronized (this.disposableBeans) { disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet()); } for (int i = disposableBeanNames.length - 1; i >= 0; i--) { destroySingleton(disposableBeanNames[i]); } // 清空相关数据 this.containedBeanMap.clear(); this.dependentBeanMap.clear(); this.dependenciesForBeanMap.clear(); synchronized (this.singletonObjects) { this.singletonObjects.clear(); this.singletonFactories.clear(); this.earlySingletonObjects.clear(); this.registeredSingletons.clear(); this.singletonsCurrentlyInDestruction = false; } } // 销毁某个单例类 public void destroySingleton(String beanName) { // Remove a registered singleton of the given name, if any. removeSingleton(beanName); // Destroy the corresponding DisposableBean instance. DisposableBean disposableBean; synchronized (this.disposableBeans) { disposableBean = (DisposableBean) this.disposableBeans.remove(beanName); } destroyBean(beanName, disposableBean); } // 删除之前添加的各种依赖 protected void destroyBean(String beanName, DisposableBean bean) { // Trigger destruction of dependent beans first... Set dependencies = this.dependentBeanMap.remove(beanName); if (dependencies != null) { if (logger.isDebugEnabled()) { logger.debug("Retrieved dependent beans for bean '" + beanName + "': " + dependencies); } for (String dependentBeanName : dependencies) { destroySingleton(dependentBeanName); } } // Actually destroy the bean now... if (bean != null) { try { bean.destroy(); } catch (Throwable ex) { logger.error("Destroy method on bean with name '" + beanName + "' threw an exception", ex); } } // Trigger destruction of contained beans... Set containedBeans = this.containedBeanMap.remove(beanName); if (containedBeans != null) { for (String containedBeanName : containedBeans) { destroySingleton(containedBeanName); } } // Remove destroyed bean from other beans' dependencies. synchronized (this.dependentBeanMap) { for (Iterator it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) { Map.Entry entry = it.next(); Set dependenciesToClean = entry.getValue(); dependenciesToClean.remove(beanName); if (dependenciesToClean.isEmpty()) { it.remove(); } } } // Remove destroyed bean's prepared dependency information. this.dependenciesForBeanMap.remove(beanName); } // public final Object getSingletonMutex() { return this.singletonObjects; }}AbstractBeanFactory
= public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry { // 存放工厂生产的单例集（查询的结果暂存，像hibernate或mybatis的调用缓存思路一致） private final Map factoryBeanObjectCache = new ConcurrentHashMap(16); // 返回指定beanFactory工厂的类型 /** public interface FactoryBean { T getObject() throws Exception; boolean isSingleton(); } */ protected Class getTypeForFactoryBean(final FactoryBean factoryBean) { try { // 安全相关检查 我不去了解了 if (System.getSecurityManager() != null) { return AccessController.doPrivileged((PrivilegedAction) beanInstance); return (type != null && ClassUtils.isAssignable(typeToMatch, type)); } else { return ClassUtils.isAssignableValue(typeToMatch, beanInstance); } } // 不是工厂Bean，那就直接判断 else { return !BeanFactoryUtils.isFactoryDereference(name) && ClassUtils.isAssignableValue(typeToMatch, beanInstance); } } // 单例表中，对应的Key没有值，也不包含Bean定义，说明没有注册，返回false else if (containsSingleton(beanName) && !containsBeanDefinition(beanName)) { return false; } // 以下是包含Bean定义的情况 else { // 先查父类的Bean定义 BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // No bean definition found in this factory -> delegate to parent. return parentBeanFactory.isTypeMatch(originalBeanName(name), targetType); } // 直接查合并后的根定义 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // 构建类型数组 Class[] typesToMatch = (FactoryBean.class.equals(typeToMatch) ? new Class[] { typeToMatch } : new Class[] { FactoryBean.class, typeToMatch }); // Check decorated bean definition, if any: We assume it'll be easier // to determine the decorated bean's type than the proxy's type. // 得到Bean定义的持有者 BeanDefinitionHolder dbd = mbd.getDecoratedDefinition(); if (dbd != null && !BeanFactoryUtils.isFactoryDereference(name)) {// 若为Bean工厂生成的实例，先得到根定义 RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd); Class targetClass = predictBeanType(dbd.getBeanName(), tbd, typesToMatch);// 得到预测的根定义 if (targetClass != null && !FactoryBean.class.isAssignableFrom(targetClass)) { return typeToMatch.isAssignableFrom(targetClass); } } Class beanType = predictBeanType(beanName, mbd, typesToMatch);// 预测后的类型 if (beanType == null) { return false; } if (FactoryBean.class.isAssignableFrom(beanType)) {// BeanFactory是否为其子类 if (!BeanFactoryUtils.isFactoryDereference(name)) {// 若不为工厂Bean的产物 // If it's a FactoryBean, we want to look at what it creates, not the // factory class. beanType = getTypeForFactoryBean(beanName, mbd); if (beanType == null) { return false; } } } else if (BeanFactoryUtils.isFactoryDereference(name)) {// 若为工厂类Bean的产物 beanType = predictBeanType(beanName, mbd, FactoryBean.class);// 预测类型 if (beanType == null || !FactoryBean.class.isAssignableFrom(beanType)) { return false; } } return typeToMatch.isAssignableFrom(beanType); }}// 返回类型public Class getType(String name) throws NoSuchBeanDefinitionException { String beanName = transformedBeanName(name); // Check manually registered singletons. Object beanInstance = getSingleton(beanName, false); if (beanInstance != null) { if (beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) { return getTypeForFactoryBean((FactoryBean) beanInstance); } else { return beanInstance.getClass(); } } else if (containsSingleton(beanName) && !containsBeanDefinition(beanName)) { // null instance registered return null; } else { // No singleton instance found -> check bean definition. BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // No bean definition found in this factory -> delegate to parent. return parentBeanFactory.getType(originalBeanName(name)); } RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // Check decorated bean definition, if any: We assume it'll be easier // to determine the decorated bean's type than the proxy's type. BeanDefinitionHolder dbd = mbd.getDecoratedDefinition(); if (dbd != null && !BeanFactoryUtils.isFactoryDereference(name)) { RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd); Class targetClass = predictBeanType(dbd.getBeanName(), tbd); if (targetClass != null && !FactoryBean.class.isAssignableFrom(targetClass)) { return targetClass; } } Class beanClass = predictBeanType(beanName, mbd); // Check bean class whether we're dealing with a FactoryBean. if (beanClass != null && FactoryBean.class.isAssignableFrom(beanClass)) { if (!BeanFactoryUtils.isFactoryDereference(name)) { // If it's a FactoryBean, we want to look at what it creates, not at // the factory class. return getTypeForFactoryBean(beanName, mbd); } else { return beanClass; } } else { return (!BeanFactoryUtils.isFactoryDereference(name) ? beanClass : null); } }}// 重写了，得到别名的方法。@Overridepublic String[] getAliases(String name) { String beanName = transformedBeanName(name); List aliases = new ArrayList(); boolean factoryPrefix = name.startsWith(FACTORY_BEAN_PREFIX); String fullBeanName = beanName; if (factoryPrefix) { fullBeanName = FACTORY_BEAN_PREFIX + beanName; } if (!fullBeanName.equals(name)) { aliases.add(fullBeanName); } String[] retrievedAliases = super.getAliases(beanName); for (String retrievedAlias : retrievedAliases) { String alias = (factoryPrefix ? FACTORY_BEAN_PREFIX : "") + retrievedAlias; if (!alias.equals(name)) { aliases.add(alias); } } if (!containsSingleton(beanName) && !containsBeanDefinition(beanName)) { BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null) { aliases.addAll(Arrays.asList(parentBeanFactory.getAliases(fullBeanName))); } } return StringUtils.toStringArray(aliases);}// ---------------------------------------------------------------------// Implementation of HierarchicalBeanFactory interface// ---------------------------------------------------------------------// 返回本Bean工厂的父Bean工厂public BeanFactory getParentBeanFactory() { return this.parentBeanFactory;}// 是否在本容器中（就是说，并不是工厂bean生产出来的）public boolean containsLocalBean(String name) { String beanName = transformedBeanName(name); // 转换后的名字 // （是否为单例或有对应的Bean定义） 且（不是工厂Bean生产出来的 或 本身就是工厂bean） return ((containsSingleton(beanName) || containsBeanDefinition(beanName)) && (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(beanName)));}// ---------------------------------------------------------------------// Implementation of ConfigurableBeanFactory interface// ---------------------------------------------------------------------public void setParentBeanFactory(BeanFactory parentBeanFactory) { if (this.parentBeanFactory != null && this.parentBeanFactory != parentBeanFactory) { throw new IllegalStateException("Already associated with parent BeanFactory: " + this.parentBeanFactory); } this.parentBeanFactory = parentBeanFactory;}public void setBeanClassLoader(ClassLoader beanClassLoader) { this.beanClassLoader = (beanClassLoader != null ? beanClassLoader : ClassUtils.getDefaultClassLoader());}public ClassLoader getBeanClassLoader() { return this.beanClassLoader;}public void setTempClassLoader(ClassLoader tempClassLoader) { this.tempClassLoader = tempClassLoader;}public ClassLoader getTempClassLoader() { return this.tempClassLoader;}public void setCacheBeanMetadata(boolean cacheBeanMetadata) { this.cacheBeanMetadata = cacheBeanMetadata;}public boolean isCacheBeanMetadata() { return this.cacheBeanMetadata;}public void setBeanExpressionResolver(BeanExpressionResolver resolver) { this.beanExpressionResolver = resolver;}public BeanExpressionResolver getBeanExpressionResolver() { return this.beanExpressionResolver;}public void setConversionService(ConversionService conversionService) { this.conversionService = conversionService;}public ConversionService getConversionService() { return this.conversionService;}public void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar) { Assert.notNull(registrar, "PropertyEditorRegistrar must not be null"); this.propertyEditorRegistrars.add(registrar);}/** * Return the set of PropertyEditorRegistrars. */public Set getPropertyEditorRegistrars() { return this.propertyEditorRegistrars;}public void registerCustomEditor(Class requiredType, Class, Class... typesToMatch) throws CannotLoadBeanClassException { try { if (mbd.hasBeanClass()) { return mbd.getBeanClass(); } if (System.getSecurityManager() != null) { return AccessController.doPrivileged( new PrivilegedExceptionAction run() throws Exception { return doResolveBeanClass(mbd, typesToMatch); } }, getAccessControlContext()); } else { return doResolveBeanClass(mbd, typesToMatch); } } catch (PrivilegedActionException pae) { ClassNotFoundException ex = (ClassNotFoundException) pae.getException(); throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex); } catch (ClassNotFoundException ex) { throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex); } catch (LinkageError err) { throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err); }}// 真正的解析类型private Class doResolveBeanClass(RootBeanDefinition mbd, Class... typesToMatch) throws ClassNotFoundException { if (!ObjectUtils.isEmpty(typesToMatch)) { ClassLoader tempClassLoader = getTempClassLoader();// 找到临时的类加载器 if (tempClassLoader != null) { if (tempClassLoader instanceof DecoratingClassLoader) {// 若为装饰类加载器 DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader; for (Class typeToMatch : typesToMatch) { dcl.excludeClass(typeToMatch.getName()); } } String className = mbd.getBeanClassName(); return (className != null ? ClassUtils.forName(className, tempClassLoader) : null); } } return mbd.resolveBeanClass(getBeanClassLoader());}/** * Evaluate the given String as contained in a bean definition, potentially resolving * it as an expression. * * @param value the value to check * @param beanDefinition the bean definition that the value comes from * @return the resolved value * @see #setBeanExpressionResolver */protected Object evaluateBeanDefinitionString(String value, BeanDefinition beanDefinition) { if (this.beanExpressionResolver == null) { return value; } Scope scope = (beanDefinition != null ? getRegisteredScope(beanDefinition.getScope()) : null); return this.beanExpressionResolver.evaluate(value, new BeanExpressionContext(this, scope));}// 预测类型protected Class predictBeanType(String beanName, RootBeanDefinition mbd, Class... typesToMatch) { // 若根Bena定义的工厂方法名存在，说明它是工厂Bean创建的，无法预测类型？ if (mbd.getFactoryMethodName() != null) { return null; } // 否则，解析Bean的Class return resolveBeanClass(mbd, beanName, typesToMatch);}/** * Check whether the given bean is defined as a {@link FactoryBean}. * * @param beanName the name of the bean * @param mbd the corresponding bean definition */protected boolean isFactoryBean(String beanName, RootBeanDefinition mbd) { Class beanType = predictBeanType(beanName, mbd, FactoryBean.class); return (beanType != null && FactoryBean.class.isAssignableFrom(beanType));}// 返回工厂Bean的类型protected Class getTypeForFactoryBean(String beanName, RootBeanDefinition mbd) { if (!mbd.isSingleton()) { return null; } try { FactoryBean factoryBean = doGetBean(FACTORY_BEAN_PREFIX + beanName, FactoryBean.class, null, true); return getTypeForFactoryBean(factoryBean); } catch (BeanCreationException ex) { // Can only happen when getting a FactoryBean. if (logger.isDebugEnabled()) { logger.debug( "Ignoring bean creation exception on FactoryBean type check: " + ex); } onSuppressedException(ex); return null; }}// 标记这个Bean已经被创建protected void markBeanAsCreated(String beanName) { this.alreadyCreated.put(beanName, Boolean.TRUE);}/** * Determine whether the specified bean is eligible for having its bean definition * metadata cached. * * @param beanName the name of the bean * @return {@code true} if the bean's metadata may be cached at this point already */// 若本根Bean定义包含Bean元定义作为缓存，这个方法应被之类覆盖，这里仅判断Bean是否已经被创建protected boolean isBeanEligibleForMetadataCaching(String beanName) { return this.alreadyCreated.containsKey(beanName);}/** * Remove the singleton instance (if any) for the given bean name, but only if it * hasn't been used for other purposes than type checking. * * @param beanName the name of the bean * @return {@code true} if actually removed, {@code false} otherwise */protected boolean removeSingletonIfCreatedForTypeCheckOnly(String beanName) { if (!this.alreadyCreated.containsKey(beanName)) { removeSingleton(beanName); return true; } else { return false; }}// 返回它自己或工厂Bean创建的实例protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) { // 如果这个Bean是工厂Bean创建的 且 这个Bean实例并不是FactoryBean实例，抛异常 if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) { throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass()); } // 如果这个Bean实例并不是FactoryBean实例 或 这个Bean是工厂Bean创建的，直接返回 if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) { return beanInstance; } // ——————————以下都是 这个Bean实例是FactoryBean实例的情况 Object object = null; if (mbd == null) {// 若根Bean定义为空，取这个BeanFactory所生产的实例 object = getCachedObjectForFactoryBean(beanName); } if (object == null) {// 若取不到，那么手动取 FactoryBean factory = (FactoryBean) beanInstance;// 把这个实例转化成一个FactoryBean // Caches object obtained from FactoryBean if it is a singleton. if (mbd == null && containsBeanDefinition(beanName)) {// 若根Bean定义为空，但是容器内有Bean定义 mbd = getMergedLocalBeanDefinition(beanName);// 返回合并后的Bean定义 } boolean synthetic = (mbd != null && mbd.isSynthetic());// 标记这个Bean定义是合并的 object = getObjectFromFactoryBean(factory, beanName, !synthetic);// 从工厂Bean中取 } return object;}// 判断给定的Bean是否被使用过public boolean isBeanNameInUse(String beanName) { // 若是别名 或 并非工厂bean生产出来的 或 被其他某个bean所依赖，那么判断其被使用过 return isAlias(beanName) || containsLocalBean(beanName) || hasDependentBean(beanName);}/** * Determine whether the given bean requires destruction on shutdown. * * The default implementation checks the DisposableBean interface as well as a * specified destroy method and registered DestructionAwareBeanPostProcessors. * * @param bean the bean instance to check * @param mbd the corresponding bean definition * @see org.springframework.beans.factory.DisposableBean * @see AbstractBeanDefinition#getDestroyMethodName() * @see org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor */protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) { return (bean != null && (DisposableBeanAdapter.hasDestroyMethod(bean, mbd) || hasDestructionAwareBeanPostProcessors()));}/** * Add the given bean to the list of disposable beans in this factory, registering its * DisposableBean interface and/or the given destroy method to be called on factory * shutdown (if applicable). Only applies to singletons. * * @param beanName the name of the bean * @param bean the bean instance * @param mbd the bean definition for the bean * @see RootBeanDefinition#isSingleton * @see RootBeanDefinition#getDependsOn * @see #registerDisposableBean * @see #registerDependentBean */protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) { AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null); if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) { if (mbd.isSingleton()) { // Register a DisposableBean implementation that performs all destruction // work for the given bean: DestructionAwareBeanPostProcessors, // DisposableBean interface, custom destroy method. registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc)); } else { // A bean with a custom scope... Scope scope = this.scopes.get(mbd.getScope()); if (scope == null) { throw new IllegalStateException( "No Scope registered for scope '" + mbd.getScope() + "'"); } scope.registerDestructionCallback(beanName, new DisposableBeanAdapter( bean, beanName, mbd, getBeanPostProcessors(), acc)); } }}// ---------------------------------------------------------------------// Abstract methods to be implemented by subclasses// ---------------------------------------------------------------------// 标记是否包含Bean定义的方法protected abstract boolean containsBeanDefinition(String beanName);// 根据Bean名返回其BeanDefinitionprotected abstract BeanDefinition getBeanDefinition(String beanName) throws BeansException;// 根据指定的bean定义和bean名、参数，创建对象protected abstract Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException;}
由于文章篇幅有限，IOC 面试和 AOP 相关问题将留待下一篇仔细讲解。
本文首发于GitChat，未经授权不得转载，转载需与GitChat联系。
阅读全文: http://gitbook.cn/gitchat/activity/5a03ab9fb993597ed32f8ef1
您还可以下载 CSDN 旗下精品原创内容社区 GitChat App ，阅读更多 GitChat 专享技术内容哦。
