Hibernate 关系映射 收集、总结整理

《Hibernate 关系映射》是我很早之前收集、总结整理的,在此也发上来 希望对大家有用。因为是很早之前写的,不当之处请指正。

一、概念:

关系:名词,事物之间相互作用、相互联系的状态。

关联:名词:表示对象(数据库表)之间的关系;动词:将对象(数据库表)之间通过某种方式联系起来。

映射:将一种形式转化为另一种形式,包括关系。

级联:动词,有关系的双方中操作一方,另一方也将采取一些动作。

值类型:对象不具备数据库同一性,属于一个实体实例其持久化状态被嵌入到所拥有的实体的表行中,没有标识符。

实体类型:具有数据库标识符。

二、数据库:

1、关系

2.1.1、一对一、一对多、多对多

2.1.2、如何表示?外键+索引

2、级联

2.2.1、级联删除

三、面向对象语言中(Java中):

1、关系

3.1.1、一对一、一对多、多对多

3.1.2、如何表示?实例变量(对象+集合)

2、级联:

3.2.1、级联删除

3.2.2、级联更新

3.2.3、级联保存

四、如何把数据库关系表示为面向对象中的关系:

1、关联:将数据库表之间的关系转化为对象之间的关系;在Hibernate中总指实体之间的关系。

2、映射:完成java对象到数据库表的双向转换。

3、级联(可选):将数据库中的级联转化为对象中的级联(两者(对象和数据库表)没关系)。

4、Hibernate的表和对象的映射:

1、实体类型映射:

4.1.1、主键之间的映射

4.1.2、类属性与表字段的映射

4.1.3、组件映射

4.1.4、集合映射

2、实体关联关系映射:

4.2.1、关联关系映射

五、Hibernate映射示例:

5.1、实现

5.1.1、数据库表定义(主表)

5.1.1.1、用户表

Java代码 收藏代码
  1. CREATETABLETBL_USER(
  2. UUIDNUMBER(10)NOTNULL,
  3. NAMEVARCHAR2(100),
  4. AGENUMBER(10)NOTNULL,
  5. PROVINCEVARCHAR2(100),
  6. CITYVARCHAR2(100),
  7. STREETVARCHAR2(100),
  8. CONSTRAINTPK_USERPRIMARYKEY(UUID));

5.1.1.2、用户普通信息表(一个用户有一个资料)

Java代码 收藏代码
  1. CREATETABLETBL_USER_GENERAL(
  2. UUIDNUMBER(10)NOTNULL,
  3. REALNAMEVARCHAR2(10),
  4. GENDERVARCHAR2(10),
  5. BIRTHDAYNUMBER(10),
  6. HEIGHTNUMBER(10),
  7. WEIGHTNUMBER(10),
  8. CONSTRAINTPK_USER_GENERALPRIMARYKEY(UUID),
  9. CONSTRAINTFK_USER_GENERALFOREIGNKEY(UUID)
  10. REFERENCESTBL_USER(UUID));

5.1.1.3、农场表(一个用户有多个农场)

Java代码 收藏代码
  1. CREATETABLETBL_FARM(
  2. UUIDNUMBER(10)NOTNULL,
  3. NAMEVARCHAR2(10),
  4. FK_USER_IDNUMBER(10),
  5. CONSTRAINTPK_FARMPRIMARYKEY(UUID),
  6. CONSTRAINTFK_USER_FARMFOREIGNKEY(FK_USER_ID)
  7. REFERENCESTBL_USER(UUID));

5.1.2、对象定义

5.1.2.1、用户地址Model

Java代码 收藏代码
  1. packagecn.javass.h3test.model;
  2. publicclassAddressModelimplementsjava.io.Serializable{
  3. privateStringprovince;//省
  4. privateStringcity;//市
  5. privateStringstreet;//街道
  6. }

5.1.2.2、用户Model

Java代码 收藏代码
  1. packagecn.javass.h3test.model;
  2. importjava.util.HashSet;
  3. importjava.util.Set;
  4. publicclassUserModelimplementsjava.io.Serializable{
  5. privateintuuid;
  6. privateStringname;//名称
  7. privateintage;//年龄
  8. privateAddressModeladdress;//地址
  9. privateUserGeneralModeluserGeneral;//用户普通信息
  10. privateSet<FarmModel>farms=newHashSet<FarmModel>();//拥有的农场
  11. }

