转载

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

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

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

另外，我发现网上关于连表查询这一块并没有太多比较有参考价值的博客，所以对这部分也做了详细的总结，以供大家学习参考

项目代码基于 Spring Boot 最新的 2.1.9.RELEASE 版本构建(截止到这篇文章写完)，另外，新建项目的过程就不多说了。

一 JPA 基础：常见操作

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); 
 
    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 语句会非常有用。

根据 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 
    @Transactional 
    @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 的基本用法：

使用 JPA 自带的方法进行增删改查以及条件查询。

自定义 SQL 语句进行查询或者更新数据库。

创建异步的方法。

在下一篇关于 JPA 的文章中我会介绍到非常重要的两个知识点：

基本分页功能实现

多表联合查询以及多表联合查询下的分页功能实现。

二 JPA 连表查询和分页

对于连表查询，在 JPA 中还是非常常见的，由于 JPA 可以在 respository 层自定义 SQL 语句，所以通过自定义 SQL 语句的方式实现连表还是挺简单。这篇文章是在上一篇入门 JPA的文章的基础上写的，不了解 JPA 的可以先看上一篇文章。

在上一节的基础上我们新建了两个实体类，如下：

1.相关实体类创建

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; 
} 

2.自定义 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 对象的操作。

3.自定义 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()); 

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

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

IN 查询

BETWEEN 查询

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

4.1 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 personList=new ArrayList<>(Arrays.asList("person1","person2"));List userDTOS = personRepository.filterUserInfo(personList);

4.2 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 userDTOS = personRepository.filterUserInfoByAge(19,20);

5.测试类和源代码地址

@SpringBootTest 
@RunWith(SpringRunner.class) 
public class PersonRepositoryTest2 { 
    @Autowired 
    private PersonRepository personRepository; 
 
    @Sql(scripts = {"classpath:/init.sql"}) 
    @Test 
    public void find_person_age_older_than_18() { 
        List<Person> personList = personRepository.findByAgeGreaterThan(18); 
        assertEquals(1, personList.size()); 
    } 
 
    @Sql(scripts = {"classpath:/init.sql"}) 
    @Test 
    public void should_get_user_info() { 
        Optional<UserDTO> userInformation = personRepository.getUserInformation(1L); 
        System.out.println(userInformation.get().toString()); 
    } 
 
    @Sql(scripts = {"classpath:/init.sql"}) 
    @Test 
    public void should_get_user_info_list() { 
        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(scripts = {"classpath:/init.sql"}) 
    @Test 
    public void should_filter_user_info() { 
        List<String> personList=new ArrayList<>(Arrays.asList("person1","person2")); 
        List<UserDTO> userDTOS = personRepository.filterUserInfo(personList); 
        System.out.println(userDTOS); 
    } 
 
    @Sql(scripts = {"classpath:/init.sql"}) 
    @Test 
    public void should_filter_user_info_by_age() { 
        List<UserDTO> userDTOS = personRepository.filterUserInfoByAge(19,20); 
        System.out.println(userDTOS); 
    } 
} 

六 总结

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

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

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

条件查询：IN 查询，BETWEEN查询。

我们这一节是把 SQl 语句连表查询的逻辑放在 Dao 层直接写的，这样写的好处是比较方便，也比较简单明了。但是可能会不太好维护，很多时候我们会选择将这些逻辑放到 Service 层去做，这样也是可以实现的，后面章我就会介绍到如何将这些写在 Dao 层的逻辑转移到 Service 层去。

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

原文  http://developer.51cto.com/art/201910/604500.htm
正文到此结束
所属分类： Spring

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
Java入门教程 bootstrap3 CSS springboot-demo Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 Struts2教程 MongoDB教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 SpringCloud ANTLR教程 Hive教程 java实例教程 Ant教程 Hazelcast教程 Elastic-Job-Lite XStream教程 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 WebService CXF学习 Hadoop教程 solr教程 JPA教程 ActiveMQ中文指南 Java内存模型 dubbo教程 Linux入门视频教程
近期评论
  1. 1 Spring Boot集成Spring Session快速入门Demo
  2. 2 Spring Boot集成RabbitMQ快速入门Demo
  3. 3 Spring Boot集成Quartz快速入门Demo
  4. 4 Spring Boot集成Mybatis Plus快速入门Demo
  5. 5 Spring Boot集成zipkin快速入门Demo
  6. 6 能用365块大洋去解决的事，千万不要用时间
  7. 7 Spring Boot集成atomikos快速入门Demo
  8. 8 Spring Boot集成fastdfs快速入门Demo
  9. 9 Spring Boot集成Https快速入门Demo
  10. 10 Spring Boot集成easypoi快速入门Demo
网站信息
  • 文章总数：155,463 篇
  • 文件总数：468,744 个
  • 标签总数：2,266 个
  • 分类总数：90 个
  • 留言数量：2,542 条
  • 在线人数：671 人
  • 运行天数：4,197天
  • 最后更新：2024年04月24日04点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG