SpringDataJPA的集成

最新推荐文章于 2024-09-27 10:14:30 发布
最新推荐文章于 2024-09-27 10:14:30 发布
阅读量280 收藏
点赞数 3
分类专栏： JavaJpa Java JavaSpringJPA JavaSpringDataJPA JPA Java技术 计算机 开发 编程 后端 文章标签： JPA JavaJPA JavaSpringJPA JavaSpringDataJPA JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/WinerCode/article/details/95109015
版权

1.SpringDataJpa

1.1.SpringDataJpa的概念

它是JPA规范的再次封装抽象，底层使用了Hibernate的JPA技术实现，引用JPQL的查询语句 ，属于JavaSpring的生成体系中的一部分。SpringDataJpa上手简单，使用起来方便，开发效率高，使开发人员不需要关心和配置更多的东西。并且SpringDataJpa对对象的支持非常好，还十分的灵活。

1.2.SpringDataJpa的结构

JavaSprangDataJPA结构图

通过Intellij Idea,打开SimpleJpaRepository.java文件,单击鼠标右键show diagrams，就可以以图表的形式打开与查询类的关系层次图)。图中的实线表示继承（extends），虚线表示的是实现（implement）

2.SpringDataJPA集成项目的创建

 2.1 创建maven结构项目并引入所需要的包

 2.2 配置applicationContext.xml文件

                2.2.1   导入资源文件

                2.2.2   配置DataSource

                2.2.3   配置entityManagerFactory

                2.2.4   开启事物扫描支持

                2.2.5   SpringDataJpa的扫描

         2.3 准备一个用来存放类的Domain包

              2.3.1  父类:BaseDomain

package cn.itsource.pss.domain;

import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;

@MappedSuperclass
// 在JPA里面就表示是父类，不持久化到表
public class BaseDomain {
    @Id
    @GeneratedValue
    protected Long id;
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
}

             2.3.2  子类:Employee

@Entity
@Table(name="employee")
public class Employee extends  BaseDomain {

    private String username;
    private String password;
    private String email; 
    private Integer age;
   //省略getter,setter与toString(注意:Alt+Insert可以自动生成)
}

2.4 完成Repository的功能

package cn.itsource.pss.repository;

import cn.itsource.pss.domain.Employee;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * 必需继续JpaRepository<1v,2v>
 *     1v:代表你要操作的是哪一个domain对象
 *     2v:这个domain对象的主键的类型
 */
public interface EmployeeRepository extends JpaRepository<Employee, Long> {
}

 2.5 测试集成是否成功

package cn.itsource.repository;

import cn.itsource.pss.domain.Employee;
...
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class EmployeeRepositoryTest  {
    @Autowired
    private EmployeeRepository employeeRepository;
    @Test
    public void testFind() throws Exception{
        List<Employee> emps = employeeRepository.findAll();
        for (Employee emp :emps){
            System.out.println(emp);
        }
    }
}

3.JpaRepository的基本功能

3.1普通的CRUD

//获取所有数据
@Test
public void testFindAll() throws Exception{
    List<Employee> emps = employeeRepository.findAll();
    for (Employee emp :emps){
        System.out.println(emp);
    }
}
//根据id到一条数据
@Test
public void testFindOne() throws Exception{
    Employee employee = employeeRepository.findOne(1L);
    System.out.println(employee);
}

//添加与修改都使用save(主要看对象有没有id)
@Test
public void testSave() throws Exception{
    Employee employee = new Employee();
    //employee.setId(103L);
    employee.setUsername("张三");
    employee.setPassword("1234");
    employee.setEmail("zhangsha@163.com");
    employeeRepository.save(employee);
}
//删除数据
@Test
public void testDelete() throws Exception{
    employeeRepository.delete(103L);
}
//得到总条数
@Test
public void testCount(){
    System.out.println(employeeRepository.count());
}

3.2分页排序功能