5.1.2.3、用户普通信息Model

Java代码 收藏代码
  1. packagecn.javass.h3test.model;
  2. publicclassUserGeneralModelimplementsjava.io.Serializable{
  3. privateintuuid;
  4. privateStringrealname;//真实姓名
  5. privateStringgender;//性别
  6. privateStringbirthday;//生日
  7. privateintweight;//体重
  8. privateintheight;//身高
  9. privateUserModeluser;//所属用户
  10. }

5.1.2.4、农场Model

Java代码 收藏代码
  1. packagecn.javass.h3test.model;
  2. publicclassFarmModelimplementsjava.io.Serializable{
  3. privateintuuid;
  4. privateStringname;//农场的名称
  5. privateUserModeluser;//所属用户
  6. }

5.2、配置

5.2.1、实体类型映射:

5.2.1.1、主键的映射(UserModel.hbm.xml)

Java代码 收藏代码
  1. <idname="uuid">
  2. <generatorclass="sequence">
  3. <paramname="sequence">user_uuid</param>
  4. </generator>
  5. </id>

5.2.1.2、类属性与表字段的映射(UserModel.hbm.xml)

Java代码 收藏代码
  1. <propertyname="name"/>

5.2.1.3、组件映射(UserModel.hbm.xml)

Java代码 收藏代码
  1. <componentname="address"class="cn.javass.h3test.model.AddressModel">
  2. <propertyname="province"/>
  3. <propertyname="city"/>
  4. <propertyname="street"/>
  5. </component>

5.2.1.4、集合映射(Set、List、Map)(都是通过外键连接的,,,默认延迟抓取)

Set:

Java代码 收藏代码
  1. privateSet<String>farmSet=newHashSet<String>();

Java代码 收藏代码
  1. <setname="farmSet"table="TBL_FARM">
  2. <keycolumn="fk_user_id"/><!—该外键是tbl_farm的-->
  3. <elementtype="string"column="name"/>
  4. </set>

Java代码 收藏代码
  1. privateList<String>farmList=newArrayList<String>();

Java代码 收藏代码
  1. <listname="farmList"table="TBL_FARM">
  2. <keycolumn="fk_user_id"/>
  3. <list-indexcolumn="uuid"></list-index>
  4. <elementtype="string"column="name"/>
  5. </list>

Java代码 收藏代码
  1. privateMap<Integer,String>farmMap=newHashMap<Integer,String>();
Java代码 收藏代码
  1. <mapname="farmMap"table="TBL_FARM">
  2. <keycolumn="fk_user_id"/>
  3. <map-keytype="int"column="uuid"/>
  4. <elementtype="string"column="name"></element>
  5. </map>

对于集合类型默认是延迟加载的,且只能单向导航,不能双向。

5.2.2、实体关联关系映射:

5.2.2.1、单向关联关系映射,不演示。

5.2.2.2、双向关联关系映射

Java代码 收藏代码
  1. 单向
  2. 定义:不知道另一端什么情况,获取一端另一端自动获取,因为单向,你不知道另一侧是什么。
  3. classA{Bb;}
  4. classB{}
  5. 只能从A导航到B,不能从B导航到A
  6. 关系维护:另一端维护,如B维护
  7. 双向
  8. 定义:知道另一端(两个单向),从一端获取另一端,从另一端也能获取一端
  9. classA{Bb;}
  10. classB{Aa;}
  11. 只能从A导航到B,也能从B导航到A
  12. 关系维护:两端,对关联的一侧所作的改变,会立即影响到另一侧
  13. 关联的多样性:
  14. 从一侧看是多对一,从另一侧看是一对多
  15. 另外还有一对一、多对多
  16. EJBCMP:天生双向,对关联的一侧所作的改变,会立即影响到另一侧,
  17. 如userGeneral.set(user),则自动调用user.setUserGeneral(userGeneral)
  18. Hibernate、JPA:天生单向,两侧关系的维护是不同的关联,必须手工维护
  19. 如userGeneral.set(user),则需要手工调用user.setUserGeneral(userGeneral)。

5.2.2.3、一对一主键关系映射(非延迟抓取)

