spring学习（三）——BeanDefinition的拼装（标签解析：bean）

最新推荐文章于 2023-03-15 23:35:35 发布
最新推荐文章于 2023-03-15 23:35:35 发布
阅读量146 收藏
点赞数
分类专栏： # Spring源码 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq330983778/article/details/88544580
版权

参考文章：

http://www.iocoder.cn/

解析方法

bean解析的方法在：DefaultBeanDefinitionDocumentReader.processBeanDefinition(ele, delegate);

相关代码解读在 完成注册

  1. 调用 BeanDefinitionParserDelegate#parseBeanDefinitionElement(Element ele, BeanDefinitionParserDelegate delegate) 方法，进行元素解析。
    • 如果解析失败，则返回 null，错误由 ProblemReporter 处理。
    • 如果解析成功，则返回 BeanDefinitionHolder 实例 bdHolder 。BeanDefinitionHolder 为持有 name 和 alias 的 BeanDefinition。
    • 详细解析，见 「2. parseBeanDefinitionElement」 。
  2. 若实例 bdHolder 不为空，则调用 BeanDefinitionParserDelegate#decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder bdHolder) 方法，进行自定义标签处理。
  3. 解析完成后，则调用 BeanDefinitionReaderUtils#registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) 方法，对 bdHolder 进行 BeanDefinition 的注册。
  4. 发出响应事件，通知相关的监听器，完成 Bean 标签解析。

 

parseBeanDefinitionElement

对属性进行解析并封装成 AbstractBeanDefinition 实例

        // 进行 bean 元素解析。
		// 如果解析成功，则返回 BeanDefinitionHolder 对象。而 BeanDefinitionHolder 为 name 和 alias 的 BeanDefinition 对象
		// 如果解析失败，则返回 null 。
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

BeanDefinitionParserDelegate#parseBeanDefinitionElement(Element ele, BeanDefinitionParserDelegate delegate) 方法，进行 <bean> 元素解析

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
		return parseBeanDefinitionElement(ele, null);
	}

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
		// 解析ID和name
		String id = ele.getAttribute(ID_ATTRIBUTE);
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
		// 别名列表
		List<String> aliases = new ArrayList<>();
		// 保存别名
		if (StringUtils.hasLength(nameAttr)) {
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			aliases.addAll(Arrays.asList(nameArr));
		}
		// 类名优先使用ID
		String beanName = id;
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			// 假如不存在，则使用别名的第一个
			beanName = aliases.remove(0);
			if (logger.isTraceEnabled()) {
				logger.trace("No XML 'id' specified - using '" + beanName +
						"' as bean name and " + aliases + " as aliases");
			}
		}
		// 检查beanName的唯一性
		if (containingBean == null) {
			checkNameUniqueness(beanName, aliases, ele);
		}
		// 解析属性 构造AbstractBeanDefinition
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		if (beanDefinition != null) {
			if (!StringUtils.hasText(beanName)) {
				try {
					if (containingBean != null) {
						// 重新生成唯一的beanName
						beanName = BeanDefinitionReaderUtils.generateBeanName(
								beanDefinition, this.readerContext.getRegistry(), true);
					}
					else {
						// 生成唯一的 beanName
						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)) {
							aliases.add(beanClassName);
						}
					}
					if (logger.isTraceEnabled()) {
						logger.trace("Neither XML 'id' nor 'name' specified - " +
								"using generated bean name [" + beanName + "]");
					}
				}
				catch (Exception ex) {
					error(ex.getMessage(), ele);
					return null;
				}
			}

			// 创建 BeanDefinitionHolder 对象
			String[] aliasesArray = StringUtils.toStringArray(aliases);
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
	}

beanName验证

