JPA(学习)

最新推荐文章于 2024-03-18 08:00:00 发布
最新推荐文章于 2024-03-18 08:00:00 发布
阅读量158 收藏 1
点赞数 1
分类专栏： Jpa 文章标签： jpa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wflsyf/article/details/116293899
版权

ORM思想

操作实体类就相当于操作数据库表。
就要建立两个映射关系：

  1. 建立实体类和表的关系。
  2. 建立实体类中属性和表中字段的关系。
    不再关注重点：SQl语句
    实现了ORM思想的框架：Mybatis、Hibernate。
    配置两个映射关系：
@ToString
@Data//get和set方法
/**
 * 注意！！！：导包都是javax.persistence的包
 * 1、完成实体类和表的映射关系
 * @Entity 声明实体类
 * @Table  配置实体类和表的映射关系
 *      name:配置数据库表的名称
 * 2、实体类中属性和表中字段的关系
 *
 */
@Entity
@Table(name = "cst_customer")
public class Customer {
    /**
     *     @Id 声明主键的配置
     *     @GeneratedValue 配置主键的策略
     *     (strategy = GenerationType.IDENTITY) 自增
     *     @Column 配置属性数据表中字段的映射关系
     *      name：数据库表中字段的名称
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id")
    private Long cust_id;
    @Column(name = "cust_name")
    private String cust_name;
    @Column(name = "cust_source")
    private String cust_source;
    @Column(name = "cust_industry")
    private String cust_industry;
    @Column(name = "cust_level")
    private String cust_level;
    @Column(name = "cust_address")
    private String cust_address;
    @Column(name = "cust_phone")
    private String cust_phone;
}

其中主键的生成策略：
* @GeneratedValue 配置主键的策略
* strategy
* GenerationType.IDENTITY: 自增 （底层数据库必须要支持自动增长）Mysql
* GenerationType.SEQUENCE: 序列 （底层数据库必须支持序列） Oracle
* GenerationType.TABLE : Jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增 相当于除了你的表，他会自己再建一个表来放下一次的自增id为多少
* GenerationType.AUTO : 由程序自动的帮助我们选择主键生成策略
测试代码：

    /**
     * 测试jpa的保存
     *      案例：保存一个客户到数据库
     * Jpa的操作
     *      1.加载配置文件创建工厂（实体管理类工厂）对象
     *      2.通过实体类管理类工厂获取实体类管理器
     *      3.获取事务对象，开启事务
     *      4.完成增删改查操作
     *      5.提交事务（回滚事务）
     *      6.释放资源
     */
    @Test
    void JpaTest() {
        //1.加载配置文件创建工厂（实体管理类工厂）对象
        /*维护了很多内容：浪费资源
         *线程安全，多个线程访问同一个不会有线程安全问题
         *如何解决资源浪费
         *创建一个公共的EntityManagerFactory对象
         *静态代码块形式创建
        */
        EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("MyJpa");//配置文件中persistence-unit的名字
        //2.通过实体类管理类工厂获取实体类管理器
        /*
        *getTransaction：创建事务对象
        *persist:保存
        *merge:更新
        *remove:删除
        * find/getRefrence:根据id查询
        */
        EntityManager entityManager = myJpa.createEntityManager();
        // 3.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        // 4.完成增删改查操作
        Customer customer=new Customer();
        customer.setCust_name("cqupt");
        customer.setCust_address("南山");
        //保存
        entityManager.persist(customer);
        // 5.提交事务（回滚事务:rollback）
        transaction.commit();
        // 6.释放资源
        entityManager.close();
        myJpa.close();
    }

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
<!--需要配置persistence-unit节点
    持久化单元：
        name:持久化单元名称
        transaction-type:事务管理的方式
            JTA:分布式事务管理（不同的表在不同的数据库）
            RESOURCE_LOCAL：本地事务管理（不同的表在同一数据库）
-->
    <persistence-unit name="MyJpa" transaction-type="RESOURCE_LOCAL">
<!--        JPA的实现方式-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <properties>
<!--            数据库信息
                用户名:javax.persistence.jdbc.user
                密码:javax.persistence.jdbc.password
                驱动:javax.persistence.jdbc.driver
                数据库地址:javax.persistence.jdbc.url
-->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="19980605"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/syfwfl?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true&amp;serverTimezone=UTC"/>
            <!--可选配置：配置JPA实现方的信息
                显示Sql       :hibernate.show_sql:false|true
                自动创建数据库表:hibernate.hbm2ddl.auto:
                                                      create: 程序运行时创建数据库（如果有表先删除表再创建）
                                                      update: 程序运行时创建表（如果有表不会创建）
                                                      none  : 不会创建表
            -->
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
        </properties>
    </persistence-unit>
</persistence>

工具类

为减少实体类工厂资源的浪费，写成静态代码块获取：

public class JpaUtils {
    private static final EntityManagerFactory myJpa;