配置1(UserModel.hbm.xml)

Java代码 收藏代码
  1. <one-to-onename="userGeneral"cascade="all"/>

配置2(UserGeneralModel.hbm.xml)

Java代码 收藏代码
  1. <idname="uuid">
  2. <generatorclass="foreign">
  3. <paramname="property">user</param>
  4. </generator>
  5. </id>
  6. <one-to-onename="user"
  7. class="cn.javass.h3test.model.UserModel"/>

关联的对象所对应的数据库表之间,通过一个外键引用对主键进行约束。

测试:保存对象,只需保存user,自动级联保存用户信息Model

Java代码 收藏代码
  1. UserModeluser=newUserModel();
  2. user.setName("昵称");
  3. UserGeneralModeluserGeneral=newUserGeneralModel();
  4. userGeneral.setRealname("真实姓名");
  5. userGeneral.setUser(user);
  6. user.setUserGeneral(userGeneral);
  7. session.save(user);
  8. //若没有cascade="all",这句必须
  9. //session.save(userGeneral);

1、一对一必须手工维护双向关系。

2、cascade="all":表示保存user时自动保存userGeneral,否则还需要一条save(userGeneral)

3、constrained:添加把userGeneral表的主键映射到user主键的外键约束

5.2.2.4、一对多关系映射(父/子关系映射)

配置1(UserModel.hbm.xml)

Java代码 收藏代码
  1. <setname="farms"cascade="all">
  2. <keycolumn="fk_user_id"/>
  3. <one-to-manyclass="cn.javass.h3test.model.FarmModel"/>
  4. </set>

配置2(FarmModel.hbm.xml)

Java代码 收藏代码
  1. <many-to-onename="user"column="fk_user_id"
  2. class="cn.javass.h3test.model.UserModel">

测试:保存对象,只需保存user,自动级联保存用户信息Model

Java代码 收藏代码
  1. UserModeluser=newUserModel();
  2. user.setName("昵称");
  3. UserGeneralModeluserGeneral=newUserGeneralModel();
  4. userGeneral.setRealname("真实姓名");
  5. userGeneral.setUser(user);
  6. user.setUserGeneral(userGeneral);
  7. FarmModelfarm=newFarmModel();
  8. farm.setName("farm1");
  9. farm.setUser(user);
  10. user.getFarms().add(farm);
  11. //session.save(farm);//若没有cascade=all的话需要这条语句
  12. session.save(user);

以上配置有问题:

Java代码 收藏代码
  1. insertintoTBL_USER(name,age,province,city,street,uuid)values(?,?,?,?,?,?)
  2. insertintoTBL_USER_GENERAL(realname,gender,birthday,weight,height,uuid)values(?,?,?,?,?,?)
  3. insertintoTBL_FARM(name,fk_user_id,uuid)values(?,?,?)
  4. updateTBL_FARMsetfk_user_id=?whereuuid=?

1、持久化user(UserModel)

2、持久化user的一对一关系,即userGeneral(UserGeneralModel);

3、持久化user的一对多关系,即farms(Set<FarmModel>)

3.1、首先发现farm是TO,级联save;(因为在这可能是PO,PO的话就应该update,而不是save);

3.2、其次发现farm在farms集合中,因此需要更新外键(fk_user_id),即执行“update TBL_FARM set fk_user_id=? where uuid=?“。

解决这个问题:

告诉Hibernate应该只有一端来维护关系(外键),另一端不维护;通过指定<set>端的inverse=”true”,表示关系应该由farm端维护。即更新外键(fk_user_id)将由farm端维护。

配置修改(UserModel.hbm.xml)

Java代码 收藏代码
  1. <setname="farms"cascade="all"inverse="true">
  2. <keycolumn="fk_user_id"/>
  3. <one-to-manyclass="cn.javass.h3test.model.FarmModel"/>
  4. </set>

再测试:保存对象,只需保存user,自动级联保存用户信息Model

