Spring Data JPA：简化Java持久化的艺术

dazhong2012

已于 2024-05-12 22:58:16 修改

阅读量1k

点赞数 20

于 2024-04-20 10:27:57 首次发布

本文链接：https://blog.csdn.net/dazhong2012/article/details/137979688

版权

springboot 同时被 2 个专栏收录

41 篇文章 0 订阅

订阅专栏

java web

34 篇文章 0 订阅

订阅专栏

一、引言

Spring Data JPA是Spring Data项目的一部分，它简化了对JPA（Java Persistence API）的使用，使开发者能够更快速地构建Spring应用程序。通过Spring Data JPA，我们可以避免编写大量的数据访问层代码，而专注于业务逻辑的实现。本文将介绍Spring Data JPA的核心知识点，以及在Spring Boot项目中引入JPA的具体流程，并展示JPA的具体方法及分页调用封装案例，最后给出Controller测试案例。

二、Spring Data JPA核心知识点

1. Repository接口：

Spring Data JPA的核心是Repository接口，它提供了基本的数据访问操作，如保存、删除、查找等。开发者只需定义接口，无需编写实现类，Spring Data JPA会根据接口方法名自动生成实现。

2. 查询方法：

Spring Data JPA 支持通过方法名解析生成查询语句，例如findByName会自动解析为按名称查询。此外，还可以使用@Query注解自定义JPQL或SQL查询。

3. 分页与排序：

Spring Data JPA提供了分页和排序的支持，通过Pageable接口可以轻松实现分页查询，同时支持多字段排序。

4. 事务管理：

Spring Data JPA集成了Spring的事务管理功能，可以方便地控制数据访问层的事务。

三、Spring Boot项目中引入JPA的具体流程

添加依赖：在Spring Boot项目的pom.xml文件中添加Spring Data JPA和数据库驱动的依赖。

<dependencies>  
    <!-- Spring Boot Starter Data JPA -->  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-data-jpa</artifactId>  
    </dependency>  
    <!-- 数据库驱动，以MySQL为例 -->  
    <dependency>  
        <groupId>mysql</groupId>  
        <artifactId>mysql-connector-java</artifactId>  
        <scope>runtime</scope>  
    </dependency>  
    <!-- 其他依赖... -->  
</dependencies>

配置数据源：在application.properties或application.yml文件中配置数据源信息，包括数据库URL、用户名、密码等。

spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase  
spring.datasource.username=root  
spring.datasource.password=password  
spring.jpa.hibernate.ddl-auto=update  
spring.jpa.show-sql=true

创建实体类：使用JPA注解定义实体类，映射数据库表结构。

@Entity  
@Table(name = "users")  
public class User {  
    @Id  
    @GeneratedValue(strategy = GenerationType.IDENTITY)  
    private Long id;  
    private String name;  
    private String email;  
    // 省略getter和setter方法...  
}

创建Repository接口：继承JpaRepository接口，定义数据访问方法。

public interface UserRepository extends JpaRepository<User, Long> {  
    List<User> findByName(String name);  
}

四、JPA具体方法及分页调用封装案例

基本方法调用：通过Repository接口直接调用定义的方法。

@Autowired  
private UserRepository userRepository;  
  
public List<User> getAllUsers() {  
    return userRepository.findAll();  
}

分页调用封装：使用Pageable接口进行分页查询，并封装成通用方法。

public Page<User> getUsersByPage(int pageNo, int pageSize) {  
    Pageable pageable = PageRequest.of(pageNo - 1, pageSize);  
    return userRepository.findAll(pageable);  
}

五、动态查询条件参数封装案例

在实际应用中，我们通常需要根据用户输入的多个条件进行动态查询。Spring Data JPA提供了JpaSpecificationExecutor接口，使得我们可以使用Specification构建动态查询条件。下面是一个示例，展示如何封装动态查询条件。

首先，我们需要让UserRepository接口继承JpaSpecificationExecutor：

public interface UserRepository extends JpaRepository<User, Long>, JpaSpecificationExecutor<User> {  
    // 其他方法...  
}