/**
	 * 如果 id 不为空，则 beanName = id 。
	 * 如果 id 为空，但是 aliases 不空，则 beanName 为 aliases 的第一个元素
	 * 如果两者都为空，则根据默认规则来设置 beanName
	 */
	protected void checkNameUniqueness(String beanName, List<String> aliases, Element beanElement) {
		String foundName = null;

		//寻找是否 beanName 已经使用
		if (StringUtils.hasText(beanName) && this.usedNames.contains(beanName)) {
			foundName = beanName;
		}
		if (foundName == null) {
			foundName = CollectionUtils.findFirstMatch(this.usedNames, aliases);
		}
		// 若已使用，使用 problemReporter 提示错误
		if (foundName != null) {
			error("Bean name '" + foundName + "' is already used in this <beans> element", beanElement);
		}

		this.usedNames.add(beanName);
		this.usedNames.addAll(aliases);
	}

 

parseBeanDefinitionElement

#parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean) 方法，对属性进行解析并封装成 AbstractBeanDefinition 实例

public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, @Nullable BeanDefinition containingBean) {

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

		String className = null;
		//解析class
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}
		String parent = null;
		//解析parent
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}

		try {
			// 初始化AbstractBeanDefinition
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);
			//解析类属性
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			//设置描述
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
			//解析meta属性，元数据
			parseMetaElements(ele, bd);
			//解析 lookupOverride 代码实现
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			//解析 ReplacedMethod 方法替换配置
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
			//解析 ConstructorArg 属性
			parseConstructorArgElements(ele, bd);
			//解析 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;
	}

createBeanDefinition

创建 GenericBeanDefinition 对象，并设置 parentName、className、beanClass 属性

protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName)
			throws ClassNotFoundException {

		return BeanDefinitionReaderUtils.createBeanDefinition(
				parentName, className, this.readerContext.getBeanClassLoader());
	}

//初始化一个空的bean，并设置parent名字和类名
public static AbstractBeanDefinition createBeanDefinition(
			@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {

		GenericBeanDefinition bd = new GenericBeanDefinition();
		bd.setParentName(parentName);
		if (className != null) {
			if (classLoader != null) {
				bd.setBeanClass(ClassUtils.forName(className, classLoader));
			}
			else {
				bd.setBeanClassName(className);
			}
		}
		return bd;
	}

 

parseBeanDefinitionAttributes

再调用 #parseBeanDefinitionAttributes(Element ele, String beanName, BeanDefinition containingBean, AbstractBeanDefinition bd) 方法，该方法将创建好的 GenericBeanDefinition 实例当做参数，对 bean 标签的所有属性进行解析

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
			@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {

		// 解析 scope 属性
		if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
			error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
		}
		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属性
		String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
		if (isDefaultValue(lazyInit)) {
			lazyInit = this.defaults.getLazyInit();
		}
		bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
		// 解析 autowire 属性
		String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
		bd.setAutowireMode(getAutowireMode(autowire));
		// 解析 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 (isDefaultValue(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);
			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));
		}
		if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
			bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
		}

		return bd;
	}

 

完成 bean 标签的基本属性解析会依次调用

  • #parseMetaElements(lement ele, BeanMetadataAttributeAccessor attributeAccessor)：对子元素 meta完成解析
  • #parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides)：对lookup-method完成解析
  • #parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) ：对replace-method 完成解析

 

  • <meta> ：元数据。
  • <lookup-method> ：Spring 动态改变 bean 里方法的实现。方法执行返回的对象，使用 Spring 内原有的这类对象替换，通过改变方法返回值来动态改变方法。内部实现为使用 cglib 方法，重新生成子类，重写配置的方法和返回对象，达到动态改变的效果。
  • <replace-method> ：Spring 动态改变 bean 里方法的实现。需要改变的方法，使用 Spring 内原有其他类（需要继承接口org.springframework.beans.factory.support.MethodReplacer）的逻辑，替换这个方法。通过改变方法执行逻辑来动态改变方法。

parseMetaElements

