一文搞懂如何在 Spring Boot 中正确使用 JPA

最新推荐文章于 2024-06-21 07:03:05 发布
最新推荐文章于 2024-06-21 07:03:05 发布
阅读量388 收藏
点赞数
分类专栏： springboot 文章标签： java spring
原文链接：https://github.com/Snailclimb/springboot-guide/blob/master/docs/basis/springboot-jpa.md
版权

一文搞懂如何在 Spring Boot 中正确使用 JPA

JPA 这部分内容上手很容易，但是涉及到的东西还是挺多的，网上大部分关于 JPA 的资料都不是特别齐全，大部分用的版本也是比较落后的。另外，我下面讲到了的内容也不可能涵盖所有 JPA 相关内容，我只是把自己觉得比较重要的知识点总结在了下面。我自己也是参考着官方文档写的，官方文档非常详细了，非常推荐阅读一下。这篇文章可以帮助对 JPA 不了解或者不太熟悉的人来在实际项目中正确使用 JPA。

项目代码基于 Spring Boot 最新的 2.1.9.RELEASE 版本构建（截止到这篇文章写完），另外，新建项目就不多说了，前面的文章已经很详细介绍过。

1.相关依赖

我们需要下面这些依赖支持我们完成这部分内容的学习：

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

2.配置数据库连接信息和JPA配置

下面的配置中需要单独说一下 spring.jpa.hibernate.ddl-auto=create这个配置选项。

这个属性常用的选项有四种：

  1. create:每次重新启动项目都会重新创新表结构，会导致数据丢失
  2. create-drop:每次启动项目创建表结构，关闭项目删除表结构
  3. update:每次启动项目会更新表结构
  4. validate:验证表结构，不对数据库进行任何更改

但是，一定要不要在生产环境使用 ddl 自动生成表结构，一般推荐手写 SQL 语句配合 Flyway 来做这些事情。

spring.datasource.url=jdbc:mysql://localhost:3306/springboot_jpa?useSSL=false&serverTimezone=CTT
spring.datasource.username=root
spring.datasource.password=123456
# 打印出 sql 语句
spring.jpa.show-sql=true

spring.jpa.hibernate.ddl-auto=create

spring.jpa.open-in-view=false
# 创建的表的 ENGINE 为 InnoDB
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL55Dialect

3.实体类

我们为这个类添加了 @Entity 注解代表它是数据库持久化类，还配置了主键 id。

import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
@Data
@NoArgsConstructor
public class Person {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)//主键自增长
    private Long id;
    
    @Column(unique = true)
    private String name;
    private Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

}

如何检验你是否正确完成了上面 3 步?很简单，运行项目，查看数据如果发现控制台打印出创建表的 sql 语句，并且数据库中表真的被创建出来的话，说明你成功完成前面 3 步。

控制台打印出来的 sql 语句类似下面这样：

drop table if exists person
CREATE TABLE `person` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `age` int(11) DEFAULT NULL,
  `name` varchar(255) DEFAULT NULL，
   PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
alter table person add constraint UK_p0wr4vfyr2lyifm8avi67mqw5 unique (name)

4.创建操作数据库的 Repository 接口

@Repository
public interface PersonRepository extends JpaRepository<Person, Long> {
    //泛型的两个参数分别是：实体映射，主键的类型
}

首先这个接口加了 @Repository 注解，代表它和数据库操作有关。另外，它继承了 JpaRepository接口，而JpaRepository长这样：

@NoRepositoryBean
public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {
    List<T> findAll();

    List<T> findAll(Sort var1);

    List<T> findAllById(Iterable<ID> var1);

    <S extends T> List<S> saveAll(Iterable<S> var1);

    void flush();

    <S extends T> S saveAndFlush(S var1);//更改将立即刷新到DB

    void deleteInBatch(Iterable<T> var1);

    void deleteAllInBatch();

    T getOne(ID var1);

    <S extends T> List<S> findAll(Example<S> var1);

    <S extends T> List<S> findAll(Example<S> var1, Sort var2);
}

