Hibernate中的关系映射

最新推荐文章于 2019-11-04 08:29:44 发布
最新推荐文章于 2019-11-04 08:29:44 发布
阅读量115 收藏
点赞数
分类专栏： hibernate知识点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxkzhang/article/details/102513732
版权

Hibernate中的关系映射

  • 都需要 hibernate.cfg.xml 中配置 mapper

      * 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/hibernate01</property>
  	        <property name="connection.username">root</property>
  	        <property name="connection.password">root</property>

  	        <!-- SQL dialect sql方言-->
  	        <property name="dialect">
  	            org.hibernate.dialect.MySQLDialect
  	        </property>
  	        
  	        <!-- 控制台打印sql以及格式化sql -->
  	        <property name="show_sql">true</property>
  	        <property name="format_sql">true</property>

  	        <!--映射文件 -->
  	        <mapping resource="com/demos/bean/News.hbm.xml"/>
  	        <mapping resource="com/demos/bean/Student.hbm.xml"/>
  	        <mapping resource="com/demos/bean/Paper.hbm.xml"/>
  	        <mapping resource="com/demos/bean/Grade.hbm.xml"/>
  	        <mapping resource="com/demos/bean/Course.hbm.xml"/>

  	    </session-factory>

  	</hibernate-configuration>

  1. 双向的一对一

     	Student-----Paper
 	1.表与表之间的关系转换为实体和实体之间的关系,在双方的实体类中加入另一方的实体类型属性
 		在Student类中添加Papper类型的属性以及其set和get方法，(一定不能写 gid 外键字段,会冲突)
 			* 字段 (sid,sname,sex,gid)
 			* public class Student {
 					private int sid;
 					private String sname;
 					private String sex;
 					private Paper paper;
 				}
 		在Paper类中添加Student类型的属性以及其set和get方法。
 			* 字段(pid(既是主键,又是外键),pdesc)
 			* public class Paper {
 					private int pid;
 					private String pdesc;
 					private Student student;
 				}
 	2.在映射文件中配置自定义类型属性映射
 		* Paper.hbm.xml
 			<?xml version="1.0" encoding="utf-8"?>
 			<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 			"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 			<!--package:实体类所在的包名，可以省略，省略后class里的类名写全路径（包名+类名）  --> 
 			<hibernate-mapping package="com.demos.bean">
 				<!-- name：指定类名 ，table：实体类对应的数据库表名-->
 			    <class name="Paper" table="paper" >
 			    	<!--id:主键，name：类中主键对应的的属性名，column：表里主键的列名  -->
 			        <id name="pid" type="java.lang.Integer">
 			            <column name="pid" />
 			            <!-- 设置主键的增长方式:使用另外一个相关联的对象的主键作为该对象主键 -->
 			            <generator class="foreign">
 			            	<!-- 设置另外一个相关联的对象(在当前类中关联另一方的属性名) -->
 			            	<param name="property">student</param>
 			            </generator>
 			        </id>
 			        <!-- column省略不写，默认和属性名一致，
 			        type：指定列或者属性的类型，有三种指定方式（属性类型，hibernate 提供的类型，数据库列的类型） -->
 			        <property name="pdesc" type="java.lang.String">
 			            <column name="pdesc" length="50" not-null="true" />
 			        </property>
 			        <!-- name:自定义类型的属性名，
 					     class="自定义属性的类型" ,
 					     cascade:级联操作，默认none,save-update,delete,all  
 					     constrained通过外键来级联-->
 					<one-to-one name="student" class="Student" cascade="all" constrained="true"></one-to-one>
 			    </class>
 			</hibernate-mapping>

 			语法：
 				<one-to-one name="自定义类型的属性名" class="自定义类型的属性的类型">
 				</one-to-one>
 				注意：含有外键的实体映射文件中主键的增长方式
 		* Student.hbm.xml
 			<?xml version="1.0" encoding="utf-8"?>
 			<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 			"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 			<!-- 此处表示的是进行POJO类与数据表之间的映射 -->
 			<hibernate-mapping package="com.demos.bean">
 				<!-- 配置的是类的相关定义，name表示类的名字，同时设置table对应的数据表，catalog表示的是数据库的名字 -->
 				<class name="Student" table="student">
 					<!-- 配置主键，name表示的是类之中的属性名称，type表示的是student类的sid类型 -->
 					<id name="sid" type="java.lang.Integer">
 						<column name="sid" />
 						<!-- 主键的生成方式，根据代码自动分配 -->
 						<generator class="assigned"></generator>
 					</id>
 					<property name="sname" type="java.lang.String">
 						<!-- 定义类中的属性与表之中的映射字段 -->
 						<column name="sname" length="50" not-null="true" />
 					</property>
 					<property name="sex" type="java.lang.String">
 						<column name="sex" length="10" />
 					</property>
 					<!-- name:自定义类型的属性名，class="自定义属性的类型" -->
 					<one-to-one name="paper" class="Paper"></one-to-one>
 				</class>
 			</hibernate-mapping>
 	3.测试使用
 		public class OneToOne {
 			Session session;

 			@Before
 			public void startUp() {
 				Configuration configure = new Configuration().configure("hibernate.cfg.xml");
 				SessionFactory sf = configure.buildSessionFactory();
 				session = sf.openSession();
 			}

 			// 根据学生的id查询学生的基本信息以及其学生证信息（面向对象）
 			@Test
 			public void getinfo() {
 				Student student = session.get(Student.class, 6001);
 				System.out.println(student);
 				//Paper paper = student.getPaper();
 				//System.out.println(paper);
 			}
 			// 保存学生以及学生的学生证信息
 			@Test
 			public void saveStuPaper() {
 				Student s = new Student();
 				s.setSid(71503001);
 				s.setSname("小张");
 				s.setSex("男");
 				
 				Paper p = new Paper();
 				p.setPdesc("河大");
 				p.setStudent(s);
 				
 				//session.save(s);
 				session.save(p);
 				
 				session.beginTransaction().commit();
 				session.close();
 			}
 			// 根据学生证号71503001更新学生证描述以及学生的姓名
 			@Test
 			public void updateSp() {
 				// 获取学生证信息根据学生证号
 				Paper paper = session.get(Paper.class,71503001);
 				paper.setPdesc("北京大学");
 				Student student = paper.getStudent();
 				student.setSname("夏夏");
 				session.beginTransaction().commit();
 				session.close();
 			}
 		}

  2. 一对多

     	Grade ----Student 
 	1.在一的一方加入多的一方的Set集合属性，在多的一方加入一的一方的实体属性。
 		在Grade中加入Student的Set集合属性以及属性的set,get方法
 			Grade.java
 				public class Grade {
 					private int gid;
 					private String gname;
 					private String gdesc;
 					private Set<Student> sSet = new HashSet<>();
 				}
 		在Student中加入Grade的实体属性以及属性的set,get方法
 			Student.java
 				private Grade grade;
 	2.映射文件
 		一的一方的映射文件：
 			* Grade.hbm.xml
 				<?xml version="1.0" encoding="utf-8"?>
 				<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 				"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 				<hibernate-mapping package="com.demos.bean">
 				    <class name="Grade" table="grade" >
 				        <id name="gid" type="java.lang.Integer">
 				            <column name="GID" />
 				            <generator class="assigned" />
 				        </id>
 				        <property name="gname" type="java.lang.String">
 				            <column name="GNAME" length="10" not-null="true" />
 				        </property>
 				         <property name="gdesc" type="java.lang.String">
 				            <column name="GDESC" length="50" />
 				        </property>

 				        <!--name:set集合属性名  -->
 				        <set name="sSet">
 				        	<!--column：多的一方表中的外键字段  -->
 				        	<key column="gid"></key>
 				           	<!--class：关联的另一方的类型  -->
 				           	<one-to-many class="Student"/>
 				        </set>

 				    </class>
 				</hibernate-mapping>
 		多的一方的映射文件：
 			* Student.hbm.xml
 				<?xml version="1.0" encoding="utf-8"?>
 				<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 				"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 				<!-- 此处表示的是进行POJO类与数据表之间的映射 -->
 				<hibernate-mapping package="com.demos.bean">
 					<!-- 配置的是类的相关定义，name表示类的名字，同时设置table对应的数据表，catalog表示的是数据库的名字 -->
 					<class name="Student" table="student">
 						<!-- 配置主键，name表示的是类之中的属性名称，type表示的是student类的sid类型 -->
 						<id name="sid" type="java.lang.Integer">
 							<column name="sid" />
 							<!-- 主键的生成方式，根据代码自动分配 -->
 							<generator class="assigned"></generator>
 						</id>
 						<property name="sname" type="java.lang.String">
 							<!-- 定义类中的属性与表之中的映射字段 -->
 							<column name="sname" length="50" not-null="true" />
 						</property>
 						<property name="sex" type="java.lang.String">
 							<column name="sex" length="10" />
 						</property>
 						<!-- name:自定义类型的属性名，class="自定义属性的类型" -->
 						<one-to-one name="paper" class="Paper" ></one-to-one>
 						
 						<!--name:关联的一的一方的属性名，class：属性的类型  column：当前方和另一方关联的外键字段-->
 						<many-to-one name="grade" class="Grade" column="gid"></many-to-one>
 						
 					</class>
 				</hibernate-mapping>
 	3.测试
 		public class OneToMany {
 			Session session;

 			@Before
 			public void startUp() {
 				Configuration configure = new Configuration().configure("hibernate.cfg.xml");
 				SessionFactory sf = configure.buildSessionFactory();
 				session = sf.openSession();
 			}

 			// 根据年级的id获取年级的基本信息以及该年级下的学生
 			@Test
 			public void getinfo() {
 				Grade grade = session.get(Grade.class, 4);
 				/*System.err.println(grade);
 				Set<Student> sSet = grade.getsSet();
 				for (Student student : sSet) {
 					System.err.println(student);
 				}*/
 				System.out.println(grade.getGname() + "--" + grade.getGdesc());
 				Set<Student> sset = grade.getsSet();
 				for (Student s : sset) {
 					System.out.println(s.getSid() + "--" + s.getSname());
 				}
 			}
 			
 			// 将某个新生加入到4年级
 			@Test
 			public void addStuToGtade() {
 				Grade grade = session.get(Grade.class, 4);

 				Student s = new Student();
 				s.setSid(71503003);
 				s.setSname("小李");
 				s.setSex("男");
 				
 				//grade.getsSet().add(s);
 				s.setGrade(grade);
 				session.save(s);
 				session.beginTransaction().commit();
 				session.close();
 			}
 			
 		}

  3. 多对多

     	学生----课程
 	1.在双方的实体类中加入另一方的set集合属性
 		* 在Student 类中添加Course的集合属性以及其set,get方法
 			private Set<Course> cSet = new HashSet<>();
 		* 在Course类中添加Student的集合属性以及其set,get方法
 			private Set<Student> sSet = new HashSet<>();
 	2.映射文件
 		* Student.hbm.xml
 			<?xml version="1.0" encoding="utf-8"?>
 			<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 			"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 			<!-- 此处表示的是进行POJO类与数据表之间的映射 -->
 			<hibernate-mapping package="com.demos.bean">
 				<!-- 配置的是类的相关定义，name表示类的名字，同时设置table对应的数据表，catalog表示的是数据库的名字 -->
 				<class name="Student" table="student">
 					<!-- 配置主键，name表示的是类之中的属性名称，type表示的是student类的sid类型 -->
 					<id name="sid" type="java.lang.Integer">
 						<column name="sid" />
 						<!-- 主键的生成方式，根据代码自动分配 -->
 						<generator class="assigned"></generator>
 					</id>
 					<property name="sname" type="java.lang.String">
 						<!-- 定义类中的属性与表之中的映射字段 -->
 						<column name="sname" length="50" not-null="true" />
 					</property>
 					<property name="sex" type="java.lang.String">
 						<column name="sex" length="10" />
 					</property>
 					<!-- name:自定义类型的属性名，class="自定义属性的类型" -->
 					<one-to-one name="paper" class="Paper" ></one-to-one>
 					
 					<!--name:关联的一的一方的属性名，class：属性的类型  column：当前方和另一方关联的外键字段-->
 					<many-to-one name="grade" class="Grade" column="gid"></many-to-one>
 					
 					<!--name:另一方的集合属性名，table:中间表  -->
 					<set name="cSet" table="sc">
 						<!--column：当前方和中间表关联的外键字段  -->
 			        	<key column="sid"></key>
 			        	<!--column：关联的另一方和中间表关联的外键字段 class: 关联的另一方的类型 -->
 			        	<many-to-many column="cid" class="Course"></many-to-many>
 					</set>
 					
 				</class>
 			</hibernate-mapping>
 		* Course.hbm.xml
 			<?xml version="1.0" encoding="utf-8"?>
 			<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 			"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 			<hibernate-mapping package="com.demos.bean">
 			    <class name="Course" table="COURSE" >
 			        <id name="cid" type="java.lang.Integer">
 			            <column name="CID" />
 			            <generator class="assigned" />
 			        </id>
 			        <property name="cname" type="java.lang.String">
 			            <column name="CNAME" length="20" not-null="true" />
 			        </property>
 			         <property name="cdesc" type="java.lang.String">
 			            <column name="CDESC" length="50" />
 			        </property>

 			        <set name="sSet">
 			        	<!--column：当前方和中间表关联的外键字段  -->
 			        	<key column="cid"></key>
 			        	<!--column：关联的另一方和中间表关联的外键字段 
 			        		class: 关联的另一方的类型 -->
 			        	<many-to-many column="sid" class="Student"></many-to-many>
 			        </set>

 			    </class>
 			</hibernate-mapping>
 	3.测试
 		public class ManyToMany {
 			Session session;

 			@Before
 			public void startUp() {
 				Configuration configure = new Configuration().configure("hibernate.cfg.xml");
 				SessionFactory sf = configure.buildSessionFactory();
 				session = sf.openSession();
 			}
 			// 根据学生的id查询学生的基本信息以及学生选修的所有课程
 			@Test
 			public void getStuCous() {
 				Student stu = session.get(Student.class, 71503001);
 				System.out.println(stu.getSname());
 				Set<Course> cset = stu.getcSet();
 				for (Course c : cset) {
 					System.out.println(c.getCname());
 				}
 			}
 			// 让某个学生选修某门课程
 			@Test
 			public void tosc() {
 				Student stu = session.get(Student.class, 71503002);// 持久状态
 				Course course = session.get(Course.class, 1001);// 持久状态
 				stu.getcSet().add(course);
 				// course.getSset().add(stu);
 				// session.update(stu);
 				session.beginTransaction().commit();
 				session.close();
 			}
 		}
