Spring IoC源码学习：parseDefaultElement 详解，关于Redis主从节点数据过期一致性的思考

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {

// 1.默认命名空间的处理

if (delegate.isDefaultNamespace(root)) {

NodeList nl = root.getChildNodes();

// 遍历root的子节点列表

for (int i = 0; i < nl.getLength(); i++) {

Node node = nl.item(i);

if (node instanceof Element) {

Element ele = (Element) node;

if (delegate.isDefaultNamespace(ele)) {

// 1.1 默认命名空间节点的处理，例如：

parseDefaultElement(ele, delegate);

}

else {

// 1.2 自定义命名空间节点的处理，例如：context:component-scan/、aop:aspectj-autoproxy/

delegate.parseCustomElement(ele);

}

}

}

} else {

// 2.自定义命名空间的处理

delegate.parseCustomElement(root);

}

}

1.1 默认命名空间节点的处理，见下面 parseDefaultElement 方法。

parseDefaultElement

===================

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {

// 1.对import标签的处理

if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {

importBeanDefinitionResource(ele);

}

// 2.对alias标签的处理

else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {

processAliasRegistration(ele);

}

// 3.对bean标签的处理(最复杂最重要)

else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {

processBeanDefinition(ele, delegate);

}

// 4.对beans标签的处理

else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {

// recurse

doRegisterBeanDefinitions(ele);

}

}

可以看到默认命名空间的一级节点只有4种：import、alias、bean、beans。这4种节点中，最重要、最复杂的就是  节点，本文只会介绍  节点的处理，理解了  节点后，其他的都不难理解。另外， 节点只是递归调用之前的 doRegisterBeanDefinitions 方法，因此无需再介绍。

接下来，让我们从 processBeanDefinition(ele, delegate) 方法正式开始。

processBeanDefinition

---

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

// 1.进行节点定义解析, 经过这个方法后，bdHolder会包含一个Bean节点的所有属性，例如name、class、id

BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

if (bdHolder != null) {

// 2.若存在默认标签的子节点下再有自定义属性，需要再次对自定义标签再进行解析(基本不用，不做深入解析)

bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

try {

// Register the final decorated instance.

// 3.解析节点定义完成后，需要对解析后的bdHolder进行注册

BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

} catch (BeanDefinitionStoreException ex) {

getReaderContext().error(“Failed to register bean definition with name '” +

bdHolder.getBeanName() + “'”, ele, ex);

}

// Send registration event.

// 4.最后发出响应事件，通知相关的监听器，这个Bean已经加载完成了

getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));

}

}

1. 进行节点定义解析，见代码块1详解。

2. 例如下图这种，基本不用，不做深入解析。

3. 解析节点定义完成后，需要对解析后的 bdHolder 进行注册，见代码块13详解。

4. 发出响应事件，通知相关的监听器，不做深入解析。

代码块1：parseBeanDefinitionElement

---

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {

return parseBeanDefinitionElement(ele, null);

}

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {

// 1.解析name和id属性

// 解析id属性

String id = ele.getAttribute(ID_ATTRIBUTE);

// 解析name属性

String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

// 分割name属性（通过逗号或分号）

// 例如：，分割后aliases为[demoService, demoServiceAlias]

List aliases = new ArrayList();

if (StringUtils.hasLength(nameAttr)) {

String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);

aliases.addAll(Arrays.asList(nameArr));

}

// beanName默认使用id

String beanName = id;

if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {

// 如果id为空，并且aliases不为空，则取aliases的第一个元素作为beanName，其他的仍作为别名

beanName = aliases.remove(0);

if (logger.isDebugEnabled()) {

logger.debug(“No XML ‘id’ specified - using '” + beanName +

“’ as bean name and " + aliases + " as aliases”);

}

}

if (containingBean == null) {

// 检查beanName和aliases是否在同一个 下已经存在

checkNameUniqueness(beanName, aliases, ele);

}

// 2.进一步解析bean的其他所有属性并统一封装至GenericBeanDefinition类型实例中

AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

