hibernate与JPA的基本使用及CRUD

Web服务器 专栏收录该内容
30 篇文章 0 订阅

JPA入门学习

ORM、hibernate、JPA概述

ORM(Object-Relational Mapping) 表示对象关系映射。在面向对象的软件开发中,通过ORM,就可以把对象映射到关系型数据库中。只要有一套程序能够做到建立对象与数据库的关联,操作对象就可以直接操作数据库数据,就可以说这套程序实现了ORM对象关系映射

简单的说:ORM就是建立实体类和数据库表之间的关系,从而达到操作实体类就相当于操作数据库表的目的。

为什么使用ORM

当实现一个应用程序时(不使用O/R Mapping),我们可能会写特别多数据访问层的代码,从数据库保存数据、修改数据、删除数据,而这些代码都是重复的。而使用ORM则会大大减少重复性代码。对象关系映射(Object Relational Mapping,简称ORM),主要实现程序对象到关系数据库数据的映射。

hibernate概述

Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

JPA概述

JPA的全称是Java Persistence API, 即Java 持久化API,是SUN公司推出的一套基于ORM的规范,内部是由一系列的接口和抽象类构成。

JPA通过JDK 5.0注解描述对象-关系表的映射关系,并将运行期的实体对象持久化到数据库中。

JPA规范本质上就是一种ORM规范,注意不是ORM框架——因为JPA并未提供ORM实现,它只是制订了一些规范,提供了一些编程的API接口,但具体实现则由服务厂商来提供实现。

JPA与hibernate的关系

JPA和Hibernate的关系就像JDBC和JDBC驱动的关系,JPA是规范,Hibernate除了作为ORM框架之外,它也是一种JPA实现。JPA怎么取代Hibernate呢?JDBC规范可以驱动底层数据库吗?答案是否定的,也就是说,如果使用JPA规范进行数据库操作,底层需要hibernate作为其实现类完成数据持久化工作。

JPA的入门案例

由于JPA是sun公司制定的API规范,所以我们不需要导入额外的JPA相关的jar包,只需要导入JPA的提供商的jar包。我们选择Hibernate作为JPA的提供商,所以需要导入Hibernate的相关jar包。

下载网址:

http://sourceforge.net/projects/hibernate/files/hibernate-orm/5.0.7.Final/

搭建开发环境

传统工程导入jar包、maven工程导入坐标

 <properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.hibernate.version>5.0.7.Final</project.hibernate.version>
	</properties>

	<dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
            <version>1.18.16</version>
        </dependency>
		<!-- junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>

		<!-- hibernate对jpa的支持包 -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-entitymanager</artifactId>
			<version>${project.hibernate.version}</version>
		</dependency>

		<!-- c3p0 -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-c3p0</artifactId>
			<version>${project.hibernate.version}</version>
		</dependency>

		<!-- log日志 -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>

		<!-- Mysql and MariaDB -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.6</version>
		</dependency>
	</dependencies>

创建客户的数据库表和客户的实体类