接着，在UserService中，我们定义一个searchUsers方法，该方法接受查询条件（如名称、邮箱等）和分页信息，并返回满足条件的用户列表：

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.data.domain.Page;  
import org.springframework.data.domain.PageRequest;  
import org.springframework.data.jpa.domain.Specification;  
import org.springframework.stereotype.Service;  
import javax.persistence.criteria.*;  
import java.util.ArrayList;  
import java.util.List;  
  
@Service  
public class UserService {  
  
    @Autowired  
    private UserRepository userRepository;  
  
    public Page<User> searchUsers(String name, String email, int pageNo, int pageSize) {  
        // 构建查询条件  
        Specification<User> specification = buildSpecification(name, email);  
          
        // 创建分页请求  
        PageRequest pageable = PageRequest.of(pageNo - 1, pageSize);  
          
        // 执行分页查询  
        return userRepository.findAll(specification, pageable);  
    }  
  
    private Specification<User> buildSpecification(final String name, final String email) {  
        return new Specification<User>() {  
            @Override  
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {  
                List<Predicate> predicates = new ArrayList<>();  
                  
                if (name != null && !name.isEmpty()) {  
                    predicates.add(criteriaBuilder.like(root.get("name"), "%" + name + "%"));  
                }  
                  
                if (email != null && !email.isEmpty()) {  
                    predicates.add(criteriaBuilder.equal(root.get("email"), email));  
                }  
                  
                return criteriaBuilder.and(predicates.toArray(new Predicate[predicates.size()]));  
            }  
        };  
    }  
}

在buildSpecification方法中，我们创建了一个Specification匿名内部类，并重写了toPredicate方法。在这个方法中，我们根据传入的条件构建了Predicate列表，然后使用CriteriaBuilder的and方法将多个Predicate组合成一个复合查询条件。如果某个条件为空，则不会将其添加到Predicate列表中。

这样，我们就可以通过调用searchUsers方法，并传入不同的查询条件和分页信息，来实现动态查询了。

六、动态处理自定义SQL案例

除了使用JPQL或Criteria API构建查询外，Spring Data JPA也支持使用自定义SQL查询。这通常是通过在Repository接口的方法上使用@Query注解来实现的。

1.使用 @Query 注解

public interface UserRepository extends JpaRepository<User, Long> {  
  
    @Query("SELECT u FROM User u WHERE u.name = ?1")  
    User findByName(String name);  
  
    @Query("SELECT u FROM User u WHERE u.age > ?1")  
    List<User> findByAgeGreaterThan(int age);  
  
    // 使用JPQL的分页查询  
    @Query("SELECT u FROM User u ORDER BY u.id DESC")  
    Page<User> findAllDescOrdered(Pageable pageable);  
}

2. 使用原生SQL

如果你想要使用原生SQL查询，你需要设置nativeQuery属性为true。但是，请注意，原生SQL查询可能会限制你的代码可移植性，因为它直接依赖于你的数据库方言。

@Query(value = "SELECT * FROM users WHERE name = ?1", nativeQuery = true)  
User findByNameNative(String name);

3. 使用@Modifying 和 @Query 执行更新和删除操作

对于更新和删除操作，可以使用@Modifying注解来表明你的查询是一个修改查询。同时，对于更新操作，可能还需要使用@Transactional注解来确保操作在事务的上下文中执行。

public interface UserRepository extends JpaRepository<User, Long> {  
  
    @Modifying  
    @Query("UPDATE User u SET u.name = ?1 WHERE u.id = ?2")  
    int setName(String name, Long id);  
  
    @Modifying  
    @Transactional  
    @Query("DELETE FROM User u WHERE u.id = ?1")  
    void deleteById(Long id);  
}

4.参数语法

在使用@Query注解时，你可以使用SpEL（Spring Expression Language）表达式来引用方法参数，例如?1、?2等，或者使用@Param注解来命名参数

使用位置参数（?1, ?2, …）
这是通过方法参数的位置来引用它们的。第一个参数用?1表示，第二个参数用?2表示，依此类推。

public interface UserRepository extends JpaRepository<User, Long> {  
  