//进行分页功能
@Test
public void testPage() {
    //1.需要先创建一个page对象(注意：页数是从0开始计算【0就是第1页】)
    Pageable pageable = new PageRequest(0, 10);
    //2.进行查询
    Page<Employee> page = employeeRepository.findAll(pageable);
    System.out.println(page.getTotalElements()); //总条数
    System.out.println(page.getTotalPages()); //总页数
    System.out.println(page.getContent()); //当前页数据
    System.out.println(page.getNumber()); //第几页
    System.out.println(page.getNumberOfElements()); //当前页有多少个数据
    System.out.println(page.getSize()); //每页条数
}

//进行排序功能
@Test
public void testSort() {
    //排序 ：第一个参数是排序的规则(DESC/ASC)  后面参数是排序的字符
    Sort sort = new Sort(Sort.Direction.DESC,"username");
    List<Employee> emps = employeeRepository.findAll(sort);
    for (Employee emp : emps) {
        System.out.println(emp);
    }
}

//分页与排序的集成
@Test
public void testPageAndSort() {
    //排序 ：第一个参数是排序的规则(DESC/ASC)  后面参数是排序的字符
    Sort sort = new Sort(Sort.Direction.DESC,"username");
    Pageable pageable = new PageRequest(0, 10,sort);
    //2.进行查询
    Page<Employee> page = employeeRepository.findAll(pageable);
    for (Employee employee : page) {
        System.out.println(employee);
    }
}

3.3根据条件进行查询

按照规范创建查询方法，一般按照java驼峰式书写规范加一些特定关键字，例如我们想通过员工的名来获取到对应的员工的对象。

public interface EmployeeRepository extends JpaRepository<Employee, Long> {
    //根据名称模糊查询
    List<Employee> findByUsernameLike(String username);
    //根据名称进行查询
    List<Employee> findByUsername(String username);
}

这种方案看起来有意思，但是功能它都只针对简单的单表查询(而且如果条件太多，这个名称还是比较麻烦)，如果遇到复杂的查询，还有方案就显得力不从心了。

3.4@Query注解查询

在Respository方法中一定要按照查询方法的命名规则，其实是比较麻烦的如果我们想不遵循 查询方法的命名规则，还可以使用@Query的方法进行查询。

只需要将@Query定义在Respository的方法之上即可。

例如:根据用户名和密码拿到相应的员工
根据参数顺序
@Query("select o from cn.itsource.pss.domain.Employee o where  o.username like ?1 and o.email like ?2")
List<Employee> query02(String username,String email);

根据参数名称
@Query("select o from cn.itsource.pss.domain.Employee o where  o.username like :username and o.email like :email")
List<Employee> query03(@Param("username") String username,@Param("email")  String email);

Query的注解注入非常灵活，在开发中也经常使用到(只是写JPQL/SQL有点麻烦)。

4.JpaSpecificationExecutor的认识

JpaSpecificationExecutor(JPA规则执行者)是JPA2.0提供的Criteria API的使用封装，可以用于动态生成Query来满足我们业务中的各种复杂场景。

Spring Data JPA为我们提供了JpaSpecificationExecutor接口，只要简单实现toPredicate方法就可以实现复杂的查询。

4.1单个条件的查询