Java代码 收藏代码
  1. UserModeluser=newUserModel();
  2. user.setName("昵称");
  3. UserGeneralModeluserGeneral=newUserGeneralModel();
  4. userGeneral.setRealname("真实姓名");
  5. userGeneral.setUser(user);
  6. user.setUserGeneral(userGeneral);
  7. FarmModelfarm=newFarmModel();
  8. farm.setName("farm1");
  9. farm.setUser(user);
  10. user.getFarms().add(farm);
  11. //session.save(farm);//若没有cascade=all的话需要这条语句
  12. session.save(user);

更新外键,需要修改FarmModel的外键并update:

Java代码 收藏代码
  1. insertintoTBL_USER(name,age,province,city,street,uuid)values(?,?,?,?,?,?)
  2. insertintoTBL_USER_GENERAL(realname,gender,birthday,weight,height,uuid)values(?,?,?,?,?,?)
  3. insertintoTBL_FARM(name,fk_user_id,uuid)values(?,?,?)

级联删除

1、当删除user时自动删除user下的farm

Java代码 收藏代码
  1. user=(UserModel)session.get(UserModel.class,1);
  2. session.delete(user);

结果:

Java代码 收藏代码
  1. Hibernate:deletefromTBL_USER_GENERALwhereuuid=?
  2. Hibernate:deletefromTBL_FARMwhereuuid=?
  3. Hibernate:deletefromTBL_USERwhereuuid=?

2、删除user中的farms的一个元素

Java代码 收藏代码
  1. UserModeluser=
  2. (UserModel)session.get(UserModel.class,118);
  3. FarmModelfarm=(FarmModel)user.getFarms().toArray()[user.getFarms().size()-1];
  4. user.getFarms().remove(farm);//1.必须先从集合删除
  5. session.delete(farm);//2.然后才能删除

结果:

Java代码 收藏代码
  1. Hibernate:deletefromTBL_FARMwhereuuid=?

如果将子对象从集合中移除,实际上我们是想删除它。要实现这种要求,就必须使用cascade="all-delete-orphan"。无需再调用session.delete(farm)

5.2.2.5、多对多关系映射:不用

为什么不使用多对多:当添加新字段时给谁?

那实际项目如何用:拆成两个一对多。

六、涉及的SQL语句会按照下面的顺序发出执行:

1、查询

1、所有对实体进行插入的语句,其顺序按照对象执行Session.save()的时间顺序

2、所有对实体进行更新的语句

3、所有进行集合插入的语句(实体类型)

4、所有对集合元素进行删除、更新或插入的语句(值类型)

5、所有进行集合删除的语句(实体类型)

6、所有对实体进行删除的语句,其顺序按照对象执行Session.delete()的时间顺序

(有一个例外是,如果对象使用native方式来生成ID(持久化标识)的话,它们一执行save就会被插入。)

七、影响关系映射抓取的cfg配置:

hibernate.max_fetch_depth

为单向关联(一对一, 多对一)的外连接抓取(outer join fetch)树设置最大深度. 值为0意味着将关闭默认的外连接抓取.

取值建议在0到3之间取值

hibernate.default_batch_fetch_size

为Hibernate关联的批量抓取设置默认数量.

取值建议的取值为4, 8, 和16

如果你的数据库支持ANSI, Oracle或Sybase风格的外连接,外连接抓取通常能通过限制往返数据库次数 (更多的工作交由数据库自己来完成)来提高效率. 外连接抓取允许在单个SELECTSQL语句中, 通过many-to-one, one-to-many, many-to-many和one-to-one关联获取连接对象的整个对象图.

将hibernate.max_fetch_depth设为0能在全局范围内禁止外连接抓取. 设为1或更高值能启用one-to-one和many-to-one外连接关联的外连接抓取, 它们通过 fetch="join"来映射.

八、抓取策略

1、抓取策略定义

抓取策略(fetching strategy)是指:当应用程序需要在(Hibernate实体对象图的)关联关系间进行导航的时候, Hibernate如何获取关联对象的策略。抓取策略可以在O/R映射的元数据中声明,也可以在特定的HQL 或条件查询(CriteriaQuery)中重载声明。

2、Hibernate3定义了如下几种抓取策略:

连接抓取(Join fetching)- Hibernate通过 在SELECT语句使用OUTER JOIN(外连接)来 获得对象的关联实例或者关联集合。 默认非延迟加载
集合抓取需要通过配置fetch="join"来指定。下行数据太多(冗余),IO

