JPA——API介绍、完成JPA的CRUD操作、JPQL完成复杂查询操作

最新推荐文章于 2022-09-03 18:57:57 发布
最新推荐文章于 2022-09-03 18:57:57 发布
阅读量936 收藏 1
点赞数
分类专栏： # Spring Data 文章标签： JPA CRUD JPQL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37989980/article/details/105936488
版权

目录

一、JPA的API介绍

跳转到目录

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

  • EntityManagerFactory: EntityManagerFactory 接口主要用来创建 EntityManager 实例; 由于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代码中承接的功能比较简单

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

二、抽取JPAUtils工具类

跳转到目录

  • 由于EntityManagerFactory 是一个线程安全的对象（即多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题），并且EntityManagerFactory 的创建极其浪费资源，所以在使用JPA编程时，我们可以对EntityManagerFactory 的创建进行优化，只需要做到一个工程只存在一个EntityManagerFactory 即可
/**
 * Description: Jpa的工具类
 *
 * 解决实体管理器工厂的浪费资源和耗时问题
 *      通过静态代码块的形式,当程序第一次访问此工具类时,创建一个公共的实体管理器工厂对象
 *      第一次访问getEntityManager方法: 经过静态代码块创建一个factory对象, 再调用方法创建一个EntityManager对象
 *      第二次方法getEntityManager方法: 直接通过一个已经创建好的factory对象, 创建EntityManager对象
 *
 * @author zygui
 * @date 2020/5/5 10:30
 */
public class JpaUtils {

    private static EntityManagerFactory factory;

    static {
        // 加载配置文件, 创建entityManagerFactory
        factory = Persistence.createEntityManagerFactory("myJpa");
    }

    // 获取EntityManager对象
    public static EntityManager getEntityManager() {
        return factory.createEntityManager();
    }
}

三、JPA完成增删改查操作

跳转到目录

/**
 * Description: 测试Jpa的test
 *
 * @author zygui
 * @date 2020/5/5 08:53
 */
public class JpaTest {

    /**
     * 测试jpa的保存
     *      案例：保存一个客户到数据库中
     *  Jpa的操作步骤
     *     1.加载配置文件创建工厂（实体管理器工厂）对象
     *     2.通过实体管理器工厂获取实体管理器
     *     3.获取事务对象，开启事务
     *     4.完成增删改查操作
     *     5.提交事务（回滚事务）
     *     6.释放资源
     */
    @Test
    public void testSave() {
        //1. 加载配置文件创建工厂(实体管理器工厂)对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        //2. 通过实体管理器工厂获取实体管理器
        EntityManager em = factory.createEntityManager();
        //3. 获取事务对象, 开启事务
        EntityTransaction tx = em.getTransaction(); // 获取事务对象
        tx.begin(); // 开启事务
        //4. 完成增删改查操作: 保存一个客户到数据库中
        Customer customer = new Customer();
        customer.setCustName("gzy");
        customer.setCustIndustry("learn");
        // 保存到数据库的操作
        em.persist(customer);
        //5. 提交事务
        tx.commit();
        //6. 释放资源
        em.close();
        factory.close();
    }

    // 使用工具类
    @Test
    public void testSave1() {
        // 通过工具类来创建实体管理器
        EntityManager em = JpaUtils.getEntityManager();
        //3. 获取事务对象, 开启事务
        EntityTransaction tx = em.getTransaction(); // 获取事务对象
        tx.begin(); // 开启事务
        //4. 完成增删改查操作: 保存一个客户到数据库中
        Customer customer = new Customer();
        customer.setCustName("gzy1");
        customer.setCustIndustry("learn1");
        // 保存到数据库的操作
        em.persist(customer);
        //5. 提交事务
        tx.commit();
        //6. 释放资源
        em.close();
        // factory.close(); 工厂不关闭, 因为是公共的,关闭后,其他线程就不能使用了,又需要重新创建
    }

    /**
     * 根据id查询客户
     *  使用find方法查询：
     *      1.查询的对象就是当前客户对象本身
     *      2.在调用find方法的时候，就会发送sql语句查询数据库
     *
     *  立即加载
     */
    @Test
    public void testFind() {
        EntityManager entityManager = JpaUtils.getEntityManager();
        EntityTransaction tx = entityManager.getTransaction();
        tx.begin();
        /*
            根据id来查询客户
                find: 根据id查询数据
                    class: 查询数据的结果需要包装的实体类类型的字节码
                    id: 查询主键的取值
         */
        Customer customer = entityManager.find(Customer.class, 1L);
        System.out.println(customer);
        tx.commit();
        entityManager.close();
    }