zxkzhang
关注
专栏目录
hibernate中的对象关系映射
08-29
【hibernate中的对象关系映射】是Java开发中一种重要的技术，它允许开发者使用面向对象的方式来处理数据库操作，从而避免了直接与SQL打交道的复杂性。Hibernate是Java领域的一个ORM框架，它提供了数据持久化的解决...
hibernate查询结果行转列
三狼编码
12-11 280
业务说明 对应的业务需求 每个X对应的每项Y的Z值，将Y作为行纬度将X作列纬度展示Z的值 举例：已知每个学生对应的每道题的得分 二纬表，转换为每道题每个学生的得分二纬表。 hibernate 查询sql对应的代码 String _sql = "select id, pm, yhdm, name, df from Student_Score"; //表说明： //Student_Score 每个学生每道题目的得分明细表 //id 为Student_Score 主键列 //pm 题目表的外键 //yhdm 学生
JAVAWEB开发之Hibernate详解（二）——Hibernate的持久化类状态与转换、以及一级缓存详解、关联关系的映射（一对多、多对多、级联）...
iteye_18817的博客
04-03 980
持久化对象的状态 Hibernate持久化对象存在三种状态： 瞬时态 transient:(临时态) 不存在持久化标识OID，尚未与Hibernate Session关联对象，被认为是瞬时状态，失去引用将被JVM回收。特点：无持久化标识OID，未与Session关联。 持久态 persistent:存在持久化标识OID，与当前Session有关联，并且相关联的Session没有关闭，并且事务未提交...
hibernate 列数据转换
weixin_43632687的博客
11-04 523
在需要转换的model字段上添加注释 @ColumnTransformer(read="kg*1000",write="?/1000") 表结构： model： @Entity @Table(name = "testguid") public class GUID implements Serializable { @Id @Column(name = "guid") @Generat...
Hibernate映射解析——七种映射关系
dengyll的专栏
07-19 488
首先我们了解一个名词ORM，全称是（Object Relational Mapping），即对象关系映射。ORM的实现思想就是将关系数据库中表的数据映射成对象，以对象的形式展现，这样开发人员就可以把对数据库的操作转化为对这些对象的操作。Hibernate正是实现了这种思想，达到了方便开发人员以面向对象的思想来实现对数据库的操作。 Hibernate在实现ORM功能的时候...
Hibernate的七种映射关系之七种关联映射（一）
weixin_34239169的博客
04-27 134
　　 　　关联映射就是将关联关系映射到数据库里，在对象模型中就是一个或多个引用。　　 　　一、Hibernate多对一关联映射：就是在“多”的一端加外键，指向“一”的一端。 　　比如多个学生对应一个班级，多个用户对应一个级别等等，都是多对一关系。 　　 　　1、“多”端实体加入引用“一”端实体的变量及getter,setter方法。 　　比如说多个学生对应一个班级，在学生实体类加入：p...
hibernate的关系映射
05-29
**二、Hibernate关系映射的类型** 1. **一对一（OneToOne）**: 表示一个实体对应另一个实体的唯一实例。这可以通过在两个类中都定义`@OneToOne`注解来实现，并通过`mappedBy`属性指定被引用的一方。 2. **一对多...
hibernate对象关系映射案例demo
最新发布
03-04
**hibernate对象关系映射案例demo** 在Java开发领域，对象关系映射（ORM）是一种将数据库中的数据与程序中的对象进行关联的技术，它极大地简化了数据操作。Hibernate作为一款流行的ORM框架，使得开发者无需关注底层...
Hibernate对象关系映射
08-27
Hibernate对象关系映射一对多 很基础等文档
hibernate的多种映射关系
07-08
Hibernate 是一个流行的对象关系映射（ORM）框架，它允许开发者使用 Java 对象来操作数据库，消除了直接编写 SQL 的需要。在 Hibernate 中，映射关系是将数据库表与 Java 类之间的关联方式，使得对象模型可以与关系...
SSH：Hibernate框架（七种关联关系映射及配置详解）
流年少年
11-27 1万+
概念          基本映射是对一个实体进行映射，关联映射就是处理多个实体之间的关系，将关联关系映射到数据库中，所谓的关联关系在对象模型中有一个或多个引用。   分类                                关联关系分为上述七种，但是由于相互之间有各种关系，可以简化，例如：多对一与一对多映射，只是侧重的角度不对而已。
hibernate 映射关系 一对多(多对一)
盖世小可爱的博客
09-10 943
一:一对多(多对一)关系 概念:一对多关系是关系型数据库中两个表之间的一种关系。通常在数据库层级中，两表之间是有主外键关系的。在ORM中，如何通过对象描述表之间的关系，是ORM核心。 2.Hibernate的一对多关联映射【重点】 eg:国家-&gt;省份-&gt;城市 (表设计) Nation.hbm.xml &lt;class name="com.zking.entity.N...
SSH框架之Hibernate的关联映射之一对多、多对一映射
一点一滴
12-19 1万+
关联映射之一对多、多对一映射 一、需求： 部门与员工 一个部门有多个员工 【一对多】 多个员工，属于一个部门 【多对一】 二、逻辑分析： 三、代码实现 1、javabean及映射文件的配置： 1）Employee.java、Employee.hbm.xml 2）Dept.java、Dept.hbm.xml
Hibernate关联映射（一对多/多对多）
热门推荐
知飞翀的博客
11-22 1万+
3.  Hibernate关联映射 上接Hibernate持久化类：https://blog.csdn.net/biggerchong/article/details/84260707 目录 3.  Hibernate关联映射 3.1 数据库表之间的关系 3.1.1 一对多关系 3.1.2 多对多关系 3.1.3 一对一关系（实际开发中使用较少） 3.2 实战Hibernate...
Hibernate中的映射关系（一）
阳
04-27 415
在Hibernate的学习中，最最主要的就是Hibernate中的几种常用的映射关系了。 （一）单项一对一的映射     案例：在生活中，我们每个人都有一个身份证号，所以当我们存储人和身份证号信息的时候就是一种一对一的映射关联关系： 实现方式的原理很简单，就是将Person表和IDCard表的主键设置成一致的，这样就可以使得Person表中的每条记录都与IDCard表中的记录唯一对应
Hibernate中的一对多关系映射
越是憧憬，越要风雨兼程
10-17 1991
Hibernate框架中关系映射中有：一对一、一对多和多对多，但常用的就是一对多，所以本篇博客就大体概述了一下一对多关系映射。 一对多关系： 例如：客户和订单，客户是一，订单是多 创建customers、orders数据表 在多方添加一方的外键 （在orders表添加customer_id） 建立多对一关系映射  ： 在 Order.hbm.xml 配置&lt;m...
Hibernate入门第九讲——数据库中表与表之间的关系
李阿昀的博客
04-12 5860
Hibernate关联映射——对象的三种关系Hibernate框架基于ORM设计思想，它将关系型数据库中的表与我们java中的类进行映射，一个对象就对应着表中的一条记录，而表中的字段对应着类中的属性。数据库中表与表之间存在着三种关系，也就是系统设计中的三种实体关系。下面进行简单阐述。一对一创建表的原则有两种： 唯一外键对应 在任意一方添加一个外键来描述对应关系。如下图所示： 或者 主键对应
浅谈JavaEE中的Hibernate中的四种关系映射(三)
Mikyou的专栏
07-10 4314
今天我们一起来探讨一下有关Hibernate四种关系映射，大家可能会有疑惑，关系映射不就是只有三种(一对一，一对多，多对多)吗？这里我们再多说一个继承映射关系，虽然它使用频繁度没有前三个那么多，但是它在一些特定情况下，还是非常有用的，至于有什么用下面马上就要讲。这些关系映射实际上就是对应着关系型数据库中的几种关系的类型。我们都知道Hibernate的作用是将面向关系数据操作，转换成面向对象的操作，
深入理解Hibernate对象关系映射（ORM）机制
"本文详细介绍了Hibernate中的对象关系映射(ORM)，包括ORM映射文件的使用、映射分类以及基本类映射的示例。" 在Java的持久化框架Hibernate中，对象关系映射（ORM）是核心功能之一，它允许开发者以面向对象的方式来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值