Spring Data Jpa (三)

2024-01-01  本文已影响0人  刘彦青

操作数据库

  1. 基础的 CRUD 操作：
    Spring Data JPA 提供了一组简单的方法，用于执行基本的 CRUD 操作（Create、Read、Update、Delete）。这包括通过主键查找、保存实体、更新实体和删除实体等操作。这些操作可以通过继承 JpaRepository 接口来实现。
public interface UserRepository extends JpaRepository<User, Long> {
 
     // 保存\更新单个用户
    User save(User user);
    // 保存\更新多个用户
    List<User> saveAll(Iterable<User> users);

    // 根据主键查询用户
    Optional<User> findById(Long id);
    // 根据主键集合查询用户
    List<User> findAllById(Iterable<Long> ids);
       // 自定义查询方法
    List<User> findByLastName(String lastName);
    // 复杂查询：根据多个属性查询用户
    List<User> findByFirstNameAndLastName(String firstName, String lastName);
     // 查询所有用户
    List<User> findAll();

    // 根据主键删除用户
    void deleteById(Long id);
    // 删除单个用户
    void delete(User user);
    // 删除多个用户
    void deleteAll(Iterable<User> users);
    // 删除所有用户
    void deleteAll();
    
}
  1. 自定义查询方法：
    Spring Data JPA 允许通过方法名命名规则自动生成查询，无需手动编写 SQL。例如，在方法名中使用 findBy 关键字和属性名称，Spring Data JPA 将自动生成相应的查询。
// 自动生成查询：select * from User where lastName = ?
List<User> findByLastName(String lastName);

除了方法名规则，还可以使用 @Query 注解定义自定义的 JPQL 或原生 SQL 查询。

@Query("SELECT u FROM User u WHERE u.email = ?1")
User findByEmail(String email);
  1. 分页和排序：
    Spring Data JPA 支持分页和排序功能，可以轻松地对查询结果进行分页和排序。通过传递 Pageable 对象，可以指定查询的页数、每页数量和排序规则。
Page<User> findByLastName(String lastName, Pageable pageable);
  1. 动态查询：
    Spring Data JPA 支持通过使用 Specification 对象创建动态查询条件。Specification 允许在运行时动态构建查询条件，更灵活地适应不同的查询需求。
public interface UserRepository extends JpaRepository<User, Long>, JpaSpecificationExecutor<User> {
    // 自定义动态查询方法
    List<User> findAll(Specification<User> spec);
}
  1. 事务支持：
    Spring Data JPA 与 Spring 框架集成，因此可以直接使用 Spring 的事务管理机制。通过 @Transactional 注解，可以将一系列数据库操作组织成一个事务。
@Transactional
public void updateUserName(Long userId, String newName) {
    User user = userRepository.findById(userId).orElseThrow();
    user.setName(newName);
    userRepository.save(user);
}
  1. 查询统计：
    Spring Data JPA 提供了一些统计查询方法，例如 count、exists 等，用于对查询结果进行统计。这些方法不仅能够获取数据，还可以了解数据的一些基本信息。
long countByLastName(String lastName);

使用@Query实现自定义查询

1. 使用 JPQL 查询

基本查询
// UserRepository.java
public interface UserRepository extends JpaRepository<User, Long> {
    @Query("SELECT u FROM User u WHERE u.lastName = ?1")
    List<User> findByLastName(String lastName);
}

在这个例子中，@Query 注解中的查询语句是 JPQL，它查询了所有姓氏为指定值的用户。

带有参数的查询
// UserRepository.java
public interface UserRepository extends JpaRepository<User, Long> {
    @Query("SELECT u FROM User u WHERE u.firstName = :firstName AND u.lastName = :lastName")
    List<User> findByFirstNameAndLastName(@Param("firstName") String firstName, @Param("lastName") String lastName);
}

这个例子中，使用了命名参数 :firstName 和 :lastName，并通过 @Param 注解将方法参数与查询语句中的命名参数进行绑定。

返回部分字段
// UserRepository.java
public interface UserRepository extends JpaRepository<User, Long> {
    @Query("SELECT NEW com.example.UserProjection(u.id, u.firstName) FROM User u WHERE u.lastName = ?1")
    List<UserProjection> findPartialByLastName(String lastName);
}

通过 SELECT NEW 关键字，可以返回部分字段，并使用自定义的投影接口 UserProjection 来接收查询结果。

2. 使用原生 SQL 查询

// UserRepository.java
public interface UserRepository extends JpaRepository<User, Long> {
    @Query(value = "SELECT * FROM users u WHERE u.last_name = ?1", nativeQuery = true)
    List<User> findByLastNameNativeQuery(String lastName);
}

在这个例子中，@Query 注解的 nativeQuery 属性被设置为 true，表示使用原生 SQL 查询。

分页排序查询

在 Spring Data JPA 中，分页和排序查询是常见的数据库查询操作，用于处理大量数据并提供更好的用户体验。以下是关于分页和排序查询的详细讲解：

