SpringBoot整合SpringData JPA

最新推荐文章于 2024-05-29 11:53:10 发布
最新推荐文章于 2024-05-29 11:53:10 发布
阅读量193 收藏
点赞数
分类专栏： # SpringBoot # SpringData 文章标签： SpringBoot SpringData JPA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rj2017211811/article/details/96437853
版权

1.创建maven项目，编写pom.xml文件

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.2.RELEASE</version>

	</parent>
	<groupId>per.czt</groupId>
	<artifactId>22-spring-boot-jpa</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>22-spring-boot-jpa</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<dependencies>


		<!-- web -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!-- thymeleaf -->

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
		</dependency>
		<!-- Spring Data JPA -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<!-- junit环境的jar包 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
		</dependency>

		<!-- mysql数据库驱动 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>8.0.13</version>
		</dependency>

		<!-- druid数据库连接池 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.17</version>
		</dependency>

		<!-- jaxb-api -->
		<dependency>
			<groupId>javax.xml.bind</groupId>
			<artifactId>jaxb-api</artifactId>
			<version>2.2.4</version>
		</dependency>
		<!-- jaxb-core -->
		<dependency>
			<groupId>org.glassfish.jaxb</groupId>
			<artifactId>jaxb-core</artifactId>
			<version>2.3.0</version>
		</dependency>
		<!-- jaxb-impl -->
		<dependency>
			<groupId>javax.xml</groupId>
			<artifactId>jaxb-impl</artifactId>
			<version>2.1</version>
		</dependency>
		<!-- javax.activation-api -->
		<dependency>
			<groupId>javax.activation</groupId>
			<artifactId>javax.activation-api</artifactId>
			<version>1.2.0</version>
		</dependency>





	</dependencies>
</project>

2.编写application.properties文件
application.properties

spring.datasource.driverName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/springbootjpa?serverTimezone=UTC&charset=UTF-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=200934652qwe
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

3.测试
(1)五个接口
前四个接口就不测试了，这里只给出JpaRepository和JpaSepcificationExecutor接口的测试
编写个接口继承JpaRepository和JpaSepcificationExecutor接口
UserRepositorySpecificationExecutor.java

package per.czt.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

import per.czt.pojo.Users;

public interface UsersRepositoryJpaSpecificationExecutor extends JpaRepository<Users, Integer>,JpaSpecificationExecutor<Users>{

}

测试类
UsersRepositoryJpaSpecificationExecutorTest.java

package per.czt.test;

import java.util.List;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import per.czt.dao.UsersRepositoryJpaSpecificationExecutor;
import per.czt.pojo.Users;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class UsersRepositoryJpaSpecificationExecutorTest {

	@Autowired
	private UsersRepositoryJpaSpecificationExecutor usersRepositoryJpaSpecificationExecutor;
	/*
	*多条件查询+分页+排序
	*/
	@Test
	public void test1() {
		Specification<Users> spec=new Specification<Users>() {

			@Override
			public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
				// TODO Auto-generated method stub
				return cb.and(cb.notEqual(root.get("username"), "xiaoming"),cb.isNotNull(root.get("username")));
			}
			
		};
		Order order1=new Order(Direction.ASC,"username");
		Order order2=new Order(Direction.ASC,"userage");
		Sort sort =new Sort(order1,order2);
		int page=0;
		int pageSize=1;
		
		Pageable pageable=new PageRequest(page, pageSize, sort);
		Page<Users> pages=usersRepositoryJpaSpecificationExecutor.findAll(spec, pageable);
		for(Users users:pages.getContent()) {
			System.out.println(users);
		}
		
	}
}

(2)一对多关系
Users.java

package per.czt.pojo;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name="t_users")
public class Users {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="user_id")
	private Integer userid;
	@Column(name="user_name")
	private String username;
	@Column(name="user_age")
	private Integer userage;
	@Column(name="user_address")
	private String useraddress;
	
	@ManyToOne(cascade=CascadeType.PERSIST,fetch=FetchType.EAGER)
	@JoinColumn(name="roles_id")
	private Roles roles;
	public Roles getRoles() {
		return roles;
	}

	public void setRoles(Roles roles) {
		this.roles = roles;
	}

	public Integer getUserid() {
		return userid;
	}

	public void setUserid(Integer userid) {
		this.userid = userid;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public Integer getUserage() {
		return userage;
	}

	public void setUserage(Integer userage) {
		this.userage = userage;
	}

	public String getUseraddress() {
		return useraddress;
	}

	public void setUseraddress(String useraddress) {
		this.useraddress = useraddress;
	}

	public Users() {
		super();
		// TODO Auto-generated constructor stub
	}

	@Override
	public String toString() {
		return "Users [userid=" + userid + ", username=" + username + ", userage=" + userage + ", useraddress="
				+ useraddress + ", roles=" + roles + "]";
	}

	

	
	

}

