父子关系inverse=true

最新推荐文章于 2024-11-16 17:49:09 发布
最新推荐文章于 2024-11-16 17:49:09 发布
阅读量521 收藏
点赞数
文章标签： hibernate insert integer session table java

首先以父子关系为例：

<

对应生成的DDL drop table PARENT;

Java代码 复制代码
  1. drop table CHILD;    
  2. create table PARENT (ID INTEGER not null generated by default as identity, primary key (ID););;    
  3. create table CHILD (ID INTEGER not null generated by default as identity, PARENTID INTEGER, primary key (ID););;    
  4. alter table CHILD add constraint FK3D1FCFC74B18345 foreign key (PARENTID); references PARENT;   
drop table CHILD; 
create table PARENT (ID INTEGER not null generated by default as identity, primary key (ID););; 
create table CHILD (ID INTEGER not null generated by default as identity, PARENTID INTEGER, primary key (ID););; 
alter table CHILD add constraint FK3D1FCFC74B18345 foreign key (PARENTID); references PARENT;



*大写的部分inverse="true"表示 ParentPO 本身不维护表之间的关系！，而由想反的一方 children来维护，

*CASCADE=“ALL”表示 无论是update,insert ,delete 都保持几连关系

*lazy="true"表示初始化父亲的时候不会把所有的儿子都从数据库中load进来。

下面先看一下几个例子：

生成的SQL:

Java代码 复制代码
  1. Hibernate: insert into PARENT (ID); values (default);    
  2. Hibernate: insert into CHILD (PARENTID, ID); values (?, default);    
  3. Hibernate: insert into CHILD (PARENTID, ID); values (?, default);   
Hibernate: insert into PARENT (ID); values (default); 
Hibernate: insert into CHILD (PARENTID, ID); values (?, default); 
Hibernate: insert into CHILD (PARENTID, ID); values (?, default);



结果 C:/Myapp/SQLLIB/BIN>db2 select * from child

Java代码 复制代码
  1. ID          PARENTID    
  2. ----------- -----------    
  3.          71          44    
  4.          72          44    
  5.          73          44    
  6. C:/Myapp/SQLLIB/BIN>db2 select * from parent    
  7.     
  8. ID    
  9. -----------    
  10.          44    
  11.    
ID          PARENTID 
----------- ----------- 
         71          44 
         72          44 
         73          44 
C:/Myapp/SQLLIB/BIN>db2 select * from parent 
 
ID 
----------- 
         44



注意之只有一句：session.save(parent);就把两个儿子保存进了数据库。

*首先讲讲inverse=true作用： 这里关系是由儿子维护的，所以如果只是往父亲里加入儿子，不给儿子设置父亲的话session.save(parent)，就不会保存儿子！ 看这个例子：注意与例子1的对比

Java代码 复制代码
  1. *ChildPO child = new ChildPO(parent);---〉ChildPO child = new ChildPO();，    
  2.   
  3.                 ITxMgr tx = null;    
  4.                 tx = HibernateTxMgr.beginTrans("Add a new relationships...");;    
  5.                 session = (Session); tx.getSession();;    
  6.                 parent = new ParentPO();;    
  7.                 ChildPO child = new ChildPO();;    
  8.                 ChildPO child2 = new ChildPO();;    
  9.                 List list = new ArrayList();;    
  10.                 list.add(child);;    
  11.                 list.add(child2);;    
  12.                 parent.setChildren(list);;    
  13.                 session.save(parent);;    
  14.                 session.flush();;    
  15.                 System.out.println("dddddddddddddddddddddddddddddddddddddddddddddddddddddd"); ;    
  16.                 ChildPO child3 = new ChildPO();;    
  17.                 child3.setParent(parent);;    
  18.                 session.save(child3);;    
  19.                 session.flush();;    
  20.                 System.out.println("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"); ;    
  21.                 tx.endTrans();;   
