Spring Data JPA介绍与CRUD实战演练

---

一、Spring Data JPA 简介

Spring Data JPA 是 Spring 框架中的一个模块，它旨在简化 Java Persistence API (JPA) 的使用，进而简化数据访问层的开发。JPA 是 Java 平台上用于管理关系数据库的对象关系映射(ORM)的标准。而 Spring Data JPA 在此基础之上提供了额外的抽象层，允许开发者以更简洁的方式编写数据访问代码，无需手动编写大量的实现代码。

核心特点包括：

1. 简化 CRUD 操作：通过继承 JpaRepository 或其他 Spring Data 提供的接口，你可以直接在自定义的 Repository 接口中声明方法，而无需编写实现。Spring Data JPA 会根据方法名自动生成查询语句。

2. 方法命名查询：依据一定的命名规则，Spring Data JPA 能够根据 Repository 接口中的方法名称自动生成 SQL 或 HQL 查询语句，例如 findByUsernameAndPassword 会自动转换为寻找匹配用户名和密码的查询。

3. 查询DSL：除了方法命名查询，它还提供了强大的查询dsl（领域特定语言），允许构建类型安全的复杂查询。

4. 分页与排序：轻松实现数据的分页查询和排序功能。

5. 事务管理：集成 Spring 的事务管理，使得数据操作更加安全可靠。

6. 动态查询：支持 Criteria API 和 Specifications，可以构建复杂的动态查询条件。

7. 减少样板代码：大量减少了传统 JPA 开发中需要编写的 DAO 层实现代码，提高开发效率。

8. 扩展性：虽然提供了很多开箱即用的功能，但同时也允许开发者自定义查询逻辑，保持了高度的灵活性。

通过这些特性，Spring Data JPA 成为了快速开发 Java 应用，特别是那些需要与关系型数据库交互的应用的首选框架之一。开发者只需关注业务逻辑，而不必过多担忧数据访问层的细节。

---

二、Spring Data JPA 与 MyBatis Plus 比较

Spring Data JPA 和 MyBatis Plus 是两种不同的持久层框架，它们各有特色，适用于不同场景和需求。以下是它们之间的一些关键区别：

设计哲学和抽象层次

• Spring Data JPA 基于 JPA 规范，提供了高度抽象的数据访问层，允许开发者以面向对象的方式操作数据库，减少了直接编写 SQL 的需要。它通过方法命名约定来自动生成查询，支持实体映射和事务管理，更适合那些希望快速开发、遵循 Java EE 标准且偏好 ORM（对象关系映射）的项目。

• MyBatis Plus 则是对 MyBatis 的增强，它依然保留了 MyBatis 手动编写 SQL 的灵活性，同时加入了许多开箱即用的功能，如常见的 CRUD 操作、分页、性能优化等。MyBatis Plus 更加适合需要高度定制 SQL 查询、对性能有严格要求或者需要直接控制 SQL 执行的场景。

SQL 控制

• Spring Data JPA 主要通过方法命名约定来自动生成 SQL，虽然也支持 @Query 注解来自定义 SQL，但其强项在于无须编写 SQL 即可完成大部分 CRUD 操作。

• MyBatis Plus 支持 SQL 的完全自定义，这为开发者提供了更大的灵活性，特别是在处理复杂的联表查询和性能优化时更为明显。它还提供了 MapKey 注解等特性，便于在多表关联查询中进行数据关联。

学习曲线和技术要求

• Spring Data JPA 因其高度抽象，初学者可能更容易上手，但深入理解和调试 ORM 映射问题可能需要更多专业知识。

• MyBatis Plus 虽然需要手动编写 SQL，但对 SQL 较熟悉的开发者可能会觉得这种方式更直接、可控，学习成本相对较低，尤其是在已有 MyBatis 使用经验的基础上。

性能与优化

• Spring Data JPA（及底层的 Hibernate）由于其抽象层次较高，可能会在某些简单查询上略逊于直接编写 SQL 的框架。但它提供了缓存管理、延迟加载等特性，对提高整体应用性能有帮助。

• MyBatis Plus 直接控制 SQL，因此在查询优化和性能调优上有更多空间，特别是对于复杂的查询场景，能够通过精确控制 SQL 来达到更好的性能。