    /**
     * 解决实体类工厂的资源浪费问题，
     * 通过静态代码块，当程序第一次访问时创建一个公共的实体类工厂，后面再访问时直接创建EntityManager就可以了
     *
     */
    static {
        myJpa = Persistence.createEntityManagerFactory("MyJpa");//配置文件中persistence-unit的名字
    }
    public static EntityManager GetEntityManager(){
        //2.通过实体类管理类工厂获取实体类管理器
        return myJpa.createEntityManager();
    }
}

增、删、改、查、查所有、分页查、条件查、计数：

 public static void Insert(){
          //SpringApplication.run(JpaApplication.class, args);
          /**
           * 测试jpa的保存
           *      案例：保存一个客户到数据库
           * Jpa的操作
           *      1.加载配置文件创建工厂（实体管理类工厂）对象
           *      2.通过实体类管理类工厂获取实体类管理器
           *      3.获取事务对象，开启事务
           *      4.完成增删改查操作
           *      5.提交事务（回滚事务）
           *      6.释放资源
           */
//         //1.加载配置文件创建工厂（实体管理类工厂）对象
//         EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("MyJpa");//配置文件中persistence-unit的名字
//         //2.通过实体类管理类工厂获取实体类管理器
//         EntityManager entityManager = myJpa.createEntityManager();

          EntityManager entityManager=JpaUtils.GetEntityManager();
          // 3.获取事务对象，开启事务
          EntityTransaction transaction = entityManager.getTransaction();
          transaction.begin();
          // 4.完成增删改查操作
          Customer customer=new Customer();
          customer.setCust_name("cqupt5");
          customer.setCust_address("南山");
          //保存
          entityManager.persist(customer);
          // 5.提交事务（回滚事务）
          transaction.commit();
          // 6.释放资源
          entityManager.close();
//         myJpa.close();
     }
     public static void Find(){
          //1.根据工具类获取EntityManager对象
          EntityManager entityManager=JpaUtils.GetEntityManager();
          //2.获取事务对象，开启事务
          EntityTransaction transaction = entityManager.getTransaction();
          transaction.begin();
          //3.完成增删改查操作
          Customer customer;
          /**
           * find:根据id查询数据
           *   class：查询数据的结果需要包装的实体类类型的字节码
           *   Object:查询的主键取值 加L表Long型
           * 直接返还查询结果，调用find方法时，就会发送sql语句
           * 立即加载
           */
          customer=entityManager.find(Customer.class,2L);
          //4.提交事务（回滚事务）
          transaction.commit();
          //5.释放资源
          entityManager.close();
          System.out.println(customer);
     }
    public static void GetReference(){
        //1.根据工具类获取EntityManager对象
        EntityManager entityManager=JpaUtils.GetEntityManager();
        //2.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //3.完成增删改查操作
        Customer customer;
        /**
         * getReference:根据id查询数据
         *   class：查询数据的结果需要包装的实体类类型的字节码
         *   Object:查询的主键取值 加L表Long型
         * 当调用查询结果对象的时候，才会发送sql语句
         * 延迟加载
         */
        customer=entityManager.getReference(Customer.class,2L);
        System.out.println(customer);
        //4.提交事务（回滚事务）
        transaction.commit();
        //5.释放资源
        entityManager.close();

    }

    /**
     * 删
     */
    public static void Remove(){
        //1.根据工具类获取EntityManager对象
        EntityManager entityManager=JpaUtils.GetEntityManager();
        //2.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //3.完成增删改查操作
        /**
         * getReference:根据id查询数据
         *   class：查询数据的结果需要包装的实体类类型的字节码
         *   Object:查询的主键取值 加L表Long型
         * 当调用查询结果对象的时候，才会发送sql语句
         * 延迟加载
         */
        // i 根据id查询客户
        // ii调用remove方法删除
        entityManager.remove(entityManager.find(Customer.class,2L));
        //4.提交事务（回滚事务）
        transaction.commit();
        //5.释放资源
        entityManager.close();
    }

    /**
     * 更新
     */