这表明我们只要继承了JpaRepository 就具有了 JPA 为我们提供好的增删改查、分页查询以及根据条件查询等方法。

4.1 JPA 自带方法实战

1) 增删改查

1.保存用户到数据库

    Person person = new Person("SnailClimb", 23);
    personRepository.save(person);

save()`方法对应 sql 语句就是:`insert into person (age, name) values (23,"snailclimb")

2.根据 id 查找用户

    Optional<Person> personOptional = personRepository.findById(id);

findById()`方法对应 sql 语句就是：`select * from person p where p.id = id

3.根据 id 删除用户

    personRepository.deleteById(id);

deleteById()`方法对应 sql 语句就是：`delete from person where id=id

4.更新用户

更新操作也要通过 save()方法来实现，比如：

    Person person = new Person("SnailClimb", 23);
    Person savedPerson = personRepository.save(person);

    // 更新 person 对象的姓名
    savedPerson.setName("UpdatedName");
    personRepository.save(savedPerson);

在这里 save()方法相当于 sql 语句：update person set name="UpdatedName" where id=id

2) 带条件的查询

下面这些方法是我们根据 JPA 提供的语法自定义的，你需要将下面这些方法写到 PersonRepository 中。

假如我们想要根据 Name 来查找 Person ，你可以这样：

    Optional<Person> findByName(String name);

如果你想要找到年龄大于某个值的人，你可以这样：

    List<Person> findByAgeGreaterThan(int age);

4.2 自定义 SQL 语句实战

很多时候我们自定义 sql 语句会非常有用。

在springDataJPA中，如果你想使用?1 ?2 …这种带问号的语句格式，这个时候你就可以不用带@Param，但是你如果使用 :name 这种格式，就必须使用@Param

根据 name 来查找 Person：

    @Query("select p from Person p where p.name = :name")
    
    Optional<Person> findByNameCustomeQuery(@Param("name") String name);

Person 部分属性查询，避免 select *操作：

    @Query("select p.name from Person p where p.id = :id")
    
    String findPersonNameById(@Param("id") Long id);

根据 id 更新Person name：

    @Modifying
    @Query("update Person p set p.name = ?1 where p.id = ?2")
    void updatePersonNameById(String name, Long id);

4.3 创建异步方法

如果我们需要创建异步方法的话，也比较方便。

异步方法在调用时立即返回，然后会被提交给TaskExecutor执行。当然你也可以选择得出结果后才返回给客户端。如果对 Spring Boot 异步编程感兴趣的话可以看这篇文章：《新手也能看懂的 SpringBoot 异步编程指南》 。

@Async
Future<User> findByName(String name);               

@Async
CompletableFuture<User> findByName(String name);

5.测试类和源代码地址

测试类：

@SpringBootTest
@RunWith(SpringRunner.class)
public class PersonRepositoryTest {
    @Autowired
    private PersonRepository personRepository;
    private Long id;

    /**
     * 保存person到数据库
     */
    @Before
    public void setUp() {
        assertNotNull(personRepository);
        Person person = new Person("SnailClimb", 23);
        Person savedPerson = personRepository.saveAndFlush(person);// 更新 person 对象的姓名
        savedPerson.setName("UpdatedName");
        personRepository.save(savedPerson);

        id = savedPerson.getId();
    }

    /**
     * 使用 JPA 自带的方法查找 person
     */
    @Test
    public void should_get_person() {
        Optional<Person> personOptional = personRepository.findById(id);
        assertTrue(personOptional.isPresent());
        assertEquals("SnailClimb", personOptional.get().getName());
        assertEquals(Integer.valueOf(23), personOptional.get().getAge());

        List<Person> personList = personRepository.findByAgeGreaterThan(18);
        assertEquals(1, personList.size());
        // 清空数据库
        personRepository.deleteAll();
    }

    /**
     * 自定义 query sql 查询语句查找 person
     */

