面试官:详细介绍一下Spring的循环依赖?

面试官:Spring如何解决循环依赖? 介绍 先说一下什么是循环依赖,Spring在初始化A的时候需要注入B,而初始化B的时候需要注入A,在Spring启动后这2个Bean都要被初始化完成 Spring的循环依赖有两种场景 构造器的循环依赖 属性的循环依赖 构造器的循环依赖,可以在构造函数中使用@Lazy注解延迟加载。在注入依赖时,先注入代理对象,当首次使用时再创建对象完成注入 属性的循环依赖主要是通过3个map来解决的 构造器的循环依赖 @Component public class ConstructorA { private Co. 阅读详情

一、什么是循环依赖

Spring 循环依赖是指:两个不同的 Bean 对象,相互成为各自的字段,当这两个 Bean 中的其中一个 Bean 进行依赖注入时,会陷入死循环,即循环依赖现象。

代码例子:

@Component
public class UserServiceA {
    @Autowire
    private UserServiceB userServiceB;
}

@Component
public class UserServiceB {
    @Autowire
    private UserServiceA userServiceA;
}
  • UserServiceA 与 UserServiceB 之间相互依赖

二、三级缓存解决循环依赖

2.1 三级缓存

针对循环依赖的现象,Spring 中使用提供了三级缓存解决循环的问题,我们先看 Spring 中使用到三级缓存的代码:

public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {
​
    /**
     * 一级缓存
     */
    private Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
​
    /**
     * 二级缓存
     */
    private Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();
​
    /**
     * 三级缓存
     */
    private Map<String, ObjectFactory<?>> singletonFactory = new HashMap<>();
​
    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // Quick check for existing instance without full singleton lock
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                synchronized (this.singletonObjects) {
                    // Consistent creation of early reference within full singleton lock
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
                            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                            if (singletonFactory != null) {
                                singletonObject = singletonFactory.getObject();
                                this.earlySingletonObjects.put(beanName, singletonObject);
                                this.singletonFactories.remove(beanName);
                            }
                        }
                    }
                }
            }
        }
        return singletonObject;
    }
}
  • SingletonObjects:一级缓存,存储完整的 Bean;
  • EarlySingletonObjects:二级缓存,存储从第三级缓存中创建出代理对象的 Bean,即半成品的 Bean;
  • SingletonFactory:三级缓存,存储实例化完后,包装在 FactoryBean 中的工厂 Bean;

在上面的 getSingleton 方法中,先从 SingletonObjects 中获取完整的 Bean,如果获取失败,就从 EarlySingletonObjects 中获取半成品的 Bean,如果 EarlySingletonObjects 中也没有获取到,那么就从 SingletonFactory 中,通过 FactoryBean 的 getBean 方法,获取提前创建 Bean。如果 SingletonFactory 中也没有获取到,就去执行创建 Bean 的方法。

2.2 解决循环依赖

Spring 产生一个完整的 Bean 可以看作三个阶段:

  • createBean:实例化 Bean;
  • populateBean:对 Bean 进行依赖注入;
  • initializeBean:执行 Bean 的初始化方法;

产生循环依赖的根本原因是:对于一个实例化后的 Bean,当它进行依赖注入时,会去创建它所依赖的 Bean,但此时它本身没有缓存起来,如果其他的 Bean 也依赖于它自己,那么就会创建新的 Bean,陷入了循环依赖的问题。

所以,三级缓存解决循环依赖的根本途径是:当 Bean 实例化后,先将自己存起来,如果其他 Bean 用到自己,就先从缓存中拿,不用去创建新的 Bean 了,也就不会产生循环依赖的问题了。过程如下图所示:

  • 在 Spring 源码中,调用完 createInstance 方法后,然后就把当前 Bean 加入到 SingletonFactory 中,也就是在实例化完毕后,就加入到三级缓存中;

2.3 为什么需要三级缓存?一层和两层可以吗?

2.3.1 一级缓存失效的原因

对于只使用一级缓存的情况,是不能够解决循环依赖的,有下面两个原因:

  1. 如果只使用一级缓存,在创建 Bean 的过程中,我们会在初始化完毕(注意是初始化,如果只有一级缓存,该缓存需要存储完整的 Bean)后把 Bean 放入到缓存中。此时依然会产生循环依赖问题,因为依赖注入的过程是在初始化之前的,依赖注入时是从缓存中获取不了对应的 Bean,从而再次引起循环依赖问题。
  1. 那如果我们提前在 Bean 实例化后就放入到缓存呢?答案也是不行的。因为我们没有考虑到代理对象(Spring AOP) ,如果我们创建的 Bean 是代理对象,就要在实例化后就要创建出来,那么就会带来新的问题:JDK Proxy 代理对象实现的是目标类的接口,在进行依赖注入时会找不到对应的属性和方法而报错(也就是说,提前创建出来的代理对象是没有原来对象的属性和方法的)。

