Skip to content

S
Spring-FrameWork

奋斗的小菜菜 / Spring-FrameWork

通知 5
Star 2
Fork 0
S
Spring-FrameWork

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 73c95be3 编写于 作者: C congshuo_cnki
浏览文件
操作

输出bean执行流程

上级 8acb0fa9
隐藏空白更改
内联 并排
Showing with 128 addition and 10 deletion
spring-beans/src/main/java/org/springframework/beans/BeanUtils.java
浏览文件 @ 73c95be3
......@@ -139,6 +139,7 @@ public abstract class BeanUtils {
Constructor<T> ctor;
try {
// 通过class获取当前对象的构造
System.err.println("通过class获取当前对象的构造:" + clazz);
ctor = clazz.getDeclaredConstructor();
}
catch (NoSuchMethodException ex) {
......
spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java
浏览文件 @ 73c95be3
......@@ -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<String> 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 [" +
......
spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanDefinitionReader.java
浏览文件 @ 73c95be3
......@@ -106,6 +106,7 @@ public abstract class AbstractBeanDefinitionReader implements BeanDefinitionRead
@Override
public final BeanDefinitionRegistry getRegistry() {
System.out.println("获取注册实例registry：" + this.registry);
return this.registry;
}
......
spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanFactory.java
浏览文件 @ 73c95be3
......@@ -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)) {
......
spring-beans/src/main/java/org/springframework/beans/factory/support/BeanDefinitionReaderUtils.java
浏览文件 @ 73c95be3
......@@ -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;
}
......
spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java
浏览文件 @ 73c95be3
......@@ -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);
}
......
spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java
浏览文件 @ 73c95be3
......@@ -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);
}
}
......
spring-beans/src/main/java/org/springframework/beans/factory/xml/BeanDefinitionParserDelegate.java
浏览文件 @ 73c95be3
......@@ -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<DefaultsDefinition> ");
}
/**
......@@ -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 <beans> 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;
}
......
spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultBeanDefinitionDocumentReader.java
浏览文件 @ 73c95be3
......@@ -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.
/**
* 在此方法中，任何嵌套的<beans>元素都将导致递归。在为了正确地传播和保存<beans> 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<Resource> 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) {
......
spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultDocumentLoader.java
浏览文件 @ 73c95be3
......@@ -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) {
......
spring-beans/src/main/java/org/springframework/beans/factory/xml/XmlBeanDefinitionReader.java
浏览文件 @ 73c95be3
......@@ -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);
}
......
spring-beans/src/test/java/org/springframework/beans/cstest/carfactorybean/CarFactoryBeanTest.java
浏览文件 @ 73c95be3
......@@ -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前面加上&
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或