    @Test
    public void should_get_person_use_custom_query() {
        // 查找所有字段
        Optional<Person> personOptional = personRepository.findByNameCustomeQuery("SnailClimb");
        assertTrue(personOptional.isPresent());
        assertEquals(Integer.valueOf(23), personOptional.get().getAge());
        // 查找部分字段
        String personName = personRepository.findPersonNameById(id);
        assertEquals("SnailClimb", personName);
        System.out.println(id);
        // 更新
        personRepository.updatePersonNameById("UpdatedName", id);
        Optional<Person> updatedName = personRepository.findByNameCustomeQuery("UpdatedName");
        assertTrue(updatedName.isPresent());
        // 清空数据库
        personRepository.deleteAll();
    }

}

源代码地址：https://github.com/Snailclimb/springboot-guide/tree/master/source-code/basis/jpa-demo

6. 总结

本文主要介绍了 JPA 的基本用法：

  1. 使用 JPA 自带的方法进行增删改查以及条件查询。
  2. 自定义 SQL 语句进行查询或者更新数据库。
  3. 创建异步的方法。

JPA 连表查询和分页

对于连表查询，在 JPA 中还是非常常见的，由于 JPA 可以在 respository 层自定义 SQL 语句，所以通过自定义 SQL 语句的方式实现连表还是挺简单。

相关实体类创建

//Company.java
@Entity
@Data
@NoArgsConstructor
public class Company {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(unique = true)
    private String companyName;
    private String description;

    public Company(String name, String description) {
        this.companyName = name;
        this.description = description;
    }
}
//School.java
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
public class School {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(unique = true)
    private String name;
    private String description;
}

自定义 SQL语句实现连表查询

假如我们当前要通过 person 表的 id 来查询 Person 的话，我们知道 Person 的信息一共分布在Company、School、Person这三张表中，所以，我们如果要把 Person 的信息都查询出来的话是需要进行连表查询的。

首先我们需要创建一个包含我们需要的 Person 信息的 DTO （数据传输）对象,我们简单第将其命名为 UserDTO，用于保存和传输我们想要的信息。

@Data
@NoArgsConstructor
@Builder(toBuilder = true)
@AllArgsConstructor
public class UserDTO {
    private String name;
    private int age;
    private String companyName;
    private String schoolName;
}

下面我们就来写一个方法查询出 Person 的基本信息。

    /**
     * 连表查询
     */
    @Query(value = "select new github.snailclimb.jpademo.model.dto.UserDTO(p.name,p.age,c.companyName,s.name) " +
            "from Person p left join Company c on  p.companyId=c.id " +
            "left join School s on p.schoolId=s.id " +
            "where p.id=:personId")
    Optional<UserDTO> getUserInformation(@Param("personId") Long personId);

可以看出上面的 sql 语句和我们平时写的没啥区别，差别比较大的就是里面有一个 new 对象的操作。

自定义 SQL 语句连表查询并实现分页操作

假如我们要查询当前所有的人员信息并实现分页的话，你可以按照下面这种方式来做。可以看到，为了实现分页，我们在@Query注解中还添加了 countQuery 属性。

@Query(value = "select new github.snailclimb.jpademo.model.dto.UserDTO(p.name,p.age,c.companyName,s.name) " +
        "from Person p left join Company c on  p.companyId=c.id " +
        "left join School s on p.schoolId=s.id ",
        countQuery = "select count(p.id) " +
                "from Person p left join Company c on  p.companyId=c.id " +
                "left join School s on p.schoolId=s.id ")
Page<UserDTO> getUserInformationList(Pageable pageable);

实际使用：

//分页选项
PageRequest pageRequest = PageRequest.of(0, 3, Sort.Direction.DESC, "age");
Page<UserDTO> userInformationList = personRepository.getUserInformationList(pageRequest);
//查询结果总数
System.out.println(userInformationList.getTotalElements());// 6
//按照当前分页大小，总页数
System.out.println(userInformationList.getTotalPages());// 2
System.out.println(userInformationList.getContent());