    @Query("SELECT u FROM User u WHERE u.name = ?1 AND u.age = ?2")  
    List<User> findByNameAndAge(String name, int age);  
}

使用命名参数（@Param）
通过使用@Param注解，可以为方法参数提供一个名字，并在查询字符串中通过这个名字来引用它们。这通常使得查询更加易读。

public interface UserRepository extends JpaRepository<User, Long> {  
  
    @Query("SELECT u FROM User u WHERE u.name = :name AND u.age = :age")  
    List<User> findByNameAndAge(@Param("name") String name, @Param("age") int age);  
}

5.自定义SQL查询实例

下面是一个使用自定义SQL查询的例子：

import org.springframework.data.jpa.repository.JpaRepository;  
import org.springframework.data.jpa.repository.Query;  
import org.springframework.data.repository.query.Param;  
import org.springframework.stereotype.Repository;  
import java.util.List;  
  
@Repository  
public interface UserRepository extends JpaRepository<User, Long> {  
  
    @Query(value = "SELECT * FROM users WHERE name LIKE :namePattern", nativeQuery = true)  
    List<User> findByNamePattern(@Param("namePattern") String namePattern);  
}

在这个例子中，我们定义了一个findByNamePattern方法，并使用@Query注解指定了一个自定义的SQL查询语句。nativeQuery = true表示这是一个原生SQL查询，而不是JPQL查询。在查询语句中，我们使用了:namePattern作为占位符，并在方法参数中通过@Param注解指定了对应的参数名。

然后，在UserService中，我们可以像调用其他Repository方法一样调用这个自定义查询方法：

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
import org.springframework.transaction.annotation.Transactional;  
import java.util.List;  
  
@Service  
public class UserService {  
  
    @Autowired  
    private UserRepository userRepository;  
  
    @Transactional(readOnly = true)  
    public List<User> findUsersByNamePattern(String namePattern) {  
        // 可以在这里添加对namePattern的验证逻辑，比如非空检查、格式检查等  
        if (namePattern == null || namePattern.isEmpty()) {  
            throw new IllegalArgumentException("Name pattern cannot be null or empty.");  
        }  
  
        // 使用LIKE查询时，通常需要在模式前后加上百分号来执行模糊匹配  
        String formattedNamePattern = "%" + namePattern + "%";  
          
        // 调用自定义查询方法  
        List<User> users = userRepository.findByNamePattern(formattedNamePattern);  
          
        return users;  
    }  
  
    // 其他方法...  
}

在上面的findUsersByNamePattern方法中，我们首先进行了对namePattern参数的验证，确保其不为空。然后，我们将模式字符串前后添加了百分号，以执行模糊匹配。接着，我们调用了userRepository的findByNamePattern方法，并返回查询到的用户列表。

同时，我们在方法上添加了@Transactional注解，并设置readOnly = true，表示这个操作是只读的，不需要进行数据库事务的提交。这通常用于查询操作，以优化性能。

七、错误处理和日志记录

在实际应用中，错误处理和日志记录也是非常重要的。你可以使用Spring的@ExceptionHandler注解来处理特定类型的异常，或者在方法内部使用日志框架（如SLF4J、Logback等）记录关键信息。

import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import org.springframework.web.bind.annotation.ExceptionHandler;  
import org.springframework.web.bind.annotation.RestControllerAdvice;  
  
@RestControllerAdvice  
public class GlobalExceptionHandler {  
  
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);  
  
    @ExceptionHandler(value = Exception.class)  
    public ResponseEntity<Object> handleGeneralException(Exception ex) {  
        logger.error("General exception occurred: ", ex);  
        // 可以构建自定义的错误响应对象，返回给前端  
        return new ResponseEntity<>(new CustomErrorResponse("General error occurred."), HttpStatus.INTERNAL_SERVER_ERROR);  
    }  
  
    @ExceptionHandler(value = IllegalArgumentException.class)  
    public ResponseEntity<Object> handleIllegalArgumentException(IllegalArgumentException ex) {  
        logger.warn("Illegal argument exception occurred: ", ex);  
        // 构建针对特定异常的响应  
        return new ResponseEntity<>(new CustomErrorResponse("Invalid argument provided."), HttpStatus.BAD_REQUEST);  
    }  
}