*ChildPO child = new ChildPO(parent);---〉ChildPO child = new ChildPO();， 

                ITxMgr tx = null; 
                tx = HibernateTxMgr.beginTrans("Add a new relationships...");; 
                session = (Session); tx.getSession();; 
                parent = new ParentPO();; 
                ChildPO child = new ChildPO();; 
                ChildPO child2 = new ChildPO();; 
                List list = new ArrayList();; 
                list.add(child);; 
                list.add(child2);; 
                parent.setChildren(list);; 
                session.save(parent);; 
                session.flush();; 
                System.out.println("dddddddddddddddddddddddddddddddddddddddddddddddddddddd"); ; 
                ChildPO child3 = new ChildPO();; 
                child3.setParent(parent);; 
                session.save(child3);; 
                session.flush();; 
                System.out.println("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"); ; 
                tx.endTrans();;



生成的SQL没有变

Java代码 复制代码
  1. Hibernate: insert into PARENT (ID); values (default);    
  2.     
  3. Hibernate: insert into CHILD (PARENTID, ID); values (?, default);    
  4.     
  5. Hibernate: insert into CHILD (PARENTID, ID); values (?, default);    
  6.     
  7. dddddddddddddddddddddddddddddddddddddddddddddddddddddd    
  8. Hibernate: insert into CHILD (PARENTID, ID); values (?, default);    
  9. eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee   
Hibernate: insert into PARENT (ID); values (default); 
 
Hibernate: insert into CHILD (PARENTID, ID); values (?, default); 
 
Hibernate: insert into CHILD (PARENTID, ID); values (?, default); 
 
dddddddddddddddddddddddddddddddddddddddddddddddddddddd 
Hibernate: insert into CHILD (PARENTID, ID); values (?, default); 
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee



*注意父子关系丢失了 C:/Myapp/SQLLIB/BIN>db2 select * from child

Java代码 复制代码
  1. ID          PARENTID    
  2. ----------- -----------    
  3.          74           -    
  4.          75           -    
  5.          76          45    
  6. C:/Myapp/SQLLIB/BIN>db2 select * from parent    
  7.     
  8. ID    
  9. -----------    
  10.          45   
ID          PARENTID 
----------- ----------- 
         74           - 
         75           - 
         76          45 
C:/Myapp/SQLLIB/BIN>db2 select * from parent 
 
ID 
----------- 
         45



*为什么最后一个孩子的父亲没有丢失呢？ 就在于child3.setParent(parent);，所以关系是由孩子维护的，如果child不setParent，或者 new childPO(父亲)的话 父子关系就丢失了，parent.setChildren(list);是没有用的！
*这里就又引入了另外一个问题为什么要用inverse? 用了它维护关系起岂不是很麻烦？，这里给出个例子给大家一个解释：（关键原因在于性能）

下面这个例子和例子一完全一样，所差的就是没有用inverse=true

例子2：

Java代码 复制代码
  1. hibernate-mapping>    
  2.     <class name="com.etech.bm.po.ChildPO" table="CHILD">    
  3.                 <id name="id" column="ID" type="integer">    
  4.                         <generator class="identity"/>    
  5.                 </id>    
  6.         <many-to-one name="parent" class="com.etech.bm.po.ParentPO" column="PARENTID"/>    
  7.     </class>    
  8.     <class name="com.etech.bm.po.ParentPO" table="PARENT">    
  9.                 <id name="id" column="ID" type="integer">    
  10.                         <generator class="identity"/>    
  11.                 </id>    
  12.         <bag name="children"  CASCADE=“ALL”>    
  13.                 <key column="PARENTID"/>    
  14.                 <one-to-many class="com.etech.bm.po.ChildPO"/>    
  15.         </bag>    
  16.     </class>    
  17.     
  18. </hibernate-mapping>   
hibernate-mapping> 
    <class name="com.etech.bm.po.ChildPO" table="CHILD"> 
                <id name="id" column="ID" type="integer"> 
                        <generator class="identity"/> 
                </id> 
        <many-to-one name="parent" class="com.etech.bm.po.ParentPO" column="PARENTID"/> 
    </class> 
    <class name="com.etech.bm.po.ParentPO" table="PARENT"> 
                <id name="id" column="ID" type="integer"> 
                        <generator class="identity"/> 
                </id> 
        <bag name="children"  CASCADE=“ALL”> 
                <key column="PARENTID"/> 
                <one-to-many class="com.etech.bm.po.ChildPO"/> 
        </bag> 
    </class> 
 
