Hibernate双向多对一映射关系02双向级联，维护主外键关系

最新推荐文章于 2024-08-11 20:00:32 发布
最新推荐文章于 2024-08-11 20:00:32 发布
阅读量101 收藏
点赞数
文章标签： java 数据库
原文链接：https://my.oschina.net/u/3848699/blog/2223088
版权

一、双向一对多

双向一对多==双向多对一，就是通过双方度能够找到对方的信息。

09e4c2f3a16e3198655f42f493ebf472e2e.jpg

　数据库关系：跟单向一对多和单向多对一是一样的。

a552f824c4e71ad94c46b8b874bd26bf54d.jpg

实例

cd97bc27a9d9cd7a2b58bb88d61fa49ef27.jpg

Student.java

package com.java.model;

public class Student {
	private String name;
	private long id;
	
    //定义一个班级对象
	private Classes c;

	public Classes getC() {
		return c;
	}
	public void setC(Classes c) {
		this.c = c;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", id=" + id + ", c=" + c + "]";
	}
	

}

Student.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
       <!--学生表class name对应类名，table对应数据库中的表名  -->
	<class name="com.java.model.Student" table="t_student">
	
	<!--主键id name对应实体类的属性,column对应数据库表中的字段 ,generator主键 -->
	<id name="id" column="student_id">
		<generator class="native"></generator>
	</id>
	
	<!-- 该对象的基本属性 -->
	<property name="name" column="student_name">
	</property>
	
	
	 <!-- 重点在这里 
	 		学生表外键和班级表主键相关联，
            name：学生实体类中定义的那个对象的引用名称:private Class c;。
            column：学生表中的外键名称。注意，是被外键约束的字段的名称，写这些配置文件，要时刻记得那两张数据库表的关系。
			学生表外键名可以取和班级表主键名不一样的名字
			本例学生表外键名：classId  
			本例班级表主键名：class_id  
         -->
         
	 <many-to-one name="c" column="classId" class="com.java.model.Classes" cascade="save-update"></many-to-one>
	 
	</class>


</hibernate-mapping>

Classes.java

package com.java.model;

import java.util.HashSet;
import java.util.Set;

public class Classes {
	private String name;
	private long id;
	private Set<Student> students=new HashSet<Student>();
	
	
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	@Override
	public String toString() {
		return "Classes [name=" + name + ", id=" + id + "]";
	}
	
}

Classes.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
       <!--班级表class name对应类名，table对应数据库中的表名  -->
	<class name="com.java.model.Classes" table="t_classes">
	
	<!--主键id name对应实体类的属性,column对应数据库表中的字段 ,generator主键 -->
	<id name="id" column="class_id">
		<generator class="native"></generator>
	</id>
	
		<!-- 该对象的基本属性 -->
	<property name="name" column="class_name">
	</property>
	
	
	
        <!--关键在这里，
            name:set集合属性的名称（model里的classes类的学生集合名称）
            key/column：这个是外键名，这个外键字段名不一定要和本类的主键字段名相同，这点要搞清楚，记住数据库表的关系，谁指向谁就不会混淆
                        这个外键值放在学生表里（不管是单向一对多还是单向多对一，都需要在多方加上外键）
            one to many/class：一对多，所映射的类名(全限定类名，直接写类名也可以，hibernate会帮我们自动写好)
        -->
		        <set name="students" cascade="save-update">
		            <key column="classId"></key>
		            <one-to-many class="com.java.model.Student" />
		        </set>
		</class>
</hibernate-mapping>

导入映射文件hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        <!--数据库连接设置 -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
        <property name="connection.username">root</property>
        <property name="connection.password">123456</property>

       
        <!-- 方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
	
        <!-- 控制台显示SQL -->
        <property name="show_sql">true</property>

        <!-- 自动更新表结构 -->
        <property name="hbm2ddl.auto">update</property>
        
      <!--导入映射文件-->
	  	<mapping resource="com/java/model/Student.hbm.xml"/>
	  	<mapping resource="com/java/model/Classes.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

测试类

package com.java.service;

import static org.junit.Assert.*;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.java.model.Classes;
import com.java.model.Student;
import com.java.util.HibernateUtil;