if (beanDefinition != null) {

if (!StringUtils.hasText(beanName)) {

try {

// 3.如果bean定义存在，但是beanName为空，则用Spring默认的生成规则为当前bean生成beanName

if (containingBean != null) {

beanName = BeanDefinitionReaderUtils.generateBeanName(

beanDefinition, this.readerContext.getRegistry(), true);

}

else {

// Spring提供的生成规则生成beanName，例如：com.joonwhee.open.demo.service.impl.DemoServiceImpl#0

beanName = this.readerContext.generateBeanName(beanDefinition);

// Register an alias for the plain bean class name, if still possible,

// if the generator returned the class name plus a suffix.

// This is expected for Spring 1.2/2.0 backwards compatibility.

String beanClassName = beanDefinition.getBeanClassName();

if (beanClassName != null &&

beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&

!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {

// 如果Spring默认的生成规则生成的beanName为:类名加后缀，则将类名注册为别名

aliases.add(beanClassName);

}

}

if (logger.isDebugEnabled()) {

logger.debug("Neither XML ‘id’ nor ‘name’ specified - " +

“using generated bean name [” + beanName + “]”);

}

}

catch (Exception ex) {

error(ex.getMessage(), ele);

return null;

}

}

String[] aliasesArray = StringUtils.toStringArray(aliases);

// 4.将bean定义、beanName、bean别名数组封装成BeanDefinitionHolder

return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);

}

return null;

}

1.解析 name 和 id 属性，其中 name 属性可以通过分割符设置多个。如果 id 存在，则 使用 id 作为 beanName，name 属性分割后全部作为别名；如果 id 不存在，则将 name 属性分割后的第1个作为 beanName，剩下的全部作为别名。

举个例子：

配置1：beanName=appleService，aliases=[appleOne, appleTwo] ；

配置2：beanName=bananaOne，aliases=[bananaTwo]

2.进一步解析 bean 的其他所有属性并统一封装至 GenericBeanDefinition 类型实例中，见代码块2详解。

代码块2：parseBeanDefinitionElement

---

public AbstractBeanDefinition parseBeanDefinitionElement(

Element ele, String beanName, BeanDefinition containingBean) {

this.parseState.push(new BeanEntry(beanName));

String className = null;

// 1.解析class、parent属性

// 解析class属性

if (ele.hasAttribute(CLASS_ATTRIBUTE)) {

className = ele.getAttribute(CLASS_ATTRIBUTE).trim();

}

try {

String parent = null;

// 解析parent属性

if (ele.hasAttribute(PARENT_ATTRIBUTE)) {

parent = ele.getAttribute(PARENT_ATTRIBUTE);

}

// 2.创建用于承载属性的AbstractBeanDefinition类型的GenericBeanDefinition

AbstractBeanDefinition bd = createBeanDefinition(className, parent);

// 3.解析bean的各种属性

parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);

// 提取description

bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

// 解析元数据子节点(基本不用, 不深入介绍)

parseMetaElements(ele, bd);

// 解析lookup-method子节点(基本不用, 不深入介绍)

parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

// 解析replaced-method子节点(基本不用, 不深入介绍)

parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

// 4.解析constructor-arg子节点

parseConstructorArgElements(ele, bd);

// 5.解析property子节点

parsePropertyElements(ele, bd);

// 解析qualifier子节点(基本不用, 不深入介绍)

parseQualifierElements(ele, bd);

bd.setResource(this.readerContext.getResource());

bd.setSource(extractSource(ele));

return bd;

}

catch (ClassNotFoundException ex) {

error(“Bean class [” + className + “] not found”, ele, ex);

}

catch (NoClassDefFoundError err) {

error(“Class that bean class [” + className + “] depends on not found”, ele, err);

}

catch (Throwable ex) {

error(“Unexpected failure during bean definition parsing”, ele, ex);

}

finally {

this.parseState.pop();

}

return null;

}

1.解析了class、parent属性，因为第2步创建 AbstractBeanDefinition 需要用到这两个属性，否则，这两个属性可以放到第3步一起解析。

2.创建用于承载属性的 AbstractBeanDefinition 类型的 GenericBeanDefinition。比较简单，直接 new 一个 GenericBeanDefinition，如果 className 和 classLoader 不为空，则通过反射构建出 BeanClass，并设置为 GenericBeanDefinition 的属性。

3.解析 bean 的剩余属性，见代码块3详解。

4.解析 constructor-arg 子节点，见代码块4详解。

5.解析 property 子节点，见代码块11详解。

代码块3：parseBeanDefinitionAttributes

---

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,

BeanDefinition containingBean, AbstractBeanDefinition bd) {

// 解析singleton属性

if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {

// singleton属性已经不支持, 如果使用了会直接抛出异常, 请使用scope属性代替

error(“Old 1.x ‘singleton’ attribute in use - upgrade to ‘scope’ declaration”, ele);

}

// 解析scope属性

else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {

bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));

}

else if (containingBean != null) {

// Take default from containing bean in case of an inner bean definition.

bd.setScope(containingBean.getScope());

}

// 解析abstract属性

if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {

bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));

}

// 解析lazy-init属性, 默认为false

String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);

if (DEFAULT_VALUE.equals(lazyInit)) {

lazyInit = this.defaults.getLazyInit();

}

bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