</hibernate-mapping>


Java代码 复制代码
  1. drop table PARENT;    
  2. drop table CHILD;    
  3. create table PARENT (ID INTEGER not null generated by default as identity, primary key (ID););;    
  4. create table CHILD (ID INTEGER not null generated by default as identity, PARENTID INTEGER, primary key (ID););;    
  5. alter table CHILD add constraint FK3D1FCFC74B18345 foreign key (PARENTID); references PARENT;   
drop table PARENT; 
drop table CHILD; 
create table PARENT (ID INTEGER not null generated by default as identity, primary key (ID););; 
create table CHILD (ID INTEGER not null generated by default as identity, PARENTID INTEGER, primary key (ID););; 
alter table CHILD add constraint FK3D1FCFC74B18345 foreign key (PARENTID); references PARENT;


Java代码 复制代码
  1. ITxMgr tx = null;    
  2.                 tx = HibernateTxMgr.beginTrans("Add a new relationships...");;    
  3.                 session = (Session); tx.getSession();;    
  4.                 parent = new ParentPO();;    
  5.                 ChildPO child = new ChildPO(parent);;    
  6.                 ChildPO child2 = new ChildPO(parent);;    
  7.                 List list = new ArrayList();;    
  8.                 list.add(child);;    
  9.                 list.add(child2);;    
  10.                 parent.setChildren(list);;    
  11.                 session.save(parent);;    
  12.                 session.flush();;    
  13.                 System.out.println("dddddddddddddddddddddddddddddddddddddddddddddddddddddd"); ;    
  14.                 ChildPO child3 = new ChildPO();;    
  15.                 child3.setParent(parent);;    
  16.                 session.save(child3);;    
  17.                 session.flush();;    
  18.                 System.out.println("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"); ;    
  19.                 tx.endTrans();;     
ITxMgr tx = null; 
                tx = HibernateTxMgr.beginTrans("Add a new relationships...");; 
                session = (Session); tx.getSession();; 
                parent = new ParentPO();; 
                ChildPO child = new ChildPO(parent);; 
                ChildPO child2 = new ChildPO(parent);; 
                List list = new ArrayList();; 
                list.add(child);; 
                list.add(child2);; 
                parent.setChildren(list);; 
                session.save(parent);; 
                session.flush();; 
                System.out.println("dddddddddddddddddddddddddddddddddddddddddddddddddddddd"); ; 
                ChildPO child3 = new ChildPO();; 
                child3.setParent(parent);; 
                session.save(child3);; 
                session.flush();; 
                System.out.println("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"); ; 
                tx.endTrans();;



hibernate 生成的sql Hibernate: insert into PARENT (ID) values (default)

Java代码 复制代码
  1. Hibernate: insert into CHILD (PARENTID, ID); values (?, default);    
  2.     
  3. Hibernate: insert into CHILD (PARENTID, ID); values (?, default);    
  4.     
  5. Hibernate: update CHILD set PARENTID=? where ID=?    
  6. dddddddddddddddddddddddddddddddddddddddddddddddddddddd    
  7. Hibernate: insert into CHILD (PARENTID, ID); values (?, default);    
  8. Hibernate: values IDENTITY_VAL_LOCAL();   
Hibernate: insert into CHILD (PARENTID, ID); values (?, default); 
 
Hibernate: insert into CHILD (PARENTID, ID); values (?, default); 
 
Hibernate: update CHILD set PARENTID=? where ID=? 
dddddddddddddddddddddddddddddddddddddddddddddddddddddd 
Hibernate: insert into CHILD (PARENTID, ID); values (?, default); 
Hibernate: values IDENTITY_VAL_LOCAL();



