spring源码加载bean定义信息 loadBeanDefinitions-自定义标签解析（component-scan-2）

最新推荐文章于 2024-05-31 11:42:39 发布
最新推荐文章于 2024-05-31 11:42:39 发布
阅读量544 收藏 1
点赞数
分类专栏： 源码 spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaomengxin521/article/details/123474810
版权

上篇传送门
上篇大体了解了下执行BFPP的过程，BFPP的作用也介绍了，但是并没有深入看下如何实现的，接下来咱们了解下context:component-scan 标签是如何解析的

概述

咱们开发过程中会使用到很多的注解配置等，这些注解必须要被扫描到才能被识别

spring中标签分为几种

分为两种

  1. 标签
  2. 自定义标签（除了bean标签外）
源码之前先了解两个类
  1. DefaultBeanDefinitionDocumentReader 调度者
  2. BeanDefinitionParserDelegate 解析策略类用于策略模式的指令执行者
  3. NamespaceHandler 策略抽象，用于制定规范

源码

咱们继续回到DefaultBeanDefinitionDocumentReader.parseBeanDefinitions方法

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)) {
			//只有解析bean标签的时候才是默认标签，其他事自定义标签
			//解析bean标签
			parseDefaultElement(ele, delegate);
		}else {
			//使用策略类解析自定义标签
			delegate.parseCustomElement(ele);
		}
	}
}
BeanDefinitionParserDelegate.parseCustomElement 解析自定义标签，使用策略模式
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
	//根据节点名称获取对应命名空间
	String namespaceUri = getNamespaceURI(ele);
	if (namespaceUri == null) {
		return null;
	}
	//获取处理器
	//具体在spring-context/resources/spring.handlers文件中配置
	NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
	if (handler == null) {
		return null;
	}
	//使用处理器进行解析
	return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}
DefaultNamespaceHandlerResolver.resolve 得到对应的命令空间的处理器
public NamespaceHandler resolve(String namespaceUri) {
	//获取spring-context/META-INF/spring.handlers文件中的缓存
	Map<String, Object> handlerMappings = getHandlerMappings();
	Object handlerOrClassName = handlerMappings.get(namespaceUri);
	if (handlerOrClassName == null) {
		return null;
	}else if (handlerOrClassName instanceof NamespaceHandler) {
		//如果实例化过了
		return (NamespaceHandler) handlerOrClassName;
	}else {
		String className = (String) handlerOrClassName;
		try {
			Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
			if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
				throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +"] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
			}
			//实例化
			NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
			//初始化
			namespaceHandler.init();
			//替换缓存中的value为对象
			handlerMappings.put(namespaceUri, namespaceHandler);
			return namespaceHandler;
		}catch (ClassNotFoundException ex) {
			throw new FatalBeanException("Could not find NamespaceHandler class [" + className +"] for namespace [" + namespaceUri + "]", ex);
		}
		catch (LinkageError err) {
			throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +className + "] for namespace [" + namespaceUri + "]", err);
		}
	}
}
NamespaceHandlerSupport.parse 使用处理器解析元素标签（使用策略模式）
public BeanDefinition parse(Element element, ParserContext parserContext) {
	//获取到标签的解析器 从ContextNamespaceHandler里面获取
	BeanDefinitionParser parser = findParserForElement(element, parserContext);
	return (parser != null ? parser.parse(element, parserContext) : null);
}
NamespaceHandlerSupport.parse 使用处理器解析元素标签

在这里插入图片描述