meta 所声明的 key 并不会在 Bean 中体现，只是一个额外的声明，当我们需要使用里面的信息时，通过调用 BeanDefinition 的 #getAttribute(String name) 方法来获取

	public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {
		NodeList nl = ele.getChildNodes();
		// 遍历子节点
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			// 标签名称为meta
			if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {
				Element metaElement = (Element) node;
				//获得key
				String key = metaElement.getAttribute(KEY_ATTRIBUTE);
				//获得value
				String value = metaElement.getAttribute(VALUE_ATTRIBUTE);
				//创建BeanMetadataAttribute
				BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
				attribute.setSource(extractSource(metaElement));
				//添加到BeanMetadataAttributeAccessor中
				attributeAccessor.addMetadataAttribute(attribute);
			}
		}
	}

 

parseLookupOverrideSubElements

lookup-method ：获取器注入，就是把一个只有声明没有实现的bean的逻辑实现通过配置到配置文件中，然后spring将其加载进容器。该方法可以用于设计一些可插拔的功能上，解除程序依赖。

	public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
		NodeList nl = beanEle.getChildNodes();
		// 遍历子节点
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			// 标签为lookup-method
			if (isCandidateElement(node) && nodeNameEquals(node, LOOKUP_METHOD_ELEMENT)) {
				Element ele = (Element) node;
				String methodName = ele.getAttribute(NAME_ATTRIBUTE);
				String beanRef = ele.getAttribute(BEAN_ELEMENT);
				// 创建LookupOverride对象
				LookupOverride override = new LookupOverride(methodName, beanRef);
				override.setSource(extractSource(ele));
				overrides.addOverride(override);
			}
		}
	}

 

parseReplacedMethodSubElements

可以在运行时调用新的方法替换现有的方法，还能动态的更新原有方法的逻辑，动态的进行方法替换

public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			// 标签为replaced-method
			if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) {
				Element replacedMethodEle = (Element) node;
				String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);
				String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);
				// 创建 ReplaceOverride 对象
				ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
				// Look for arg-type match elements.
				List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT);
				for (Element argTypeEle : argTypeEles) {
					// arg-type 子标签
					String match = argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE);
					// arg-type 子标签的 match 属性
					match = (StringUtils.hasText(match) ? match : DomUtils.getTextValue(argTypeEle));
					if (StringUtils.hasText(match)) {
						replaceOverride.addTypeIdentifier(match);
					}
				}
				replaceOverride.setSource(extractSource(replacedMethodEle));
				overrides.addOverride(replaceOverride);
			}
		}
	}

 