结果 C:/Myapp/SQLLIB/BIN>db2 select * from parent

Java代码 复制代码
  1. ID    
  2. -----------    
  3.          46    
  4. ID          PARENTID    
  5. ----------- -----------    
  6.          77          46    
  7.          78          46    
  8.          79          46   
ID 
----------- 
         46 
ID          PARENTID 
----------- ----------- 
         77          46 
         78          46 
         79          46



明显比原来多了一句Hibernate: update CHILD set PARENTID=? where ID=?针对每一个孩子都去更新父亲的id明显速度很慢，因为父亲有个孩子的集合，他无法知道哪个孩子的父亲id已经指向自己了,所以对于每一个孩子,都要更新父亲使他只想自己，而这个关系由孩子维护就好多了，每个孩子只有一个父亲，只有设置过的才需要更新，所以显然，这个父子关系由孩子来维护比较省力.减轻了数据库的负担

*现在我们再来看看在没有 inverse=true 的条件下 ChildPO child = new ChildPO(parent)---〉ChildPO child = new ChildPO()，

Java代码 复制代码
  1. ITxMgr tx = null;    
  2.                 tx = HibernateTxMgr.beginTrans("Add a new relationships...");;    
  3.                 session = (Session); tx.getSession();;    
  4.                 parent = new ParentPO();;    
  5.                 ChildPO child = new ChildPO();;    
  6.                 ChildPO child2 = new ChildPO();;    
  7.                 List list = new ArrayList();;    
  8.                 list.add(child);;    
  9.                 list.add(child2);;    
  10.                 parent.setChildren(list);;    
  11.                 session.save(parent);;    
  12.                 session.flush();;    
  13.                 System.out.println("dddddddddddddddddddddddddddddddddddddddddddddddddddddd"); ;    
  14.                 ChildPO child3 = new ChildPO();;    
  15.                 child3.setParent(parent);;    
  16.                 session.save(child3);;    
  17.                 session.flush();;    
  18.                 System.out.println("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"); ;    
  19.                 tx.endTrans();;     
ITxMgr tx = null; 
                tx = HibernateTxMgr.beginTrans("Add a new relationships...");; 
                session = (Session); tx.getSession();; 
                parent = new ParentPO();; 
                ChildPO child = new ChildPO();; 
                ChildPO child2 = new ChildPO();; 
                List list = new ArrayList();; 
                list.add(child);; 
                list.add(child2);; 
                parent.setChildren(list);; 
                session.save(parent);; 
                session.flush();; 
                System.out.println("dddddddddddddddddddddddddddddddddddddddddddddddddddddd"); ; 
                ChildPO child3 = new ChildPO();; 
                child3.setParent(parent);; 
                session.save(child3);; 
                session.flush();; 
                System.out.println("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"); ; 
                tx.endTrans();;



生成的sql和结果和上面的是一样的 hibernate 生成的sql Hibernate: insert into PARENT (ID) values (default)

Java代码 复制代码
  1. Hibernate: insert into CHILD (PARENTID, ID); values (?, default);    
  2.     
  3. Hibernate: insert into CHILD (PARENTID, ID); values (?, default);    
  4.     
  5. Hibernate: update CHILD set PARENTID=? where ID=?    
  6. dddddddddddddddddddddddddddddddddddddddddddddddddddddd    
  7. Hibernate: insert into CHILD (PARENTID, ID); values (?, default);    
  8. Hibernate: values IDENTITY_VAL_LOCAL();   
Hibernate: insert into CHILD (PARENTID, ID); values (?, default); 
 
Hibernate: insert into CHILD (PARENTID, ID); values (?, default); 
 
Hibernate: update CHILD set PARENTID=? where ID=? 
dddddddddddddddddddddddddddddddddddddddddddddddddddddd 
Hibernate: insert into CHILD (PARENTID, ID); values (?, default); 
Hibernate: values IDENTITY_VAL_LOCAL();



结果 C:/Myapp/SQLLIB/BIN>db2 select * from child