Roles.java

package per.czt.pojo;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;
@Entity
@Table(name="t_roles")
public class Roles implements Serializable {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="role_id")
	private Integer roleid;
	@Column(name="role_name")
	private String rolename;
	
	@OneToMany(mappedBy="roles",cascade=CascadeType.PERSIST,fetch=FetchType.EAGER)
	private Set<Users> usersSet=new HashSet<Users>();
	

	
	
	public Set<Users> getUsersSet() {
		return usersSet;
	}
	public void setUsersSet(Set<Users> usersSet) {
		this.usersSet = usersSet;
	}
	public Integer getRoleid() {
		return roleid;
	}
	public void setRoleid(Integer roleid) {
		this.roleid = roleid;
	}
	public String getRolename() {
		return rolename;
	}
	public void setRolename(String rolename) {
		this.rolename = rolename;
	}
	@Override
	public String toString() {
		return "Roles [roleid=" + roleid + ", rolename=" + rolename + "]";
	}
	public Roles() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	

}

测试代码:
OneToManyTest.java

package per.czt.test;

import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import per.czt.App;
import per.czt.dao.UsersRepositoryJpaRepository;
import per.czt.pojo.Roles;
import per.czt.pojo.Users;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes= {App.class})
public class OneToManyTest {
	
	@Autowired
	private UsersRepositoryJpaRepository usersRepositoryJpaRepository;
	/*
	 * 添加
	 */
	@Test
	public void test1() {
		
		Roles roles=new Roles();
		roles.setRolename("管理员");
		
		Users users=new Users();
		users.setUseraddress("山东省");
		users.setUserage(11);
		users.setUsername("李四");
		
		users.setRoles(roles);
		roles.getUsersSet().add(users);
		
		usersRepositoryJpaRepository.save(users);
	}
	/*
	 * 查询
	 */
	@Test
	public void test2() {
		List<Users> usersList=usersRepositoryJpaRepository.findAll();
		for(Users users:usersList) {
			System.out.println(users);
		}
	}
}

(3)多对多关系
假设roles和menus是多对多关系
Roles.java

package per.czt.pojo;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;
@Entity
@Table(name="t_roles")
public class Roles implements Serializable {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="role_id")
	private Integer roleid;
	@Column(name="role_name")
	private String rolename;
	
	@OneToMany(mappedBy="roles",cascade=CascadeType.PERSIST,fetch=FetchType.EAGER)
	private Set<Users> usersSet=new HashSet<Users>();
	
	@ManyToMany(cascade=CascadeType.PERSIST,fetch=FetchType.EAGER)
	@JoinTable(name="t_roles_menus",joinColumns=@JoinColumn(name="roles_id"),inverseJoinColumns=@JoinColumn(name="menus_id"))
	private Set<Menus> menusSet=new HashSet<Menus>();
	
	
	public Set<Users> getUsersSet() {
		return usersSet;
	}
	public void setUsersSet(Set<Users> usersSet) {
		this.usersSet = usersSet;
	}
	public Integer getRoleid() {
		return roleid;
	}
	public void setRoleid(Integer roleid) {
		this.roleid = roleid;
	}
	public String getRolename() {
		return rolename;
	}
	public void setRolename(String rolename) {
		this.rolename = rolename;
	}
	@Override
	public String toString() {
		return "Roles [roleid=" + roleid + ", rolename=" + rolename + "]";
	}
	public Roles() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Set<Menus> getMenusSet() {
		return menusSet;
	}
	public void setMenusSet(Set<Menus> menusSet) {
		this.menusSet = menusSet;
	}
	

}

Menus.java