@Test
public void testFind() {
    /**
*官方解释:
     * Root<T> root:代表了可以查询和操作的实体对象的根，
     *              可以通过它的 Path<Y> get(String attributeName); 这个方法拿到我们要操作的字段
     *              注意:只可以拿到对应的T的字段(Employee)
     * CriteriaQuery<?> query:代表一个specific的顶层查询对象
     *              包含查询的各个部分,比如select,from,where,group by ,order by 等
     *              简单理解 就是它提供 了查询ROOT的方法(where,select,having)
     * CriteriaBuilder cb:用来构建CriteriaQuery的构建器对象(相当于条件或者说条件组合)
     *              构造好后以Predicate的形式返回
     */
/**
* 非官方理解:
 * 查询的时候就需要给一个标准（规范）
 *  -》 根据规范（这个规范我们可以先简单理解为查询的条件）进行查询
 *
 *      Root：查询哪个表（定位到表和字段-> 用于拿到表中的字段）
 *            可以查询和操作的实体的根
 *              Root接口：代表Criteria查询的根对象，Criteria查询的查询根定义了实体类型，能为将来导航获得想要的结果，它与SQL查询中的FROM子句类似
 *             Root<Employee> 相当于 from Employee
 *             Root<Product> 相当于  from Product
 *      CriteriaQuery：查询哪些字段，排序是什么(主要是把多个查询的条件连系起来)
 *      CriteriaBuilder：字段之间是什么关系，如何生成一个查询条件，每一个查询条件都是什么方式
 *                      主要判断关系（和这个字段是相等，大于，小于like等）
 *      Predicate（Expression）：单独每一条查询条件的详细描述 整个 where xxx=xx and yyy=yy ...
 */
    List<Employee> emps = employeeRepository.findAll(
            new Specification<Employee>() {
                @Override
                public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                    Path path = root.get("username");//拿到要做查询的字段
                    Predicate p = cb.like(path, "%1%");//like代表做模糊查询，后面就是它的条件值
                    return p;
                }
            }
    );
    for (Employee emp : emps) {
        System.out.println(emp);
    }
}

4.2多个条件查询

@Test
public void testFind02() {
    Specification spec = new Specification<Employee>() {
        @Override
        public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
            //加上第一个条件: username like '%1%'
            Path path1 = root.get("username");
            Predicate p1 = cb.like(path1, "%1%");
            //加上第二个条件: email like '%2%'
            Path path2 = root.get("email");
            Predicate p2 = cb.like(path2,"%2%");
            //加上第二个条件: age < 20
            Path path3 = root.get("age");
            Predicate p3 = cb.lt(path3, 20);
           //下面是加上or的条件的方案
           //Predicate p3 = cb.or(p1,p2);

            //把两个查询条件放到query对象中去(条件使用where)
            CriteriaQuery where = query.where(p1, p2, p3);
            //返回查询条件
            return where.getRestriction();
        }
    };

    List<Employee> emps = employeeRepository.findAll(spec);
    for (Employee emp : emps) {
        System.out.println(emp);
    }

}

4.3条件查询+分页排序

@Test
public void testFind03() {
    Specification spec = new Specification<Employee>() {
        @Override
        public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
            //加上条件: username like '%1%'
            Path path1 = root.get("username");
            Predicate p1 = cb.and(cb.like(path1, "%1%"));
            //把两个查询条件放到query对象中去(条件使用where)
            CriteriaQuery where = query.where(p1);
            //返回查询条件
            return where.getRestriction();
        }
    };

    //排序 ：第一个参数是排序的规则(DESC/ASC)  后面参数是排序的字符
    Sort sort = new Sort(Sort.Direction.DESC,"username");
    Pageable pageable = new PageRequest(0, 10,sort);

    Page<Employee> page = employeeRepository.findAll(spec, pageable);
    for (Employee emp : page) {
        System.out.println(emp);
    }
}

JpaSpecificationExecutor功能也是非常强大的，可以让我们不写一句SQL即可完成相应的查询功能。在外面也很不少公司使用这种方法，然后直接可以进行功能的抽取。

不过这个方案在设计上理解不是很容易，而且代码还比较臃肿烦杂。

5.jpa-spec插件

这是一个动态生成Query功能的一个封装版，如果我们使用这个插件，在完成查询与分页的时候功能会简单不少。

基于Spring Data Jpa的动态查询库 https://github.com/wenhao/jpa-spec

5.1功能介绍

  1. 兼容Spring Data Jpa 和JPA2.1接口。
  2. Equal/NotEqual/Like/NotLike/In/NotIn支持可变参数, Equal/NotEqual 支持空(Null)值。
  3. 每个条件支持关联查询。
  4. 支持自定义条件查询。
  5. 条件构建器。
  6. 支持分页和排序。

5.2功能测试

      5.2.1单个条件查询