综合考虑

选择 Spring Data JPA 还是 MyBatis Plus，通常取决于项目的需求、团队的技术栈偏好以及对 SQL 控制的需求程度。如果项目追求快速开发、代码的简洁性，且对 SQL 的直接控制需求不高，Spring Data JPA 是个不错的选择。相反，如果项目需要复杂的 SQL 查询、高度的性能优化，或者团队更倾向于 SQL 的直接操控，MyBatis Plus 可能更加合适。在实际应用中，两者并非互斥，根据具体模块的需求混合使用也是常见做法。

---

三、SpringDataJpa实战演练

1. 创建user表

CREATE TABLE `user` (`id` int(11) NOT NULL AUTO_INCREMENT,`name` varchar(50) DEFAULT NULL,`age` int(11) DEFAULT NULL,PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=130 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci

2. 搭建Spring Boot开发环境

目录结构如下：

springboot-template-jpa
│  pom.xml
│  springboot-template-jpa.iml
│
├─src
│  └─main
│      ├─java
│      │  └─com
│      │      └─zcs
│      │          │  Application.java
│      │          │
│      │          ├─common
│      │          │      Result.java
│      │          │
│      │          ├─config
│      │          ├─controller
│      │          │      UserController.java
│      │          │
│      │          ├─domain
│      │          ├─entity
│      │          │      User.java
│      │          │
│      │          ├─mapper
│      │          ├─repository
│      │          │      UserRepository.java
│      │          │
│      │          ├─service
│      │          │      UserService.java
│      │          │
│      │          └─utils
│      └─resources
│              application.yml

3. pom.xml文件内容

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.7.15</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.zcs</groupId><artifactId>springboot-template-jpa</artifactId><version>1.0.0</version><name>springboot-template</name><description>springboot-template</description><properties><java.version>1.8</java.version><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency><!-- 引入Spring Boot Actuator的起步依赖，用于监控和管理生产环境中的应用程序 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId></dependency><dependency><groupId>com.baomidou</groupId><artifactId>dynamic-datasource-spring-boot-starter</artifactId><version>4.3.0</version></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.3.1</version></dependency><!-- 数据库驱动，例如MySQL --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.15</version><scope>runtime</scope></dependency><!-- https://mvnrepository.com/artifact/com.oracle.database.jdbc/ojdbc8 --><dependency><groupId>com.oracle.database.jdbc</groupId><artifactId>ojdbc8</artifactId><version>21.5.0.0</version></dependency><!-- https://mvnrepository.com/artifact/com.microsoft.sqlserver/mssql-jdbc --><dependency><groupId>com.microsoft.sqlserver</groupId><artifactId>mssql-jdbc</artifactId><version>9.4.1.jre8</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><!-- Spring Boot Starter Web --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-configuration-processor</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope><optional>true</optional></dependency><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>2.0.0</version></dependency><dependency><groupId>commons-io</groupId><artifactId>commons-io</artifactId><version>2.7</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter-test</artifactId><version>2.3.1</version><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><includeSystemScope>true</includeSystemScope><excludes><exclude><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></exclude></excludes></configuration></plugin></plugins></build></project>

4. application.yml文件内容

server:port: 8090
---
spring:web:resources:static-locations: classpath:/static/datasource:dynamic:primary: master # 设置默认数据源strict: false # 设置严格模式，true则未匹配到数据源时抛异常，false则使用默认数据源datasource:master: # 池名称url: jdbc:mysql://192.168.145.103:3306/test?useSSL=false&useUnicode=true&characterEncoding=UTF-8username: rootpassword: rootdriver-class-name: com.mysql.cj.jdbc.Driverdruid:validation-query: "select 1"
---
mybatis:configuration:map-underscore-to-camel-case: true
#    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
---
# 开启所有Actuator的端点暴露，以便可以通过HTTP进行访问
management:endpoints:web:exposure:include: "*"# 配置健康端点的详细程度，always表示总是显示完整的健康信息endpoint:health:show-details: always

5. Application.java

package com.zcs;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}

6. Result.java