Spring AOP 是依赖于
AnnotationAwareAspectJAutoProxyCreator 的,这是一个后置处理器,在 Bean 实例化完毕后在初始化方法中才执行的。

2.3.2 不使用二级缓存的原因

先说结论,使用二级缓存是可以的。

对于普通对象来说,使用二级缓存是可以解决循环依赖的。在实例化后把对象存入第一级缓存中,如果其他对象依赖注入该对象,就从第一级缓存中拿就行了。对象初始化完毕后,再写入到第二级缓存中即可。

但是对于代理对象来说,就显得十分麻烦了。如果循环依赖注入的对象是代理对象,我们就需要在对象实例化后提前把代理对象创建出来,即提前创建出所有的代理对象。但是在目前 Spring AOP 的设计来说,代理对象的创建是在初始化方法中的
AnnotationAwareAspectJAutoProxyCreator 后置处理器创建的。这与 Spring AOP 的代理设计原则是相违背的。

所以,Spring 就再引用了一层缓存 SingletonFactory,存储着 FactoryBean,我们来看看代码:

if (beanDefinition.isSingleton()) {
    Object finalBean = bean;
    //加入FactoryBean
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, beanDefinition, finalBean));
}

当我们调用这个 FactoryBean 的 getBean 方法时:

protected Object getEarlyBeanReference(String beanName, BeanDefinition beanDefinition, Object bean) {
​
    Object exposedObject = bean;
    List<BeanPostProcessor> beanPostProcessors = getBeanPostProcessors();
    for (BeanPostProcessor beanPostProcessor : beanPostProcessors) {
        if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
            exposedObject = ((InstantiationAwareBeanPostProcessor) beanPostProcessor).getEarlyBeanReference(bean, beanName);
            if (exposedObject == null) {
                return exposedObject;
            }
        }
    }
    return exposedObject;
}
​
// AnnotationAwareAspectJAutoProxyCreator
@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
    earlyProxyReferences.add(bean);
    return wrapIfNecessary(bean,beanName);
}

发现它其实通过
InstantiationAwareBeanPostProcessor 接口的 getEarlyBeanReference 来创建代理对象。所以对于代理对象来说,Spring 没有直接提前创建,而是在它产生循环依赖时,再通过 getEarlyBeanReference 方法来创建代理对象的。

三、循环依赖被完全解决了吗

3.1 循环依赖只支持单例对象

对于 scope 为 property 的 Bean,三级缓存是没有解决循环依赖的。因为它们的作用域是原型,每次使用到时都会创建一个新对象,不进缓存!

    @Override
    protected Object createBean(String beanName, BeanDefinition beanDefinition, Object... args) throws BeansException {
​
    Object bean = null;
    try {
        // 加入一级缓存
        if (beanDefinition.isSingleton()) {
            Object finalBean = bean;
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, beanDefinition, finalBean));
        }
​
    } catch (Exception e) {
        throw new BeansException("Instantiation of bean failed", e);
    }
​
    Object exposeObject = bean;
    if (beanDefinition.isSingleton()) {
​
        // 从二级缓存中获取对象
        exposeObject = getSingleton(beanName);
        registerSingleton(beanName, exposeObject);
    }
    return exposeObject;
}
  • 可见,在加入缓存时,都会判断当前的 Bean 是不是 Singleton 的,如果不是就不加入到缓存中。

3.2 通过构造器注入的类无法解决循环依赖

@Component
public class BeanB {
    private BeanA a;
    public BeanB(BeanA a) {
        this.a = a;
    }
}
​
@Component
public class BeanA {
    private BeanB b;
    public BeanA(BeanB b) {
        this.b = b;
    }
}

上述代码中,我们通过构造器来注入 BeanA 和 Bean B,Spring 是无法解决它们循环依赖的问题的。

因为在调用 BeanA 的构造器方法时 BeanA 是没有实例化完成的,缓存中不存在 BeanA 对象,此时就要注入 BeanB 对象,毫无疑问的会产生循环依赖的问题。

但是,对于这种情况来说,我们可以通过 @Lazy 注解来延迟 BeanB 的加载。即调用构造器方法时先不创建 BeanB 对象,当使用到BeanB 对象时才继续创建,此时 BeanB 也已经创建完成了,就不会产生循环依赖的问题了。