@Test
public void testSpecFind01() {
    Specification<Employee> spec = Specifications.<Employee>and().like("username", "%1%").build();
    List<Employee> emps = employeeRepository.findAll(spec);
    for (Employee emp : emps) {
        System.out.println(emp);
    }
}

     5.2.2多个条件查询

@Test
public void testSpecFind02() {
    Specification<Employee> spec = Specifications.<Employee>and().like("username", "%1%")
            .like("email","%2%").lt("age", 20).build();
    List<Employee> emps = employeeRepository.findAll(spec);
    for (Employee emp : emps) {
        System.out.println(emp);
    }
}

    5.2.3条件+排序分页功能

//条件集成+分页
@Test
public void testSpecFind03() {
    Specification<Employee> spec = Specifications.<Employee>and().like("username", "%1%").build();
    //排序 ：第一个参数是排序的规则(DESC/ASC)  后面参数是排序的字符
    Sort sort = new Sort(Sort.Direction.DESC,"username");
    Pageable pageable = new PageRequest(0, 10,sort);

    Page<Employee> page = employeeRepository.findAll(spec, pageable);
    for (Employee emp : page) {
        System.out.println(emp);
    }
}

6.Query查询条件

6.1BaseQuery:公共的分页条件

                        父类BaseQuery,主要写分页内容,排序方法及定义获取查询条件的方法

package cn.itsource.pss.query;
/**
 * 公共的条件与规范
 */
public abstract class BaseQuery {

    //当前页(从1开始)
    private int currentPage = 1;
    //每页条数
    private int pageSize = 10;

    //排序方式 ASC/DESC
    private String orderByType ="ASC";
    //排序字段
    private String orderByName;

    public int getCurrentPage() {
        return currentPage;
    }
    /**
     * 专门准备的方法，因为前台用户传的是从第1页开始，而我们后台分页又是从0开的
     * @return
     */
    public int getJpaPage() {
        return currentPage - 1;
    }

    public void setCurrentPage(int currentPage) {
        this.currentPage = currentPage;
    }
    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }
    public String getOrderByType() {
        return orderByType;
    }

    public void setOrderByType(String orderByType) {
        this.orderByType = orderByType;
    }

    public String getOrderByName() {
        return orderByName;
    }

    public void setOrderByName(String orderByName) {
        this.orderByName = orderByName;
    }
}

6.2​​​​​​​EmployeeQuery:Employee特有的一些条件

                     子类EmployeeQuery,主要写对象上的字段及实现的父类的方法

package cn.itsource.pss.query;

public class EmployeeQuery extends BaseQuery {