// 解析autowire属性

String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);

bd.setAutowireMode(getAutowireMode(autowire));

// 解析dependency-check属性

String dependencyCheck = ele.getAttribute(DEPENDENCY_CHECK_ATTRIBUTE);

bd.setDependencyCheck(getDependencyCheck(dependencyCheck));

// 解析depends-on属性

if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {

String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);

bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));

}

// 解析autowire-candidate属性

String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);

if (“”.equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {

String candidatePattern = this.defaults.getAutowireCandidates();

if (candidatePattern != null) {

String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);

bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));

}

}

else {

bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));

}

// 解析primary属性

if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {

bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));

}

// 解析init-method属性

if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {

String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);

if (!“”.equals(initMethodName)) {

bd.setInitMethodName(initMethodName);

}

}

else {

if (this.defaults.getInitMethod() != null) {

bd.setInitMethodName(this.defaults.getInitMethod());

bd.setEnforceInitMethod(false);

}

}

// 解析destroy-method属性

if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {

String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);

bd.setDestroyMethodName(destroyMethodName);

}

else {

if (this.defaults.getDestroyMethod() != null) {

bd.setDestroyMethodName(this.defaults.getDestroyMethod());

bd.setEnforceDestroyMethod(false);

}

}

// 解析factory-method属性

if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {

bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));

}

// 解析factory-bean属性

if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {

bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));

}

return bd;

}

内容比较简单，就是从节点 ele 拿到所有的属性值，塞给 AbstractBeanDefinition 的对应属性。这些属性的使用如下图。

代码块4：parseConstructorArgElements

---

public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {

// 拿到beanEle节点的所有子节点

NodeList nl = beanEle.getChildNodes();

for (int i = 0; i < nl.getLength(); i++) {

Node node = nl.item(i);

if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {

// 解析constructor-arg

parseConstructorArgElement((Element) node, bd);

}

}

}

拿到 beanEle 节点的所有子节点，遍历解析所有是 constructor-arg 节点的子节点，见代码块5详解。

例子：

constructor-arg 的使用如下图所示，constructor-arg 节点类似于构造函数，bean 中必须要有相应的构造函数才可以使用，否则会报错。

代码块5：parseConstructorArgElement

---

public void parseConstructorArgElement(Element ele, BeanDefinition bd) {

// 1.提取基础属性index、type、name属性值

// 提取index属性

String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);

// 提取type属性

String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);

// 提取name属性

String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

if (StringUtils.hasLength(indexAttr)) {

try {

int index = Integer.parseInt(indexAttr);

if (index < 0) {

error(“‘index’ cannot be lower than 0”, ele);

}

else {

try {

// 2.index不为空的处理

this.parseState.push(new ConstructorArgumentEntry(index));

// 2.1解析ele节点对应的属性值

Object value = parsePropertyValue(ele, bd, null);

// 2.2使用ConstructorArgumentValues.ValueHolder类型来封装解析出来的元素

ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);

// 2.3将type属性封装到ConstructorArgumentValues.ValueHolder

if (StringUtils.hasLength(typeAttr)) {

valueHolder.setType(typeAttr);

}

// 2.4将name属性封装到ConstructorArgumentValues.ValueHolder

if (StringUtils.hasLength(nameAttr)) {

valueHolder.setName(nameAttr);

}

valueHolder.setSource(extractSource(ele));

// 2.5判断index是否重复指定, 如果是则抛出异常

if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {

error("Ambiguous constructor-arg entries for index " + index, ele);

}

else {

// 将index和valueHolder以key-value形式添加至当前BeanDefinition的constructorArgumentValues

// 的indexedArgumentValues属性中，（用于上面判断index是否重复指定）

bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);

}

}

finally {

this.parseState.pop();

}

}

}

catch (NumberFormatException ex) {

error(“Attribute ‘index’ of tag ‘constructor-arg’ must be an integer”, ele);

}

}

else {

try {

// 3.index为空的处理

this.parseState.push(new ConstructorArgumentEntry());

// 3.1解析ele节点对应的属性值

Object value = parsePropertyValue(ele, bd, null);

// 3.2使用ConstructorArgumentValues.ValueHolder类型来封装解析出来的元素

ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);

// 3.3将type属性封装到ConstructorArgumentValues.ValueHolder

if (StringUtils.hasLength(typeAttr)) {

valueHolder.setType(typeAttr);

}

// 3.4将name属性封装到ConstructorArgumentValues.ValueHolder

if (StringUtils.hasLength(nameAttr)) {

valueHolder.setName(nameAttr);

}

valueHolder.setSource(extractSource(ele));

// 3.5将valueHolder添加至当前BeanDefinition的constructorArgumentValues的genericArgumentValues属性中

// 与上面的indexedArgumentValues类似，上面有index存为map，这边没index存为list

bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);

}

