Spring Data JPA介绍与CRUD实战演练

文章目录

[一、Spring Data JPA 简介](#一、Spring Data JPA 简介)
[二、Spring Data JPA 与 MyBatis Plus 比较](#二、Spring Data JPA 与 MyBatis Plus 比较)
- 设计哲学和抽象层次
- [SQL 控制](#SQL 控制)
- 学习曲线和技术要求
- 性能与优化
- 综合考虑
三、SpringDataJpa实战演练
- [1. 创建user表](#1. 创建user表)
- [2. 搭建Spring Boot开发环境](#2. 搭建Spring Boot开发环境)
- [3. pom.xml文件内容](#3. pom.xml文件内容)
- [4. application.yml文件内容](#4. application.yml文件内容)
- [5. Application.java](#5. Application.java)
- [6. Result.java](#6. Result.java)
- [7. User.java](#7. User.java)
- [8. UserRepository.java](#8. UserRepository.java)
- [9. UserService.java](#9. UserService.java)
- [10. UserController.java](#10. UserController.java)

一、Spring Data JPA 简介

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

核心特点包括：

简化 CRUD 操作 ：通过继承 JpaRepository 或其他 Spring Data 提供的接口，你可以直接在自定义的 Repository 接口中声明方法，而无需编写实现。Spring Data JPA 会根据方法名自动生成查询语句。
方法命名查询 ：依据一定的命名规则，Spring Data JPA 能够根据 Repository 接口中的方法名称自动生成 SQL 或 HQL 查询语句，例如 findByUsernameAndPassword 会自动转换为寻找匹配用户名和密码的查询。
查询DSL：除了方法命名查询，它还提供了强大的查询dsl（领域特定语言），允许构建类型安全的复杂查询。
分页与排序：轻松实现数据的分页查询和排序功能。
事务管理：集成 Spring 的事务管理，使得数据操作更加安全可靠。
动态查询：支持 Criteria API 和 Specifications，可以构建复杂的动态查询条件。
减少样板代码：大量减少了传统 JPA 开发中需要编写的 DAO 层实现代码，提高开发效率。
扩展性：虽然提供了很多开箱即用的功能，但同时也允许开发者自定义查询逻辑，保持了高度的灵活性。

通过这些特性，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表

sql 复制代码

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 复制代码

<?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文件内容

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-8
          username: root
          password: root
          driver-class-name: com.mysql.cj.jdbc.Driver
      druid:
        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

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

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

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

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

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 {

    @Resource
    private 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

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 {
    @Resource
    private UserRepository userRepository;

    @Resource
    private UserService userService;

    @GetMapping
    public 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
    @PostMapping
    public Result<User> insertOrUpdateUser(@RequestBody User user) {
        User user1 = userService.insertOrUpdateUser(user);
        return Result.success("success", user1);
    }

    // 插入或更新user，且刷新
    @PutMapping
    public 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);
    }

}