Java代码 收藏代码
  1. //配置fetch="join"(lazy="true"不起作用了)
  2. session.get(UserModel.class,118);//是获取对象的
  3. Hibernate:select…fromTBL_USERusermodel0_,TBL_FARMfarms1_
  4. whereusermodel0_.uuid=farms1_.fk_user_id(+)andusermodel0_.uuid=?

查询抓取(Select fetching)-另外发送一条SELECT语句抓取当前对象的关联实体或集合。除非你显式的指定lazy="false"禁止延迟抓取(lazy fetching),否则只有当你真正访问关联关系的时候,才会执行第二条select语句。

Java代码 收藏代码
  1. 配置lazy=”true”默认(或者lazy="false"fetch="select")
  2. session.get(UserModel.class,118);//是获取对象的
  3. Hibernate:select…fromTBL_USERusermodel0_whereusermodel0_.uuid=?
  4. Hibernate:select…fromTBL_FARMfarms0_wherefarms0_.fk_user_id=?

默认用于lazy="true"情况的集合抓取,如果lazy="false"需要指定fetch="select"来通过查询抓取。会造成DB的CPU利用率非常高,计算密集

子查询抓取(Subselect fetching)-另外发送一条SELECT语句抓取在前面查询到(或者抓取到)的所有实体对象的关联集合。除非你显式的指定lazy="false"禁止延迟抓取(lazy fetching),否则只有当你真正访问关联关系的时候,才会执行第二条select语句。
当通过Query等接口查询多个实体时,如果指定fetch="subselect"则将通过子查询获取集合

Java代码 收藏代码
  1. 配置fetch="subselect"
  2. Queryq=session.createQuery("fromUserModel");
  3. System.out.println(q.list());
  4. Hibernate:select……fromTBL_USERusermodel0_
  5. Hibernate:select……fromTBL_FARMfarms0_wherefarms0_.fk_user_id
  6. in(selectusermodel0_.uuidfromTBL_USERusermodel0_)

批量抓取(Batch fetching)- 对查询抓取的优化方案, 通过指定一个主键或外键列表,Hibernate使用单条SELECT语句获取一批对象实例或集合。

当通过Query等接口查询多个实体时,如果指定farm的batch-size="……"则将通过使用单条SELECT语句获取一批对象实例或集合

Java代码 收藏代码
  1. Queryq=session.createQuery("fromUserModel");
  2. List<UserModel>userList=q.list();System.out.println(userList);
  3. Hibernate:select…TBL_USERusermodel0_
  4. Hibernate:select…fromTBL_FARMfarms0_wherefarms0_.fk_user_idin(?,?)

可指定全局批量抓取策略:hibernate.default_batch_fetch_size,取值:建议的取值为4, 8,和16。

如果batch-size="4",而某个user有19个农场,Hibernate将只需要执行五次查询,分别为4、4、4、4、3。

测试必须数据量足够多,,如果只有一条不行

3、使用延迟属性抓取(Using lazy property fetching)

属性的延迟载入要求在其代码构建时加入二进制指示指令(bytecode instrumentation),如果你的持久类代码中未含有这些指令,Hibernate将会忽略这些属性的延迟设置,仍然将其直接载入。

Hibernate3对单独的属性支持延迟抓取,这项优化技术也被称为组抓取(fetch groups)。 请注意,该技术更多的属于市场特性。在实际应用中,优化行读取比优化列读取更重要。但是,仅载入类的部分属性在某些特定情况下会有用,例如在原有表中拥有几百列数据、数据模型无法改动的情况下。

4、Hibernate在抓取时会lazy区分下列各种情况:

立即抓取-当宿主被加载时,关联、集合或属性被立即抓取。

Lazy collection fetching,延迟集合抓取-直到应用程序对集合进行了一次操作时,集合才被抓取。(对集合而言这是默认行为。)

Extra-lazy" collection fetching,"Extra-lazy"集合抓取-对集合类中的每个元素而言,都是直到需要时才去访问数据库。除非绝对必要,Hibernate不会试图去把整个集合都抓取到内存里来(适用于非常大的集合)。