加餐:自定以SQL语句的其他用法

下面我只介绍两种比较常用的：

  1. IN 查询
  2. BETWEEN 查询

当然，还有很多用法需要大家自己去实践了。

IN 查询

在 sql 语句中加入我们需要筛选出符合几个条件中的一个的情况下，可以使用 IN 查询，对应到 JPA 中也非常简单。比如下面的方法就实现了，根据名字过滤需要的人员信息。

@Query(value = "select new github.snailclimb.jpademo.model.dto.UserDTO(p.name,p.age,c.companyName,s.name) " +
        "from Person p left join Company c on  p.companyId=c.id " +
        "left join School s on p.schoolId=s.id " +
        "where p.name IN :peopleList")
List<UserDTO> filterUserInfo(List peopleList);

实际使用:

List<String> personList=new ArrayList<>(Arrays.asList("person1","person2"));
List<UserDTO> userDTOS = personRepository.filterUserInfo(personList);

BETWEEN 查询

查询满足某个范围的值。比如下面的方法就实现查询满足某个年龄范围的人员的信息。

    @Query(value = "select new github.snailclimb.jpademo.model.dto.UserDTO(p.name,p.age,c.companyName,s.name) " +
            "from Person p left join Company c on  p.companyId=c.id " +
            "left join School s on p.schoolId=s.id " +
            "where p.age between :small and :big")
    List<UserDTO> filterUserInfoByAge(int small,int big);

实际使用：

List<UserDTO> userDTOS = personRepository.filterUserInfoByAge(19,20);

总结

本节我们主要学习了下面几个知识点：

  1. 自定义 SQL 语句实现连表查询；
  2. 自定义 SQL 语句连表查询并实现分页操作；
  3. 条件查询：IN 查询，BETWEEN查询。
