操作数据库
-
基础的 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();
}
-
自定义查询方法：
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);
-
分页和排序：
Spring Data JPA 支持分页和排序功能，可以轻松地对查询结果进行分页和排序。通过传递Pageable对象，可以指定查询的页数、每页数量和排序规则。
Page<User> findByLastName(String lastName, Pageable pageable);
-
动态查询：
Spring Data JPA 支持通过使用Specification对象创建动态查询条件。Specification允许在运行时动态构建查询条件，更灵活地适应不同的查询需求。
public interface UserRepository extends JpaRepository<User, Long>, JpaSpecificationExecutor<User> {
// 自定义动态查询方法
List<User> findAll(Specification<User> spec);
}
-
事务支持：
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);
}
-
查询统计：
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自定义查询
-
创建实体类
首先，我们需要一个实体类，假设我们有一个User实体类：
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String firstName;
private String lastName;
private int age;
// 省略其他字段、构造函数和 getter/setter
}
- **创建 **
**UserRepository**
创建一个继承自JpaRepository的接口，同时实现JpaSpecificationExecutor接口：
public interface UserRepository extends JpaRepository<User, Long>, JpaSpecificationExecutor<User> {
}
JpaSpecificationExecutor 提供了使用 Specification 进行动态查询的功能。
-
创建
**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 组合成一个复合条件。
-
使用
**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 进行查询。