    private String username;//姓名
    private String email;//邮件
    private Integer age;//年龄

    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

6.3​​​​​​​功能测试

//根据Query对象进行查询
@Test
public void testSpecFindByQuery() {
    //创建模块一个Query对象
    EmployeeQuery baseQuery = new EmployeeQuery();
//下面的都是测试的条件，可以任何放开进行测试
    //baseQuery.setUsername("1");
    //baseQuery.setAge(20);
    //baseQuery.setEmail("2");
    //baseQuery.setOrderByName("username");
    //baseQuery.setOrderByType("DESC");
    //baseQuery.setCurrentPage(2);
    //baseQuery.setPageSize(5);

	//like(条件boolean值,字段,值)
    Specification<Employee> spec = Specifications.<Employee>and()
            .like(StringUtils.isNotBlank(baseQuery.getUsername()), "username","%"+baseQuery.getUsername()+"%")
            .like(StringUtils.isNotBlank(baseQuery.getEmail()), "email","%"+baseQuery.getEmail()+"%")
            .lt(baseQuery.getAge()!=null, "age",baseQuery.getAge())
            .build();


    //这里确定是否需要排序
    Sort sort = null;
    if(baseQuery.getOrderByName()!=null){
        Sort.Direction desc = "DESC".equals(baseQuery.getOrderByType())?Sort.Direction.DESC:Sort.Direction.ASC;
        sort = new Sort(desc,baseQuery.getOrderByName());
    }
    Pageable pageable = new PageRequest(baseQuery.getJpaPage(), baseQuery.getPageSize(),sort);

    Page<Employee> page = employeeRepository.findAll(spec, pageable);
    for (Employee emp : page) {
        System.out.println(emp);
    }
}

通过上面的功能测试，我们已经知道如果前台传数据过来，后面的查询应该怎么处理了。但是大家也应该发现了，除了创建Specification对象这一，分页排序的部分每次查询的代码都应该是一样的，所以我们现在需要做的就是把代码开始进行功能抽取。

6.4创建Specification的流程放到Query里

BaseQuery中添加抽象方法

public abstract class BaseQuery {
...
//拿到查询的条件对象(由子类实现)
	public abstract Specification createSpecification();
//拿到排序的数据
	public Sort createSort() {
    		Sort sort = null;
    		if (StringUtils.isNotBlank(orderByName)) {
        		Sort.Direction type=  "ASC".equals(orderByType.toUpperCase())? Sort.Direction.ASC:Sort.Direction.DESC;
       		 sort = new Sort(type,orderByName);
    		}
    		return sort;
	}
...
}

EmployeeQuery中实现相应方法
(以后每一个Query要做高级查询都写在这个位置)
public class EmployeeQuery extends BaseQuery {
    ...
@Override
	public Specification createSpecification() {
    	//根据条件把数据返回即可
   	return  Specifications.<Employee>and()
            .like(StringUtils.isNotBlank(username), "username","%"+username+"%")
            .like(StringUtils.isNotBlank(email), "email","%"+email+"%")
            .lt(age!=null, "age",age)
            .build();
	}
...
}

 

 

 

 

 

 

 

 

 

集成 Spring Data JPA
一个想交朋友的陌生人
03-16 858
spring data jpa
Spring Data JPA的优点和难点.pdf
12-05
Spring Data JPA的主要优点在于其高度的开发效率、成熟的语法结构以及与Spring框架的紧密集成。 1. **开发效率极高**： - Spring Data JPA通过提供自动化的 Repository 实现，减少了大量手动编写SQL和DAO层代码的...
SpringBoot-SpringData-JPA集成
热门推荐
BraveWangDev
10-13 1万+
介绍 SpringDataJPA 的使用，包括：简介、SpringBoot集成、项目结构、框架特性、单元测试等；
Maven项目-集成SSJ(Spring+SpringMVC+SpringDataJpa)
Lonely Programmer
11-21 750
Maven项目-集成SSJ（Spring+SpringMVC+SpringDataJpa）一.什么是SpringDataJpa二.项目导包三 集成SpringDataJpa3.1.1 准备db.propeties3.2.2 准备applicationContext.xml3.2 集成SpringDataJpa3.2.1 准备domain(父类)3.2.2 准备Repository接口3.2.3 扫...
SpringBoot集成Spring Data JPA
安澜公子的博客
05-20 545
SpringBoot集成Spring Data JPA 项目环境 IDEA 2019.1 SpringBoot 2.1.5 Gradle 4.10 操作步骤 创建数据库 创建数据库microservice，后续会使用 新增配置和依赖 在build.gradle中添加要使用的依赖包，如下所示： //数据库连接使用druid连接池 compile('org.springframew...
springboot 集成Spring Data JPA
最新发布
虾米大王的学习历程
09-27 1095
我们除了使用JpaRepository接口提供的增删改查分页等方法之外，还可以自定义查询方法。/***/在AvUserRepository中，我们自定义了3个查询的方法。从代码可以看出，Spring Data JPA为我们约定了一系列的规范，只要按照规范编写代码，Spring Data JPA就会根据代码翻译成相关的SQL语句，进行数据库查询。
Spring Data JPA中文文档[1.4.3]_springdatajpa_erlang_waitxpf_
10-02
6. **Integration with Spring MVC**：Spring Data JPA 可以无缝集成到 Spring MVC 应用中，方便在 Web 层进行数据操作。通过 ModelMapper 和 Controller 方法，可以直接将 Repository 中的数据转换为视图模型并返回...
cloud-provide-user-druid:spring cloud使用spring Data jpa集成druid数据源和监控
05-10
spring cloud使用spring Data jpa继承druid数据源和监控 使用方法 修改application.yml中数据库连接信息 执行sql创建表 运行UserApplication.java 访问localhost:8000/1 实现REST Api访问 访问localhost:8000/druid/...
Spring Data JPA 笔记
04-16
5. **事务管理**：Spring Data JPA集成Spring的事务管理，可以方便地在方法级别控制事务的开始、提交、回滚，确保数据一致性。 6. ** auditing**：Spring Data JPA还提供了审计功能，通过`@CreationTimestamp`和`@...
SpringBoot | 第三十章：Spring-data-jpa的集成和使用
weixin_34143774的博客
10-31 161
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringMVC+Spring+Spring-Data-JPA整合-完整Demo
02-27
SpringMVC+Spring+Spring-Data-JPA整合-完整Demo
java框架整合例子（spring、spring mvc、spring data jpa、hibernate）
10-13
java框架整合例子（spring、spring mvc、spring data jpa、hibernate）
springboot集成spring-data-JPA
qq_37641547的博客
07-08 223
Spring Data是Spring的一个子项目。用于简化数据库访问，支持NoSQL和关系数据存储。其主要目标是使用数据库的访问变得方便快捷。 SpringData 项目所支持NoSQL存储： MongoDB（文档数据库） Neo4j（图形数据库） Redis（键/值存储） Hbase（列族数据库） SpringData 项目所支持的关系数据存储技术： JDBC JPA Spring Data : 致力于减少数据访问层 (DAO) 的开发量. 开发者唯一要做的，就只是声明持久层的接口，其他都交给 Sprin
Spring+SpringDataJpa集成与简单使用
wangyisheng233的博客
03-14 378
SpringDataJpa一.什么是SpringDataJpa二.Spring+SpringDataJpa集成2.1 导入SpringDataJpa2.2 配置applicationContext.xml文件三.使用SpringDataJpa3.1.继承JpaRepositoryJpaRepository接口3.2 完成基本的crud3.3高级查询四.高级查询与分页1.JpaSpecificati...
SpringMVC + Spring + SpringData\JPA 整合
MADE_Y
03-27 8476
涉及技术： –1.SpringMVC、Spring、SpringData\JPA整合完成CRUD、翻页 –2.基于Restful风格 –3.使用JPA二级缓存 –4.使用@ResponseBody注解完成Ajax. 完成分页操作 •Dao 层： –不带查询查询条件的分页，所以可以直接调用 PagingAndSortingRepository# findAll(Page
Spring Data JPA系列2：SpringBoot集成JPA详细教程，快速在项目中熟练使用JPA
是Vzn呀
06-23 1081
作为SpringData JPA系列内容的第二篇，此处以SpringBoot项目为基准，讲一下集成SpringData JPA的相关要点，带你快速的上手SpringData JPA，并用实例演示常见的DB操作场景，让你分分钟轻松玩转JPA。
SpringData JPA 基本使用（Springboot集成）
孙正_大正
12-29 794
什么是Spring Data：
三、JPA和SpringData集成快速入门
欲望以提升热忱 毅力以磨平高山
03-30 2193
学习贵在分享，分享是一种美德，美德成就了优秀的你！
Fenix — 比 MyBatis 更加强大的 Spring Data JPA 扩展库
学亮编程手记
07-29 1204
MyBatis和FenixMyBatis只能写原生SQL，无法享受跨数据库时的兼容性；由于Fenix是基于SpringDataJPA的扩展，即可以写JPQL语句，也可以写原生SQL语句，上述示例中写的是JPQL语句，SQL的字段表达上更简洁。MyBatis书写动态SQL依赖只能if/else、foreach等分支循环操作，灵活性高，但是代码量和重复性较高；而Fenix也有if/else、foreach等分支循环操作，但内置了大量的更加简单、强大和语义化的XMLSQL标签。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值