分页查询

方法签名

Page<T> findAll(Pageable pageable);

示例

// UserRepository.java
public interface UserRepository extends JpaRepository<User, Long> {
    // 分页查询所有用户
    Page<User> findAll(Pageable pageable);
}

使用

// 在业务逻辑中调用
Pageable pageable = PageRequest.of(0, 10); // 第一页，每页10条记录
Page<User> users = userRepository.findAll(pageable);
List<User> userList = users.getContent(); // 获取当前页的数据列表

排序查询

方式一：

List<T> findAll(Sort sort);

// UserRepository.java
public interface UserRepository extends JpaRepository<User, Long> {
    // 根据姓氏排序查询所有用户
    List<User> findAll(Sort sort);
}

// 在业务逻辑中调用
List<User> users = userRepository.findAll(Sort.by(Sort.Order.asc("lastName")));

方式二：

List<T> findAllByOrderByLastNameAsc();

// UserRepository.java
public interface UserRepository extends JpaRepository<User, Long> {
    // 根据姓氏升序排序查询所有用户
    List<User> findAllByOrderByLastNameAsc();
}

// 在业务逻辑中调用
List<User> users = userRepository.findAllByOrderByLastNameAsc();

分页和排序联合查询

方法签名

Page<T> findAll(Pageable pageable);

示例

// UserRepository.java
public interface UserRepository extends JpaRepository<User, Long> {
    // 分页和排序查询所有用户
    Page<User> findAll(Pageable pageable);
}

使用

// 在业务逻辑中调用
Pageable pageable = PageRequest.of(0, 10, Sort.by("lastName").ascending()); // 第一页，每页10条记录，按姓氏升序排序
Page<User> users = userRepository.findAll(pageable);
List<User> userList = users.getContent(); // 获取当前页的数据列表

动态查询是在运行时动态构建 JPA 查询条件的一种方法。Spring Data JPA 提供了 Specification 接口，它允许你通过编程的方式构建查询条件，从而实现动态查询。下面是一个详细的示例：

假设我们有一个实体类 User，包含字段 id、firstName、lastName 和 age。我们将使用 Specification 来动态查询 User 实体。

Specification自定义查询

  1. 创建实体类
    首先，我们需要一个实体类，假设我们有一个 User 实体类：
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String firstName;
    private String lastName;
    private int age;

    // 省略其他字段、构造函数和 getter/setter
}
  1. **创建 ****UserRepository**
    创建一个继承自 JpaRepository 的接口，同时实现 JpaSpecificationExecutor 接口：
public interface UserRepository extends JpaRepository<User, Long>, JpaSpecificationExecutor<User> {
}

JpaSpecificationExecutor 提供了使用 Specification 进行动态查询的功能。

  1. 创建 **UserSpecifications** 类
    创建一个辅助类，用于构建 Specification 对象：
import org.springframework.data.jpa.domain.Specification;
import javax.persistence.criteria.Predicate;
import java.util.ArrayList;
import java.util.List;

public class UserSpecifications {

    public static Specification<User> hasFirstName(String firstName) {
        return (root, query, criteriaBuilder) ->
                criteriaBuilder.equal(root.get("firstName"), firstName);
    }

    public static Specification<User> hasLastName(String lastName) {
        return (root, query, criteriaBuilder) ->
                criteriaBuilder.equal(root.get("lastName"), lastName);
    }

    public static Specification<User> hasAgeGreaterThan(int age) {
        return (root, query, criteriaBuilder) ->
                criteriaBuilder.greaterThan(root.get("age"), age);
    }

    public static Specification<User> combineSpecifications(List<Specification<User>> specifications) {
        return (root, query, criteriaBuilder) -> {
            List<Predicate> predicates = new ArrayList<>();
            specifications.forEach(spec -> predicates.add(spec.toPredicate(root, query, criteriaBuilder)));
            return criteriaBuilder.and(predicates.toArray(new Predicate[0]));
        };
    }
}

在 UserSpecifications 中，我们定义了几个静态方法，每个方法返回一个 Specification 对象，用于定义不同的查询条件。combineSpecifications 方法用于将多个 Specification 组合成一个复合条件。

  1. 使用 **Specification** 进行查询
    创建一个服务类，使用 Specification 进行动态查询：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public List<User> findUsersByCriteria(String firstName, String lastName, int age, Pageable pageable) {
        List<Specification<User>> specifications = List.of(
                UserSpecifications.hasFirstName(firstName),
                UserSpecifications.hasLastName(lastName),
                UserSpecifications.hasAgeGreaterThan(age)
        );

        Specification<User> combinedSpec = UserSpecifications.combineSpecifications(specifications);

        return userRepository.findAll(combinedSpec, pageable).getContent();
    }
}

在 UserService 类中，我们将 Specification 组合成一个复合条件，并使用 userRepository.findAll 进行查询。

上一篇下一篇

猜你喜欢

热点阅读