    /**
     * 根据id查询客户
     *      getReference方法
     *          1.获取的对象是一个动态代理对象
     *          2.调用getReference方法不会立即发送sql语句查询数据库
     *              * 当使用到查询结果对象的时候，才会发送查询的sql语句：什么时候用，什么时候发送sql语句查询数据库
     *
     * 延迟加载（懒加载）
     *      * 得到的是一个动态代理对象
     *      * 什么时候用，什么使用才会查询
     */
    @Test
    public  void testReference() {
        //1.通过工具类获取entityManager
        EntityManager entityManager = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = entityManager.getTransaction();
        tx.begin();
        //3.增删改查 -- 根据id查询客户
        /**
         * getReference : 根据id查询数据
         *      class：查询数据的结果需要包装的实体类类型的字节码
         *      id：查询的主键的取值
         */
        Customer customer = entityManager.getReference(Customer.class, 1L);
        System.out.print(customer);
        //4.提交事务
        tx.commit();
        //5.释放资源
        entityManager.close();
    }

    /**
     * 删除客户的案例
     *
     */
    @Test
    public  void testRemove() {
        //1.通过工具类获取entityManager
        EntityManager entityManager = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = entityManager.getTransaction();
        tx.begin();
        //3.增删改查 -- 删除客户

        //i 根据id查询客户
        Customer customer = entityManager.find(Customer.class,1L);
        //ii 调用remove方法完成删除操作
        entityManager.remove(customer);

        //4.提交事务
        tx.commit();
        //5.释放资源
        entityManager.close();
    }


    /**
     * 更新客户的操作
     *      merge(Object)
     */
    @Test
    public  void testUpdate() {
        //1.通过工具类获取entityManager
        EntityManager entityManager = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = entityManager.getTransaction();
        tx.begin();
        //3.增删改查 -- 更新操作

        //i 查询客户
        Customer customer = entityManager.find(Customer.class,1L);
        //ii 更新客户
        customer.setCustIndustry("it教育");
        entityManager.merge(customer);

        //4.提交事务
        tx.commit();
        //5.释放资源
        entityManager.close();
    }

}

四、JPA中的复杂查询(使用JPQL)

跳转到目录
JPQL全称Java Persistence Query Language;

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

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

/**
 * Description: 测试Jpql的test
 *
 * @author zygui
 * @date 2020/5/5 08:53
 */
public class JpqlTest {

    /*
     * 测试jqpl查询
     *      jqpl: from com.zy.domain.Customer
     *      sql: SELECT * FROM cst_customer
     */
    @Test
    public void testFindAll() {
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        // 查询全部
        String jpql = "from com.zy.domain.Customer";
        Query query = em.createQuery(jpql); // 创建Query查询对象,Query执行的是jqpl对象
        // 发送查询,并封装结果集
        List resultList = query.getResultList();
        for (Object o : resultList) {
            System.out.println(o);
        }
        tx.commit();
        em.close();
    }