@Component
public class BeanA {
    private BeanB b;
    public BeanA(@Lazy BeanB b) {
        this.b = b;
    }
}
MTGS与3D高斯泼溅:如何用多轨迹数据重建自动驾驶场景(附代码解析) 本文深入解析了MTGS(多轨迹高斯泼溅)技术在自动驾驶场景重建中的工程实践。该方法通过分层场景表示,巧妙融合多轨迹数据,利用3D高斯泼溅技术统一处理静态几何与动态物体,有效解决了复杂环境下的重建难题。文章结合代码,详细阐述了其实现框架、损失函数设计及优化策略,为构建高保真数字孪生场景提供了实用指南。 阅读详情

相关推荐

Vue 实现华视身份证读卡器功能

在www.downcc.com下载“华视cvr100驱动”安装程序; 华视电子官网有相应的文档说明和程序下载 一、服务安装 选择安装目录: 启动读卡服务: 安装成功会有如图所示: 注意事项: 安装开发包必须使用管理员权限,因为windows服务和读卡器设备驱动程序均需要管理员权限,否则会安装失败。 win10需要修改组策略才有管理员权限。 二、服务的使用 打开浏览器,输入地址http://127.0.0.1:19196/mainpage,回车 点击openDevice: 点.

zyqgt960812的博客 6503

面试官:详细介绍一下Spring的循环依赖

Spring 循环依赖是指:两个不同的 Bean 对象,相互成为各自的字段,当这两个 Bean 中的其中一个 Bean 进行依赖注入时,会陷入死循环,即循环依赖现象。​@Component@Autowire@Component@AutowireUserServiceA 与 UserServiceB 之间相互依赖。

tangjieqing的博客 467

【分享】ArcGIS实现分子分母等标注实用技巧

前言 标注是显示在地图上的文字信息,是出图中不可或缺的重要元素,为了标注的样式丰富,摆放的位置灵活,因此给制图出图带来不少难度,以下分享几种本人在ArcGIS中的标注方法,实现上下标注、换行标注或分式标注的实用技巧。 普通模式与高级模式 默认为普通模式,勾选高级开启高级模式。 普通二分式标注(普通模式) [DLBM] & vbnewline & [DLMC] 标注效果展示 分行二分式标注(普通模式) [DLBM]& vbnewline & "——————" &

杨港 3万+

spring 循环依赖以及解决方案(吊打面试官)

Spring-bean的循环依赖以及解决方式 原创惜暮 最后发布于2017-09-12 08:18:21 阅读数 46063 收藏 展开 本文主要是分析Spring bean的循环依赖,以及Spring的解决方式。 通过这种解决方式,我们可以应用在我们实际开发项目中。 什么是循环依赖? 怎么检测循环依赖 Spring怎么解决循环依赖 Spring对于循环依赖无法解决的场景 Spring解决循环...

wangxuelei036的博客 5万+

分享一下如何使用labelimg制作自己的YOLO数据集

首先准备一下自己的下准备一个空文件夹用于保存标签文件,如下图所示。

skywalkerxhx的博客 832

黑客渗透测试后门隐藏技术揭秘

本文介绍了在授权渗透测试中隐藏后门文件(muma.exe)的多种技术手段。主要包括:通过WinRAR自解压脚本将后门与正常程序捆绑实现双开;利用系统自动运行目录和注册表实现开机自启;修改文件图标伪装成常用软件;将文件存放在冷门系统目录;设置系统+隐藏双重属性增强隐蔽性。此外还涉及对抗安全软件的加壳(UPX)、免杀(msfvenom编码)技术,以及进程注入、日志清除等运行隐藏方法。所有技术仅限合法授权测试使用,未经授权使用将面临法律责任。

m0_60781580的博客 1041

Spring系列五:Spring怎么解决循环依赖

Spring循环依赖Spring循环依赖简单说就是自己依赖自己,或者和别的Bean相互依赖。鸡和蛋只有单例的Bean才存在循环依赖的情况,

退役复学在校大学生,目光所至,皆为华夏 1万+

71、机器人与机器人控制器技术解析

本文深入解析了机器人控制器的通信接口、传感器数据采集与处理以及抓手技术三大核心技术。详细介绍了数字I/O、串行接口、总线系统和以太网等通信方式,探讨了各类传感器在焊接、装配、质量检测等场景中的应用,并阐述了手眼校准与路径校正的关键方法。同时,文章还分析了不同类型抓手的特点及选型设计原则,展示了机器人在现代工业自动化中的高效性与灵活性。通过实际编程示例与流程图,全面呈现了机器人系统的集成与控制逻辑。

gin88的博客 278

面试必杀技,讲一讲Spring中的循环依赖

