Spring Data JPA

最新推荐文章于 2023-07-02 15:12:42 发布
最新推荐文章于 2023-07-02 15:12:42 发布
阅读量178 收藏
点赞数
分类专栏： 【Spring】 文章标签： Spring Spring Data JPA Spring Data JPA ORM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leifchen90/article/details/84110821
版权

Spring Data

Spring Data’s mission is to provide a familiar and consistent, Spring-based programming model for data access while still retaining the special traits of the underlying data store.

常用子项目

  • Spring Data JDBC
  • Spring Data JPA
  • Spring Data MongoDB
  • Spring Data Redis

传统 JDBC

  1. JdbcUtil 工具类
import java.sql.*;

public class JdbcUtil {

    public static Connection getConnection() throws Exception {
        String url = "jdbc:mysql://localhost/db_springboot?useSSL=false";
        String user = "root";
        String password = "123456";
        String driverClass = "com.mysql.jdbc.Driver";
        Class.forName(driverClass);
        return DriverManager.getConnection(url, user, password);
    }

    public static void release(ResultSet resultSet, Statement statement,Connection connection) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}
  1. DAO 接口与实现
import java.util.List;

public interface UserDAO {
    List<User> query();
}

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class UserDAOImpl implements UserDAO {

    @Override
    public List<User> query() {
        List<User> users = new ArrayList<>();

        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        String sql = "select * from user";

        try {
            connection = JdbcUtil.getConnection();
            statement = connection.prepareStatement(sql);
            resultSet = statement.executeQuery();

            User user = null;
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                int age = resultSet.getInt("age");

                user = new User();
                user.setId(id);
                user.setName(name);
                user.setAge(age);
                users.add(user);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.release(resultSet, statement, connection);
        }

        return users;
    }
}
  1. Test
import org.junit.Assert;
import org.junit.Test;

public class JdbcUtilTest {
    @Test
    public void getConnection() throws Exception {
        Assert.assertNotNull(JdbcUtil.getConnection());
    }
}

Spring JDBC

  1. application.yml 配置 DataSource
spring:
  datasource:
    url: jdbc:mysql://localhost/db_springboot?useSSL=false
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
  1. DAO 层注入 JdbcTemplate
import org.springframework.jdbc.core.JdbcTemplate;

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

@Repository
public class UserDAOImpl implements UserDAO {

    private final JdbcTemplate jdbcTemplate;

    public UserDAOImpl(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public List<User> query() {
        final List<User> users = new ArrayList<>();

        String sql = "select * from user";
        jdbcTemplate.query(sql, (ResultSet rs) -> {
            int id = rs.getInt("id");
            String name = rs.getString("name");
            int age = rs.getInt("age");
            User user = new User();
            user.setId(id);
            user.setName(name);
            user.setAge(age);
            users.add(user);
        });

        return users;
    }
}
  1. 测试类
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;

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

    @Autowired
    private UserDAO userDAO;

    @Test
    public void query() {
        List<User> users = userDAO.query();
        users.forEach(System.out::println);
    }
}

Spring Data JPA

  1. User 使用注解可以自动创建表
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;

@Getter
@Setter
@ToString
@Entity
public class User {

    @Id
    @GeneratedValue
    private Integer id;

    @Column(length = 10)
    @NotEmpty
    private String name;

    @NotNull
    private Integer age;
}
  1. UserRepository
import org.springframework.data.repository.Repository;

public interface UserRepository extends Repository<User, Integer> {
    User findByName(String name);
}
  1. Test
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;

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

    @Autowired
    private UserRepository userRepository;

    @Test
    public void findByName() {
        System.out.println(userRepository.getfindName("LeifChen"));
    }
}

Repository 接口

  • public interface Repository<T, ID> {}

Repository 接口是 Spring Data 的核心接口，不提供任何实现方法。是一个空接口，也称为标记接口。