Java代码 收藏代码
  1. //lazy="extra"
  2. Queryq=session.createQuery("fromUserModel");
  3. Iteratorit=q.iterate();System.out.println(((UserModel)it.next()).getFarms().size());
  4. //或
  5. List<UserModel>userList=q.list();System.out.println(userList.get(0).getFarms().size());
  6. Hibernate:selectusermodel0_.uuidascol_0_0_fromTBL_USERusermodel0_
  7. Hibernate:select…fromTBL_USERusermodel0_whereusermodel0_.uuid=?
  8. Hibernate:selectcount(uuid)fromTBL_FARMwherefk_user_id=?
  9. //或
  10. Hibernate:select…fromTBL_USERusermodel0_
  11. Hibernate:selectcount(uuid)fromTBL_FARMwherefk_user_id=?

对于调用size()、contains、isEmpty是一种优化,不读取所有级联,而是按条件生产不同的sql。

Proxy fetching,代理抓取-对返回单值的关联而言,当其某个方法被调用,而非对其关键字进行get操作时才抓取。

Java代码 收藏代码
  1. //默认<many-to-onename="user"……lazy="false"/>
  2. FarmModelfarm=(FarmModel)session.get(FarmModel.class,121);
  3. System.out.println(farm.getUser().getUuid());
  4. Hibernate:select…fromTBL_FARMfarmmodel0_wherefarmmodel0_.uuid=?
  5. Hibernate:select…fromTBL_USERusermodel0_whereusermodel0_.uuid=?
  6. 118

Java代码 收藏代码
  1. //<many-to-onename="user"……lazy="proxy"/>
  2. FarmModelfarm=(FarmModel)session.get(FarmModel.class,121);
  3. System.out.println(farm.getUser().getUuid());
  4. Hibernate:select…fromTBL_FARMfarmmodel0_wherefarmmodel0_.uuid=?
  5. 118

注:如果constrained="false"或基于主键的一对一, 不可能使用代理,Hibernate会采取预先抓取!

"No-proxy" fetching,非代理抓取-对返回单值的关联而言,当实例变量被访问的时候进行抓取。与上面的代理抓取相比,这种方法没有那么“延迟”得厉害(就算只访问标识符,也会导致关联抓取)但是更加透明,因为对应用程序来说,不再看到proxy。这种方法需要在编译期间进行字节码增强操作,因此很少需要用到。

Lazy attribute fetching,属性延迟加载-对属性或返回单值的关联而言,当其实例变量被访问的时候进行抓取。需要编译期字节码强化,因此这一方法很少是必要的。

这里有两个正交的概念:关联何时被抓取,以及被如何抓取(会采用什么样的SQL语句)。不要混淆它们!我们使用抓取来改善性能。我们使用延迟来定义一些契约,对某特定类的某个脱管的实例,知道有哪些数据是可以使用的。

九、抓取优化

1、集合N+1:

可以使用batch-size来减少获取次数,即如batch-size=”10”,则是N/10+1。

开启二级缓存。

对于集合比较小且一定会用到的可采用fetch=”join”,这样只需一条语句。

2、笛卡尔积问题:

Java代码 收藏代码
  1. <setname="farms"cascade="all,all-delete-orphan"inverse="true"fetch="join">
  2. <keycolumn="fk_user_id"/>
  3. <one-to-manyclass="cn.javass.h3test.model.FarmModel"/>
  4. </set>
  5. <setname="hourses"cascade="all,all-delete-orphan"inverse="true"fetch="join">
  6. <keycolumn="fk_user_id"/>
  7. <one-to-manyclass="cn.javass.h3test.model.HourseModel"/>
  8. </set>

如上配置产生笛卡尔积问题。

select user.*,farm.*,hourse.* from UserModel user, FarmModel farm, HourseModel hourse

where user.uuid=farm.fk_user.uuid(+) and

user.uuid=hourse.fk_user.uuid(+)

解决方案:

1、fetch=”subselect”,子查询,每个User查询一套笛卡尔积

2、完全不采用关系映射。

3、大集合采用批处理,按块获取集合数据

4、复杂SQL太复杂太慢:找DBA优化,索引等是否有效,是否加载了过多的无用数据,拆分SQL,按需获取数据。

5、按需获取1对多中的集合。

6、缓存

……

不当之处,请多多指正!


原文地址:http://jinnianshilongnian.iteye.com/blog/1522591

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值