private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
	//元素标签的名称
	String localName = parserContext.getDelegate().getLocalName(element);
	//从ContextNamespaceHandler里面定义的多个标签中获取出对应的解析类
	//这里获取到的是ComponentScanBeanDefinitionParser
	BeanDefinitionParser parser = this.parsers.get(localName);
	if (parser == null) {
		parserContext.getReaderContext().fatal(
				"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
	}
	return parser;
}
ComponentScanBeanDefinitionParser.parse 真正开始解析了
public BeanDefinition parse(Element element, ParserContext parserContext) {
	//获取包扫描路径
	String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
	//使用PropertyPlaceholderHelper处理包路径
	//处理${}占位符
	basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
	//使用分隔符分割，就是咱们可以在package中写多个路径 如：“com.msg.package2,;com.msg.package2”
	String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
	// 配置扫描器
	ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
	// 开始扫描，并创建出BeanDefinitionHolder
	Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
	//开始注册组件
	registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
	return null;
}
ComponentScanBeanDefinitionParser.configureScanner 配置扫描器
protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
	boolean useDefaultFilters = true;
	if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
		useDefaultFilters = Boolean.parseBoolean(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
	}

	// 创建一个ClassPathBeanDefinitionScanner类路径扫描器并设置相应的属性
	ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);
	//设置BeanDefinitionDefaults对象
	scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());
	scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());
	if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {
		scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));
	}
	try {
		// 如果指定了 name-generator 属性，设置对应bean名称的生成器 如：<bean class=“xxx.xxx.xxx”> 这个类创建完成后对应的名字是什么（就是id值）
		parseBeanNameGenerator(element, scanner);
	}catch (Exception ex) {
		parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
	}
	try {
		// 设置 Scope 解析相关信息
		<context:component-scan base-package="com">
			<context:exclude-filter type="annotation" expression="com.msg"/>
			<context:include-filter type="annotation" expression="com.msg"/>
		</context:component-scan>
		parseScope(element, scanner);
	}catch (Exception ex) {
		parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
	}
	// 设置子标签过滤、包含相关信息
	parseTypeFilters(element, scanner, parserContext);
	return scanner;
}
ClassPathBeanDefinitionScanner.doScan 执行扫描

在这里插入图片描述

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
	Assert.notEmpty(basePackages, "At least one base package must be specified");
	Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
	for (String basePackage : basePackages) {
		// 找到符合条件的Component组件（类上标注了@Component注解）
		//classpath*:com/msgqu/debug/**/*.class
		Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
		for (BeanDefinition candidate : candidates) {
			// 解析作用域及是否需要代理作用域
			ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
			candidate.setScope(scopeMetadata.getScopeName());
			//生成bean的名称（AnnotationBeanNameGenerator）
			String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
			if (candidate instanceof AbstractBeanDefinition) {
				//设置基本属性，lazy、AutowireMode...
				postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
			}
			if (candidate instanceof AnnotatedBeanDefinition) {
				//设置注解信息 Lazy、Primary、DependsOn、Role、Description
				AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
			}
			// 检查是否符合条件 如：是不是已经注册过了
			if (checkCandidate(beanName, candidate)) {
				// 创建bean定义信息的包装类
				BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
				// 如果需要代理，重新生成definitionHolder
				definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
				//记录扫描后的容器中返回
				beanDefinitions.add(definitionHolder);
				//注册bean定义信息到工厂中
				registerBeanDefinition(definitionHolder, this.registry);
			}
		}
	}
	return beanDefinitions;
}
ComponentScanBeanDefinitionParser.registerComponents 注册必要的组件
protected void registerComponents(XmlReaderContext readerContext, Set<BeanDefinitionHolder> beanDefinitions, Element element) {

		Object source = readerContext.extractSource(element);
		CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);
		//创建内部bean以及引用
		for (BeanDefinitionHolder beanDefHolder : beanDefinitions) {
			compositeDef.addNestedComponent(new BeanComponentDefinition(beanDefHolder));
		}

		// Register annotation config processors, if necessary.
		boolean annotationConfig = true;
		if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {
			annotationConfig = Boolean.parseBoolean(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
		}
		if (annotationConfig) {
			//注册内部使用的定义信息
			Set<BeanDefinitionHolder> processorDefinitions = AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
			for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
				compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
			}
		}
		//扩展方法
		readerContext.fireComponentRegistered(compositeDef);
	}
AnnotationConfigUtils.registerAnnotationConfigProcessors 注册内部使用的对象