本系列文章: 听说你还没学Spring就被源码编译劝退了?30+张图带你玩转Spring编译 读源码,我们可以从第一行读起 你知道Spring是怎么解析配置类的吗? 配置类为什么要添加@Configuration注解? 谈谈Spring中的对象跟Bean,你知道Spring怎么创建对象的吗? 这篇文章,我们来谈一谈Spring中的属性注入 Spring中AOP相关的API及源码解析,原来AOP是这样子的 你知道Spring是怎么将AOP应用到Bean的生命周期中的吗? 推荐阅读: Spring官网阅读 .

做一个认真的程序员 4万+

FFmpeg入门详解之110:RTSP协议讲解

TCP/IP 协议体系中的一个应用层协议,该协议定义了一对多应用程序如何有效地通过 IP 网络传送多媒体数据。RTSP在体系结构上位于RTP和RTCP之上,它使用TCP或UDP完成数据传输。HTTP与RTSP相比,HTTP传送HTML,而RTSP传送的是多媒体数据。正在上传…重新上传取消RTSP是基于文本的协议,采用ISO10646字符集,使用UTF-8编码方案。行以CRLF中断(\r\n:10,13:0x0A,0x0D),包括消息类型、消息头、消息体和消息长。

福优学苑@音视频+流媒体 2530

Ardupilot二次开发(二):自定义mavlivk消息

在下面的文件添加自定义消息的xml定义然后编译固件,会生成相应的消息头文件。

超维空间科技的博客 2316

给小师妹展开说说,Spring Bean IOC、AOP 循环依赖

作者:小傅哥 博客:https://bugstack.cn 沉淀、分享、成长,让自己和他人都能有所收获!???? 一、前言 延迟满足能给你带来什么? 大学有四年时间,但几乎所有人都是临近毕业才发现找一份好工作费劲,尤其是我能非常熟悉的软件开发行业,即使是毕业了还需要额外花钱到培训机构,在学一遍编程技术才能出去找工作。好像在校这几年压根就没学到什么! 就我个人而言可能是因为上学期间喜欢编程,也从师哥、师姐那里听到一些关于毕业后找工作的不容易,也了解了一些社会上对程序员开发技能的要求级别。也就是得到了这些消

bugstack虫洞栈 5004

Flow Matching03-01:微分方程【微分方程(描述变化规律的方程):包含未知函数和它的导数的方程】【公式解(精确)、数值解(逼近)】

好的,我将从数学角度详细解释Flow Matching,从高中生能理解的基础知识开始,逐步深入到高级概念。

u013250861的博客 221

【Spring框架】一篇文章带你彻底搞懂Spring解决循环依赖的底层原理

史上最全的Spring循环依赖源码详解,一篇文章带你彻底搞懂Spring解决循环依赖的底层原理,横扫面试场。

小七的博客 9740

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

面试官:Spring循环依赖是如何解决的

很简单,就是A对象依赖了B对象,B对象依赖了A对象。在Spring中,一个对象并不是简单new出来了,而是会经过一系列的Bean的生命周期,就是因为Bean的生命周期所以才会出现循环依赖问题。当然,在Spring中,出现循环依赖的场景很多,有的场景Spring自动帮我们解决了,而有的场景则需要程序员来解决。:缓存经过了完整生命周期的bean:缓存未经过完整生命周期的bean,如果某个bean出现了循环依赖,就会提前。

2401_87311930的博客 896

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

面试官:讲讲spring循环依赖问题?

文章目录前言循环依赖问题单例属性注入spring如何解决的循环依赖问题?多例属性注入构造注入 前言 作为一道高频面试题。 循环依赖问题 关于 spring 循环依赖问题指的是循环引用,就是两个或两个以上的bean互相需要对方的引用,形成环状。 A依赖B,B依赖A(如下图) A依赖B,B依赖C,C依赖A(如下图) spring中出现循环依赖的场景有以下几种: 单例属性注入(能解决) 多例属性注入(不能解决) 构造注入(不能解决) 至于几种循环依赖的场景,有的spring帮我们解决了,而有的并没有解决掉

沸羊羊_ 3720

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Spring系列第28篇:Bean循环依赖详解

今天要说的是spring中循环依赖的问题,最近有大量粉丝问这个问题,也是高薪面试中经常会被问到的一个问题。关于循环依赖的问题,来感受一下连环炮,试试自己否可以过关斩将,轻松应对。什么是循...

路人甲Java 1万+

Spring之Bean循环依赖详解