(1) CrudRepository：继承 Repository，实现了 CRUD 相关方法。

  • <S extends T> S save(S entity); 保存实体
  • <S extends T> Iterable<S> saveAll(Iterable<S> entities); 保存实体集合
  • Optional<T> findById(ID id); 根据 id 查询实体
  • boolean existsById(ID id); 返回是否存在对应 id 的实体
  • Iterable<T> findAll(); 返回所有实体
  • Iterable<T> findAllById(Iterable<ID> ids); 根据 ids 查询实体
  • long count(); 返回实体数
  • void deleteById(ID id); 根据 id 删除实体
  • void delete(T entity); 根据实体删除
  • void deleteAll(Iterable<? extends T> entities); 根据实体列表删除
  • void deleteAll(); 删除所有实体

(2) PagingAndSortingRepository：继承 CurdRepository，实现了分页排序相关方法

  • Iterable<T> findAll(Sort sort); 查询所有实体并按照 sort 排序
  • Page<T> findAll(Pageable pageable); 分页查询

测试代码：

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.test.context.junit4.SpringJUnit4ClassRunner;

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

    @Autowired
    private UserRepository userRepository;

    @Test
    public void pageAndSort() {
        Pageable pageable = PageRequest.of(0, 5, Sort.Direction.DESC, "age");
        Page<User> page = userRepository.findAll(pageable);

        System.out.println("查询的总页数：" + page.getTotalPages());
        System.out.println("查询的总记录数：" + page.getTotalElements());
        System.out.println("查询的当前第几页：" + (page.getNumber() + 1));
        System.out.println("查询的当前页面的集合：" + page.getContent());
        System.out.println("查询的当前页面的记录数：" + page.getNumberOfElements());
    }
}

(3) JpaRepository：继承 PagingAndSortingRepository，实现了 JPA 规范相关方法

测试代码：

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;

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

    @Autowired
    private UserRepository userRepository;

    @Test
    public void find() {
        userRepository.findById(3).ifPresent(System.out::println);
    }

    @Test
    public void exist() {
        System.out.println("user(3)：" + userRepository.existsById(3));
        System.out.println("user(100)：" + userRepository.existsById(100));
    }
}

(4) JpaSpecificationExecutor：用来实现 JPA 的动态复杂条件查询

测试代码：

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.jpa.domain.Specification;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.persistence.criteria.Path;

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

    @Autowired
    private UserRepository userRepository;

    @SuppressWarnings("unchecked")
    @Test
    public void complexQuery() {
        Pageable pageable = PageRequest.of(0, 5, Sort.Direction.ASC, "age");
        Specification<User> specification = (Specification<User>) (root, query, criteriaBuilder) -> {
            Path path = root.get("age");
            return criteriaBuilder.gt(path, 30);
        };
        Page<User> page = userRepository.findAll(specification, pageable);

        System.out.println("查询的总页数：" + page.getTotalPages());
        System.out.println("查询的总记录数：" + page.getTotalElements());
        System.out.println("查询的当前第几页：" + (page.getNumber() + 1));
        System.out.println("查询的当前页面的集合：" + page.getContent());
        System.out.println("查询的当前页面的记录数：" + page.getNumberOfElements());
    }
}

自定义 Repository 接口的两种方法：

  • (1) 继承 Repository 接口
import com.chen.model.User;
import org.springframework.data.repository.Repository;

public interface UserRepository extends Repository<User, Integer> {
    User findByName(String name);
}
  • (2) 注解 @RepositoryDefinition
import org.springframework.data.repository.RepositoryDefinition;

@RepositoryDefinition(domainClass = User.class, idClass = Integer.class)
public interface UserRepository {
    User findByName(String name);
}

JPA 方法关键字定义规则

参考官方文档