public class StudentTest2 {

	private SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
	private Session session;
	
	@Before
	public void setUp() throws Exception {
		session=sessionFactory.openSession(); // 生成一个session
	    session.beginTransaction(); // 开启事务
	}

	@After
	public void tearDown() throws Exception {
		 session.getTransaction().commit(); // 提交事务
		 session.close(); // 关闭session
	}
	
	
	@Test
	public void testSaveClassAndStudentWithCascade() {
		System.out.println("通过操作学生表进行级联保存");

		 //写好班级对象
	    Classes banji=new Classes();
	    banji.setName("15数媒");
                		     
          //写好学生的对象		    
         Student s1=new Student();
	    s1.setName("王五");
	    //将班级信息保存到学生对象中
	    s1.setC(banji);

	    Student s2=new Student();
	    s2.setName("赵六");
        s2.setC(banji);
	      //持久化，只操作学生表，把学生信息放到学生表，班级表自动更新
		session.save(s1);
	    session.save(s2);


	}
	
	@Test
	public void testSaveClassAndStudentWithCascade2() {
		System.out.println("通过操作班级表进行级联保存");
		//写好班级信息对象
		Classes c=new Classes();
	    c.setName("15软件");
	    //写好学生信息对象
	    Student s1=new Student();
	    s1.setName("张三");
	    
	    Student s2=new Student();
	    s2.setName("李四");
	    
	    //把学生对象加到班级对象
	    c.getStudents().add(s1);
	    c.getStudents().add(s2);
	    
	    //将班级对象保存到班级表中，学生表自动更新
	    session.save(c);
	}
	

}

结果

d0f080f547265f9c17f1bb540405b1fb12a.jpgeee04703b389207832fbea7bcbea2983fc8.jpg

二、根据数据表调出数据

@Test
	public void getStudentsByClass(){
		System.out.println("从班级表中获取学生信息");
		Classes c=(Classes)session.get(Classes.class, Long.valueOf(2));
		Set<Student> students=c.getStudents();
		Iterator it=students.iterator();
		while(it.hasNext()){
			Student s=(Student)it.next();
			System.out.println(s);
		}
	}
	@Test
	public void getClassByStudents(){
		System.out.println("从学生表中获取该学所在班级的信息");
		Student s=(Student)session.get(Student.class, Long.valueOf(5));
		Classes classes=  s.getC();
			System.out.println(classes);
		
	}

c98e67f8223d372278da91b4f48b60a9c74.jpg086be76e871045fe80be9c7775fb4d05cb5.jpg

三、关联维护

在多对多关联中，如果设置了inverse="true"就表示本方不进行关联的维护，由另一方进行关联的维护。

在一对多的关系中，一般有“多”方进行关联维护，所以Classes.hbm.xml设置inverse="true"（班级表不进行关联维护）

首先我们先写一个添加数据方法，但不添加他们的关系

        @Test
	public void testAdd(){
		Classes c=new Classes();
	    c.setName("16信息与技术");
	    
	    Student s1=new Student();
	    s1.setName("王五");
	    
	    session.save(c);
	    session.save(s1);
	}

d67e5418012fb772bb919b1a21e45f90e10.jpgd398aef2c3f3c73e8284211962e058e6a13.jpg

外键为空，说明班级和学生没有联系

添加关联

@Test
	public void testInverse(){
		Classes c=(Classes)session.get(Classes.class, Long.valueOf(4));
		Student s=(Student)session.get(Student.class, Long.valueOf(9));
		
                 //学生添加班级
		s.setC(c);
                 //班级添加学生
		c.getStudents().add(s);
	}

0d131eaae35c97958573eda94cd0de7600a.jpg3e03cd4056b741d609e256c01fdfe600d7f.jpg

添加完成但是我们发现写了两条sql语句

f123a68a4dcf244b99d904cc56ccade3c93.jpg

我们只需要在学生端维护主外键关系即可，inverse让某一端来维护主外键关系