    public static void Update(){
        //1.根据工具类获取EntityManager对象
        EntityManager entityManager=JpaUtils.GetEntityManager();
        //2.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //3.完成增删改查操作
        // 更新
        Customer reference = entityManager.getReference(Customer.class, 1L);
        reference.setCust_phone("159456789123");
        entityManager.merge(reference);
        //4.提交事务（回滚事务）
        transaction.commit();
        //5.释放资源
        entityManager.close();
    }
    /**
     * 查询全部
     *  jqpl:不支持 select*用法,查询的是实体类全限定名称,直接实体类的类名也行
     */
    public static void testFindAll(){
        //1.根据工具类获取EntityManager对象
        EntityManager entityManager= JpaUtils.GetEntityManager();
        //2.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //3.完成增删改查操作
        String jqpl="from Customer";
        Query query = entityManager.createQuery(jqpl);//创建Query查询对象，query才是执行jpql的对象
        //发送查询，并封装结果信息
        List list=query.getResultList();
        for (Object c:list)
            System.out.println(c.toString());
        //4.提交事务（回滚事务）
        transaction.commit();
        //5.释放资源
        entityManager.close();
    }
    /**
     * 排序查询：sql: select*from cst_customer order by cust_id DESC
     *         jqpl: from Customer order by cust_id DESC
     *
     *         cust_id为实体类中的属性名称
     */
    public static void testByOrder(){
        //1.根据工具类获取EntityManager对象
        EntityManager entityManager= JpaUtils.GetEntityManager();
        //2.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //3.完成增删改查操作
        String jqpl="from Customer order by cust_id desc";
        Query query = entityManager.createQuery(jqpl);//创建Query查询对象，query才是执行jpql的对象
        //发送查询，并封装结果信息
        List list=query.getResultList();
        for (Object c:list)
            System.out.println(c.toString());
        //4.提交事务（回滚事务）
        transaction.commit();
        //5.释放资源
        entityManager.close();
    }
    /**
     * 统计总人数
     *  sql:SELECT count(cust_id) from cst_customer
     *  jqpl:SELECT count(cust_id) from cst_customer
     */
    public static void countNums(){
        //1.根据工具类获取EntityManager对象
        EntityManager entityManager= JpaUtils.GetEntityManager();
        //2.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //3.完成增删改查操作
        String jqpl="SELECT count(cust_id) from Customer";
        Query query = entityManager.createQuery(jqpl);
        //i创建Query查询对象,query才是执行jpql的对象
        //ii对参数赋值
        //iii发送查询，并封装结果信息
        Object obj=query.getSingleResult();//获取唯一结果
        System.out.println(obj);
        //4.提交事务（回滚事务）
        transaction.commit();
        //5.释放资源
        entityManager.close();
    }
    /**
     * 分页查询
     * sql:select*from cst_customer limit 0,2
     * jqpl:from cst_customer
     */
    public static void CutPageFind(){
        //1.根据工具类获取EntityManager对象
        EntityManager entityManager= JpaUtils.GetEntityManager();
        //2.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //3.完成增删改查操作
        String jqpl="from Customer";
        Query query = entityManager.createQuery(jqpl);
        //i创建Query查询对象,query才是执行jpql的对象
        //ii对参数赋值
        query.setFirstResult(0);//从0开始查 会默认省去0
        query.setMaxResults(2);//每次查询两条
        //iii发送查询，并封装结果信息
        List obj=query.getResultList();
        for (Object x:obj)
            System.out.println(x);
        //4.提交事务（回滚事务）
        transaction.commit();
        //5.释放资源
        entityManager.close();
    }
    /**
     * 条件查询
     *  查询客户名称以cq开头的用户,现在对占位符进行了改变，变成?1这种是几个就写第几个，从1开始
     * sql:SELECT*FROM cst_customer WHERE cust_name LIKE 'cq%'
     *  jqpl:FROM Customer WHERE cust_name LIKE 'cq%'
     */
    public static void ConditionalQuery(){
        //1.根据工具类获取EntityManager对象
        EntityManager entityManager= JpaUtils.GetEntityManager();
        //2.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //3.完成增删改查操作
        String jqpl="FROM Customer WHERE cust_name LIKE ?1";
        Query query = entityManager.createQuery(jqpl);
        //第一个为索引符的位置，起始为0
        query.setParameter(1,"cq%");
        List obj=query.getResultList();//获取唯一结果
        for (Object x:obj)
            System.out.println(x);
        //4.提交事务（回滚事务）
        transaction.commit();
        //5.释放资源
        entityManager.close();
    }

spring-boot整合jpa

继承了JpaRepository就行，它里面已经有很多方法了。

/**
 * JpaRepository是最底的接口，继承它等于有所有，用它来完成对数据库的操作
 * JpaRepository<T,ID>第一个T是操作的类型，第二个是ID的类型
 */
public interface UserRepository extends JpaRepository<User,Long> {

}

配置文件：

spring:
  datasource:
    url: xxx
    username: xxx
    password: xxx
    driver-class-name: com.mysql.cj.jdbc.Driver #5.0以上要cj
  jpa:
    hibernate:
      ddl-auto: update
        #create:每次都会创建一张表，
        #create-drop 每次断开后都会将表删除，
        #update自动创建表结构，没有就创，有就更新，
        #validate:验证表结构和我们定义的是否一致，不一致就抛异常
    database: mysql #选择数据库为mysql
    show-sql: true #打印sql的日志

增、删、改、查、分页查、计数：

@RestController
public class UserController {
    @Autowired
    UserRepository userRepository;
    @GetMapping("/user/{id}")
    public User GetUser(@PathVariable("id")Long id){
        return userRepository.findById(id).get();
    }
    @GetMapping("/user/is")
    public User Insert(User user){
    	//save既可以做新增又可以做插入
        userRepository.save(user);
        return user;
    }
    @GetMapping("/user/up/{id}")
    public User Update(@PathVariable("id")Long id, @RequestParam("name")String name){
        User user= userRepository.findById(id).get();
        user.setName(name);
        userRepository.saveAndFlush(user);
        return user;
    }
    @GetMapping("/user/re/{id}")
    public User Remove(@PathVariable("id")Long id){
        User user= userRepository.findById(id).get();
        userRepository.delete(user);
        return user;
    }
}
    /**
     * @return 查询全部
     */
    @GetMapping("/user/all")
    public List<User> findAll(){
        List<User>list=userRepository.findAll();
        return list;
    }
    /**
     * @return 分页查询
     */
    @GetMapping("/user/pa")
    public Page<User> findPage(@RequestParam("start")int start,@RequestParam("size")int size){
        /*  pageNo：页码（从0开始）
            size：每页条数
            direction：排序标识，即ASC或DESC
            name：需要排序的字段*/
        PageRequest pageable = PageRequest.of(start,size);
        return userRepository.findAll(pageable);
    }
        /**
     * @return 计数
     */
    @GetMapping("/user/count")
    public Long count(){
        return userRepository.count();
    }
syf_wfl
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
JPA框架
CZW2181119177的博客
08-05 9803
一、JPA 介绍 1、JDBC 2、JPA是什么 二、搭建 JPA 环境 三、JPA 注解 四、JPA API 1、缓存 2、EntityManager 3、API 五、关联关系映射 1、一对一映射 2、单向一对多 3、单向多对一 4、双向一对多及多对一 5、双向多对多 六、JPQL 1、createQuery 2、createNativeQuery......
【SpringBoot整合JPA框架（hibernate实现）详解】（附详细代码）
qq_45759093的博客
02-20 2630
Java Persistence API（JPA）是Java EE和Java SE平台的一部分，提供了一种简单的对象关系映射（ORM）机制，用于将Java对象持久化到关系型数据库中。JPA通过注解或XML配置文件实现实体类与数据库表之间的映射，简化了数据库操作的过程。
JPA与Mybatis的区别
iijik55的博客
04-04 9819
其实JPA和mybatis大体上没什么区别，架构上很相似，mybatis就是mapper层，JPA就是repository层，其他都一样的 JPA就是把mapper层的接口换成repository的接口: 那么接口具体长什么样呢？ mapper层 自己写sql语句 JPA的repository： 没有具体sql语句，看起来没有实现一样，但其实是遵循规则的实现，你只要写 findByXxx(Xxx xx) 就能根据某个键自动实现数据库查询，当然其他的语句也是可以实现的。 如果你觉得不灵活，也可以自己写，
JPA 学习
yujunlong3919的专栏
02-01 275
文章目录AuditingEntityListener AuditorAware EnableJpaAuditing@CreatedDate、@CreatedBy、@LastModifiedDate、@LastModifiedBy说明@MappedSuperclass 用在父类上 防止生成Base表japrespositoryJpaSpecificationExcutor方法命名规则条件查询find一对一一对多多对多查询前6个其他学习mappedby多表查询学习POJO (DO DTO VO)常用注释jack
JPA学习（三）
钟渊博客
12-17 564
一、JPA二级缓存 首先看下面的案例（没有配置二级缓存）： @Test public void testSecondCache(){ Customer customer1 = entityManager.find(Customer.class, 3); Customer customer2 = entityManager.find(Customer.class, 3); } 使
JPA
weixin_42464503的博客
08-01 901
JPA ORM概述 ORM（Onject-Relational Mapping）表示对象关系映射。在面向对象的软件开发中利用ORM可以把对象==（class）映射成为关系型数据库中的一张表（table），对象中的属性（property）映射成为表中的一个字段（field）每一个对象（object）映射为表中的一行记录（record）==，从而达到操作实体类就相当于操作数据库中数据表的功能。 特点：...
Spring Data JPA学习
08-10
Spring Data JPA学习 Spring Data JPA是一个基于Java持久层API（JPA）的存储库实现，它提供了一个简单、统一的方式来访问关系数据库。下面是Spring Data JPA的特征和配置步骤： 一、支持基于Spring和JPA构建存储库...
JPA学习笔记
09-17
【JPA学习笔记】 JPA（Java Persistence API）是Java平台上的一个ORM（Object-Relational Mapping）规范，它提供了一种将Java对象与数据库表进行映射的机制，简化了数据库操作。JPA允许开发者使用面向对象的方式...
JPA学习大全.docx
05-14
**JPA学习大全** 在Java开发中，Spring Data JPA是一个强大的工具，它基于ORM（对象关系映射）框架和JPA（Java Persistence API）规范，为开发者提供了一种简化数据库访问和操作的方式。通过使用Spring Data JPA，...
JPA学习资料
12-21
在开始JPA的学习之前，首先需要进行一些准备工作。创建一个Maven项目，并在pom.xml文件中设置Java编译版本为1.8。同时，引入必要的依赖库，包括Junit用于单元测试，Hibernate作为JPA的实现，以及MySQL驱动以便连接到...
JPA学习之路（基础篇）
热门推荐
程序员小王的博客
02-21 1万+
JPA学习之路（基础篇）...
JPA 概述及 SpringDataJpa 框架基本使用指南
墨鸦的博客
07-07 8200
JPA 概述及 SpringDataJpa 框架基本使用指南
浅谈JPA框架
啊Q老师
03-18 3718
JPA介绍
SpringBoot之Spring Data JPA入门学习
qinxun2008081的博客
06-07 573
SpringBoot之Spring Data JPA入门学习
（一）JPA的快速入门
个人学习使用
09-21 996
（一）JPA的快速入门
JPA与MyBatis的区别
islautao的博客
06-03 3825
JPA和MyBatis是两种不同的Java持久层框架，它们有各自的特点、优缺点和适用场景。简单地说，JPA是一种对象关系映射（ORM）的规范，它提供了一种将Java对象和数据库表之间的映射关系的抽象层，让开发者可以使用面向对象的方式来操作数据库，而不需要直接编写SQL语句²。MyBatis是一种数据映射器（Data Mapper）的框架，它允许开发者直接编写SQL语句，并将其与Java对象和方法绑定，让开发者可以更灵活地控制数据库的访问和操作³。
AI人工智能课程 机器学习算法班第18讲：循环神经网络与自然语言处理 共40页.pdf
最新发布
07-14
【课程大纲】 第1讲：概率论与数理统计 共34页.pdf 第2讲：线性代数与矩阵论 共62页.pdf 第3讲：凸优化初步 共66页.pdf 第4讲：最大熵模型与EM算法 共38页.pdf 第5讲：决策树、随机森林、GBDT、XGBoost 共36页.pdf 第8讲：机器学习中的特征工程 共51页.pdf 第9讲：机器学习调优与模型融合 共32页.pdf 第10讲：推荐系统原理与应用 共58页.pdf 第11讲：排序与CTR预估问题 共35页.pdf 第12讲：聚类和社交网络算法 共60页.pdf 第13讲：机器学习算法之图模型初步 共21页.pdf 第15讲：主体模型 共43页.pdf 第16讲：人工神经网络 共45页.pdf 第17讲：计算机视觉与卷积神经网络 共50页.pdf 第18讲：循环神经网络与自然语言处理 共40页.pdf 第19讲：深度学习框架与应用 共61页.pdf 第20讲：采样与变分 共26页.pdf
springboot+jpa学习教程
03-23
您可以在CSDN上找到很多关于Spring Boot和JPA的学习教程，例如： 1. Spring Boot + JPA 实战教程：https://blog.csdn.net/qq_35387940/article/details/81005527 2. Spring Boot + JPA + Thymeleaf 实战教程：https://blog.csdn.net/qq_35387940/article/details/81005527 3. Spring Boot + JPA + Vue.js 实战教程：https://blog.csdn.net/qq_35387940/article/details/81005527 希望对您有所帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

syf_wfl

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

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

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

打赏作者

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

抵扣说明：

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

余额充值