hibernate关联映射-单向

最新推荐文章于 2024-09-29 19:21:13 发布
最新推荐文章于 2024-09-29 19:21:13 发布
阅读量563 收藏
点赞数
分类专栏： hibernate 文章标签： hibernate class table null string 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fax5201314/article/details/6732243
版权
关联关系映射通常情况是最难配置正确的。在这个部分中，我们从单向关系映射开始，然后考虑双向关系映射，逐步讲解典型的案例。在所有的例子中，我们都使将用 Person 和 Address。
我们根据映射关系是否涉及连接表以及多样性（multiplicity）来划分关联类型。
在传统的数据建模中，允许为 Null 值的外键被认为是一种不好的实践，因此我们所有的例子中都使用不允许为 Null 的外键。这并不是 Hibernate的 要求，即使你删除
掉不允许为 Null 的约束，Hibernate 映射一样可以工作的很好。
关联关系，多的一方持有一的一方的引用比如外键
8.2. 单向关联（Unidirectional associations）
8.2.1. 单向多对一外键关联（many-to-one）   方向： 多方(person)有一方(address)关联表的引用作为 属性，方向就是我有你的引用(get方法可以查询到你)
相当于一的一方为主表，多的一方为附表，附表有主表的引用。
单向 many-to-one 关联是最常见的单向关联关系。
模型：
多个人（Person）对应一个地址（Address）。
实体：
public class Personn1fk {
    private int personid;
    private String name;
    private int age;
    private Addressn1fk addressn1fk;
 
public class Addressn1fk {
    private int addressid;
    private String addressdetail;

映射：
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<many-to-one name="address"    column="addressId"
not-null="true"/>
</class>

<class name="Address">
<id name="id" column="addressId">
<generator class="native"/>
</id>
</class>
person  ： address  单向多对一，在数据库中体现为  person还有address的 引用，多的一方肯定是有引用(比如外键）
create table Person ( personId bigint not null primary key, addressId bigint not null )
create table Address ( addressId bigint not null primary key )

8.2.2. 一对一（One-to-one）
8.2.2.1
基于外键关联的单向一对一关联和单向多对一外键关联几乎是一样的。唯一的不同就是单向一对一关联中的外键字段具有唯一性约束。
单向一对一的方向就是  person表有address的属性也就是getAddress（）方法通过person找到address 事实上，单向1-1与N-1的实质是相同的，1-1是N-1的特例，单向1-1与N-1的映射配置也非常相似。只需要将原来的many-to-one元素增加unique="true"属性，用于表示N的一端也必须是唯一的，在N的一端增加了唯一的约束，即成为单向1-1。基于外键的单向1-1的配置将与无连接表N-1关联的many-to-one增加unique="true"属性即可。
模型：
一个人（Person）对应一个地址（Address）。
实体：
public class Person11fk {
    private int personid;
    private String name;
    private int age;
    private Address11fk address11fk;
 
public class Address11fk {
    private int addressid;
    private String addressdetail;
映射：
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<many-to-one name="address"
column="addressId"
unique="true"                                                
not-null="true"/>
</class>
<class name="Address">
<id name="id" column="addressId">
<generator class="native"/>
</id>
</class>
person  ： address  单向一对一，在数据库中体现为  person还有address的 引用 并且是唯一的 1对1，简化后的多对一
create table Person ( personId bigint not null primary key, addressId bigint not null unique )
create table Address ( addressId bigint not null primary key )
8.2.2.2
基于主键关联的单向一对一关联通常使用一个特定的 id 生成器，1-1的关联可以基于主键关联，但基于主键关联的持久化类不能拥有自己的主键生成策略，它的主键由关联类负责生成。另外，另外，增加one-to-one元素来关联属性，必须为one-to-one元素增加constrained="true"属性，表明该类主键由关联类生成。
然而在这个例子中我们掉换了关联的方向：
模型：一个人（Person）对应一个地址（Address）。
实体：
public class Person11pk {
    private int personid;
    private String name;
    private int age;
    private Address11pk address11pk;
 
public class Address11pk {
    private int addressid;
    private String addressdetail;
映射：
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
</class>
<class name="Address">
<id name="id" column="personId">
<generator class="foreign">
<param name="property">person</param>
</generator>
</id>
<one-to-one name="person" constrained="true"/>
</class>
注：constrained="true"  则表明本表(address)存在外键与关联表(person)对应，并且关联表(person)中肯定存在对应的键与其对应。hibernate生成的sql将使用inner join. 另外该选项最关键的是影响save和delete的先后顺序。例如增加的时候，如果constainted=true,则会先增加关联表(person)，然后增加本表(address)。删除的时候反之先删本表(address)再删关联表(person)。
address ： person    单向一对一，在数据库中体现为 address的主键是引用person的的外键作为主键
create table Person ( personId bigint not null primary key )
create table Address ( personId bigint not null primary key )

8.2.3. 一对多（one-to-many）
基于外键关联的单向一对多关联是一种很少见的情况，我们不推荐使用它。
相当于  多(address)的一方为主表，一(person)的一方为附表  person表用set集合来维护1对多的关系，不科学。通过1来找所有的多，效率低于多方找1方
因为关系一般有多的一端来维护 这样可以提高效率
一般来说都是用多的一方 通过set方法设置维护说明多的一方属于哪一个一，比如 多(address)的所属人是谁（person）通过address.setPerson(p);

//一对多关联Set<Address> set = p.getAddress() ; set.add(address1) ; set.add(address2) ; session.save(address1) ; session.save(address2) ; 
模型：
一个人（Person）对应多个地址（Address），比如家庭地址、公司地址。
实体：
public class Person1nfk implements Serializable {
    private int personid;
    private String name;
    private int age;
    private Set addresses=new HashSet();
 
public class Address1nfk implements Serializable {
    private int addressid;
    private String addressdetail;
映射：
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<set name="addresses">
<key column="personId"
not-null="true"/>
<one-to-many class="Address"/>
</set>
</class>
<class name="Address">
<id name="id" column="addressId">
<generator class="native"/>
</id>
</class>
person  ： address  单向一对多，在数据库中体现为1对多。
create table Person ( personId bigint not null primary key )
create table Address ( addressId bigint not null primary key, personId bigint not null )
我们认为对于这种关联关系最好使用连接表。

8.3. 使用连接表的单向关联（Unidirectionalassociations with join tables）
8.3.1. 一对多（one-to-many）
基于连接表的单向一对多关联 应该优先被采用。请注意，通过指定unique="true"，我们可以把多样性从多对多改变为一对多。
一方有多方的引用，可以通过set集合t获取多方信息
模型：一个人（Person）对应多个地址（Address），比如家庭地址、公司地址。
实体：
public class Person1ntab {
    private int personid;
    private String name;
    private int age;
    private Set addresses=new HashSet();
 
public class Address1nfk implements Serializable {
    private int addressid;
    private String addressdetail;

映射：
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<!--映射集合属性，PersonAddress是连接表表名--> <!--“column="personid"”确定Person表关联到连接表的外键列名-->
<set name="addresses" table="PersonAddress">
<key column="personId"/>
  <!--“unique="true"表示1-N，Person是1，Address是多”--> <!--“column="addressid"”关联PersonAddress表的Address对象的id在连接表中的列名-->
<many-to-many column="addressId" unique="true" class="Address"/>
</set>
</class>
<class name="Address">
<id name="id" column="addressId">
<generator class="native"/>
</id>
</class>
使用连接表 单向一对多person：address 数据库中体现为3张表：一方（person） 多方（address） 连接表 personAddress，
连接表中多方（address）还有1（person）引用。数据库只能表示1：n的关系，所以永远是多的一方持有1的引用
create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId not null, addressId bigint not null primary key )
create table Address ( addressId bigint not null primary key )

8.3.2. 多对一（many-to-one）
基于连接表的单向多对一关联在关联关系可选的情况下应用也很普遍。例如：
模型：多个人（Person）对应一个地址（Address）。
实体：
public class Personn1tab {
    private int personid;
    private String name;
    private int age;
    private Addressn1tab addressn1tab;
 
public class Addressn1tab {
    private int addressid;
    private String addressdetail;
映射：
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<!--使用join元素显式确定链接表-->
<join table="PersonAddress"
optional="true">
<key column="personId" unique="true"/>
<many-to-one name="address"
column="addressId"
not-null="true"/>
</join>
</class>
<class name="Address">
<id name="id" column="addressId">
<generator class="native"/>
</id>
</class>
使用连接表 单向多对一 person ： address 数据库中体现为3张表：多方（person） 一方（address） 连接表 personAddress，
连接表中多方（person）还有1方（address）引用。数据库只能表示1：n的关系，所以永远是多的一方持有1的引用
create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null primary key, addressId bigint not null )
create table Address ( addressId bigint not null primary key )

8.3.3. 一对一（One-to-one）
基于连接表的单向一对一关联也是可行的，但非常少见。
这种情况很少见，但Hibernate同样允许采用连接表关联1-1.有连接表的1-1同样只需要将连接表的N-1的many-to-one元素增加unique=“true”
模型：一个人（Person）对应一个地址（Address）。
实体：
public class Person11tab {
    private int personid;
    private String name;
    private int age;
    private Address11tab address11tab;
 
public class Address11tab {
    private int addressid;
    private String addressdetail;

映射：
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<join table="PersonAddress"
optional="true">
<!--映射1-1关联属性，其中unique=“true”属性确定为“1-1”-->
<key column="personId"
unique="true"/>
<many-to-one name="address"
column="addressId"
not-null="true"
unique="true"/>
</join>
</class>
<class name="Address">
<id name="id" column="addressId">
<generator class="native"/>
</id>
</class>
使用连接表 单向一对一 person ： address 数据库中体现为3张表：多方（person） 一方（address） 连接表 personAddress，
连接表中多方（person）还有1方（address）引用。数据库只能表示1：n的关系，所以永远是多的一方持有1的引用。 这里是简化的连接表单向多对一
create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null primary key, addressId bigint not null
unique )
create table Address ( addressId bigint not null primary key )

8.3.4. 多对多（many-to-many）
最后，这里是一个单向多对多关联的例子。
模型：一个人可对应多个地址，一个地址也可以对应多个人。
实体：
public class Personnn {
    private int personid;
    private String name;
    private int age;
    private Set addresses=new HashSet();
 
public class Addressnn {
    private int addressid;
    private String addressdetail;
映射：
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<!--映射集合属性，PersonAddress是连接表表名--><!--“column="personid"”确定Person表关联到连接表的外键列名-->
<set name="addresses" table="PersonAddress">
<key column="personId"/>
<!--“column="addressid"”关联Person表的Address对象的id在连接表中的列名-->
<many-to-many column="addressId"
class="Address"/>
</set>
</class>
<class name="Address">
<id name="id" column="addressId">
<generator class="native"/>
</id>
</class>
使用连接表 单向多对多 person ： address 数据库中体现为3张表： 连接表 personAddress，
连接表中互相引用。数据库只能表示1：n的关系，所以永远是多的一方持有1的引用。 连接表等于是2个1：n的关系。
create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key
(personId, addressId) )
create table Address ( addressId bigint not null primary key )8.4. 双向关联（Bidirectional associations）


8.4.1. 一对多（one to many)/多对一（many to one）
双向多对一关联 是最常见的关联关系。下面的例子解释了这种标准的父/子关联关系。
模型：一个人（Person）对应多个地址（Address）。
实体：

<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<many-to-one name="address"
column="addressId"
not-null="true"/>
</class>

<class name="Address">
<id name="id" column="addressId">
<generator class="native"/>
</id>
<set name="people" inverse="true">
<key column="addressId"/>
<one-to-many class="Person"/>
</set>
</class>
create table Person ( personId bigint not null primary key, addressId bigint not null )
create table Address ( addressId bigint not null primary key )
如果你使用 List（或者其他 有序集合类），你需要设置 外键对应的 key 列为 not null。Hibernate将从集合端管理关联，维护每个元素的索引，并通过设置 update="false" 和 insert="false" 来对另一端反向操作。
<class name="Person">
<id name="id"/>
<many-to-one name="address"
column="addressId"
not-null="true"
insert="false"
update="false"/>
</class>

<class name="Address">
<id name="id"/>
<list name="people">
<key column="addressId" not-null="true"/>
<list-index column="peopleIdx"/>
<one-to-many class="Person"/>
</list>
</class>
假若集合映射的 <key> 元素对应的底层外键字段是 NOT NULL 的，那么为这一 key 元素定义 notnull="
true" 是很重要的。不要仅仅为可能的嵌套 <column>元素定义 not-null="true"，<key> 元素
也是需要的。

8.4.2. 一对一（One-to-one）
基于外键关联的双向一对一关联也很常见。
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<many-to-one name="address"
column="addressId"
unique="true"
not-null="true"/>
</class>
<class name="Address">
<id name="id" column="addressId">
<generator class="native"/>
</id>
<one-to-one name="person"
property-ref="address"/>
</class>
create table Person ( personId bigint not null primary key, addressId bigint not null unique )
create table Address ( addressId bigint not null primary key )

基于主键关联的一对一关联需要使用特定的 id 生成器：
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<one-to-one name="address"/>
</class>

<class name="Address">
<id name="id" column="personId">
<generator class="foreign">
<param name="property"
>person</param>
</generator>
</id>
<one-to-one name="person"
constrained="true"/>
</class>
create table Person ( personId bigint not null primary key )
create table Address ( personId bigint not null primary key )

8.5. 使用连接表的双向关联（Bidirectional associationswith join tables）
8.5.1. 一对多（one to many)/多对一（many to one）
下面是一个 基于连接表的双向一对多关联的例子。注意 inverse="true" 可以出现在关联的任意一端，即 collection 端或者 join 端。
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<set name="addresses"
table="PersonAddress">
<key column="personId"/>
<many-to-many column="addressId"
unique="true"
class="Address"/>
</set>
</class>

<class name="Address">
<id name="id" column="addressId">
<generator class="native"/>
</id>
<join table="PersonAddress"
inverse="true"
optional="true">
<key column="addressId"/>
<many-to-one name="person"
column="personId"
not-null="true"/>
</join>
</class>
连接表中多方（address）还有1方（person）引用。
create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null, addressId bigint not null primary key )
create table Address ( addressId bigint not null primary key )

8.5.2. 一对一（one to one）
基于连接表的双向一对一关联也是可行的，但极为罕见。
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<join table="PersonAddress"
optional="true">
<key column="personId"
unique="true"/>
<many-to-one name="address"
column="addressId"
not-null="true"
unique="true"/>
</join>
</class>

<class name="Address">
<id name="id" column="addressId">
<generator class="native"/>
</id>
<join table="PersonAddress"
optional="true"
inverse="true">
<key column="addressId"
unique="true"/>
<many-to-one name="person"
column="personId"
not-null="true"
unique="true"/>
</join>
</class>
create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null primary key, addressId bigint not null
unique )
create table Address ( addressId bigint not null primary key )

8.5.3. 多对多（many-to-many）
下面是一个双向多对多关联的例子。
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<set name="addresses" table="PersonAddress">
<key column="personId"/>
<many-to-many column="addressId"
class="Address"/>
</set>
</class>

<class name="Address">
<id name="id" column="addressId">
<generator class="native"/>
</id>
<set name="people" inverse="true" table="PersonAddress">
<key column="addressId"/>
<many-to-many column="personId"
class="Person"/>
</set>
</class>

create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key
(personId, addressId) )
create table Address ( addressId bigint not null primary key )

http://lavasoft.blog.51cto.com/62575/39398这篇博客有详细代码解释
fax5201314
关注
专栏目录
hibernate关系映射--单向多对多@ManyToMany
路在路上的博客
08-23 2653
1.单向多对多关联必须使用连接表，它和有链接表的单向一对多很相似 2.主要代码@ManyToMany(cascade={CascadeType.ALL}) @JoinTable(name="T_JC_test1_tese2",joinColumns=@JoinColumn(name="test1ID"),inverseJoinColumns=@JoinColumn(name="test2ID"
HIbernate关系映射--单向一对多@OneToMany
路在路上的博客
08-15 908
1.单向的一对多(1-N)，和集合@ElementCollection有点类似，不同的是，单向一对多，集合里的元素是关联的实体 2.对于单向的一对多关联关系，只需在1的一方添加一个集合类型（List，Set，Map）的成员变量，然后给它提供getter，setter方法 3.使用时机：一个表引用另一个表，但只是但向引用，而且建议使用有链接表的单向一对多（1-N） 4.主要注解代码： @
Hibernate关联映射--多对一映射
白净垃圾桶-
08-30 259
单向多对一关联关系： eg：多个学生属于一个班级。在一对多的例子上，我们进行一些改变来建立单向多对一映射： 在student类中增加一个grade班级属性，建立其get/set方法： private int sid; //学生编号 private String sname; //学生姓名 private String sex; //学生性别 //在多方定义
Hibernate关联映射--一对多映射
白净垃圾桶-
08-29 474
映射类型（4种）： 常见的及常用的：一对多、多对一。一对多映射（one-to-many）： 如何表示一对多的关联关系： 例子：一个班级对应多个学生。在班级中定义一个学生的集合。 在数据库中创建表student（学生表）和grade（班级表） hibernate.cfg.xml（注意指定映射文件的路径）：<?xml version='1.0' encoding='UTF-8'?>
Hibernate关系映射----单向一对多实例
小梦想的博客
07-26 606
Hibernate关系映射----单向一对多实例 一对多关系： 我们都知道，一个用户对应多个订单，而一个订单只能对应一个用户，那么数据库中是如何实现这种情况的呢？         建立两张表，一张表是用户表，一张表是订单表，并且在订单表中加入用户表的主键id作为外键。如下图所示： 那么，在hibernate中是如何处理这种情况的呢? hibernate中分为两种情况处理：
Hibernate - 单向多对一关联关系映射
小小默：进无止境
10-09 716
在领域模型中, 类与类之间最普遍的关系就是关联关系。 在 UML 中, 关联是有方向的。 以 Customer 和 Order 为例： 一个用户能发出多个订单, 而一个订单只能属于一个客户。从 Order 到 Customer 的关联是多对一关联; 而从 Customer 到 Order 是一对多关联。 【1】单向n-1 单向 n-1 关联只需从 n 的一端可以访问 1 的一端。 域模型: 从 O...
Hibernate关系映射---单向多对多增删查改实例
小梦想的博客
07-27 453
Hibernate关系映射---单向多对多增删查改实例 实际情况：一个订单中有多个商品，一个商品也有多个订单，所以订单和商品是多对多的关系，此处展现是订单和商品的单向多对多的关系，由订单来操作商品。 1、新建一个Java工程，添加hibernate3.3支持，连接test数据库 2、在src下新建com.etc.dao包，在包下新建Order.java类： package com.etc.
关联映射-单向Set-based关联
热爱学习，享受生活
02-14 1159
继第一个Hibernate应用程序的代码基础上做的hibernate单项Set-based关联。 package org.hibernate.tutorial.domain; import java.util.HashSet; import java.util.Set; public class Person { private Long id; private int age
Hibernate - 单向一对多关联关系映射
小小默：进无止境
10-10 515
上篇博文描述了Hibernate - 单向多对一关联关系映射，本篇博文继续学习单向一对多关系映射。 【1】修改Customer和Order Customer修改如下： public class Customer { private Integer customerId; private String customerName; private Set&amp;amp;lt;Order&amp;amp;gt; orde...
Hibernate关联映射-one to one单向外键关联
03-26
本话题主要探讨的是Hibernate中的一种关联映射方式——一对一（One-to-One）单向外键关联。这种关联模式通常用于两个实体之间存在唯一对应的关系，例如一个用户对应一个唯一的账户。 在Hibernate中，一对一关联可以...
hibernate 全面学习->hibernate 关联映射学习
03-05
本文将深入探讨Hibernate的关联映射学习，包括一对多、多对一、一对一等多种关系映射的方式。 首先，我们来看一下“一对多”（One-to-Many）的映射关系。在Hibernate中，这种关系通常用在一个实体可以拥有多个子...
hibernate一对多关联映射（单向关联）
03-01
这篇博客文章“hibernate一对多关联映射（单向关联）”将深入讲解如何配置和使用这种映射关系。 在单向关联中，只有一个实体知道另一个实体的存在，也就是说，只有父实体（"一"的一端）有对子实体（"多"的一端）的...
Hibernate一对一主键关联映射（单向关联）
03-05
总结来说，Hibernate中的一对一主键关联映射允许两个实体共享同一个主键，实现单向关联时只需在依赖方添加对另一方的引用。在实际应用中，应根据业务需求谨慎选择关联类型，以确保数据的完整性和一致性。
hibernate one-to-one 一对一唯一外键关联映射_单向 and 双向
10-03
Hibernate 一对一唯一外键关联映射详解 Hibernate是一种流行的Java持久层框架，提供了多种关联映射方式，其中一对一唯一外键关联映射是一种常见的关联方式。在本文中，我们将详细介绍Hibernate一对一唯一外键关联...
javax.naming.NoInitialContextException: Need to specify class name in environment or system property
热门推荐
彷徨de等待
12-07 1万+
javax.naming.NoInitialContextException: Need to specify class name in environment or system property, or as an applet parameter, or in an application resource file:  java.naming.factory.initial 在使用hi
hibernate3.6 load和get区别
彷徨de等待
12-06 939
1、load() 和get() 方法 首先都会去session中 check 是否存在相同PK的instance。      (1)、如果存在，那么就立刻返回  session中的 instance 。可能返回 一个代理(load方式内含主键),也可能返回一个actual entity class instance(get方式)。      (2)、如果不存在，load方法 创建并返回一个
hibernate关联映射-双向
彷徨de等待
11-24 498
8.4. 双向关联（Bidirectional associations） 8.4.1. 一对多（one to many)/多对一（many to one） 双向多对一关联 是最常见的关联关系。下面的例子解释了这种标准的父/子关联关系。 模型：多个人（Person）对应一个地址（Address）。 实体： public class Person1nfk_sx implem
Web安全 - 跨站点请求伪造CSRF（Cross Site Request Forgery）
最新发布
小工匠
09-29 1209
CSRF (Cross-Site Request Forgery，跨站请求伪造) 是一种攻击方式，攻击者诱导用户在不知情的情况下发起非授权的请求。例如，用户在登录某个站点后，攻击者通过社交工程等手段诱使用户点击包含恶意请求的链接，利用用户已登录的状态，发起用户意图之外的操作，如转账、修改账户设置等。：在每次受保护的请求中，服务器生成一个唯一的CSRF Token，注入到表单或请求头中。：对于敏感操作，可以要求用户进行额外的身份验证，如验证码或短信验证，防止攻击者即便利用用户的认证状态，也无法完成关键操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值