今天要说的是spring中循环依赖的问题,最近有大量粉丝问这个问题,也是高薪面试中经常会被问到的一个问题。 关于循环依赖的问题,来感受一下连环炮,试试自己否可以过关斩将,轻松应对。 什么是循环依赖? 如何检测是否存在循环依赖? 如何解决循环依赖? 多例的情况下,循环依赖问题为什么无法解决? 单例的情况下,虽然可以解决循环依赖,是否存在其他问题? 为什么采用三级缓存解决循环依赖?如果直接将早期bean丢到二级缓存可以么? 前面4个ok的,超越了80

azhou的代码园 4709

Spring循环依赖以及为什么需要三级缓存

什么是循环依赖? A创建时—>需要B---->B去创建—>需要A,从而产生了循环 什么情况下循环依赖可以被处理? 从上面的测试结果我们可以看到,不是只有在setter方法注入的情况下循环依赖才能被解决,即使存在构造器注入的场景下,循环依赖依然被可以被正常处理掉。 三级缓存 三级缓存是通用的叫法。 如果只有一级缓存 实例化A对象。 填充A的属性阶段时需要去填充B对象,而此时B对象还没有创建,所以这里为了完成A的填充就必须要先去创建B对象; 实例化B对象。 执行到B对象的填充属性阶

qq_40277163的博客 1万+

面试官:Spring解决循环依赖一定需要三级缓存吗?

我是大明哥,一个专注 [] 的硬核程序员。

chenssy 的技术博客 1385

面试官:Spring 循环依赖怎么破? 三级缓存:我来Carry!

想象一下,你有两个好朋友:小明 👦 和小红 👧。小明说:“我需要小红 👧 帮我做作业 ✍️,才能完成我的作业。小红说:“我需要小明 👦 帮我整理笔记 📒,才能完成我的笔记。这就尴尬了!🤦‍♂️ 小明等小红,小红等小明,谁也完不成自己的任务。这就是循环依赖,也叫循环引用。

qq_56158663的博客 1183

面试官:SpringBoot如何解决循环依赖!

⼀个或多个对象之间存在直接或间接的依赖关系,这种依赖关系构成⼀个环形调⽤,有下⾯ 3 种⽅式。我们看⼀个简单的 Demo,对标“情况 2”。typescript复制代码这是⼀个经典的循环依赖,它能正常运⾏,后⾯我们会通过源码的⻆度,解读整体的执⾏流程。⼀级缓存:为“Spring 的单例属性”⽽⽣,就是个单例池,⽤来存放已经初始化完成的单例 Bean;⼆级缓存:为“解决 AOP”⽽⽣,存放的是半成品的 AOP 的单例 Bean;

weixin_43734579的博客 4021

Spring Bean的循环依赖问题

A对象中有B属性。B对象中有A属性。这就是循环依赖。我依赖你,你也依赖我。比如:丈夫类Husband,妻子类Wife。Husband中有Wife的引用。Wife中有Husband的引用。

qq_52897007的博客 1191

面试官:Spring是如何解决循环依赖的,一定需要三级缓存吗?

Component@Autowired// A依赖B@Component@Autowired// B依赖A。但实际开发中,Spring却成功解决了这个问题!它的秘密武器就是三级缓存。Spring通过三级缓存+提前暴露半成品对象解决循环依赖问题,核心目的是处理AOP代理对象的唯一性。虽然理论上两级缓存可以解决部分场景,但三级缓存是Spring设计上的必要选择。理解这一机制,不仅能应对面试,还能在遇到相关Bug时快速定位原因!

Like0703的博客 1225

Spring循环依赖的终极解析

当面试官问到你给我讲一下什么是循环依赖吧,该如何回答可以参考一下话术spring的循环依赖就是在代码中接口互相调用产生的情况列入接口a引用接口b 接口b引用接口a 形成一种闭环的引用关系,而不是指循环调用循环调用循环调用是指方法之间的互相调用,形成一个闭环。如果没有适当的终止条件,这种调用会导致无限循环,最终可能导致栈溢出(StackOverflowError)或其他运行时错误。

小电玩 1318

【Java面试真题】Spring是如何解决循环依赖问题?

🔔这个面试题是面到 Spring 必问的,要想很好的去回答还是要研究下源码的,而不是纯靠背八股文。接下我就剖析下如何解决的,面试也可以按照我介绍的去回答。结构化的表达会给面试官留下一个好印象,觉得你是一个逻辑清晰的开发。

激流丶的博客 2967
上一篇: 9张图深入剖析ConcurrentHashMap!
下一篇: 面试官 : 你能说清楚 Redis 哈希槽和一致性哈希的要点吗?
加班不秃顶
博客等级 码龄7年 1822粉丝 599原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值