package com.zcs.common;import lombok.Data;@Data
public class Result<T> {private int code;private int success;private String msg;private T data;public Result(int code, String msg, int success) {this.code = code;this.msg = msg;this.success = success;}public Result(int code, String msg, int success, T data) {this.code = code;this.msg = msg;this.success = success;this.data = data;}public static <T> Result<T> success() {return new Result<>(200, "", 0);}public static <T> Result<T> success(String msg) {return new Result<>(200, msg, 0);}public static <T> Result<T> success(String msg, T data) {return new Result<>(200, msg, 0, data);}public static <T> Result<T> error(int code, String message) {return new Result<>(code, message, -1);}public static <T> Result<T> error(int code, String message, T data) {return new Result<>(code, message, -1, data);}
}

7. User.java

package com.zcs.entity;import lombok.Data;import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;@Data
@Entity
public class User {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Integer id;private String name;private Integer age;
}

8. UserRepository.java

package com.zcs.repository;import com.zcs.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;@Mapper
@Repository
public interface UserRepository extends JpaRepository<User, Integer> {@Select("SELECT * FROM user WHERE id = #{id}")User getUserById(Integer id);}

9. UserService.java

package com.zcs.service;import com.zcs.entity.User;
import com.zcs.repository.UserRepository;
import org.springframework.data.domain.*;
import org.springframework.data.repository.query.FluentQuery;
import org.springframework.stereotype.Service;import javax.annotation.Resource;
import java.nio.file.DirectoryStream;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;@Service
public class UserService {@Resourceprivate UserRepository userRepository;public List<User> getAllUsers() {return userRepository.findAll();}public List<User> getAllUsersByIds(List<Integer> ids) {return userRepository.findAllById(ids);}public User getUserById(Integer id) {return userRepository.getUserById(id);}public User insertOrUpdateUser(User user) {return userRepository.save(user);}public User insertOrUpdateAndFlushUser(User user) {return userRepository.saveAndFlush(user);}public String deleteById(Integer id) {boolean b = userRepository.existsById(id);if (b) {userRepository.deleteById(id);return "数据删除成功";}return "要删除的数据不存在";}public boolean existsById(Integer id) {return userRepository.existsById(id);}public Optional<User> findOne(String name) {User probeUser = new User(); // 假设User类有name属性probeUser.setName(name); // 设置你想查询的名字// 创建一个ExampleMatcher来定义匹配规则，例如忽略大小写等ExampleMatcher matcher = ExampleMatcher.matching().withIgnoreCase() // 忽略属性比较时的大小写.withStringMatcher(ExampleMatcher.StringMatcher.EXACT); // 使用"contains"方式匹配字符串// 创建Example实例Example<User> example = Example.of(probeUser, matcher);Function<FluentQuery.FetchableFluentQuery<User>, Optional<User>> one = FluentQuery.FetchableFluentQuery::first;// 使用findOne方法根据example查询return userRepository.findBy(example, one);}public Optional<User> getUserByName(String name) {User probeUser = new User(); // 假设User类有name属性probeUser.setName(name); // 设置你想查询的名字ExampleMatcher matcher = ExampleMatcher.matching().withIgnoreCase() // 忽略大小写匹配.withStringMatcher(ExampleMatcher.StringMatcher.EXACT); // 精确匹配Example<User> example = Example.of(probeUser, matcher);Function<FluentQuery.FetchableFluentQuery<User>, Optional<User>> queryFunction = FluentQuery.FetchableFluentQuery::first;return userRepository.findBy(example, queryFunction);}public List<User> getAllUserByName(String name) {User probeUser = new User(); // 假设User类有name属性probeUser.setName(name); // 设置你想查询的名字ExampleMatcher matcher = ExampleMatcher.matching().withIgnoreCase() // 忽略大小写匹配.withStringMatcher(ExampleMatcher.StringMatcher.EXACT); // 精确匹配Example<User> example = Example.of(probeUser, matcher);Function<FluentQuery.FetchableFluentQuery<User>, List<User>> all = FluentQuery.FetchableFluentQuery::all;return userRepository.findBy(example, all);}public List<User> getAllUserByNameAndAge(String name, Integer age) {User probeUser = new User(); // 假设User类有name属性probeUser.setName(name); // 设置你想查询的名字probeUser.setAge(age); // 设置你想查询的名字ExampleMatcher matcher = ExampleMatcher.matching().withIgnoreCase() // 忽略大小写匹配.withStringMatcher(ExampleMatcher.StringMatcher.EXACT); // 精确匹配Example<User> example = Example.of(probeUser, matcher);// Function<FluentQuery.FetchableFluentQuery<User>, Optional<User>> queryFunction = query -> query.one();Function<FluentQuery.FetchableFluentQuery<User>, List<User>> all = FluentQuery.FetchableFluentQuery::all;// Function<FluentQuery.FetchableFluentQuery<User>, Stream<User>> stream = FluentQuery.FetchableFluentQuery::stream;return userRepository.findBy(example, all);}public Page<User> getUsers(int pageNumber, int pageSize) {// 创建Pageable对象，参数分别是页码（从0开始）和页面大小Pageable pageable = PageRequest.of(pageNumber, pageSize);// 调用findAll方法传入Pageable对象进行分页查询return userRepository.findAll(pageable);}
}

10. UserController.java

package com.zcs.controller;import com.zcs.common.Result;
import com.zcs.entity.User;
import com.zcs.repository.UserRepository;
import com.zcs.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.web.bind.annotation.*;import javax.annotation.Resource;
import java.util.List;
import java.util.Optional;@Slf4j
@RestController
@RequestMapping("/users")
public class UserController {@Resourceprivate UserRepository userRepository;@Resourceprivate UserService userService;@GetMappingpublic List<User> getAllUsers() {return userService.getAllUsers();}// 根据id查询user@GetMapping("/{id}")public Result<User> getById(@PathVariable Integer id) {User user = userRepository.findById(id).get();return Result.success("success", user);}// 查询user表的行数@GetMapping("/count")public Result<Long> count() {long count = userRepository.count();return Result.success("success", count);}// 根据name查询匹配到的第一条数据@GetMapping("/findOne")public Result<Optional<User>> findOne(@RequestParam String name) {Optional<User> userServiceOne = userService.findOne(name);return Result.success("success", userServiceOne);}// 根据id列表（用逗号分隔）查询user@GetMapping("/ids/{ids}")public Result<List<User>> getAllUsersByIds(@PathVariable List<Integer> ids) {List<User> allUsersByIds = userService.getAllUsersByIds(ids);return Result.success("success", allUsersByIds);}// 根据id查询user@GetMapping("/id/{id}")public Result<User> getUserById(@PathVariable Integer id) {User userById = userService.getUserById(id);return Result.success("success", userById);}// 根据name查询user匹配到的第一个数据@GetMapping("/getUserByName")public Result<Optional<User>> getUserByName(@RequestParam String name) {Optional<User> userByName = userService.getUserByName(name);return Result.success("success", userByName);}// 根据name查询匹配到的所有user@GetMapping("/getAllUserByName")public Result<List<User>> getAllUserByName(@RequestParam String name) {List<User> allUserByName = userService.getAllUserByName(name);return Result.success("success", allUserByName);}// 根据name和age查询匹配到的所有user@GetMapping("/getAllUserByNameAndAge")public Result<List<User>> getAllUserByNameAndAge(@RequestParam String name, @RequestParam Integer age) {List<User> allUserByName = userService.getAllUserByNameAndAge(name, age);return Result.success("success", allUserByName);}// 根据id查询数据是否存在@GetMapping("/exists/{id}")public Result<Boolean> existsById(@PathVariable Integer id) {boolean b = userService.existsById(id);return Result.success("success", b);}// 插入或更新user@PostMappingpublic Result<User> insertOrUpdateUser(@RequestBody User user) {User user1 = userService.insertOrUpdateUser(user);return Result.success("success", user1);}// 插入或更新user，且刷新@PutMappingpublic Result<User> insertOrUpdateAndFlushUser(@RequestBody User user) {User user1 = userService.insertOrUpdateAndFlushUser(user);return Result.success("success", user1);}// 根据id删除数据@DeleteMapping("/{id}")public Result<String> deleteById(@PathVariable Integer id) {String string = userService.deleteById(id);return Result.success("success", string);}// 分页查询@GetMapping("/page")public Result<Page<User>> getUsersByPage(@RequestParam int pageNumber, @RequestParam(defaultValue = "10") int pageSize) {Page<User> users = userService.getUsers(pageNumber, pageSize);return Result.success("success", users);}}