package per.czt.pojo;

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

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Entity
@Table(name="t_menus")
public class Menus {
	

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="menu_id")
	private Integer menuid;
	@Column(name="menu_name")
	private String menuname;
	@Column(name="menu_url")
	private String menuurl;
	@Column(name="father_id")
	private Integer fatherid;
	@ManyToMany(mappedBy="menusSet",cascade=CascadeType.PERSIST,fetch=FetchType.EAGER)
	private Set<Roles> rolesSet=new HashSet<Roles>();
	public Integer getMenuid() {
		return menuid;
	}
	public void setMenuid(Integer menuid) {
		this.menuid = menuid;
	}
	public String getMenuname() {
		return menuname;
	}
	public void setMenuname(String menuname) {
		this.menuname = menuname;
	}
	public String getMenuurl() {
		return menuurl;
	}
	public void setMenuurl(String menuurl) {
		this.menuurl = menuurl;
	}
	public Integer getFatherid() {
		return fatherid;
	}
	public void setFatherid(Integer fatherid) {
		this.fatherid = fatherid;
	}
	public Set<Roles> getRolesSet() {
		return rolesSet;
	}
	public void setRolesSet(Set<Roles> rolesSet) {
		this.rolesSet = rolesSet;
	}
	@Override
	public String toString() {
		return "Menus [menuid=" + menuid + ", menuname=" + menuname + ", menuurl=" + menuurl + ", fatherid=" + fatherid
				+ "]";
	}
	

}

RolesRepository.java

package per.czt.dao;

import org.springframework.data.jpa.repository.JpaRepository;

import per.czt.pojo.Roles;

public interface RolesRepository extends JpaRepository<Roles, Integer>{

}

多对多测试
ManyToManyTest,java

package per.czt.test;