Classes.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
       <!--班级表class name对应类名，table对应数据库中的表名  -->
	<class name="com.java.model.Classes" table="t_classes">
	
	<!--主键id name对应实体类的属性,column对应数据库表中的字段 ,generator主键 -->
	<id name="id" column="class_id">
		<generator class="native"></generator>
	</id>
	
		<!-- 该对象的基本属性 -->
	<property name="name" column="class_name">
	</property>
	
	
	
   <!--inverse="true" 表示本方classes不进行关联的维护，由另一方进行关联的维护。-->
		        <set name="students" cascade="save-update" inverse="true">
		            <key column="classId"></key>
		            <one-to-many class="com.java.model.Student" />
		        </set>
		</class>
</hibernate-mapping>

把数据库数据删除，执行添加数据方法

06114dfd7a580cc93c4323f3898f33ab4d9.jpg1599537a8131ee1eeb15da1fa024500512a.jpg

添加关联方法

89bd2a35af19a82cbfe756aa4b281be5611.jpg

发现只执行了学生端s.setC(c);的sql语句，“多”的一段维护主外键关系设置成功

a4d56082a51cd2f5fc8a38487ec685eb505.jpg

 

四、级联删除

先添加数据

eae16b0553cbb330f74ea9e7bda86262f2d.jpg8d241f33aa47eb4d66eba5dc3c525f9fbe2.jpg

我们想删除班级就可以删除完所有关联的学生，这就需要级联删除

首先先写一个删除方法

	@Test
	public void testDeleteClassCascade(){
		Classes c=(Classes)session.get(Classes.class, Long.valueOf(5));
		session.delete(c);
	}

执行发现报错了，因为班级表关联着学生，所以不能删除班级

b83df0724a8b4bf6f68718d14903d4cd691.jpg

实现级联删除只需要在Classes.hbm.xml设置cascade="delete"（在班级端）

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
       <!--班级表class name对应类名，table对应数据库中的表名  -->
	<class name="com.java.model.Classes" table="t_classes">
	
	<!--主键id name对应实体类的属性,column对应数据库表中的字段 ,generator主键 -->
	<id name="id" column="class_id">
		<generator class="native"></generator>
	</id>
	
		<!-- 该对象的基本属性 -->
	<property name="name" column="class_name">
	</property>
	
		        <set name="students" cascade="delete" inverse="true">
		            <key column="classId"></key>
		            <one-to-many class="com.java.model.Student" />
		        </set>
		</class>
</hibernate-mapping>

执行成功

6320bfb5d04af4357c7fd94150ef19c3338.jpg50981da1093ee111fe2c17ea9ac8dc2b534.jpg5e1ec3d454958312173ff0a3b4d2582e52d.jpg

五、删除学生

重新添加数据

69b9ea3c7de41e138f10cce60b0f932e932.jpg1ab7a6b6b5c74eae7e288181425a031f089.jpg

执行删除学生方法

	@Test
	public void testDeleteStudent(){
		Student s=(Student)session.get(Student.class, Long.valueOf(13));
		session.delete(s);
	}

说明学生端是可以直接删除数据，删除学生班级不会删除，班级端要删除数据，所有关联学生都要删除，所以只需要在Classes.hbm.xml设置cascade="delete"

6b7f79430ac9fcd874a8dda35ec4f753a97.jpg7c6e405ce06353670c36acf7f47ea9e76cd.jpg24fafa70d162dc7222962fbf36845d2ad4e.jpg

六、一对多双向自身关联关系映射

自身是一也是多

Node.java

package com.java.model;
import java.util.HashSet;
import java.util.Set;

public class Node {

	private long id;
	private String name;
	//父节点 ，自己是“多”的一方，设置一个类
	private Node parentNode;
	//子节点 ，集合，自己是“一”的一方，设置一个集合
	private Set<Node> childNodes=new HashSet<Node>();
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Node getParentNode() {
		return parentNode;
	}
	public void setParentNode(Node parentNode) {
		this.parentNode = parentNode;
	}
	public Set<Node> getChildNodes() {
		return childNodes;
	}
	public void setChildNodes(Set<Node> childNodes) {
		this.childNodes = childNodes;
	}

	
	
}