在GlobalExceptionHandler中，我们定义了两个异常处理方法，分别处理通用的Exception和特定的IllegalArgumentException。在方法内部，我们使用SLF4J的Logger记录异常信息，并构建合适的HTTP响应返回给前端。

这样，当服务层抛出异常时，这些异常会被GlobalExceptionHandler捕获并处理，同时，关键的日志信息也会被记录下来，便于后续的排查和监控。

这些是对上述内容的一些完善，包括动态查询条件的封装、自定义SQL查询、异常处理和日志记录等方面。实际应用中，可能还需要考虑更多的业务逻辑和性能优化，这些都需要根据具体需求进行定制和扩展。

七、Controller层测试案例

下面是一个简单的UserController类，其中包含了对UserService的调用，并提供了RESTful API接口。

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.http.HttpStatus;  
import org.springframework.http.ResponseEntity;  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.PathVariable;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RestController;  
import java.util.List;  
  
@RestController  
@RequestMapping("/api/users")  
public class UserController {  
  
    @Autowired  
    private UserService userService;  
  
    @GetMapping("/byname/{namePattern}")  
    public ResponseEntity<List<User>> findUsersByNamePattern(@PathVariable String namePattern) {  
        try {  
            List<User> users = userService.findUsersByNamePattern(namePattern);  
            return new ResponseEntity<>(users, HttpStatus.OK);  
        } catch (Exception e) {  
            // 可以在这里进行更详细的异常处理，比如转换为自定义错误响应  
            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);  
        }  
    }  
  
    // 其他API方法...  
}

接下来，我们可以编写一个简单的测试类来测试UserController的findUsersByNamePattern方法。使用Spring Boot的@WebMvcTest注解可以方便地模拟MVC层的测试，而无需启动整个应用程序。

import org.junit.jupiter.api.Test;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;  
import org.springframework.http.MediaType;  
import org.springframework.test.web.servlet.MockMvc;  
import org.springframework.test.web.servlet.MvcResult;  
  
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;  
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;  
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;  
import static org.hamcrest.Matchers.notNullValue;  
import static org.hamcrest.Matchers.hasSize;  
import static org.hamcrest.Matchers.is;  
  
@WebMvcTest(UserController.class)  
public class UserControllerTest {  
  
    @Autowired  
    private MockMvc mockMvc;  
  
    @Test  
    public void testFindUsersByNamePattern() throws Exception {  
        String namePattern = "test";  
        MvcResult mvcResult = mockMvc.perform(get("/api/users/byname/{namePattern}", namePattern)  
                .contentType(MediaType.APPLICATION_JSON))  
                .andExpect(status().isOk())  
                .andDo(print()) // 打印请求和响应信息，便于调试  
                .andReturn();  
  
        String responseContent = mvcResult.getResponse().getContentAsString();  
        // 这里可以添加对响应内容的断言，比如解析为JSON对象并验证其结构  
        // 由于示例简单，这里仅检查非空和状态码  
        assertThat(responseContent, notNullValue());  
    }  
}

在上面的测试类中，我们使用MockMvc来模拟发送HTTP请求到UserController，并验证响应的状态码。testFindUsersByNamePattern方法发送了一个GET请求到/api/users/byname/{namePattern}，并期望得到一个状态码为200的响应。我们还使用了print()方法来打印请求和响应的详细信息，这在开发和调试过程中非常有用。

为了调用这个API接口，你可以使用任何HTTP客户端（如curl、Postman或浏览器）发送GET请求到http://localhost:8080/api/users/byname/test（假设你的Spring Boot应用程序在8080端口上运行）。你应该会看到一个包含匹配用户名的用户列表的JSON响应。

dazhong2012

关注

20
点赞
踩
16

收藏

觉得还不错? 一键收藏
2
评论
Spring Data JPA：简化Java持久化的艺术

除了使用JPQL或Criteria API构建查询外，Spring Data JPA也支持使用自定义SQL查询。这通常是通过在Repository接口的方法上使用@Query注解来实现的。List;
复制链接

扫一扫