Java代码 复制代码
  1. ID          PARENTID    
  2. ----------- -----------    
  3.          83          48    
  4.          84          48    
  5.          85          48   
ID          PARENTID 
----------- ----------- 
         83          48 
         84          48 
         85          48


C:/Myapp/SQLLIB/BIN>db2 select * from parent

Java代码 复制代码
  1. ID    
  2. -----------    
  3.          48   
ID 
----------- 
         48



*显然在 没有 inverse=true 的情况下，父子两边都维护父子关系所以 只要有 parent.setchildren(),或者 child.setparent()两者之一就可以了

对inverse=true的总结：不用inverse=ture,对开发者来说写代码比较方便，但是程序执行的效率比较低下，，用inverse=ture一定要注意，一定要对维护关系的一方进行调用，否则会有意想不到的破坏力。

chong800
关注
关系/对象映射 多对多关系(@ManyToMany 注释)【重新认识】
吃螃蟹的虾子
06-11 4万+
查了好多资料old：@ManyToMany 注释：表示此类是多对多关系的一边，mappedBy 属性定义了此类为双向关系的维护端，注意：mappedBy 属性的值为此关系的另一端的属性名。例如，在Student类中有如下方法：被控方:            @ManyToMany(fetch = FetchType.LAZY, mappedBy = "students")p
LLVM-Analysis-LoopInfo
yeshahayes的博客
07-27 2258
  LLVM中对循环的识别是十分的简单。他是一种类似于Tarjan的可规约流图识别（《Testing flow graph reducibility》），不同的是LLVM是基于dom-tree的遍历，这有点像区域分析。因为这个原因，LoopInfo这个模块是没法找到不可规约结构的，因为不可规约循环的循环头不支配循环体。其实这点也可以理解，不可规约循环本来就少见，LLVM也不是什么高性能计算编译器。...