Node.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

	<class name="com.java.model.Node" table="t_node">
	<id name="id" column="nodeId">
			<generator class="native"></generator>
		</id>
		
		<property name="name" column="nodeName"></property>
	     <!--"多"方， 多对一 -->
         <many-to-one name="parentNode" column="parentId" class="com.java.model.Node" cascade="save-update"></many-to-one>
		
		<!--“一"方 ，一对多 -->
		<set name="childNodes"  inverse="true">
			<key column="parentId"></key>
			<one-to-many class="com.java.model.Node"/>
		</set>
	 
	</class>


</hibernate-mapping>

hibernate.cfg.xml

<mapping resource="com/java/model/Node.hbm.xml"/>

测试NodeTest.java

package com.java.service;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.java.model.Node;
import com.java.util.HibernateUtil;

public class NodeTest {

	private SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
	private Session session;
	
	@Before
	public void setUp() throws Exception {
		session=sessionFactory.openSession(); // 生成一个session
	    session.beginTransaction(); // 开启事务
	}

	@After
	public void tearDown() throws Exception {
		 session.getTransaction().commit(); // 提交事务
		 session.close(); // 关闭session
	}

	@Test
	public void testSaveMenu() {
		//设置一个父节点
		Node node=new Node();
		node.setName("根节点");
		
		Node subNode1=new Node();
		subNode1.setName("子节点1");
		
		Node subNode2=new Node();
		subNode2.setName("子节点2");
	    
		//字节的添加父节点，实现级联操作
		subNode1.setParentNode(node);
		subNode2.setParentNode(node);
		
		session.save(subNode1);
		session.save(subNode2);
	}
	
	
}

结果截图

84e04fc325daa9558f9aabf78ee3561eb73.jpg

转载于:https://my.oschina.net/u/3848699/blog/2223088