KeywordSampleJPQL snippet
AndfindByNameAndAge… where x.name = ?1 and x.age = ?2
OrfindByNameOrAge… where x.name = ?1 or x.age = ?2
Is,EqualsfindByName,findByNameIs,findByNameEquals… where x.name = ?1
BetweenfindByStartDateBetween… where x.startDate between ?1 and ?2
LessThanfindByAgeLessThan… where x.age < ?1
LessThanEqualfindByAgeLessThanEqual… where x.age <= ?1
GreaterThanfindByAgeGreaterThan… where x.age > ?1
GreaterThanEqualfindByAgeGreaterThanEqual… where x.age >= ?1
AfterfindByStartDateAfter… where x.startDate > ?1
BeforefindByStartDateBefore… where x.startDate < ?1
IsNullfindByAgeIsNull… where x.age is null
IsNotNull,NotNullfindByAge(Is)NotNull… where x.age is not null
LikefindByNameLike… where x.name like ?1
NotLikefindByNameNotLike… where x.name not like ?1
StartingWithfindByNameStartingWith… where x.name like ?1 (parameter bound with appended %)
EndingWithfindByNameEndingWith… where x.name like ?1 (parameter bound with prepended %)
ContainingfindByNameContaining… where x.name like ?1 (parameter bound wrapped in %)
OrderByfindByNameOrderByAgeDesc… where x.name = ?1 order by x.age desc
NotfindByNameNot… where x.lastname <> ?1
InfindByAgeIn(Collection<Age> ages)… where x.age in ?1
NotInfindByAgeNotIn(Collection<Age> ages)… where x.age not in ?1
TruefindByActiveTrue()… where x.active = true
FalsefindByActiveFalse()… where x.active = false
IgnoreCasefindByNameIgnoreCase… where UPPER(x.name) = UPPER(?1)

其中 find 关键字也可以为 get (例如：getByName) ，使用关键字命名方法会导致名称特别长，并且很难实现复杂查询，因此还可以通过注解的方式扩展。

注解

  • @Query：查询
  • @Modifying：更新、删除
  • @Transactional：事务，一般在 Service 层

参考代码：

  1. UserRepository
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.query.Param;

import java.util.List;

public interface UserRepository extends Repository<User, Integer> {

    /**
     * 根据名称查询用户（使用 JPA 命名规则）
     *
     * @param name 名称
     * @return
     */
    User findByName(String name);

    /** 
    * 查询 id 为最大值的用户 
    * 
    * @return 
    */
    @Query("select u from #{#entityName} u where id=(select max(id) from User t1)")
    User findByMaxId();

    /**
     * 根据名称、年龄查询用户（使用 @Query 注解及占位符 ? 绑定参数）
     *
     * @param name 名称
     * @param age  年龄
     * @return
     */
    @Query("select u from #{#entityName} u where u.name like ?1% and u.age >= ?2")
    List<User> findByParam(String name, Integer age);

    /**
     * 根据名称、年龄查询用户（使用 @Query 注解及 @Param 绑定参数）
     *
     * @param name 名称
     * @param age  年龄
     * @return
     */
    @Query("select u from #{#entityName} u where u.name like :name% and u.age >= :age")
    List<User> findByParam2(@Param("name") String name, @Param("age") Integer age);

    /**
     * 查询用户数
     *
     * @return
     */
    @Query(nativeQuery = true, value = "select count(1) from user")
    long count();

    /**
     * 根据 id 更新用户年龄
     *
     * @param id
     * @param age 年龄
     */
    @Modifying
    @Query("update User u set u.age = :age where u.id = :id")
    void updateById(@Param("id") Integer id, @Param("age") Integer age);

    /**
     * 根据 id 删除用户
     *
     * @param id
     */
    @Modifying
    @Query("delete from User u where u.id = :id")
    void deleteById(@Param("id") Integer id);
}
  1. UserRepositoryTest
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;

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

    @Autowired
    private UserRepository userRepository;

    @Test
    public void findByName() {
        System.out.println(userRepository.findByName("LeifChen"));
    }

    @Test
    public void findByMaxId() {
        System.out.println(userRepository.findByMaxId());
    }

    @Test
    public void findByParam() {
        System.out.println(userRepository.findByParam("Test", 20));
    }

    @Test
    public void findByParam2() {
        System.out.println(userRepository.findByParam2("Test", 20));
    }

    @Test
    public void count() {
        System.out.println(userRepository.count());
    }
}
  1. UserService