import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import per.czt.App;
import per.czt.dao.RolesRepository;
import per.czt.dao.UsersRepositoryJpaRepository;
import per.czt.pojo.Menus;
import per.czt.pojo.Roles;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes= {App.class})
public class ManyToManyTest {
	@Autowired
	private RolesRepository rolesRepository;
	/*
	 * 添加
	 */
	/*@Test
	public void test1() {
		
		Roles roles=new Roles();
		roles.setRolename("管理员");
		
		Menus menus=new Menus();
		menus.setFatherid(1);
		menus.setMenuname("xx管理");
		menus.setMenuurl(null);
		
		Menus menus1=new Menus();
		menus1.setFatherid(2);
		menus1.setMenuname("aa管理");
		menus1.setMenuurl(null);
		
		menus.getRolesSet().add(roles);
		
		menus1.getRolesSet().add(roles);
	
		roles.getMenusSet().add(menus1);
		roles.getMenusSet().add(menus);
		
		rolesRepository.save(roles);
		
	}*/
	/*
	 * 查询
	 */
	@Test
	public void test2() {
		List<Roles> rolesList=rolesRepository.findAll();
		for(Roles roles:rolesList) {
			System.out.println(roles);
			System.out.println(roles.getMenusSet());
		}
	}

}
I like study.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot 整合SpringData JPA
我爱吃红薯的博客
07-08 137
1，导入starter 1.1，或者直接在pom中导入相关依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</...
SpringBoot整合Spring Data JPA
淮右布衣的博客
03-16 110
1.添加Spring Data JPA的起步依赖 <!-- springBoot JPA的起步依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifa...
SpringBoot 一文搞懂Spring JPA
matafeiyanll的博客
05-06 1万+
一文搞懂Spring JPA 什么是 JPA spirng data jpa是spring提供的一套简化JPA开发的框架，按照约定好的【方法命名规则】写dao层接口，就可以在不写接口实现的情况下，实现对数据库的访问和操作。同时提供了很多除了CRUD之外的功能，如分页、排序、复杂查询等等。 Spring Data JPA 可以理解为 JPA 规范的再次封装抽象，底层还是使用了 Hibernate 的 JPA 技术实现。 Springboot整合SpringData JPA SpringData简介 整合Sp
SpringBoot整合JPA
YIYIYI
07-22 7515
SpringBoot整合JPA
SpringBoot——集成Spring Data JPA保存数据
最新发布
戏拈秃笔的博客
05-29 862
Spring Boot整合JPA（Java Persistence API）是一种常见的方式，用于在Spring应用程序中实现持久化和数据库访问
【SpringBoot新手篇】SpringBoot集成JPA
输入技术、输出想法
04-30 2854
SpringBoot整合JPASpring Boot Jpa 介绍首先了解 Jpa 是什么？Spring Data JPA特征整合SpringData JPAPomymlentityRepositoryUserServiceUserServiceImplcontroller首页展示高级查询功能预先生成方法自定义简单查询复杂查询分页查询限制查询 Spring Boot Jpa 介绍 首先了解 Jpa 是什么？ Jpa (Java Persistence API)是 Sun官方提出的Java 持久化规范。它为
Spring Boot(三)：Spring Boot Jpa的介绍及Jpa的使用
weixin_52841956的博客
01-13 8015
Spring Boot Jpa 介绍 首先了解 Jpa 是什么？ Jpa (Java Persistence API) 是 Sun 官方提出的 Java 持久化规范。它为 Java 开发人员提供了一种对象/关联映射工具来管理 Java 应用中的关系数据。它的出现主要是为了简化现有的持久化开发工作和整合 ORM 技术，结束现在 Hibernate，TopLink，JDO 等 ORM 框架各自为营的局面。 值得注意的是，Jpa是在充分吸收了现有 Hibernate，TopLink，JDO 等 ORM 框架的基础
springboot整合jpa，步骤详细（图文结合讲解）
热门推荐
weixin_43442127的博客
08-27 2万+
编译器Intellij IDEA 关系型数据库MySql 5.7 对象关系映射框架JPA 首先新建springboot工程，取名为springbootjpa，设置好java版本后点击next
springBoot整合springData JPA
08-18
**SpringBoot整合SpringData JPA** 是一个现代Java开发中的常见技术栈，它结合了Spring Boot的便捷性和Spring Data JPA的数据访问效率。Spring Boot简化了应用的初始搭建以及配置，而Spring Data JPA则是Spring ...
idea下整合springboot+spring data jpa
02-02
本文将详细介绍如何在IntelliJ IDEA（idea）环境下整合Spring Boot和Spring Data JPA。 首先，我们需要创建一个新的Spring Boot项目。打开IntelliJ IDEA，选择"New Project"，然后选择"Spring Initializr"。在...
SpringBoot如何整合SpringDataJPA
08-24
在使用SpringBoot整合SpringDataJPA之前，需要在pom.xml文件中添加相关依赖。这些依赖包括SpringBoot的Web依赖、SpringDataJPA依赖、MySQL连接依赖和Fastjson依赖。这些依赖都是将SpringBoot与SpringDataJPA进行整合...
SpringBoot集成Spring Data JPA及读写分离
08-30
SpringBoot集成Spring Data JPA及读写分离是现代Java Web应用程序中常见的技术组合，用于高效地管理和处理数据库操作。Spring Boot简化了应用的初始化和配置，而Spring Data JPA则进一步降低了使用Java Persistence ...
Spring Boot整合Spring Data Jpa代码实例
08-25
Spring Boot 整合 Spring Data Jpa 代码实例 以下是对 Spring Boot 整合 Spring Data Jpa 代码实例的详细知识点解释： 一、Spring Data Jpa 简介 Spring Data Jpa 是 Spring Framework 提供的一个操作数据的框架...
Spring Boot整合SpringDataJPA
01-07
本教程将深入探讨如何在Spring Boot项目中整合Spring Data JPA，实现高效且简洁的数据持久化。 首先，Spring Boot整合Spring Data JPA的基础是引入相关的依赖。在`pom.xml`或`build.gradle`文件中，我们需要添加...
springboot+spring data jpa+thymeleaf学习web项目整合demo源码
10-30
在 "springboot+spring data jpa+thymeleaf学习web项目整合demo源码" 中，我们可以学习到以下几个关键知识点： 1. **Spring Boot 整合**：Spring Boot 可以与多个框架集成，如 Spring MVC、Spring Data 和 ...
SpringBoot整合spring-data-jpa的方法
08-19
SpringBoot整合spring-data-jpa的方法 SpringBoot是一个基于Java的微服务框架，而spring-data-jpa是Spring基于Java持久层（Java Persistence API，简称JPA）的一种实现。spring-data-jpa提供了一个简洁的方式来访问...
SpringBoot环境下JPA的使用
m0_49261516的博客
10-09 1124
SpringBoot整合jpa的使用，快速上手
使用Hibernate连接MySQL
ljh_learn_from_base的博客
05-30 517
hibernate.cfg.xmlxml version="1.0" encoding="UTF-8"?>DOCTYPE hibernate-configuration PUBLIC          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"          "http://hibernate.sourceforge.net/hiber
Spring Boot整合JPA
梁辰兴的博客
06-13 3872
创建文章仓库接口ArticleRepository/*** 功能：文章仓库接口* 日期：2023年06月13日* 作者：梁辰兴/*** 根据文章ID进行分页查询评论* nativeQuery = true, 表示使用原生SQL语句，否则使用HQL语句* @param aId 查询条件字段（文章编号）* @param pageable 可分页对象，分页查询需要该参数* @return 返回page对象，包含page的相关信息及查询结果集/*** 根据文章ID进行分页查询评论。
SpringBoot整合SpringDataJPA实战教程
内容涵盖SpringDataJPA的介绍、SpringBoot如何整合SpringDataJPA，以及相关的代码示例。" SpringDataJPA是SpringData框架的一个子项目，它基于Java Persistence API (JPA)标准，为数据访问提供了统一的接口，极大地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值