finally {

this.parseState.pop();

}

}

}

1.首先拿到基础属性 index、type、name 的属性值。

2.index不为空的处理：

2.1 首先解析 ele 节点的值，可以看代码块4里的图，每个 constructor-arg 节点必然有一个属性值，可能是通过 value 属性、ref 属性、list 属性等。见代码块6详解。

2.5 判断index是否重复指定，如果是则抛出异常；如果不重复，则将 index 和 valueHolder 以 key-value 形式添加至当前BeanDefinition 的 constructorArgumentValues 的 indexedArgumentValues 属性中（用于前面判断index是否重复指定）。

3.index为空的处理。基本与2相同，不在赘述。

代码块6：parsePropertyValue

---

public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {

String elementName = (propertyName != null) ?

“ element for property '” + propertyName + “'” :

“ element”;

// Should only have one child element: ref, value, list, etc.

// 1.拿到ele节点的子节点，例如list、map

NodeList nl = ele.getChildNodes();

Element subElement = null;

for (int i = 0; i < nl.getLength(); i++) {

Node node = nl.item(i);

// 跳过description或者meta节点

if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&

!nodeNameEquals(node, META_ELEMENT)) {

// Child element is what we’re looking for.

if (subElement != null) {

// 只能有1个子节点，否则抛出异常

error(elementName + " must not contain more than one sub-element", ele);

} else {

// 找到子节点，赋值给subElement

subElement = (Element) node;

}

}

}

// 2.解析constructor-arg上的ref属性

boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);

// 3.解析constructor-arg上的value属性

boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);

// 4.合法性校验。在constructor-arg上：ref属性、value属性、子节点，三者只能有1个，因为这三个都是用来表示该节点的值。

if ((hasRefAttribute && hasValueAttribute) ||

((hasRefAttribute || hasValueAttribute) && subElement != null)) {

error(elementName +

" is only allowed to contain either ‘ref’ attribute OR ‘value’ attribute OR sub-element", ele);

}

if (hasRefAttribute) {

// 5.ref属性的处理，使用RuntimeBeanReference封装对应的ref值（该ref值指向另一个bean的beanName），

// RuntimeBeanReference起到占位符的作用，ref指向的beanName将在运行时被解析成真正的bean实例引用

String refName = ele.getAttribute(REF_ATTRIBUTE);

if (!StringUtils.hasText(refName)) {

error(elementName + " contains empty ‘ref’ attribute", ele);

}

RuntimeBeanReference ref = new RuntimeBeanReference(refName);

ref.setSource(extractSource(ele));

return ref;

} else if (hasValueAttribute) {

// 6.value属性的处理，使用TypedStringValue封装

TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));

valueHolder.setSource(extractSource(ele));

return valueHolder;

} else if (subElement != null) {

// 7.解析子节点

return parsePropertySubElement(subElement, bd);

} else {

// 8.既没有ref属性，也没有value属性，也没有子节点，没法获取ele节点的值，直接抛异常

// Neither child element nor “ref” or “value” attribute found.

error(elementName + " must specify a ref or value", ele);

return null;

}

}

1.拿到 ele 节点的子节点，并赋值给变量 subElement。例如下图中 index=“3” 的节点就有子节点，子节点为 list，其他 4 个都没有子节点。

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）

最后

针对以上面试题，小编已经把面试题+答案整理好了

面试专题

除了以上面试题+答案，小编同时还整理了微服务相关的实战文档也可以分享给大家学习

t。例如下图中 index=“3” 的节点就有子节点，子节点为 list，其他 4 个都没有子节点。

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-92fbzebv-1711005507841)]
[外链图片转存中…(img-76MKeVQQ-1711005507842)]
[外链图片转存中…(img-nIPPxMjb-1711005507842)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
[外链图片转存中…(img-1KsBCwXD-1711005507843)]

最后

针对以上面试题，小编已经把面试题+答案整理好了

[外链图片转存中…(img-5Nea5ax8-1711005507843)]

[外链图片转存中…(img-Xk4t1EuB-1711005507843)]

[外链图片转存中…(img-kuB500QE-1711005507844)]

面试专题

[外链图片转存中…(img-qD67mNp6-1711005507844)]

除了以上面试题+答案，小编同时还整理了微服务相关的实战文档也可以分享给大家学习

[外链图片转存中…(img-IshveAlC-1711005507845)]

[外链图片转存中…(img-W4GfhuXD-1711005507845)]

[外链图片转存中…(img-dW4KBi8N-1711005507845)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录