    /**
     * 排序查询： 倒序查询全部客户（根据id倒序）
     *      sql：SELECT * FROM cst_customer ORDER BY cust_id DESC
     *      jpql：from Customer order by custId desc
     *
     * 进行jpql查询
     *      1.创建query查询对象
     *      2.对参数进行赋值
     *      3.查询，并得到返回结果
     */
    @Test
    public void testOrders() {
        //1.获取entityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        String jpql = "from Customer order by custId desc";
        Query query = em.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象

        //发送查询，并封装结果集
        List list = query.getResultList();

        for (Object obj : list) {
            System.out.println(obj);
        }

        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

    /**
     * 使用jpql查询，统计客户的总数
     *      sql：SELECT COUNT(cust_id) FROM cst_customer
     *      jpql：select count(custId) from Customer
     */
    @Test
    public void testCount() {
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        // 查询全部
        //1. 根据jpql语句创建Query查询对象
        String jpql = "select count(custId) from Customer";
        Query query = em.createQuery(jpql);
        /*
            getResultList: 直接将查询结果封装为list集合
            getSingleResult: 得到唯一的结果集
         */
        Object result = query.getSingleResult();
        System.out.println(result);

        tx.commit();
        em.close();
    }

    /**
     * 分页查询
     *      sql：select * from cst_customer limit 0,2
     *      jqpl : from Customer    需要对分页设置
     */
    @Test
    public void testPaged() {
        //1.获取entityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        //i.根据jpql语句创建Query查询对象
        String jpql = "from Customer";
        Query query = em.createQuery(jpql);
        //ii.对参数赋值 -- 分页参数
        //起始索引
        query.setFirstResult(0);
        //每页查询的条数
        query.setMaxResults(1);

        //iii.发送查询，并封装结果

        /**
         * getResultList ： 直接将查询结果封装为list集合
         * getSingleResult : 得到唯一的结果集
         */
        List list = query.getResultList();

        for(Object obj : list) {
            System.out.println(obj);
        }

        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

    /**
     * 条件查询
     *     案例：查询客户名称以‘霸王别姬’开头的客户
     *          sql：SELECT * FROM cst_customer WHERE cust_name LIKE  ?
     *          jpql : from Customer where custName like ?
     */
    @Test
    public void testCondition() {
        //1.获取entityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        //i.根据jpql语句创建Query查询对象
        String jpql = "from Customer where custName like ? ";
        Query query = em.createQuery(jpql);
        //ii.对参数赋值 -- 占位符参数
        //第一个参数：占位符的索引位置（从1开始），第二个参数：取值
        query.setParameter(1, "g%");

        //iii.发送查询，并封装结果

        /**
         * getResultList ： 直接将查询结果封装为list集合
         * getSingleResult : 得到唯一的结果集
         */
        List list = query.getResultList();

        for(Object obj : list) {
            System.out.println(obj);
        }

        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }
}

五、总结

跳转到目录

第一 orm思想
	主要目的：操作实体类就相当于操作数据库表
	建立两个映射关系：
		实体类和表的映射关系
		实体类中属性和表中字段的映射关系
	不再重点关注：sql语句
	
	实现了ORM思想的框架：mybatis，hibernate

第二 hibernate框架介绍
	Hibernate是一个开放源代码的对象关系映射框架，
		它对JDBC进行了非常轻量级的对象封装，
		它将POJO与数据库表建立映射关系，是一个全自动的orm框架

第三 JPA规范
	jpa规范，实现jpa规范，内部是由接口和抽象类组成

第四 jpa的基本操作
	案例：是客户的相关操作（增删改查）
		客户：就是一家公司
	客户表：
	
	jpa操作的操作步骤
		1.加载配置文件创建实体管理器工厂
			Persisitence：静态方法（根据持久化单元名称创建实体管理器工厂）
				createEntityMnagerFactory（持久化单元名称）
			作用：创建实体管理器工厂
			
		2.根据实体管理器工厂，创建实体管理器
			EntityManagerFactory ：获取EntityManager对象
			方法：createEntityManager
			* 内部维护的很多的内容
				内部维护了数据库信息，
				维护了缓存信息
				维护了所有的实体管理器对象
				再创建EntityManagerFactory的过程中会根据配置创建数据库表
			* EntityManagerFactory的创建过程比较浪费资源
			特点：线程安全的对象
				多个线程访问同一个EntityManagerFactory不会有线程安全问题
			* 如何解决EntityManagerFactory的创建过程浪费资源（耗时）的问题？
			思路：创建一个公共的EntityManagerFactory的对象
			* 静态代码块的形式创建EntityManagerFactory
			
		3.创建事务对象，开启事务
			EntityManager对象：实体类管理器
				beginTransaction : 创建事务对象
				presist ： 保存
				merge  ： 更新
				remove ： 删除
				find/getRefrence ： 根据id查询
				
			Transaction 对象 ： 事务
				begin：开启事务
				commit：提交事务
				rollback：回滚
		4.增删改查操作
		5.提交事务
		6.释放资源
	
	i.搭建环境的过程
		1.创建maven工程导入坐标
		2.需要配置jpa的核心配置文件
			*位置：配置到类路径下的一个叫做 META-INF 的文件夹下
			*命名：persistence.xml
		3.编写客户的实体类
		4.配置实体类和表，类中属性和表中字段的映射关系
		5.保存客户到数据库中
	ii.完成基本CRUD案例
		persist ： 保存
		merge ： 更新
		remove ： 删除
		find/getRefrence ： 根据id查询
		
	iii.jpql查询
		sql：查询的是表和表中的字段
		jpql：查询的是实体类和类中的属性
		* jpql和sql语句的语法相似
		
		1.查询全部
		2.分页查询
		3.统计查询
		4.条件查询
		5.排序
white camel
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
（4）JPA - JPA API
魚
06-08 344
Persistence 控制台不再打印SQL语句信息。 再改为true： 打印sql语句了。 2 EntityManagerFactory 3 EntityManager 3.1 前期准备工作 我们进行一个测试， 创建一个test的包，底下有一个test类 然后我们写 前期准备创建，和后期的释放资源。 private EntityManagerFactory entityMana...
JPA 概述及常用注解详解、SpringDataJpa 使用指南
最新发布
Mr. David 专栏
07-16 1万+
Hibernate对数据库结构提供了较为完整的封装，Hibernate的O/R Mapping实现了POJO 和数据库表之间的映射，以及SQL 的自动生成和执行。往往只需定义好了POJO 到数据库表的映射关系，即可通过Hibernate 提供的方法完成持久层操作。甚至不需要对SQL 的熟练掌握， Hibernate/OJB 会根据制定的存储逻辑，自动生成对应的SQL 并调用JDBC 接口加以执行。
JPA基础知识----JPA 基本注解，JPA API
ChangWen的博客
10-11 1万+
JPA 是什么     Java Persistence API：用于对象持久化的 API     Java EE 5.0 平台标准的 ORM 规范，使得应用程序以统一的方式访问持久层 JPA和Hibernate的关系     JPA 是 hibernate 的一个抽象（就像JDBC和JDBC驱动的关系）：       - JPA 是规范：JPA 本质上就是一种  ORM 规范，不是
JPA 主要API 使用介绍与示例
oscar999的专栏
06-13 383
本篇介绍与演示JPA的基本API的使用，包括实体的插入、查找、更新和删除。
JPA API与注解
weixin_30367945的博客
01-19 81
一、JPA API Persistence 类：用于获取 EntityManagerFactory 实例，该类含有静态方法 createEntityManagerFactory。 //persistence.xml 中的 persistence-unit String persistenceUnitName = "jpa-1"; EntityManagerFactory entityManag...
5 Hibernate：Java Persistence API (JPA) 入门
又言又语
06-25 5669
5 Hibernate：Java Persistence API (JPA) 入门
spring boot整合JPA——demo
01-25
`JPQL`（Java Persistence Query Language）是JPA提供的SQL高级查询语言，可以在Repository接口中定义，用于更复杂的查询需求。 在这个“springboot-jpa”项目中，你可以看到这些概念是如何实际应用的。项目可能...
springboot-data-jpa-crud：使用JPA进行Crud操作
02-17
SpringBoot集成JPA（Java Persistence API）是Java开发者在构建数据访问层时常用的一种技术，它简化了数据库操作，提供了ORM（对象关系映射）功能，使得开发者可以使用面向对象的方式来处理数据库事务。本项目...
关于SH JPA 简单的CRUD操作
01-19
在本教程中，我们将深入探讨SH JPA如何进行简单的创建（Create）、读取（Read）、更新（Update）和删除（Delete）操作，同时结合Hibernate作为JPA的实现，并使用Restful风格的API来完成这些操作。 1. **创建...
09_JPA详解_使用JPQL语句进行查询.zip
05-06
在"09_传智播客JPA详解_使用JPQL语句进行查询"的课程中，你将深入学习如何利用JPQL进行复杂的查询，包括联合查询、子查询、分页查询以及使用JOIN操作来处理关联数据。通过这个课程，你可以掌握JPA的核心概念和实践...
springboot同时整合JPA和mybatis的demo
08-12
这个demo同时整合了springboot+JPA+mybatis这个两个orm框架。
jpa操作mysql数据库
08-11
6. **查询**：JPA提供了两种查询方式：JPQL（Java Persistence Query Language）和 Criteria API。JPQL类似于SQL，但以面向对象的方式编写查询。Criteria API提供了一种更动态和类型安全的方式来构建查询。 7. **...
Play 2.6 使用JPA
java scala
01-12 1165
使用JPA https://playframework.com/documentation/2.6.x/JavaJPA 添加依赖 首先腰围工程添加javaJpa依赖，这里会提供JDBC和JPA的相关依赖。 Play中没有内建的JPA实现，可以使用任何可用的实现，下面的例子使用了Hibernate libraryDependencies ++= Seq( javaJpa,
Spring Data JPA 指南——整理自官方参考文档
意大利番茄的博客
09-21 2万+
基本使用方法 自定义Repository 定义查询方法 查询方法建立 特殊参数处理 限制查询结果数量 流式查询结果 异步查询结果 关键字 使用 Query 基本用法 使用 LIKE 表达式 使用原生SQL 原生SQL分页 使用 Sort 和 JpaSort 使用已命名参数 修改查询 基本使用方法继承接口并声明查询方法interface PersonRepository extends Reposit
JPA学习笔记三：JPA的API学习
公子&小白的博客
05-27 280
文章目录1. JPA学习笔记三：JPA的API学习1.1. jpa的类Persistence1.2. jpa的EntityManagerFactory接口1.3. jpa的EntityManager的方法1.4. jpa的EntityManager的其他方法1.5. jpa的事务操作EntityTransaction 1. JPA学习笔记三：JPA的API学习 1.1. jpa的类Persiste...
JPA查询-3种查询方式
没有伞的孩子必须努力奔跑！—小林
09-03 5762
spring data jpa
springboot学习笔记5(JPA 实现分页、排序、返回map集合）
热门推荐
trntaken的博客
09-06 2万+
JPA（Java Persistence API）中文就是java持久层api，是java EE 的一个规范。 springboot 简化配置，对很多常用开源框架做了很好的集成，几乎无需配置即可直接使用，简化开发，提高开发效率。
JPA (Java Persistence API)概述
成长的足迹
01-31 9689
在ORM的概念大行其道之际，JavaEE平台也不得不做出适当调整，直接在平台层提供了对象/关系映射机制JPA，并结合了其重要的Entity JavaBean。JPA概括起来包括如下3个部分： 对象/关系映射元数据及APIJava对象查询语言Java Criteria查询API  1. Entity JPA 中的Entity是一种可持久化的域对象。一个Entity类对应关系
jpa的查询api_为JPA的本机查询API键入安全查询
最佳 Java 编程
06-22 353
jpa的查询api 当您使用JPA时-有时-JPQL不能解决问题，您将不得不使用本机SQL。 从一开始，像Hibernate这样的ORM就为这些情况保留了开放的“后门”，并为Spring的JdbcTemplate ， Apache DbUtils或jOOQ提供了类似的API，用于纯SQL 。 这很有用，因为您可以继续将ORM用作数据库交互的单个入口点。 但是，使用字符串连接编写复杂的动态S...
jpa自定义sql查询
07-14
JPA（Java Persistence API）是Java EE的一种ORM（对象关系映射）规范，它提供了一种简化数据库操作的方式。JPA本身提供了一些基本的CRUD（创建、读取、更新、删除）操作，但对于复杂的查询，我们可以使用自定义SQL来执行。 在JPA中，可以使用@Query注解来定义自定义SQL查询。以下是一个示例： ```java @Repository public interface UserRepository extends JpaRepository<User, Long> { @Query(value = "SELECT * FROM users WHERE age > ?1", nativeQuery = true) List<User> findByAgeGreaterThan(int age); } ``` 在上面的示例中，我们使用@Query注解来定义了一个自定义的SQL查询。nativeQuery参数设置为true表示使用原生SQL查询，而不是JPQL（Java Persistence Query Language）。?1表示第一个参数，它将与方法中的age参数进行绑定。 除了使用原生SQL查询，还可以使用JPQL查询。以下是一个使用JPQL的示例： ```java @Repository public interface UserRepository extends JpaRepository<User, Long> { @Query("SELECT u FROM User u WHERE u.age > :age") List<User> findByAgeGreaterThan(@Param("age") int age); } ``` 在上面的示例中，我们使用:age来表示参数名，并使用@Param注解将方法参数与查询参数进行绑定。 通过使用自定义SQL查询，我们可以更灵活地执行复杂的查询操作。但请注意，自定义SQL查询往往会导致与特定数据库相关的代码，因此在编写自定义SQL查询时应谨慎考虑跨数据库兼容性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

white camel

感谢支持~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

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

打赏作者

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

抵扣说明：

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

余额充值