import com.chen.repository.UserRepository;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Transactional(rollbackOn = Exception.class)
    public void updateById(Integer id, Integer age) {
        userRepository.updateById(id, age);
    }

    @Transactional(rollbackOn = Exception.class)
    public void deleteById(Integer id) {
        userRepository.deleteById(id);
    }
}
  1. UserServiceTest
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;

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

    @Autowired
    private UserService userService;

    @Test
    public void updateById() {
        userService.updateById(3, 28);
    }

    @Test
    public void deleteById() {
        userService.deleteById(3);
    }
}

比较

  • JDBC：代码冗余，需要手写 SQL 语句，需要手工关闭连接，每次获取连接和关闭连接会加大数据库的负担。
  • Spring JDBC：通过 Spring 管理连接池，需要手写 SQL 语句，手动映射字段关系。
  • Spring Data JPA：通过 JPA 规范命名方法，不需要手写 SQL 语句。

参考

  1. 轻松愉快之玩转SpringData
  2. GitHub
  3. Spring-Data-JPA
leifchen90
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Data JPA中文文档[1.4.3]_springdatajpa_erlang_waitxpf_
10-02
Spring Data JPA中文文档1.4.3
spring Repository
liqingtx的专栏
11-18 1498
Repository： 是springData 的一个核心接口，它不提供任何方法，开发者需要在自己定义的接口中声明需要的方法 　　　　　　仅仅是一个标识，表明任何继承它的均为仓库接口类，方便Spring自动扫描识别, @Indexed public interface Repository<T, ID> { } T ：实体类名 ID : 主键类型 CrudRepository： 继承 Repository，实现了一组 CRUD 相关的方法 1 2 ...
springdataJPA的使用
qq_43470725的博客
01-08 660
jpa
springdataJPA
最新发布
Able_Zhao的博客
07-02 141
*** jpql:原生SQL* 1、@Query 查询实体数字：索引方式查询，1代表第一个参数* 具体名：通过@Param指定*/1")/*** 增删改必须指定事务和修改注解*/@Modifying2")/*** 插入name这一个列*//*** 2、如果操作原生的表必须指定：nativeQuery=true*/1")
JPA的CrudRepository 没有update方法，那么该如何更新数据？
热门推荐
liu_rockefeller的博客
07-26 1万+
刚开始使用JPA 的小伙伴们，可能有些困惑： 如下源码所示，JPA的CrudRepository只有save 方法，没有update和create方法。我怎样告诉JPA我是要更新（update）而不是插入（create）？ @NoRepositoryBean public interface CrudRepository<T, ID> extends Repository<T, ...
Spring Data JDBC & Spring Data JPA
weixin_45594127的博客
12-03 643
jdbc & jpa repository
Spring Data JPA的优点和难点.pdf
12-05
3. 与Spring全家桶结合紧密： 4. 成熟的框架和架构 常⻅的SQL性能问题，如何优雅处理? 2. 错综复杂的关联关系如何应对？ 3. 万恶的LazyException本质是什么？ 4. ⾼并发⾼性能要求的API服务要⽤JPA吗？
Spring Data JPA API（Spring Data JPA 开发文档）.CHM
08-31
Spring Data JPA API。 Spring Data JPA 开发文档。 官网 Spring Data JPA API。
spring注解+spring data jpa文档+JPA文档.rar
04-05
spring注解完整版+spring data jpa官方文档中文翻译+JPA2.0官方文档 文档内容齐全 值得参考学习
spring data JPA 和spring data JDBC 的区别看这篇就够了
web15085599741的博客
03-23 2579
spring data JDBC : JDBC 是连接数据库操作的原生接口,是对数据库操作的统一接口,定义的是对数据库操作的规范,由具体的数据库厂家实现,如:Mysql,Oracle 等; spring data JDBC相比传统JDBC而言省去了，数据库驱动，连接等无关配置，只需要写sql，设置参数； spring data JPA: JPA 是持久化规范，是orm框架(对象关系映射框架)的标准,JPA的具体实现是由ORM框架实现,如:Hibernate等, ORM框架底层都是通过封装JDBC来实现CRU
Spring Data JDBC与JDBC的区别
12-21
JDBC规范     java.sql和javax.sql两个包中的类与接口(天龙八部)：     DataSource:数据源     DriverManager：驱动管理     Driver：JDBC驱动     Connection：数据库连接     Statement：语句，执行SQL     PrepareStatement:预编译语句，性能更好     CallableStatement：调用存储过程     ResultSet：结果集，封装了多条记录     JDBC数据库连接池/Connection Pool         DBCP:apache tomcat内置   
Spring集成Elasticsearch
xulong5000的专栏
07-15 1795
依赖组件 <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-elasticsearch</artifactId> </dependency> 配置 spring: elasticsearch: rest: uris: - ip1:port
Spring Boot使用Spring Data JPA 访问关系型数据库
fang.lovest.yang的博客
05-14 671
一、Spring Boot项目引入Spring Data步骤 第1步：引入 Spring Data JPA 如果你想在应用程序中使用 Spring Data JPA，首先需要在 pom 文件中引入 spring-boot-starter-data-jpa 依赖，如下代码所示： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spri...
Spring Data JDBC与Spring JDBC和Spring Data JPA对比
allway2的博客
10-08 1395
弹簧数据 JDBC 是弹簧数据系列的新成员。它的创建是为了填补位于春季JDBC和春季数据JPA之间的空白。如果你看一下Spring JDBC，你可能会说它太低了，因为它只有助于与数据库的连接。Spring Data JPA可能看起来太复杂了，因为它为您提供了很多选项，并且很难掌握所有这些选项。弹簧数据JDBC是一个框架，它试图为您提供与使用弹簧数据JPA相同的功能，但通过使用DDD原则使其更易于理解。它还通过在较低级别上工作并让您决定何时需要像Spring JDBC那样进行数据库交互来提供更多控制，但以更简
spring boot 学习笔记 （9） Spring Data JPA
bihansheng2010的博客
12-13 3355
Spring Data JPA 是 Spring Boot 体系中约定优于配置的最佳实现，大大简化了项目中数据库的操作 JPA 是什么 JPA（Java Persistence API）是 Sun 官方提出的 Java 持久化规范。它为 Java 开发人员提供了一种对象 / 关联映射工具来管理 Java 应用中的关系数据。它的出现主要是为了简化现有的持久化开发工作和整合 ORM 技术，结束现在...
面试向：JPA,Hiberate,Spring Data JPA, Spring DataJDBC有什么联系？
Tech in Pieces
11-28 542
SPring DAO有两种方式来访问数据库： 一种是以SQL为核心 封装JDBC操作，比如MyBaties 另一种试一Java object为核心 和数据库建立映射关系。就是常见的ORM框架 比如 HIbernate和Spring Data JPA. JDBC 是什么？ Java在操作数据库中 因为有不同的数据库 所以我们定义一组操作不同数据库的规范。我们的Java app来操作数据库 应用JDBC 提供的数据库就可以了。 就像下图： 现在 JDBC不再是唯一的java app访问数据库的规范了 后来又出
不在傻傻for循环！完美解决JPA批量插入问题
淡烟疏雨的博客
12-18 7136
前言：jpa在简单的增删改查方面确实帮助我们节省了大部分时间，但是面对复杂的情况就显得心有余而力不足了，最近遇到一个批量插入的情况，jpa虽然提供了saveAll方法，但是底层还是for循环save,如果遇到大量数据插入频繁与数据库交互必然会对性能造成影响，查阅了很多资料也没有一个满意的结果，最后还是自己想出了一个方案
记一个spring-data-elasticsearch使用的坑
chenlunhuang5289的博客
02-15 1686
之前多线程插入es的时候发现效率很低,而且线程越多效率下降的非常快,且不符合es的性能需求,遂查之 刚开始没想太多,只是进行优化,根据官方文档 比如横向扩展,调整refresh_interval之类的,基本能做的都做了,但是发现提升的不多,而且cpu一直占用很高 之后发现一个奇怪的现象,...
spring data jpa 使用（二）
成都往右的博客
08-29 2110
前面说过如果自定义Repository继承Repository接口那么会被纳入spring容器管理，而Repository接口只起到了标记的作用，不提供任何方法。但spring data还为我们提供了其他的一些接口，并且都有特定的功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值