chici7332
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hibernate总结（三）
Gray_humor的博客
03-15 233
多表设计 多表设计的总则 问题：我们为什么要学习多表映射？ 答： 在实际开发中，我们数据库的表难免会有相互的关联关系，在操作表的时候就有可能会涉及到多张表的操作。试想一下，如果把我们web阶段的在线商城案例的持久层改为hibernate的实现，我们现在根本无法实现功能。究其原因是我们在线商城中表之间都是有关联关系的。 例如：商品和分类，用户和订单，订单和商品等等。 掌握配置实体之间的关...
Hibernate一对多/多对一关系映射详解及相应的增删查改操作
热门推荐
MoLi blog
03-31 1万+
以客户与订单的关系为例 1.在实体模型类中绑定两者关系: 客户类: public class Customer { private Integer id;//客户id private String name;//客户名称 //一对多属性描述，一个客户有n个订单 private Set<Order> orders = new HashSet<Ord...
Hibernate外键维护
qfc8930858的博客
04-18 142
inverter是hibernate维护关联关系的配置 也就是说我们必须是双向关联关系踩能配置该属性，在one-to-many注解中有一个 mappedBy属性用于标记当实体之间是双向的，作用相当与Inverse属性， --------------------------------------------------- Inverse是hibernate双向关系中的基本概念。inverse的真...
Hibernate框架复习15-多表联系的双向维护与外键维护权
04-21 187
双向维护 开发当中存在多表操作的时候一般建议使用双向维护，也就是一来一回，双方都操作一下，比如这个表添加了一下对方，那么对方也添加一下自己 双向维护性能问题 使用双向维护会降低性能，因为发送了同样功能的sql语句 外键维护权 所以在使用双向维护的时候可以让没有外键的一方放弃外键的维护权 放弃外键维护权配置 在对应的object.hbm.xml文件中添加配置inverse="true"...
Hibernate框架的外键维护问题
reUseClas的博客
07-07 782
外键维护当使用Hibernate框架处理多表关联问题时,会遇到外键维护问题!也就是对应于&lt;many-to-one&gt;&lt;set&gt;标签中的inverse属性,该属性是用于指出是否不参与外键维护,默认值为false!举例说明,当把主键映射配置文件中set标签的inverse属性设置为true时,主键所对应的对象就不参与外键维护,也就是说主键不会执行update语句,用于维护外键!S...
hibernate mysql 主外键_Hibernate中映射一对一关联（按主键映射和外键映射）和组件映射...
weixin_29359515的博客
01-19 145
Hibernate中映射一对一关联(按主键映射和外键映射)和组件映射Hibernate提供了两种映射一对一关联关系的方式：按照外键映射和按照主键映射。下面以员工账号和员工档案表为例，介绍这两种映射方式，并使用这两种映射方式分别完成以下持久化操作：(1)保存员工档案的同时分配给员工一个账号。(2)加载员工档案的同时加载账号信息。1.按照外键映射步骤一：创建实体类Users1和Resume11 pac...
Hibernae - 双向多对一关联关系映射
小小默：进无止境
10-10 478
双向 1-n 与 双向 n-1 是完全相同的两种情形。双向 1-n 需要在 1 的一端可以访问 n 的一端, 反之依然。 域模型:从 Order 到 Customer 的多对一双向关联需要在Order 类中定义一个 Customer 属性, 而在 Customer 类中需定义存放 Order 对象的集合属性。 关系数据模型:ORDERS 表中的 CUSTOMER_ID 参照 CUSTOMER 表的...
多对多的映射关系和级联
东方
12-16 443
开发步骤： 创建表  用户表 CREATE TABLE sys_user ( user_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT ‘用户id’, user_code varchar(32) NOT NULL COMMENT ‘用户账号’, user_name varchar(64) NOT NULL COMMENT ‘用户名称’, user_pa...
hibernate的一对一主键双向映射关系和外键双向映射关系(一)
tuke_tuke的博客
11-12 3808
主键关联的重点是关联的两个表共享一个主键值。本例中采用，一个单位在网上的一个系统中注册会员。 1，会员数据保存在会员表company中，每个会员的登录账号保存在表login中； 2，一个会员只有一个登录账号，一个登录账号只属于一个会员，两表是一对一的对应关系； company表如下： 生成company表的sql语句如下： CREATE TABLE `company` (
hibernate3.2级联关系自身一对多双向关联
03-23
在Hibernate 3.2版本中，级联关系是处理对象间关联的重要特性，特别是自身一对多双向关联，这允许一个实体类实例与多个相同类型的其他实例相关联，而且这种关联是双向的。现在，让我们深入探讨这个主题。 首先，...
Hibernate教程04_关系映射之一对一单向外键关联
04-13
在Hibernate中，一对一关系有多种实现方式，包括单向和双向关联，以及外键在主表还是从表等不同形式。 **压缩包子文件的文件名称列表：s2sh_relation01_one2one_uni_fk** 这个文件名暗示了这是一组基于Spring、...
hibernate基于主外键的一对多/多对一关联
06-06
总结起来，Hibernate中的一对多/多对一关联是通过主外键映射来实现的，通过注解和配置文件定义实体间的关联关系，利用懒加载或立即加载策略控制数据获取，同时要注意双向关联的维护和级联操作的设置，以确保数据的...
hibernate一对多，多对一，一对多双向关联
03-22
例如，@OneToOne 可用于表示一对一关系，@ManyToOne 和 @OneToMany 用于多对一和一对多关系。 4. **外键约束：** 在数据库层面，这些关联通常通过外键实现。Hibernate允许在映射文件或注解中指定外键的生成策略。 ...
hibernate主键实现一对一单向关联关系源码
10-09
在数据库中，一对一关系意味着两个表中的每一条记录都对应另一表中的唯一一条记录。在Hibernate中，这种关系可以通过共享主键或外键来实现。由于题目中提到的是“主键实现”，我们将重点讨论共享主键的方式。 1. **...
（javaweb）请求响应postman
2301_79144798的博客
08-08 482
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
最新发布
m0_74124657的博客
08-11 269
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 235
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
Java Hibernate 实体关系映射详解：一对一与级联操作
"本Java框架课程提供了详细的实体关系映射（ORM）教程，特别是关于Hibernate框架的一对一、一对多和多对多关系的配置。适合初学者入门，通过简单的代码示例帮助理解复杂的数据库关联关系。课程内容涵盖Hibernate的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值