父子关系及inverse 详解
07-27 674
首先以父子关系为例： 对应生成的DDL drop table PARENT; java代码:  drop table CHILD; create table PARENT (ID INTEGER not null generated by d
inverse=true的总结
03-06
3. **父子关系举例**： 假设我们有一个`Department`类（父）和`Employee`类（子）的关系，一个部门可以有多个员工，而一个员工只能属于一个部门。在不设置`inverse`属性的情况下，每次新增或删除员工，Hibernate会...
JAVAWEB开发之Hibernate详解（二）——Hibernate的持久化类状态与转换、以及一级缓存详解、关联关系的映射（一对多、多对多、级联）
04-03 2722
持久化对象的状态  Hibernate持久化对象存在三种状态： 瞬时态 transient:(临时态)  不存在持久化标识OID，尚未与Hibernate  Session关联对象，被认为是瞬时状态，失去引用将被JVM回收。特点：无持久化标识OID，未与Session关联。 持久态 persistent:存在持久化标识OID，与当前Session有关联，并且相关联的Session没有关闭，并
hibernate--关联关系（多对多）
chen的博客
09-03 137
1. 数据库的多对多 数据库中不能直接映射多对多 处理：创建一个桥接表(中间表)，将一个多对多关系转换成两个一对多 注1：数据库多表联接查询 永远就是二个表的联接查询 A B C D t1 C t2 D t3 注2：交叉连接 注3：外连接：left(左)/right(右)/full(左右) 主从表：连接条件不成立时，主...
Hibernate one-to-many / many-to-one关系映射
07-03
这种关系通常需要使用外键来维护，可以通过mappedBy属性指定被引用的一方，也可以通过inverse属性设置维护关系的责任方。 2. 一对多关系： 这表示一个实体可以与多个其他实体相关联，比如一个班级有多个学生。在...
java基础——java中的父子关系
iteye_9440的博客
09-16 1135
java父类子类 例如： Class Son extends Father {    … }把Son类声明为Father类的子类，Father类是Son类的父类。2子类与父类的关系 2.1子类和父类在同一包中的继承性 访问限制修饰符不仅限制了对象对自己成员变量的操作和方法的调用，也限制了继承性。 当子类和父类在同一个包中时，父类中的private访问权限的成员变量不会被子类继承，也就是说，子类继...
inverse和cascade
tweller的专栏
11-01 615
两者都在对象的关联操作中发挥作用。 1．明确inverse和cascade的作用 inverse 决定是否把对对象中集合的改动反映到数据库中，所以inverse只对集合起作用，也就是只对one-to-many或many-to-many有效（因 为只有这两种关联关系包含集合，而one-to-one和many-to-one只含有关系对方的一个引用）。 cascade决定是否把对对象的改动反映到数据库中
《推荐系统实践》 程序实现 —— 2.4.1 基于用户的协同过滤算法
张之海的博客
10-09 1315
本文为笔者在学习《推荐系统实践》一书时，对书中程序进行的实践，仅作为学习参考，如有可以改进之处，也还请各位朋友给予指教，非常感谢。 在查询本文中，关于原书某页的算法实现时，可以直接Crtl+F，输入原书页码查询。未添加的程序实现会在之后陆续补上。 2.4 基于邻域的算法 2.4.1 基于用户的协同过滤算法 1.基础算法 p45 利用余弦相似度计算用户集中两两用户的相似度 p46 建立物品-用户的倒...
joinColumns和inverseJoinColumns的用法
热门推荐
Benjamin
07-25 3万+
最近在工作中使用springside，里面用到了hibernate的多对多 一开始我在配置department（部门表）和menu（栏目表）的时候，这样写的。 Department实体类中的getMenus上写的joinColumn是menu_id，inverseJoinColumns写的是department_id 我的页面是根据所选部门查找出对应的栏目权限从而打勾，我数据库中间表
web安全测试渗透案例知识点总结（上）——小白入狱
专研计算机网络，数据通信，网络安全，系统集成
11-03 1127
SQL注入（SQL Injection）概念：SQL注入通过在SQL查询中注入恶意代码，使攻击者能够读取、修改数据库中的数据。原理：服务器直接使用用户输入构建SQL语句，导致未经过滤的特殊字符被当成SQL指令执行。防御措施：使用参数化查询（Prepared Statement）、ORM框架，过滤特殊字符。跨站脚本（XSS）概念：通过注入脚本代码使得用户浏览器执行，常用于窃取用户信息或操控用户账户。原理：攻击者在网站中注入恶意代码，代码被受害者浏览器执行，造成数据泄露或操控。防御措施。
Mybatis
庸不易的博客
11-15 806
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 941
Rest请求处理
java加锁问题详解
qq_74056922的博客
11-14 775
java(JVAM)对加锁的API进行了封装,通过使用synchronized关键字来完成加锁操作。
什么是面向对象编程？什么是面向过程编程？
m0_70208894的博客
11-15 521
不同的编程范式适用于不同的场景，选择合适的范式可以提高代码的可维护性、可读性和效率。Java 和 Go 的选择反映了不同的设计哲学，Java 更加注重封装和对象的使用，而 Go 更加简洁，强调过程和函数的使用。
HashMap源码分析下
最新发布
L25000的专栏
11-16 624
如果这个cap刚好是2的幂次方呢，即4,8,16,32,64等这样的，这样的数已经满足条件了，再减去1，把数变成3,7,31,63。，即hash值的第5为是1，这样在扩容到32后，取索引得出来的结果就和16的不一样了，索引位置比oldCap大了一个oldCap值；,求余数，n是一个2的幂次方数，减去1，即后面全是1，前面全是0，与上这个hash，只能保证经过运算，结果都会在。，即hash值的第5为是0，这样在扩容到32后，取索引得出来的结果还是和16的一样；cap=1，2的0次方就等于1，返回的是就是4。
pyechartsAxisOpts内，inverse=True和reversed =true都报错
05-13
xaxis_opts=opts.AxisOpts(axislabel_opts=opts.LabelOpts(rotate=15, font_size=14), is_inverse=True) ) bar.render("bar_chart.html") ``` 如果还是报错，可以尝试查看具体的错误信息，或者将 Pyecharts 升级到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值