大·风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring源码解析 - bean标签的解析与注册
The Secret
04-09 379
org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader 解析默认标签元素： private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { if (delegate.nodeName...
探秘Spring(3)——BeanDefinition详细解析
qq_20221431的博客
10-10 572
本文无手写代码，所有代码均来自Spring本身 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： i
Tiles2 学习笔记之二
sammor
11-21 166
引言：       相信通过前面一个示例，就大致知道Tiles2这个框架的一个结构了。但Tile2的作用还并没有完全的体现出来呢？它的强大之处出乎了我一开始的预料了。       而这一篇，我想写的便是Tiles2的配置文件。Tiles2的强大，可以说，很大的一部分在于配置文件中的。   一、definition 标签      这是Tiles2的定义标签，每一个设置开始都需要它...
Spring源码-IOC容器(二)-Bean的定位解析注册
weixin_34194317的博客
06-03 109
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring IOC：parseDefaultElement调用链
CRUD工程师
01-17 288
1、对于传入parseDefaultElement方法的节点调用parseBeanDefinitionElement方法创建AbstractBeanDefinition对象beanDefinition，并将该节点的各类信息解析、存入beanDefinition对象中。2、将beanDefinition、beanName、aliasesArray构建成 BeanDefinitionHolder对象并返回，为后续注册做准备。
Spring学习笔记
最新发布
m0_71417028的博客
03-15 279
/bean的class对象或者类的全限定名 对应bean属性class@Nullable//bean的作用域 对应bean属性scope@Nullable//是否抽象标识 对应bean属性abstract//是否为懒加载 对应bean属性lazy-init@Nullable//注入模式 对应bean属性autowire//依赖检查。
Spring源码学习二：BeanDefinition解析1
08-04
在Spring框架中，BeanDefinition是核心组件之一，它定义了bean的基本信息和元数据，包括bean的类、...理解和掌握BeanDefinition对于深入学习Spring框架至关重要，因为它直接影响到bean的生命周期管理和依赖注入机制。
Spring源码学习五：BeanDefinition装载1
08-04
Spring 源码学习五：BeanDefinition 装载 1 在 Spring 框架中，BeanDefinition 是一个核心概念，它描述了一个 Bean 的定义，包括其依赖项、作用域、生命周期等信息。在本篇文章中，我们将深入探讨 Spring 的源码，...
Spring源码学习四：BeanDefinition装载前奏曲1
08-04
在深入Spring源码的学习过程中，我们主要关注BeanDefinition的装载过程。BeanDefinition是Spring框架的核心概念，它包含了关于Bean的所有元数据，如类名、属性、依赖关系等。在Spring初始化时，会读取XML配置文件，...
Spring Boot: Bean definition overriding
12-22
在本文中，我将讨论棘手的Spring Boot bean定义覆盖机制。 为了使您对该主题更加清楚，让我们从小测验开始。请看下一个简单的例子。 因此，我们有2种配置，它们使用名称beanName实例化bean，在主应用程序中，我们仅...
Spring多种加载Bean方式解析
08-30
Spring多种加载Bean方式...因此，怎么把xml标签解析为BeanDefinition（），入口是在org.springframework.beans.factory.xml.XmlBeanDefinitionReader这个类，但是实际干活的是在org.springframework.beans.factory.xml....
03-Spring默认标签解析
ice_image
03-09 145
默认标签的解析 上一篇分析了整体的 xml 文件解析，形成 BeanDefinition 并注册到 IOC 容器中，但并没有详细的说明具体的解析，这一篇主要说一下 默认标签的解析，下一篇主要说自定义标签的解析。 parseDefaultElement 解析默认的元素标签 private void parseDefaultElement(Element ele, BeanDefinitionPar...
Spring 源码学习笔记(三) 默认标签的解析
panjianlongWUHAN的专栏
04-20 420
个人学习Spring源码系列 默认标签的解析 默认标签种类 Spring中的标签包括默认标签和自定义标签两种，本文主要记录默认标签的解析过程，分别对4种不同标签import, alias, bean 和beans做了不同的处理 private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { //对import标签的处理 if (delegate.
struts之Tiles框架标签库介绍归纳
Roger★L☆M☆J★
08-19 864
收集：一） 作者：        Chuck Cavaness 原文：        http://www.onjava.com/pub/a/onjava/excerpt/progjakstruts_14/index3.html译者：        blasterboy        Email: zhangjy@bpusoft.com.cn        MSN: sinogod928@
Spring4.3.x 浅析xml配置的解析过程（4）——解析bean标签及其所有子标签
chyohn的博客
02-09 1917
概述 在使用ResourceLoader创建Resource对象一节中，我们探讨了Spring如何正确的查找我们指定的配置文件并为配置文件生成Resource对象。 在使用DocumentLoader创建Document对象一节中，我们又已经解析了Spring通过xerces如何把Resource对象中的XML内容转换成Document对象。 在浅析Spring4使用XmlBeanDef
Spring源码解析之加载bean
北巷以南猫
12-11 879
一、初始化阶段 ClassPathResource res = new ClassPathResource("spring/spring.xml"); //获取创建bean的beanFactory DefaultListableBeanFactory factory = new DefaultListableBeanFactory(); //创建Reader对象，用来解析res XmlBean...
spring2.0 关于singleton 的修改
garlic
12-17 106
在spring 1.0中,只需要配置singleton="false"就行了可是在spring2.0中,使用scope="singleton" 或者 "prototype"  代替singleton="true/false"
Spring源码总结.pdf
02-13
Spring源码总结.pdf

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大·风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值