火龙果儿
关注
专栏目录
Hibernate JPA-JPA在工作中使用总结（自己觉得不好用的地方）
西京刀客
02-24 535
文章目录JPA在工作中使用总结 JPA在工作中使用总结 jpa自动生成sql方法命名，当条件参数比较多的时候，你的方法命名就特别长。 如下： /** * 查询某一Sort范围区间 Sort升序排序的部门列表 * * @param parentId * @param lastUpdateType * @param sort * @return */ List<Department> findByParentI
《滚雪球学Spring Boot》教程导航帖（更新于2024.06.20）
**My Coding Family**
06-29 4万+
《滚雪球学Spring Boot》是由CSDN博主bug菌创作的全面Spring Boot教程。作者是全栈开发专家，在多个技术社区如CSDN、掘金、InfoQ、51CTO等担任博客专家，并拥有超过30万的全网粉丝。该教程分为入门篇和进阶篇，每篇包含详细的教学步骤，涵盖Spring Boot的基础和高级主题。
一文搞懂 Spring JPA
CSDN资讯
06-28 2880
作者 |阿文责编 | 屠敏什么是 JPA大家好，今天我和大家聊一下关于Spring JPA 的相关知识，我们先来了解下什么是 JPA ？JPA (Java Persistence AP...
从零开始学SpringBoot2.x（10-如何在SpringBoot中使用JPA操作数据库）
笑笑是一个码农
01-31 294
在我们日常开发中，操作数据库是必不可少的工作。在使用SpringBoot之前，我们操作数据库经常会用到Hibernate、Mybatis等ORM框架，那么在SpringBoot应用中如何操作数据库呢？下面我就与大家简单分享一下如何使用JPA。 1、什么是JPA JPA并不是一个框架，它是Sun公司所定义的ORM规范，Hibernate、Toplink、OpenJPA等ORM框架针对JPA...
springBoot+jpa的增删差改操作（CRUD）+mysql8.0以及简单分页的基本使用
轻功水上喵丶的博客
03-28 742
1. 基于之前 如果没有接触过JPA请先移步 2.修改CategoryController 为CategoryController添加： 增加、删除、获取、修改映射 package com.eknaij.springbootjpa.controller; import com.eknaij.springbootjpa.dao.CategoryDAO; import com.eknaij.spri...
一文搞懂如何在Spring Boot 正确中使用JPA
xajh_czbk的博客
10-19 230
这篇是转载文章，因为觉得写的填好了，不过在转载之前，我还是想一如既往的写点自己的话。 基础篇：1.使用JPA自带的方法进行增删改查以及条件查询。2.自定义sql语句进行查询或更新数据库。3.创建异步方法。 提高篇：1.自定义sql语句实现连表查询 2.自定义sql语句连表查询并实现分页操作 3.条件查询：IN查询，Bettween查询。 原创SnailClimbJavaGuide2019-10-18 收...
SpringBoot 一文搞懂Spring JPA
segegefe的博客
08-02 370
spirngdatajpa是spring提供的一套简化JPA开发的框架，按照约定好的【方法命名规则】写dao层接口，就可以在不写接口实现的情况下，实现对数据库的访问和操作。同时提供了很多除了CRUD之外的功能，如分页、排序、复杂查询等等。SpringDataJPA可以理解为JPA规范的再次封装抽象，底层还是使用了Hibernate的JPA技术实现。一、导入依赖二、添加配置文件在application.yml中添加datasource配置，或者springurljdbc。...
2024最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
热门推荐
**My Coding Family**
04-20 8万+
从0到1以知识点+实例+项目的教学模式对SpringBoot框架由浅入深进行学习，快来跟bug菌一起学习吧。
一文精通：Spring Boot下如何优雅实现多租户架构？
最新发布
java专栏
06-21 429
🔥关注墨瑾轩，带你探索Java的奥秘！🚀🔥超萌技术攻略，轻松晋级编程高手！🚀🔥技术宝库已备好，就等你来挖掘！🚀🔥订阅墨瑾轩，智趣学习不孤单！🚀🔥即刻启航，编程之旅更有趣！🚀在Spring Boot应用中实现多租户架构是一种常见需求，尤其在SaaS（Software as a Service）应用中更为重要。多租户意味着一个单独的应用实例能够为多个组织（租户）提供服务，同时保证每个租户的数据隔离。
Spring Boot入门(18)：使用Spring Boot快速实现静态资源映射，完美展示前端页面！
**My Coding Family**
04-29 5374
Spring Boot如何设置静态资源映射，一文带你搞定。
【Spring Boot 】JPA 的基本使用
Ls66666Ls的博客
05-30 555
JPA（Java Persistence API）是一种Java编程接口，用于简化Java应用程序与数据库之间的交互。它提供了一种标准的持久化方式，可以将Java对象映射到关系型数据库表中，实现对象和数据库之间的转换。通过JPA，开发人员可以使用面向对象的方式来操作数据库，而不需关注数据库细节和编写大量的SQL语句，从而提高开发效率和代码质量。JPA还提供了方便的查询语言JPQL，支持复杂的查询操作。
Spring Boot 集成JPA一篇就够
Lehman_Tong
10-05 437
目前市场上Java语言ORM框架有Mybatis、Hibernate、Spring Data JPA，其中JPA底层还是使用Hibernate实现，引用JPQL查询语言，属于Spring整个生态体系的一部分，使用起来比较方便，加快了研发效率。 Part-1: Jpa基础知识 本章节将通过一些例子让大家对Jpa的日常使用有一个了解。 数据库准备 CREATE TABLE `user_info` ( `id` bigint NOT NULL AUTO_INCREMENT, `first_name`
spring boot jpa 使用Oracle10gDialect使分页效率提升100倍
雾里华的博客
12-16 380
文档：Hibernate中的数据库方言（Dialect） http://note.youdao.com/noteshare?id=7d11a7bf13d8eae2decda70896ab529b&sub=76163EBA64A74F039A7F20A230E42A14 当使用Oracle10gDialect时分页为 SELECT * FROM ( SELECT row_.*, rownum rownum_ FROM ( select * fr...
jpa 自定义sql if_SpringBoot整合JPA实现多数据源及读写分离
weixin_39559277的博客
11-20 350
SpringBoot整合JPA实现多数据源及读写分离项目地址：https://github.com/baojingyu/spring-boot-jpa-dynamic-datasource本项目使用 SpringBoot 和 SpringData JPA 实现多数据源，动态数据源的切换。前段时间写 MySQL 主从复制的技术分享，我就在想，既然主从复制都搭建好了，不写个 Demo 玩玩读...
springboot + JPA
CaBCo的博客
12-16 1754
关于ORM框架的选择，左手mybatis，右手JPA，孰优孰劣，该如何选择？
Spring Boot 整合 JPA使用不兼容的数据库方言。
Java开源程序猿
01-08 978
在 Spring Boot 整合 JPA 时，选择正确的数据库方言（Dialect）非常重要，因为它影响到生成的 SQL 语句的正确性和性能。如果使用不兼容的数据库方言，可能会导致语法错误或性能下降。这样你可以在控制台上看到 Hibernate 生成的 SQL 语句，从而确认是否使用了正确的数据库方言。通过以上步骤，你应该能够确保 Spring Boot 应用程序使用了正确的数据库方言，从而避免不兼容数据库方言导致的问题。
【Java】Spring Boot 使用JPA实战
微信公众号: 后端码匠
10-23 1066
最近在项目中使用了一下jpa，发现还是挺好用的。这里就来讲一下jpa以及在spring boot中的使用。 在这里我们先来了解一下jpa。 JPA的全称是Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的 接口和抽象类 构成。 JPA通过JDK 5.0注解描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中...
[JPA] SpringBoot+JPA自动生成数据ku表以及dialect 报错ParserException如何解决！
汤圆的博客
04-06 494
server: port: 8088 spring: datasource: driver-class-name: com.mysql.jdbc.Driver url: jdbc:mysql://localhost:3306/数据库名?useUnicode=true&characterEncoding=UTF8&useSSL=false username: root password: 密码 #部分一 jpa: show-sql: tru
jpa 自定义sql if_一文搞懂如何在Spring Boot 正确中使用JPA
weixin_39704374的博客
11-20 701
本文已经整理进 JavaGuide 开源的 springboot-guide(SpringBoot 核心知识点总结。 基于 Spring Boot 2.19+)，地址：https://github.com/Snailclimb/springboot-guide 。JPA 这部分内容上手很容易，但是涉及到的东西还是挺多的，网上大部分关于 JPA 的资料都不是特别齐全，大部分用的版本也是比较...
如何在 Spring Boot 中使用 JPA
05-17
在 Spring Boot 中使用 JPA需要以下步骤： 1. 添加 JPA 依赖 在 pom.xml 文件中添加如下依赖： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> ``` 2. 配置数据源 在 application.properties 文件中添加数据源配置，例如： ``` spring.datasource.url=jdbc:mysql://localhost:3306/demo spring.datasource.username=root spring.datasource.password=password spring.datasource.driver-class-name=com.mysql.jdbc.Driver ``` 3. 创建实体类 创建与数据库表对应的实体类，例如： ``` @Entity @Table(name = "user") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = "name") private String name; @Column(name = "age") private int age; } ``` 4. 创建 Repository 接口 创建一个继承 JpaRepository 的 Repository 接口，例如： ``` public interface UserRepository extends JpaRepository<User, Long> { } ``` 5. 使用 Repository 在需要使用数据库操作的地方注入 UserRepository，并使用其提供的方法进行数据库操作，例如： ``` @Service public class UserService { @Autowired private UserRepository userRepository; public List<User> getAllUsers() { return userRepository.findAll(); } public User getUserById(Long id) { return userRepository.findById(id).orElse(null); } public User saveUser(User user) { return userRepository.save(user); } public void deleteUserById(Long id) { userRepository.deleteById(id); } } ``` 以上就是在 Spring Boot 中使用 JPA 的基本步骤，当然在实际应用中还需要更多的配置和处理，例如事务管理等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值