方法执行前
在这里插入图片描述
方法执行后
在这里插入图片描述

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source) {
	//对bean工厂做配置
	DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
	if (beanFactory != null) {
		if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
			beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
		}
		if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
			beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
		}
	}
	//定义内部解析的定义信息
	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
	//ConfigurationClassPostProcessor是一个BeanFactory的后置处理器，因此它的主要功能是参与BeanFactory的建造，在这个类中，会解析加了@Configuration的配置类，还会解析@ComponentScan、@ComponentScans注解扫描的包，以及解析@Import等注解
	//借博主的描述,后面咱们还会详细在invokBFPP方法中讲解
	if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
	}
	//支持 @Autowired 和 @Value 注解的支持也支持 @Inject 注解，也可以给setter 方法进行注入。也包括对 @Lookup 注解解析
	if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
	}
	//对@PostConstruct和@PreDestroy注解的处理，完成bean初始化前和销毁前的回调
	//对@Resource注解的处理，完成依赖字段的注入
	if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
	if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition();
		try {
			def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
					AnnotationConfigUtils.class.getClassLoader()));
		}catch (ClassNotFoundException ex) {
			throw new IllegalStateException(
					"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
		}
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
	}
	return beanDefs;
}
奔跑的蜗牛...
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring源码解析之AnnotationConfigWebApplicationContext#loadBeanDefinitions()方法加载BeanDefinition过程
蛐蛐的博客
10-13 1869
1.简介 AnnotationConfigWebApplicationContext是常用的上下文容器类，在spring boot没有流行的时候，以前用tomcat在web.xml配置 spring容器时，如果使用Java注解的配置类，一般都会使用这个上下文类 顾名思义，AnnotationConfig代表注解配置，Web代表具有web功能，可以访问ServletContext。这是这个上下文的基本功能。 之前在spring源码解析之AbstractApplicationContext#..
spring源码----loadBeanDefinitions(DefaultListableBeanFactory)详解
Code-zyc的博客
03-30 835
目录方法图片：new XmlBeanDefinitionReader接着往下执行这四个方法：loadBeanDefinitions(XmlBeanDefinitionReader）loadBeanDefinitions(String...)loadBeanDefinitions(String）loadBeanDefinitions(String,@Nullable Set《Resource》）loadBeanDefinitions(Resource...） 方法图片： 首先执行第一个方法： new Xml
spring源码aop解析xml生成bean定义信息
蜗牛也需要奔跑
05-10 216
spring面向切面编程是咱们工作中使用比较频繁的一项技术，比如：日志、事务、表单重复提交等 了解aop之前需要先了解几个概念 什么是aspect ：切面 什么是连接点：切面方法 切入点表达式：用于过滤目标方法的过滤器 什么是织入：所有切面方法的总称 什么是目标方法：被代理的对象方法 看下AOP处理器 public class AopNamespaceHandler extends NamespaceHandlerSupport { @Override public void init() {
java 自定义注解 解析器_Spring Boot自定义注解扫描器
weixin_39646970的博客
02-25 352
之前在整合Spring Boot和tkMybatis的时候使用了这个注解：这个还挺实用的，会将指定包下的相应的类加载至Spring容器中，刚好我这边也有一个独立抽取出来的权限模块也想实现这样的功能(当然可以使用@EnableXX的方式，但是注入的组件太多了，直接包扫描直接点)，而不是使用@ComponentScan或者是scanBasePackages必须指定某个包，这样显得太low了，使用注解自...
老生谈spring（十一）：自定义标签之component-scan
JankeDeng的博客
09-15 312
资深小白谈spring（十一）：自定义标签之component-scan 1、上一节讲到了spring通过resolve方法解析spring.handlers文件得到context的解析类，现在接着来看resolve方法。反射得到这个handler类以后用BeanUtils创建这个类的实例，调用init方法后放到handlerMappings容器中。 2、以context:component-scan为例，我们知道context的命名空间是由ContextNamespaceHandler来负责处理的，那么我
spring配置文件加载 loadBeanDefinitions分析
蓝天的博客
03-31 461
下面来分析loadBeanDefinitions方法，如下图： loadBeanDefinitions(beanFactory);，这里的beanFactory是对象DefaultListableBeanFactory，这个对象是具体实际干活的类， 重点看loadBeanDefinitions方法， 这里比较关键的是判断是否是默认的命名空间，如果是默认的命名空间则调用parseDefaultElement...
Spring源码--03--加载bean的定义信息---Spring注解解析原理
时光里的博客
02-13 425
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前置知识---obtainFreshBeanFactory();createBeanFactory----创建bean工厂**==new 一个 DefaultListableBeanFactory==** ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210505175837575.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5na
Spring源码：SpringBean 的注册-XML源码解析
m0_71777195的博客
06-28 834
Spring 容器是 Spring 框架的核心，是用来管理对象的。容器将创建对象，把它们连接在一起，配置它们，并管理他们的整个生命周期从创建到销毁。Spring 容器的加载主要有 2 种（不包括SpringBoot），一种是xml的方式 ClassPathXmlApplicationContext ，一种是基于注解的方式 AnnotationConfigApplicationContext ，实际上他们的顶级接口都是 ApplicationContext 。下面的用例主要就是基于XML的方式来启动Sprin
spring源代码解析
06-15
//对于XmlWebApplicationContext,当然使用的是XmlBeanDefinitionReader来对bean定义信息来进行解析 XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); ...
spring2.5.6源码
04-12
rar包内含有spring2.5.6源码，解压即可使用 源代码分析，是一件既痛苦又快乐的事情，看别人写的代码是通过的，但当你能够看明白的时候，相信快乐也会随之而来，为了减少痛苦，更快的带来快乐，在这里希望通过这篇...
testSpring
03-21
信息: Bean factory for application context [org.springframework.context.support.ClassPathXmlApplicationContext@c1f10e]: org.springframework.beans.factory.support.DefaultListableBeanFactory@15e234c ...
第14章：网络编程(day20).zip
08-21
[[03 08:58:22,467 INFO ] org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:317) - Loading XML bean definitions from file [/home/tomcats/...
springboot mqtt收发消息
最新发布
qq_34874784的博客
05-31 254
​在Spring Boot中，可以使用MQTT协议来收发消息。这样，就可以使用Spring Boot和MQTT协议来收发消息了。5. 使用MQTT消息接收和发送服务。3. 创建MQTT消息接收服务。4. 创建MQTT消息发送服务。2. 配置MQTT连接工厂。
SpringBoot集成腾讯COS流程
weixin_67727883的博客
05-30 149
SpringBoot集成腾讯COS流程
SpringBoot 异步编程
凤凰的博客
05-29 648
使用@Async注解，在默认情况下用的是线程池，该线程池不是真正意义上的线程池。使用此线程池无法实现线程重用，每次调用都会新建一条线程。若系统中不断的创建线程，最终会导致系统占用内存过高，引发= null?//判断是否开启限流，默认为否//执行前置操作，进行限流} else {//未限流的情况，执行线程任务//不断创建线程= null?//创建线程//指定线程名，task-1，task-2...
SpringBoot 的 Java 代码配置（二）
xiaotu的博客
05-29 1093
因此，如果使用 HikariCP 只用声明你要用它就行，而声明要使用 Druid，你需要自己指定所使用的版本。上面的 DruidDataSource ，我们为其属性赋值时，它的四个属性都是简单类型属性，因此十分容易处理。但是，在 Spring 的容器中，Java Bean 可能会存在引用。在上面的 Druid 的配置中，数据库连接的四大属性值是在代码中『写死』的。而在 Java 代码配置中，通过 @Bean 方法的入参来表达 Bean 之间的引用关系。，所以，我们可以直接将自定义的配置项写在。
java运行普通jar包和springboot对应的jar包中指定类的main方法
liaomingwu的专栏
05-30 232
这里分几种情况进行说明，包括普通jar包和springboot生成的jar包，运行默认启动类，运行默认启动类以外的指定类。
Spring基础知识总结（纯文字版）
weixin_54925172的博客
05-29 480
1）传播行为Spring定义了七种传播行为，以下为常见类型:PROPAGATION_REQUIRED:表示当前方法必须运行在事务中。如果当前事务存在，方法将会在该事务中运行。否则，会启动一个新的事务PROPAGATION_SUPPORTS:表示当前方法不需要事务上下文，但是如果存在当前事务的话，那么该方法会在这个事务中运行PROPAGATION_MANDATORY:表示该方法必须在事务中运行，如果当前事务不存在，则会抛出一个异常2）隔离级别隔离级别定义了一个事务可能受其他并发事务影响的程度。
springboot是怎么加载beanDefinition的
05-15
Spring Boot 启动时，会创建一个 AnnotationConfigApplicationContext 对象，该对象会调用 refresh() 方法，该方法会创建一个 BeanDefinitionReader 对象，并调用其 loadBeanDefinitions() 方法加载 Bean 的定义信息...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值