/*创建客户表*/
    CREATE TABLE cst_customer (
      cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
      cust_name varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
      cust_source varchar(32) DEFAULT NULL COMMENT '客户信息来源',
      cust_industry varchar(32) DEFAULT NULL COMMENT '客户所属行业',
      cust_level varchar(32) DEFAULT NULL COMMENT '客户级别',
      cust_address varchar(128) DEFAULT NULL COMMENT '客户联系地址',
      cust_phone varchar(64) DEFAULT NULL COMMENT '客户联系电话',
      PRIMARY KEY (`cust_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
public class Customer implements Serializable {
    
	private Long custId;
	private String custName;
	private String custSource;
	private String custIndustry;
	private String custLevel;
	private String custAddress;
	private String custPhone;
    //。。。
}

编写实体类和数据库表的映射配置

在实体类上使用JPA注解的形式配置映射关系

/**
*		* 所有的注解都是使用JPA的规范提供的注解,
 *		* 所以在导入注解包的时候,一定要导入javax.persistence下的
 */
@Data
@Entity //声明实体类
@Table(name="cst_customer") //建立实体类和表的映射关系
public class Customer {
	
	@Id//声明当前私有属性为主键
	@GeneratedValue(strategy=GenerationType.IDENTITY) //配置主键的生成策略
	@Column(name="cust_id") //指定和表中cust_id字段的映射关系
	private Long custId;
	
	@Column(name="cust_name") //指定和表中cust_name字段的映射关系
	private String custName;
	
	@Column(name="cust_source")//指定和表中cust_source字段的映射关系
	private String custSource;
	
	@Column(name="cust_industry")//指定和表中cust_industry字段的映射关系
	private String custIndustry;
	
	@Column(name="cust_level")//指定和表中cust_level字段的映射关系
	private String custLevel;
	
	@Column(name="cust_address")//指定和表中cust_address字段的映射关系
	private String custAddress;
	
	@Column(name="cust_phone")//指定和表中cust_phone字段的映射关系
	private String custPhone;
}
常用注解的说明
@Entity
	作用:指定当前类是实体类。
@Table
	作用:指定实体类和表之间的对应关系。
	属性:
	name:指定数据库表的名称
@Id
	作用:指定当前字段是主键。
@GeneratedValue
	作用:指定主键的生成方式。。
	属性:
	strategy :指定主键生成策略。
@Column
	作用:指定实体类属性和数据库表之间的对应关系
    属性:
    name:指定数据库表的列名称。
    unique:是否唯一  
    nullable:是否可以为空  
    inserttable:是否可以插入  
    updateable:是否可以更新  
    columnDefinition: 定义建表时创建此列的DDL  
    secondaryTable: 从表名。如果此列不建在主表上(默认建在主表),该属性定义该列所在从表的名字搭建开发环境

配置JPA的核心配置文件

在java工程的src路径下创建一个名为META-INF的文件夹,在此文件夹下创建一个名为persistence.xml的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence  
    http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
	version="2.0">
	<!--配置持久化单元 
		name:持久化单元名称 
		transaction-type:事务类型
		 	RESOURCE_LOCAL:本地事务管理 
		 	JTA:分布式事务管理 -->
	<persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
		<!--配置JPA规范的服务提供商 -->
		<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
		<properties>
			<!-- 数据库驱动 -->
			<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
			<!-- 数据库地址 -->
			<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/ssh" />
			<!-- 数据库用户名 -->
			<property name="javax.persistence.jdbc.user" value="root" />
			<!-- 数据库密码 -->
			<property name="javax.persistence.jdbc.password" value="root" />

			<!--jpa提供者的可选配置:我们的JPA规范的提供者为hibernate,所以jpa的核心配置中兼容hibernate的配 -->
			<property name="hibernate.show_sql" value="true" />
			<property name="hibernate.format_sql" value="true" />
			<property name="hibernate.hbm2ddl.auto" value="create" />
		</properties>
	</persistence-unit>
</persistence>

实现保存操作

	@Test
	public void test() {
		/**
		 * 创建实体管理类工厂,借助Persistence的静态方法获取
		 * 		其中传递的参数为持久化单元名称,需要jpa配置文件中指定
		 */
		EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
		//创建实体管理类
		EntityManager em = factory.createEntityManager();
		//获取事务对象
		EntityTransaction tx = em.getTransaction();
		//开启事务
		tx.begin();
		Customer c = new Customer();
		c.setCustName("sibd");
		//保存操作
		em.persist(c);
		//提交事务
		tx.commit();
		//释放资源
		em.close();
		factory.close();
	}

JPA中的主键生成策略

通过annotation(注解)来映射hibernate实体的,基于annotation的hibernate主键标识为@Id, 其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法。

JPA提供的四种标准用法为TABLE、SEQUENCE、IDENTITY、AUTO。

  • IDENTITY:主键由数据库自动生成(主要是自动增长型)

    • @Id  
      @GeneratedValue(strategy = GenerationType.IDENTITY) 
      private Long custId;
      
  • SEQUENCE:根据底层数据库的序列来生成主键,条件是数据库支持序列。

    • @Id  
      @GeneratedValue(strategy = GenerationType.SEQUENCE,generator="payablemoney_seq") 
      @SequenceGenerator(name="payablemoney_seq", sequenceName="seq_payment")  
      private Long custId;
      
      //@SequenceGenerator源码中的定义
          @Target({TYPE, METHOD, FIELD})   
          @Retention(RUNTIME)  
          public @interface SequenceGenerator {  
             //表示该表主键生成策略的名称,它被引用在@GeneratedValue中设置的“generator”值中
             String name();  
             //属性表示生成策略用到的数据库序列名称。
             String sequenceName() default "";  
             //表示主键初识值,默认为0
             int initialValue() default 0;  
             //表示每次主键值增加的大小,例如设置1,则表示每次插入新记录后自动加1,默认为50
             int allocationSize() default 50;  
          }
      
  • AUTO:主键由程序控制

    • @Id  
      @GeneratedValue(strategy = GenerationType.AUTO)  
      private Long custId;
      
  • TABLE:使用一个特定的数据库表格来保存主键

    •  	@Id  
          @GeneratedValue(strategy = GenerationType.TABLE, generator="payablemoney_gen")  
          @TableGenerator(name = "pk_gen",  
              table="tb_generator",  
              pkColumnName="gen_name",  
              valueColumnName="gen_value",  
              pkColumnValue="PAYABLEMOENY_PK",  
              allocationSize=1  
          ) 
      private Long custId;
      
      
      //@TableGenerator的定义:
          @Target({TYPE, METHOD, FIELD})   
          @Retention(RUNTIME)  
          public @interface TableGenerator {  
            //表示该表主键生成策略的名称,它被引用在@GeneratedValue中设置的“generator”值中
            String name();  
            //表示表生成策略所持久化的表名,例如,这里表使用的是数据库中的“tb_generator”。
            String table() default "";  
            //catalog和schema具体指定表所在的目录名或是数据库名
            String catalog() default "";  
            String schema() default "";  
            //属性的值表示在持久化表中,该主键生成策略所对应键值的名称。例如在“tb_generator”中将“gen_name”作为主键的键值
            String pkColumnName() default "";  
            //属性的值表示在持久化表中,该主键当前所生成的值,它的值将会随着每次创建累加。例如,在“tb_generator”中将“gen_value”作为主键的值 
            String valueColumnName() default "";  
            //属性的值表示在持久化表中,该生成策略所对应的主键。例如在“tb_generator”表中,将“gen_name”的值为“CUSTOMER_PK”。 
            String pkColumnValue() default "";  
            //表示主键初识值,默认为0。 
            int initialValue() default 0;  
            //表示每次主键值增加的大小,例如设置成1,则表示每次创建新记录后自动加1,默认为50。
            int allocationSize() default 50;  
            UniqueConstraint[] uniqueConstraints() default {};  
          } 
      
          //这里应用表tb_generator,定义为 :
          CREATE TABLE  tb_generator (  
            id NUMBER NOT NULL,  
            gen_name VARCHAR2(255) NOT NULL,  
            gen_value NUMBER NOT NULL,  
            PRIMARY KEY(id)  
          )
      

JPA的API介绍

Persistence对象

Persistence对象主要作用是用于获取EntityManagerFactory对象的 。通过调用该类的createEntityManagerFactory静态方法,根据配置文件中持久化单元名称创建EntityManagerFactory。

//1. 创建 EntitymanagerFactory
@Test
String unitName = "myJpa";
EntityManagerFactory factory= Persistence.createEntityManagerFactory(unitName);

EntityManagerFactory

EntityManagerFactory 接口主要用来创建 EntityManager 实例

//创建实体管理类
EntityManager em = factory.createEntityManager();

由于EntityManagerFactory 是一个线程安全的对象(即多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题),并且EntityManagerFactory 的创建极其浪费资源,所以在使用JPA编程时,我们可以对EntityManagerFactory 的创建进行优化,只需要做到一个工程只存在一个EntityManagerFactory 即可

EntityManager

在 JPA 规范中, EntityManager是完成持久化操作的核心对象。实体类作为普通 java对象,只有在调用 EntityManager将其持久化后才会变成持久化对象。EntityManager对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。

可以通过调用EntityManager的方法完成获取事务,以及持久化数据库的操作

方法说明:
    getTransaction : 获取事务对象
    persist : 保存操作
    merge : 更新操作
    remove : 删除操作
    find/getReference : 根据id查询

EntityTransaction

在 JPA 规范中, EntityTransaction是完成事务操作的核心对象,对于EntityTransaction在我们的java代码中承接的功能比较简单

在我们的java代码中承接的功能比较简单

begin:开启事务
commit:提交事务
rollback:回滚事务

抽取JPAUtil工具类

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public final class JPAUtil {
	// JPA的实体管理器工厂:相当于Hibernate的SessionFactory
	private static EntityManagerFactory em;
	// 使用静态代码块赋值
	static {
		// 注意:该方法参数必须和persistence.xml中persistence-unit标签name属性取值一致
		em = Persistence.createEntityManagerFactory("myPersistUnit");
	}

	/**
	 * 使用管理器工厂生产一个管理器对象
	 * 
	 * @return
	 */
	public static EntityManager getEntityManager() {
		return em.createEntityManager();
	}
}

使用JPA完成增删改查操作

保存

/**
	 * 保存一个实体
	 */
	@Test
	public void testAdd() {
		// 定义对象
		Customer c = new Customer();
		c.setCustName("sibd学院");
		c.setCustLevel("VIP客户");
		c.setCustSource("网络");
		c.setCustIndustry("IT教育");
		c.setCustAddress("昌平区北七家镇");
		c.setCustPhone("010-84389340");
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			// 获取实体管理对象
			em = JPAUtil.getEntityManager();
			// 获取事务对象
			tx = em.getTransaction();
			// 开启事务
			tx.begin();
			// 执行操作
			em.persist(c);
			// 提交事务
			tx.commit();
		} catch (Exception e) {
			// 回滚事务
			tx.rollback();
			e.printStackTrace();
		} finally {
			// 释放资源
			em.close();
		}
	}

修改

 @Test
    public void testMerge(){  
        //定义对象
        EntityManager em=null;  
        EntityTransaction tx=null;  
        try{  
          	//获取实体管理对象
          	em=JPAUtil.getEntityManager();
          	//获取事务对象
          	tx=em.getTransaction();
          	//开启事务
          	tx.begin();
          	//执行操作
          	Customer c1 = em.find(Customer.class, 6L);
          	c1.setCustName("sibd学院");
         	em.clear();//把c1对象从缓存中清除出去
            //用于实体的插入和更新操作
          	em.merge(c1);
          	//提交事务
          	tx.commit(); 
        }catch(Exception e){
          	//回滚事务
          	tx.rollback();
          	e.printStackTrace();  
        }finally{  
        	//释放资源
        	em.close();  
        }    
    }

删除

	/**
	 * 删除
	 */
	@Test
	public void testRemove() {
		// 定义对象
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			// 获取实体管理对象
			em = JPAUtil.getEntityManager();
			// 获取事务对象
			tx = em.getTransaction();
			// 开启事务
			tx.begin();
			// 执行操作
			Customer c1 = em.find(Customer.class, 6L);
			em.remove(c1);
			// 提交事务
			tx.commit();
		} catch (Exception e) {
			// 回滚事务
			tx.rollback();
			e.printStackTrace();
		} finally {
			// 释放资源
			em.close();
		}
	}

根据id查询

/**
	 * 查询一个: 使用立即加载的策略
	 */
	@Test
	public void testGetOne() {
		// 定义对象
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			// 获取实体管理对象
			em = JPAUtil.getEntityManager();
			// 获取事务对象
			tx = em.getTransaction();
			// 开启事务
			tx.begin();
			// 执行操作
			Customer c1 = em.find(Customer.class, 1L);
			// 提交事务
			tx.commit();
			System.out.println(c1); // 输出查询对象
		} catch (Exception e) {
			// 回滚事务
			tx.rollback();
			e.printStackTrace();
		} finally {
			// 释放资源
			em.close();
		}
	}

	// 查询实体的缓存问题
	@Test
	public void testGetOne() {
		// 定义对象
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			// 获取实体管理对象
			em = JPAUtil.getEntityManager();
			// 获取事务对象
			tx = em.getTransaction();
			// 开启事务
			tx.begin();
			// 执行操作
			Customer c1 = em.find(Customer.class, 1L);
			Customer c2 = em.find(Customer.class, 1L);
			System.out.println(c1 == c2);// 输出结果是true,EntityManager也有缓存
			// 提交事务
			tx.commit();
			System.out.println(c1);
		} catch (Exception e) {
			// 回滚事务
			tx.rollback();
			e.printStackTrace();
		} finally {
			// 释放资源
			em.close();
		}
	}

	// 延迟加载策略的方法:
	/**
	 * 查询一个: 使用延迟加载策略
	 */
	@Test
	public void testLoadOne() {
		// 定义对象
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			// 获取实体管理对象
			em = JPAUtil.getEntityManager();
			// 获取事务对象
			tx = em.getTransaction();
			// 开启事务
			tx.begin();
			// 执行操作
			Customer c1 = em.getReference(Customer.class, 1L);
			// 提交事务
			tx.commit();
			System.out.println(c1);
		} catch (Exception e) {
			// 回滚事务
			tx.rollback();
			e.printStackTrace();
		} finally {
			// 释放资源
			em.close();
		}
	}

JPA中的复杂查询

JPQL全称Java Persistence Query Language

基于首次在EJB2.0中引入的EJB查询语言(EJB QL),Java持久化查询语言(JPQL)是一种可移植的查询语言,旨在以面向对象表达式语言的表达式,将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的,可以被编译成所有主流数据库服务器上的SQL。

其特征与原生SQL语句类似,并且完全面向对象,通过类名和属性访问,而不是表名和表的属性。

查询全部

//查询所有客户
	@Test
	public void findAll() {
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			//获取实体管理对象
			em = JPAUtil.getEntityManager();
			//获取事务对象
			tx = em.getTransaction();
			tx.begin();
			// 创建query对象
			String jpql = "from Customer";
			Query query = em.createQuery(jpql);
			// 查询并得到返回结果
			List list = query.getResultList(); // 得到集合返回类型
			for (Object object : list) {
				System.out.println(object);
			}
			tx.commit();
		} catch (Exception e) {
			// 回滚事务
			tx.rollback();
			e.printStackTrace();
		} finally {
			// 释放资源
			em.close();
		}
	}

分页查询

//分页查询客户
	@Test
	public void findPaged () {
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			//获取实体管理对象
			em = JPAUtil.getEntityManager();
			//获取事务对象
			tx = em.getTransaction();
			tx.begin();

			//创建query对象
			String jpql = "from Customer";
			Query query = em.createQuery(jpql);
			//起始索引
			query.setFirstResult(0);
			//每页显示条数
			query.setMaxResults(2);
			//查询并得到返回结果
			List list = query.getResultList(); //得到集合返回类型
			for (Object object : list) {
				System.out.println(object);
			}
			tx.commit();
		} catch (Exception e) {
			// 回滚事务
			tx.rollback();
			e.printStackTrace();
		} finally {
			// 释放资源
			em.close();
		}
	}

条件查询

//条件查询
	@Test
	public void findCondition () {
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			//获取实体管理对象
			em = JPAUtil.getEntityManager();
			//获取事务对象
			tx = em.getTransaction();
			tx.begin();
			//创建query对象
			String jpql = "from Customer where custName like ? ";
			Query query = em.createQuery(jpql);
			//对占位符赋值,从1开始
			query.setParameter(1, "sibd%");
			//查询并得到返回结果
			Object object = query.getSingleResult(); //得到唯一的结果集对象
			System.out.println(object);
			tx.commit();
		} catch (Exception e) {
			// 回滚事务
			tx.rollback();
			e.printStackTrace();
		} finally {
			// 释放资源
			em.close();
		}
	}

排序查询

//根据客户id倒序查询所有客户
	//查询所有客户
	@Test
	public void testOrder() {
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			//获取实体管理对象
			em = JPAUtil.getEntityManager();
			//获取事务对象
			tx = em.getTransaction();
			tx.begin();
			// 创建query对象
			String jpql = "from Customer order by custId desc";
			Query query = em.createQuery(jpql);
			// 查询并得到返回结果
			List list = query.getResultList(); // 得到集合返回类型
			for (Object object : list) {
				System.out.println(object);
			}
			tx.commit();
		} catch (Exception e) {
			// 回滚事务
			tx.rollback();
			e.printStackTrace();
		} finally {
			// 释放资源
			em.close();
		}
	}

统计查询

//统计查询
	@Test
	public void findCount() {
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			//获取实体管理对象
			em = JPAUtil.getEntityManager();
			//获取事务对象
			tx = em.getTransaction();
			tx.begin();
			// 查询全部客户
			// 1.创建query对象
			String jpql = "select count(custId) from Customer";
			Query query = em.createQuery(jpql);
			// 2.查询并得到返回结果
			Object count = query.getSingleResult(); // 得到集合返回类型
			System.out.println(count);
			tx.commit();
		} catch (Exception e) {
			// 回滚事务
			tx.rollback();
			e.printStackTrace();
		} finally {
			// 释放资源
			em.close();
		}
	}
  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 打赏
    打赏
  • 扫一扫,分享海报

©️2022 CSDN 皮肤主题:游动-白 设计师:我叫白小胖 返回首页

打赏作者

小孩与狗

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值