diff --git a/spring-beans/src/main/java/org/springframework/beans/BeanUtils.java b/spring-beans/src/main/java/org/springframework/beans/BeanUtils.java index 407b8f67fae181940d662c65ad435e93a31aa97a..b57fd50aa6d44d31eade0a14eee4190554dee541 100644 --- a/spring-beans/src/main/java/org/springframework/beans/BeanUtils.java +++ b/spring-beans/src/main/java/org/springframework/beans/BeanUtils.java @@ -139,6 +139,7 @@ public abstract class BeanUtils { Constructor ctor; try { // 通过class获取当前对象的构造 + System.err.println("通过class获取当前对象的构造:" + clazz); ctor = clazz.getDeclaredConstructor(); } catch (NoSuchMethodException ex) { diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java index d4ccfef4a1adbeb9cefb5d26e77916d8b77ba659..7ad79ef65897f344d7e8e4ee5409b244b8fdaa68 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java @@ -652,6 +652,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac */ boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); + System.out.println("是否需要提早曝光：单例&允许循环依赖&当前bean正在创建中，检测循环以来"); if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace("Eagerly caching bean '" + beanName + @@ -663,6 +664,9 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac * 对bean再一次依赖引用，主要应用SmartInstantiationAwareBeanPostProcessor * 其中我们熟知的Aop就是在这里将advice动态织入bean中，若没有则直接返回bean，不做任何处理 */ + System.err.println("为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂\n" + + "对bean再一次依赖引用，主要应用SmartInstantiationAwareBeanPostProcessor\n" + + "其中我们熟知的Aop就是在这里将advice动态织入bean中，若没有则直接返回bean，不做任何处理"); addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } @@ -672,10 +676,12 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac /** * 对bean进行填充，将各个属性值注入，其中，可能存在依赖于其他bean的属性，则会递归初始化依赖bean */ + System.out.println("populateBean 对bean进行填充，将各个属性值注入，其中，可能存在依赖于其他bean的属性，则会递归初始化依赖bean"); populateBean(beanName, mbd, instanceWrapper); /** * 调用初始化方法，比如init-method */ + System.out.println("调用初始化方法，比如init-method"); exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { @@ -691,10 +697,12 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac /** * earlySingletonReference只有在检测到有循环依赖的情况下才会不为空 */ + System.out.println("earlySingletonReference只有在检测到有循环依赖的情况下才会不为空"); if (earlySingletonReference != null) { /** * 如果exposedObject没有在初始化方法中被改变，也就是没有被增强 */ + System.out.println("如果exposedObject没有在初始化方法中被改变，也就是没有被增强"); if (exposedObject == bean) { exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { @@ -702,6 +710,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); for (String dependentBean : dependentBeans) { /** 检测依赖*/ + System.out.println("检测依赖"); if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } @@ -710,6 +719,8 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac * 因为bean创建后其所依赖的bean一定是已经创建的 * actualDependentBeans不为空则表示当前bean创建后其依赖的bean却没有全部创建完，也就是说存在循环依赖 */ + System.err.println("因为bean创建后其所依赖的bean一定是已经创建的\n" + + "actualDependentBeans不为空则表示当前bean创建后其依赖的bean却没有全部创建完，也就是说存在循环依赖"); if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanDefinitionReader.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanDefinitionReader.java index 360fbff218942676338ccd76b8fd3245f412743f..8a467780e95beff5a045538d609e5bb604055750 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanDefinitionReader.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanDefinitionReader.java @@ -106,6 +106,7 @@ public abstract class AbstractBeanDefinitionReader implements BeanDefinitionRead @Override public final BeanDefinitionRegistry getRegistry() { + System.out.println("获取注册实例registry：" + this.registry); return this.registry; } diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanFactory.java index c8fcac7477ecb5ec286e6fdaf001222c21db3d40..e671bf4556aa24430a6abaf7727bcc41920a35a8 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanFactory.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanFactory.java @@ -326,9 +326,15 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp * spring创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光 * 也就是将ObjectFactory加入到缓存中，一旦下个bean创建的时候需要依赖上个bean则直接使用 */ + System.out.println("检查缓存中或者实例工厂中是否有对应的实例\n" + + "为什么首先会使用这段代码呢。\n" + + "因为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖。\n" + + "spring创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光\n" + + "也就是将ObjectFactory加入到缓存中，一旦下个bean创建的时候需要依赖上个bean则直接使用"); // Eagerly check singleton cache for manually registered singletons. /** 直接尝试从缓存获取或者singleFactories中的ObjectFactory中获取*/ Object sharedInstance = getSingleton(beanName); + System.err.println("直接尝试从缓存获取或者singleFactories中的ObjectFactory中获取 sharedInstance："+sharedInstance); if (sharedInstance != null && args == null) { if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { @@ -342,6 +348,8 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp * 返回对应的实例，有时候存在诸如BeanFactory的情况 并不是直接返回实例本身而是返回指定方法返回的实例（假定Aop） * 检验当前bean是否是BeanFactory类型 */ + System.out.println("返回对应的实例，有时候存在诸如BeanFactory的情况 并不是直接返回实例本身而是返回指定方法返回的实例（假定Aop）\n" + + "检验当前bean是否是BeanFactory类型"); beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null); System.err.println("当前的beanInstance：" + beanInstance); } @@ -354,6 +362,10 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp * 因为对于B的创建再次返回创建A，照成循环依赖，也就是下面的情况。 * isPrototypeCurrentlyInCreation(beanName)为true */ + System.out.println("只有在单例情况下才会尝试解决循环依赖，原型模式情况下，如果存在\n" + + "A中有B的属性，B中有A的属性，那么当依赖注入的时候，就会产生当A还未创建完的时候\n" + + "因为对于B的创建再次返回创建A，照成循环依赖，也就是下面的情况。\n" + + "isPrototypeCurrentlyInCreation(beanName)为true"); if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } @@ -361,10 +373,12 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp // Check if bean definition exists in this factory. BeanFactory parentBeanFactory = getParentBeanFactory(); /** 如果beanDefinitionMap中也就是在所有已经加载的类中不包括beanName则尝试从parentBeanFactory中检测*/ + System.out.println("如果beanDefinitionMap中也就是在所有已经加载的类中不包括beanName则尝试从parentBeanFactory中检测"); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. String nameToLookup = originalBeanName(name); /** 递归到BeanFactory中寻找*/ + System.out.println("递归到BeanFactory中寻找"); if (parentBeanFactory instanceof AbstractBeanFactory abf) { return abf.doGetBean(nameToLookup, requiredType, args, typeCheckOnly); } else if (args != null) { @@ -379,6 +393,7 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp } /** 如果不是仅仅做类型检查则是创建bean，这里要进行记录*/ + System.err.println("如果不是仅仅做类型检查则是创建bean，这里要进行记录"); if (!typeCheckOnly) { markBeanAsCreated(beanName); } @@ -394,12 +409,17 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp * 将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition，如果指定 * BeanName是子Bean的话同时会合并父类的相关属性 */ + System.out.println("获取xml解析完毕后的beanDefinition信息\n" + + "将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition，如果指定\n" + + "BeanName是子Bean的话同时会合并父类的相关属性"); RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); + System.out.println("RootBeanDefinition :" + mbd.toString()); checkMergedBeanDefinition(mbd, beanName, args); // Guarantee initialization of beans that the current bean depends on. String[] dependsOn = mbd.getDependsOn(); /** 若存在依赖则需要递归实例化依赖的bean*/ + System.err.println("若存在依赖则需要递归实例化依赖的bean"); if (dependsOn != null) { for (String dep : dependsOn) { if (isDependent(beanName, dep)) { diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/BeanDefinitionReaderUtils.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/BeanDefinitionReaderUtils.java index a5fae027e8a548bf0de23c0b264302a3417cf492..82c99f6e487e2ee51c2834bec0735e547bcad9c2 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/BeanDefinitionReaderUtils.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/BeanDefinitionReaderUtils.java @@ -61,7 +61,8 @@ public abstract class BeanDefinitionReaderUtils { * GenericBeanDefinition 是自 2.5 版本以后新加入的bean文件配置属性定义类，是一站式服务类 * 是AbstractBeanDefinition 其中一种解析配置类 */ - + System.out.println("GenericBeanDefinition 是自 2.5 版本以后新加入的bean文件配置属性定义类，是一站式服务类\n" + + "是AbstractBeanDefinition 其中一种解析配置类"); GenericBeanDefinition bd = new GenericBeanDefinition(); bd.setParentName(parentName); if (className != null) { @@ -69,12 +70,14 @@ public abstract class BeanDefinitionReaderUtils { /** * 如果 classLoader 不为空， 则使用以传人的 classLoader 同－虚拟机的加载类对象，否则只是记录className */ + System.out.println("如果 classLoader 不为空， 则使用以传人的 classLoader 同－虚拟机的加载类对象，否则只是记录className"); bd.setBeanClass(ClassUtils.forName(className, classLoader)); } else { bd.setBeanClassName(className); } } System.err.println("通过GenericBeanDefinition设置定义的父类" + bd.getParentName()); + System.err.println("通过GenericBeanDefinition设置定义的父类" + bd.toString()); return bd; } diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java index bb4cc282e22c59fb72ae4b582cb258874796bdab..42db55ec376bc3d90dd78fe099f4ee1e2e55adf3 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java @@ -996,6 +996,9 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto * 主要是对于AbstractBeanDefinition属性中的methodOverrides校验， * 校验methodOverride是否与工厂方法并存，或者methodOverrides对应的方法根本不存在 */ + System.err.println("注册前的最后一次检验，这里的校验不同于之前的XML文件校验，\n" + + "主要是对于AbstractBeanDefinition属性中的methodOverrides校验，\n" + + "校验methodOverride是否与工厂方法并存，或者methodOverrides对应的方法根本不存在"); abd.validate(); } catch (BeanDefinitionValidationException ex) { @@ -1005,14 +1008,17 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto } /** 当前的beanDefinitionMap 为ConcurrentHashMap 解决了程序并发访问问题*/ + System.err.println("当前的beanDefinitionMap 为ConcurrentHashMap 解决了程序并发访问问题"); BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName); /** * 处理已经注册的beanName 情况 */ if (existingDefinition != null) { + System.err.println("处理已经注册的beanName 情况"); /** * 如果对应的BeanName已经注册且在配置中配置了bean不允许被覆盖，则抛出异常 */ + System.out.println("如果对应的BeanName已经注册且在配置中配置了bean不允许被覆盖，则抛出异常"); if (!isAllowBeanDefinitionOverriding()) { throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition); } diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java index a302ef434ec9a5bb2c83c381c8400537f7072385..23b3fc8a61da24302cffc241cf73fa3348f98ee8 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java @@ -202,16 +202,19 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements protected Object getSingleton(String beanName, boolean allowEarlyReference) { // Quick check for existing instance without full singleton lock /** 检查缓存中是否存在实例*/ + System.err.println("检查缓存中是否存在实例"); Object singletonObject = this.singletonObjects.get(beanName); System.err.println("getSingleton检查缓存singletonObjects中是否存在"+ beanName +"实例:" + singletonObject); if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { /** 如果为空，则锁定全局变量并进行处理*/ + System.out.println("如果为空，则锁定全局变量并进行处理"); singletonObject = this.earlySingletonObjects.get(beanName); System.err.println("getSingleton检查缓存earlySingletonObjects中是否存在"+ beanName +"实例:" + singletonObject); if (singletonObject == null && allowEarlyReference) { synchronized (this.singletonObjects) { /** 如果此bean正在加载则不处理*/ // Consistent creation of early reference within full singleton lock + System.out.println("如果此bean正在加载则不处理"); singletonObject = this.singletonObjects.get(beanName); System.err.println("getSingleton检查缓存singletonObject中是否存在"+ beanName +"实例:" + singletonObject); if (singletonObject == null) { @@ -222,10 +225,13 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements * 当某些方法需要提前初始化的时候需要调用addSingletonFactory方法将对应的 * objectFactory初始化策略存储在singletonReferences */ + System.err.println("当某些方法需要提前初始化的时候需要调用addSingletonFactory方法将对应的\n" + + "objectFactory初始化策略存储在singletonReferences"); ObjectFactory singletonFactory = this.singletonFactories.get(beanName); System.err.println("getSingleton检查缓存singletonFactories中是否存在"+ beanName +"实例:" + singletonFactory); if (singletonFactory != null) { /** 调用预先设定的getObject方法*/ + System.out.println("调用预先设定的getObject方法"); singletonObject = singletonFactory.getObject(); /** 记录在缓存中，earlySingletonObjects和singletonFactories互斥*/ System.err.println("getSingleton把当前实例存入到earlySingletonObjects，并把当前实例从singletonFactories移出：" + beanName); @@ -260,16 +266,20 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements public Object getSingleton(String beanName, ObjectFactory singletonFactory) { Assert.notNull(beanName, "Bean name must not be null"); /** 全局变量需要同步 到一级缓存*/ + System.out.println("全局变量需要同步 到一级缓存"); synchronized (this.singletonObjects) { /** * 首先检查对应的bean是否已经加载过，因为singleton模式其实就是复用已创建的bean * 所以这一步是必须的 */ + System.out.println("首先检查对应的bean是否已经加载过，因为singleton模式其实就是复用已创建的bean\n" + + "所以这一步是必须的"); Object singletonObject = this.singletonObjects.get(beanName); System.err.println("当前singletonObjects(一级缓存)里是否存在" + beanName + " : " + singletonObject); /** * 如果为空才可以进行singleton的bean的初始化 */ + System.err.println("如果为空才可以进行singleton的bean的初始化"); if (singletonObject == null) { if (this.singletonsCurrentlyInDestruction) { throw new BeanCreationNotAllowedException(beanName, @@ -321,6 +331,8 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements * 加入缓存 * 将结果记录只缓存并删除加载bean过程中所记录的各种辅助状态 */ + System.out.println("加入缓存\n" + + "将结果记录只缓存并删除加载bean过程中所记录的各种辅助状态"); addSingleton(beanName, singletonObject); } } diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/xml/BeanDefinitionParserDelegate.java b/spring-beans/src/main/java/org/springframework/beans/factory/xml/BeanDefinitionParserDelegate.java index 219597f3234fe64831fe8fd71eacdab55f9160a5..57c15888eb3bdbeabdb15e3233147407e23b00f6 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/xml/BeanDefinitionParserDelegate.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/xml/BeanDefinitionParserDelegate.java @@ -558,6 +558,7 @@ public class BeanDefinitionParserDelegate { public void initDefaults(Element root, @Nullable BeanDefinitionParserDelegate parent) { populateDefaults(this.defaults, (parent != null ? parent.defaults : null), root); this.readerContext.fireDefaultsRegistered(this.defaults); + System.out.println("最后将默认的DocumentDefaultsDefinition，存放(注册)到List "); } /** @@ -577,8 +578,10 @@ public class BeanDefinitionParserDelegate { */ protected void populateDefaults(DocumentDefaultsDefinition defaults, @Nullable DocumentDefaultsDefinition parentDefaults, Element root) { // 是否进行懒加载 - System.err.println("BeanDefinitionParserDelegate.populateDefaults解析xml"); + System.err.println("委托类解析 BeanDefinitionParserDelegate.populateDefaults解析xml"); String lazyInit = root.getAttribute(DEFAULT_LAZY_INIT_ATTRIBUTE); + System.out.println("注这里一共3个；一个为默认类型，一个当前类，一个父类"); + System.out.println("需设置默认类型 - 检查当前的懒加载为：" + lazyInit + " 如果当前类手动设置了其模式会向上委托，保持与父类一致"); if (isDefaultValue(lazyInit)) { // Potentially inherited from outer sections, otherwise falling back to false. lazyInit = (parentDefaults != null ? parentDefaults.getLazyInit() : FALSE_VALUE); @@ -681,6 +684,10 @@ public class BeanDefinitionParserDelegate { */ @Nullable public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) { + System.out.println("1.提取元素中的id以及name属性。"); + System.out.println("2.进一步解析其他所有属性并统一封装至GenericBeanDefinition类型的实例中。"); + System.out.println("3.如果检测bean没有指定beanName，那么使用默认规则为此Bean生成BeanName(beanId)."); + System.out.println("4.将获得到的信息封装到BeanDefinitionHolder的实例中。"); System.err.println("解析：BeanDefinition"); // 解析id属性 String id = ele.getAttribute(ID_ATTRIBUTE); @@ -708,7 +715,7 @@ public class BeanDefinitionParserDelegate { if (containingBean == null) { checkNameUniqueness(beanName, aliases, ele); } - + System.out.println("AbstractBeanDefinition --- parseBeanDefinitionElement解析"); AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); if (beanDefinition != null) { if (!StringUtils.hasText(beanName)) { @@ -790,30 +797,40 @@ public class BeanDefinitionParserDelegate { try { /** 创建用于承载属性的AbstractBeanDefinition类型的GenericBeanDefinition*/ + System.out.println("创建用于承载属性的AbstractBeanDefinition类型的GenericBeanDefinition"); AbstractBeanDefinition bd = createBeanDefinition(className, parent); /** 硬编码解析bean的给种属性*/ + System.out.println("parseBeanDefinitionAttributes 硬编码解析bean的给种属性"); parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); + System.out.println("AbstractBeanDefinition:" + bd.toString()); /** 提取description*/ + System.out.println("提取description"); bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT)); /** 解析元数据*/ + System.out.println("解析元数据"); parseMetaElements(ele, bd); /** 解析lookup-method 属性*/ + System.out.println("解析lookup-method 属性"); parseLookupOverrideSubElements(ele, bd.getMethodOverrides()); /** 解析replaced-method 属性*/ + System.out.println("解析replaced-method 属性"); parseReplacedMethodSubElements(ele, bd.getMethodOverrides()); /** 解析构造函数参数*/ + System.out.println("解析构造函数参数"); parseConstructorArgElements(ele, bd); /** 解析property子元素*/ + System.out.println("解析property子元素"); parsePropertyElements(ele, bd); /** 解析qualifier子元素*/ + System.out.println("解析qualifier子元素"); parseQualifierElements(ele, bd); bd.setResource(this.readerContext.getResource()); bd.setSource(extractSource(ele)); - + System.out.println("AbstractBeanDefinition:" + bd.toString()); return bd; } catch (ClassNotFoundException ex) { @@ -842,6 +859,7 @@ public class BeanDefinitionParserDelegate { public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName, @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) { //如果设置singleton直接报错 因为升级成了scope属性 + System.err.println("如果设置singleton直接报错 因为升级成了scope属性"); if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) { error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele); } @@ -953,6 +971,7 @@ public class BeanDefinitionParserDelegate { /** 获取当前的节点*/ Node node = nl.item(i); /** 提取meta*/ + System.out.println("获取当前的节点:" + node.toString()); if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) { Element metaElement = (Element) node; String key = metaElement.getAttribute(KEY_ATTRIBUTE); @@ -964,6 +983,8 @@ public class BeanDefinitionParserDelegate { attribute.setSource(extractSource(metaElement)); /** 记录信息*/ attributeAccessor.addMetadataAttribute(attribute); + System.out.println("记录信息"); + System.out.println("使用key、value构造 BeanMetadataAttribute:" + attribute.toString()); } } } @@ -1796,6 +1817,8 @@ public class BeanDefinitionParserDelegate { * 第三个参数是父类的bean，当对某个嵌套配置进行分析时，这里需要传父类的beanDefinition,这里传入的参数 * 其实是为了使用父类的scope属性，以备若子类没有配置scope时使用父类的属性，这里是顶层配置所以传null */ + System.out.println("第三个参数是父类的bean，当对某个嵌套配置进行分析时，这里需要传父类的beanDefinition,这里传入的参数\n" + + "其实是为了使用父类的scope属性，以备若子类没有配置scope时使用父类的属性，这里是顶层配置所以传null"); return decorateBeanDefinitionIfRequired(ele, originalDef, null); } @@ -1819,8 +1842,10 @@ public class BeanDefinitionParserDelegate { // Decorate based on custom attributes first. NamedNodeMap attributes = ele.getAttributes(); /** 遍历所有的属性，看看是否有适用于修饰的属性*/ + System.err.println("遍历所有的属性，看看是否有适用于修饰的属性"); for (int i = 0; i < attributes.getLength(); i++) { Node node = attributes.item(i); + System.out.println(node.toString()); finalDefinition = decorateIfRequired(node, finalDefinition, containingBd); } @@ -1833,6 +1858,7 @@ public class BeanDefinitionParserDelegate { finalDefinition = decorateIfRequired(node, finalDefinition, containingBd); } } + return finalDefinition; } @@ -1852,14 +1878,20 @@ public class BeanDefinitionParserDelegate { /** 获取自定义名称的命名空间*/ String namespaceUri = getNamespaceURI(node); + System.err.println("获取自定义名称的命名空间:" + namespaceUri); /** 对于非默认标签进行修饰*/ + System.err.println("对于非默认标签进行修饰"); if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) { /** 根据默认命名空间找到对应的处理器*/ + System.err.println("根据默认命名空间找到对应的处理器"); NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri); + System.err.println("NamespaceHandler: " +handler.toString()); if (handler != null) { /** 进行修饰*/ + System.err.println("进行修饰"); BeanDefinitionHolder decorated = handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd)); + System.err.println("BeanDefinitionHolder: " + decorated.toString()); if (decorated != null) { return decorated; } diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultBeanDefinitionDocumentReader.java b/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultBeanDefinitionDocumentReader.java index 58602537c9b87fda4507e2c05314d09a24bbc19b..3255a0e756751790ccf23839fed2edf9f4cc6aac 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultBeanDefinitionDocumentReader.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultBeanDefinitionDocumentReader.java @@ -93,6 +93,7 @@ public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocume @Override public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) { + System.err.println("注册实例bean--registerBeanDefinitions（）：DefaultBeanDefinitionDocumentReader"); this.readerContext = readerContext; doRegisterBeanDefinitions(doc.getDocumentElement()); } @@ -126,8 +127,13 @@ public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocume // the new (child) delegate with a reference to the parent for fallback purposes, // then ultimately reset this.delegate back to its original (parent) reference. // this behavior emulates a stack of delegates without actually necessitating one. + /** + * 在此方法中，任何嵌套的元素都将导致递归。在为了正确地传播和保存 default-*属性， + * 跟踪当前(父)委托，它可能为空。创建新的(子)委托带有一个用于回退目的的父委托引用， + * 然后最终将this.delegate重置回其原始(父)引用。此行为模拟了委托堆栈，但实际上并不需要委托堆栈。 + */ - //专门处理拆解 + //专门处理拆解 设置父类的BeanDefinitionParserDelegate BeanDefinitionParserDelegate parent = this.delegate; this.delegate = createDelegate(getReaderContext(), root, parent); System.err.println("当前xml 是否使用默认环境:" + this.delegate.isDefaultNamespace(root)); @@ -153,7 +159,9 @@ public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocume // 空方法 采用模板模式 解析前处理留给子类实现 preProcessXml(root); // 这个方法获取bean的 配置 进行加载 - System.err.println("根据解析完的的xml 处理bean"); + System.err.println("根据解析完的xml 处理bean"); + System.out.println("需要解析的标签 默认命名空间 处理bean。主要是处理import、alias、bean和beans。"); + System.out.println("需要解析的标签 自定义命名空间"); parseBeanDefinitions(root, this.delegate); // 空方法 采用模板模式 解析后处理留给子类实现 postProcessXml(root); @@ -200,19 +208,23 @@ public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocume private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { // 处理import标签 if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { + System.err.println("处理import标签"); importBeanDefinitionResource(ele); } // 处理alias标签 else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { + System.err.println("处理alias标签"); processAliasRegistration(ele); } // 处理bean标签 else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { + System.err.println("处理bean标签 并注册beanDefinition"); processBeanDefinition(ele, delegate); } // 处理beans标签 else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { // recurse + System.err.println("处理beans标签"); doRegisterBeanDefinitions(ele); } } @@ -240,6 +252,7 @@ public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocume // Resolve system properties: e.g. "${user.dir}" /** 解析系统格式如 "${user.dir}"*/ + System.err.println("解析系统格式如 \"${user.dir}\""); location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location); Set actualResources = new LinkedHashSet<>(4); @@ -254,9 +267,10 @@ public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocume // cannot convert to an URI, considering the location relative // unless it is the well-known Spring prefix "classpath*:" } - + System.err.println("判定location是绝对URI还是相符URI-absoluteLocation:" + absoluteLocation); // Absolute or relative? - /** 如果是绝对URI则直接根据地址加载对应的配制酒文件*/ + /** 如果是绝对URI则直接根据地址加载对应的配制文件*/ + System.out.println("如果是绝对URI则直接根据地址加载对应的配制文件"); if (absoluteLocation) { try { int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources); @@ -356,6 +370,7 @@ public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocume */ protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { System.out.println("====================处理bean标签！！！！！！！！========================="); + System.out.println("通过delegate创建BeanDefinitionHolder"); BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); System.err.println("获得的bdHolder" + bdHolder.toString()); if (bdHolder != null) { diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultDocumentLoader.java b/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultDocumentLoader.java index 08b1d16f277893ec4d14cf15e0cf5146ca1dee3b..51a1608fa4801e0c7741264dcb67c9ec2bbeae62 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultDocumentLoader.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultDocumentLoader.java @@ -68,7 +68,8 @@ public class DefaultDocumentLoader implements DocumentLoader { @Override public Document loadDocument(InputSource inputSource, EntityResolver entityResolver, ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception { - + System.err.println("文档格式类型：" + validationMode); + System.err.println("namespaceAware：" + namespaceAware); DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware); if (logger.isTraceEnabled()) { logger.trace("Using JAXP provider [" + factory.getClass().getName() + "]"); @@ -93,10 +94,13 @@ public class DefaultDocumentLoader implements DocumentLoader { if (validationMode != XmlValidationModeDetector.VALIDATION_NONE) { factory.setValidating(true); + System.err.println("强制设置validating为true"); if (validationMode == XmlValidationModeDetector.VALIDATION_XSD) { // Enforce namespace aware for XSD... + System.err.println("如果文件格式为XSD 强制设置namespaceAware为true"); factory.setNamespaceAware(true); try { + System.err.println("设置文件解析的格式"); factory.setAttribute(SCHEMA_LANGUAGE_ATTRIBUTE, XSD_SCHEMA_LANGUAGE); } catch (IllegalArgumentException ex) { diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/xml/XmlBeanDefinitionReader.java b/spring-beans/src/main/java/org/springframework/beans/factory/xml/XmlBeanDefinitionReader.java index 5dce514698f0a5017267c2a2afb9447d80e14364..d6c04a71b8617385f4088c0ca143c438185bcb5d 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/xml/XmlBeanDefinitionReader.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/xml/XmlBeanDefinitionReader.java @@ -351,7 +351,9 @@ public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader { * 真正进入逻辑核心部分 * 通过构造的InputSource实例和Resource实例继续调用函数doLoadBeanDefinitions */ - + System.out.println("doLoadBeanDefinitions:\n " + + "真正进入逻辑核心部分\n" + + "通过构造的InputSource实例和Resource实例继续调用函数doLoadBeanDefinitions"); return doLoadBeanDefinitions(inputSource, encodedResource.getResource()); } catch (IOException ex) { @@ -410,7 +412,9 @@ public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader { * 根据返回的Document注册Bean信息。 */ System.err.println("根据规则对xml格式进行验证(验证模式)"); + System.err.println("加载XML文件，并得到对应的 Document"); Document doc = doLoadDocument(inputSource, resource); + System.out.println("Document:" + doc.toString()); int count = registerBeanDefinitions(doc, resource); if (logger.isDebugEnabled()) { logger.debug("Loaded " + count + " bean definitions from " + resource); @@ -469,19 +473,23 @@ public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader { * 获取对应资源的的验证模式 */ protected int getValidationModeForResource(Resource resource) { + System.out.println("1：自动检测 - 2：DTD - 3：XSD"); int validationModeToUse = getValidationMode(); // 如果手动指定了验证仪式则使用指定的验证模式 + System.err.println("是否手动指定了验证仪式则使用指定的验证模式:" + validationModeToUse); if (validationModeToUse != VALIDATION_AUTO) { return validationModeToUse; } // 如果未指定则使用向动检测 int detectedMode = detectValidationMode(resource); + System.err.println("如果未指定则使用向动检测:" +detectedMode); if (detectedMode != VALIDATION_AUTO) { return detectedMode; } // Hmm, we didn't get a clear indication... Let's assume XSD, // since apparently no DTD declaration has been found up until // detection stopped (before finding the document's root tag). + System.out.println("如果都没指定用XSD 对应值为3"); return VALIDATION_XSD; } @@ -557,9 +565,12 @@ public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader { */ public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { // 使用DefaultBeanDefinitionDocumentReader 实例化BeanDefinitionDocumentReader + System.err.println("使用DefaultBeanDefinitionDocumentReader 实例化BeanDefinitionDocumentReader"); BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader(); // 在实例化BeanDefinitionReader 时候会将 BeanDefinitionRegistry传入默认使用继承自DefaultListableBeanFactory + System.out.println("在实例化BeanDefinitionReader 时候会将 BeanDefinitionRegistry传入默认使用继承自DefaultListableBeanFactory"); // 记录统计前BeanDefinition的加载个数 + System.err.println("记录统计前BeanDefinition的加载个数，BeanDefinition实际是个map"); int countBefore = getRegistry().getBeanDefinitionCount(); System.err.println("统计当前bean的注册个数:" + countBefore); // 加载及注册bean @@ -575,6 +586,7 @@ public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader { * @see #setDocumentReaderClass */ protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() { + System.out.println("从xml中读取 bean 并实例化BeanDefinitionDocumentReader"); return BeanUtils.instantiateClass(this.documentReaderClass); } diff --git a/spring-beans/src/test/java/org/springframework/beans/cstest/carfactorybean/CarFactoryBeanTest.java b/spring-beans/src/test/java/org/springframework/beans/cstest/carfactorybean/CarFactoryBeanTest.java index 5d54f810496091c16f11221a61d782cb2381e4f6..6aba90ae4448e4cc013b78f8d912a558e2de44f8 100644 --- a/spring-beans/src/test/java/org/springframework/beans/cstest/carfactorybean/CarFactoryBeanTest.java +++ b/spring-beans/src/test/java/org/springframework/beans/cstest/carfactorybean/CarFactoryBeanTest.java @@ -15,6 +15,7 @@ public class CarFactoryBeanTest { DefaultListableBeanFactory factory = new DefaultListableBeanFactory(); new XmlBeanDefinitionReader(factory).loadBeanDefinitions(RETURNS_LOOK_UP_CONTEXT); //获取当前bean + System.out.println("获取第一个car"); Car car = (Car)factory.getBean("car"); System.out.println(car.toString()); //获取自定义FactoryBean，在id前面加上&