SpringBoot第九篇：整合Spring Data JPA

时间  2019-11-08
标签 springboot 第九 整合 spring data jpa 栏目 Spring 繁體版
原文   原文链接

做者：追梦1819
原文：https://www.cnblogs.com/yanfei1819/p/10910059.html
版权声明：本文为博主原创文章，转载请附上博文连接！

html

前言

  前面几章，咱们介绍了 JDBCTemplate、MyBatis 等 ORM 框架。下面咱们来介绍极简模式的 Spring Data JPA。

java

Spring Data JPA

简介

  咱们先来了解几个基本概念，捋一下各个概念之间的关系。mysql

一、JPAgit

  JPA是Java Persistence API的简称，中文名Java持久层API，SUN公司出品。是 JDK 5.0 注解或 XML 描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。github

  它的出现目的有两个：web

  • 简化数据库访问层；
  • 实现 ORM 框架的统一（目前尚未彻底作到）。

二、JPA 和 hibernate 的关系redis

  • JPA 是 Hibernate 的一个抽象，就像 JDBC 和 JDBC 驱动的关系；spring

  • JPA 是一种 ORM 规范，是 Hibernate 功能的一个子集 ；sql

  • Hibernate 是 JPA 的一个实现；mongodb

三、Spring Data

  众所周知，Spring 是一个你们庭，一个技术的生态圈，其中整合的内容一应俱全。而 Spring Data xxx 系列就是 Spring 这个生态圈对数据持久化层的整合。

  Spring Data是Spring用来解决数据访问的解决方案，它包含了大量关系型数据库以及NoSQL数据库的数据持久层访问解决方案。它包含Spring Data JPA、Spring Data MongoDB、Spring Data Neo4j、Spring Data GernFile、Spring Data Cassandra等。

  目前现有的 Spring-data-jpa，Spring-data-template，Spring-data-mongodb，Spring-data-redis 等。固然，也包括最开始用的 mybatis-spring ，MyBatis 与 Spring 的整合。

  因而，就出现了 Spring-data-jpa ，Spring 与 JPA 的整合。

  具体详情参看 Spring Data 官网介绍 。

四、关于 "dao"

  在 Java web 项目中，咱们常常会看到这个包名或者以它为后缀名的类名，它所表明的是，数据库持久化层，是 Data Access Object 的简写。不过有时候咱们也会看到 mapper 等。其实这些都是同一个意思，表明数据库持久化层。

  在 JDBCTemplate 中，可能会用 "dao"，在 MyBatis 中，可能会用 "mapper"（对应 xxxMapper.xml文件），在 JPA 中，可能会用"repository"等。

  其实名称彻底是自定义，只不过开发者在开发的时候会有一些约定俗成的习惯，仅此而已。

五、Spring Data JPA

  正如上所说，Spring Data JPA 是 Spring 与 JPA 的整合。是基于 JPA 对数据库访问层的加强支持。旨在简化数据库访问层，减小工做量。

  具体详情参看 Spring Data JPA 官网。


核心概念

  对于开发者来讲，使用起来很简单。下面咱们看看 Spring Data JPA 几个核心概念。

  • Repository：最顶层的接口，是一个空的接口，目的是为了统一全部Repository的类型，且能让组件扫描的时候自动识别；

  • CrudRepository ：是Repository的子接口，提供CRUD的功能；

    @NoRepositoryBean
public interface CrudRepository<T, ID> extends Repository<T, ID> {
  <S extends T> S save(S entity);
  <S extends T> Iterable<S> saveAll(Iterable<S> entities);
  Optional<T> findById(ID id);
  boolean existsById(ID id);
  Iterable<T> findAll();
  Iterable<T> findAllById(Iterable<ID> ids);
  long count();
  void deleteById(ID id);
  void delete(T entity);
  void deleteAll(Iterable<? extends T> entities);
  void deleteAll();
}

  • JpaRepository：是PagingAndSortingRepository的子接口，增长了一些实用的功能，好比：批量操做等；

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

  • PagingAndSortingRepository：是 CrudRepository 的子接口，添加分页和排序的功能；

    @NoRepositoryBean
public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {
  Iterable<T> findAll(Sort sort);
  Page<T> findAll(Pageable pageable);
}

  • Specification：是Spring Data JPA提供的一个查询规范，要作复杂的查询，只需围绕这个规范来设置查询条件便可；

    public interface Specification<T> extends Serializable {
    long serialVersionUID = 1L;
    static <T> Specification<T> not(Specification<T> spec) {
        return Specifications.negated(spec);
    }
    static <T> Specification<T> where(Specification<T> spec) {
        return Specifications.where(spec);
    }
    default Specification<T> and(Specification<T> other) {
        return Specifications.composed(this, other, CompositionType.AND);
    }
    default Specification<T> or(Specification<T> other) {
        return Specifications.composed(this, other, CompositionType.OR);
    }
    @Nullable
    Predicate toPredicate(Root<T> var1, CriteriaQuery<?> var2, CriteriaBuilder var3);
}

  • JpaSpecificationExecutor：用来作负责查询的接口。

    public interface JpaSpecificationExecutor<T> {
    Optional<T> findOne(@Nullable Specification<T> var1);
    List<T> findAll(@Nullable Specification<T> var1);
    Page<T> findAll(@Nullable Specification<T> var1, Pageable var2);
    List<T> findAll(@Nullable Specification<T> var1, Sort var2);
    long count(@Nullable Specification<T> var1);
}


Spring Data JPA的使用

  下面咱们演示几种 JPA 的使用。

使用内置方法

  构建SpringBoot项目，首先引入 maven 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

  而后，application.properties 中配置相关的信息：

server.address=
server.servlet.context-path=
server.port=8082

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://192.168.1.88:3306/test?serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=pass123

# 第一次建表用create，后面使用update
# 否则每次从新系统工程都会先删除表再新建
spring.jpa.hibernate.ddl-auto=create
# 控制台打印sql
spring.jpa.show-sql=true

  下一步，建立实体类 User：

package com.yanfei1819.jpademo.entity;
import javax.persistence.*;

/**
 * Created by 追梦1819 on 2019-05-05.
 */
@Entity
@Table(name="user")
public class User {
    @Id
    // 字段自动生成
    @GeneratedValue(strategy= GenerationType.AUTO)
    private Long id;
    private int age;
    private String name;
    // set/get 省略
}

  再者，建立 dao 层：

package com.yanfei1819.jpademo.repository;
import com.yanfei1819.jpademo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * Created by 追梦1819 on 2019-05-05.
 */
public interface UserRepository extends JpaRepository<User,Long> {
    
}

  最后，建立controller 层（此处为了简化代码，省略了 service 层）：

package com.yanfei1819.jpademo.web.controller;

import com.yanfei1819.jpademo.entity.User;
import com.yanfei1819.jpademo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.List;

/**
 * Created by 追梦1819 on 2019-05-05.
 */
@Controller
public class UserController {
    @Autowired
    private UserRepository userRepository;
    
    @ResponseBody
    @GetMapping("/queryUser")
    public List<User> queryUser(){
        // 经过 jpa 内置的方法进行查询
        return userRepository.findAll();
    }
}

  在上述示例中，咱们使用的是 JPA 的内置方法 findAll() ，另外也有不少别的方法，以下：

  写了几个查询方法。


建立查询方法

  在以上示例的基础上，咱们添加一个新的方法：

UserController：

@ResponseBody
@GetMapping("/queryUser/{name}")
public User queryUserByName(@PathVariable String name){
    // 经过自定义的方法进行查询
    return userRepository.findByName(name);
}

UserRepository：

User findByName(String name);

  spring-data-jpa 会根据方法的名字来自动生成 sql 语句，Spring Data JPA 支持经过定义在 Repository 接口中的方法名来定义查询，方法名是根据实体类的属性名来肯定的。咱们只须要按照方法定义的规则便可。其中findBy关键字能够用find、read、readBy、query、queryBy、get、getBy替代。

  这种方式不只仅限制这种简单的参数支持，还包括限制返回的查询的结果、返回流式查询结果、异步查询等，能够参看示例：

// 限制查询结果
User findTopByOrderByAgeDesc();
Page<User> queryFirst10ByLastname(String lastname, Pageable pageable);

// 返回流式查询结果
Stream<User> readAllByFirstnameNotNull();

// 异步查询
@Async
Future<User> findByFirstname(String firstname);


@Query查询

  在上述示例中添加新的方法：

UserController：

@ResponseBody
@GetMapping("/queryUser2/{id}")
public User queryUserById(@PathVariable Long id){
    // 经过 @Query 注解查询
    return userRepository.withIdQuery(id);
}

UserRepository：

// @Query("select u from User u where u.id = :id ")
@Query(value = "select u from User u where u.id = ?1 ",nativeQuery = true)
User withIdQuery(@Param("id") Long id);

  使用这种命名查询来声明实体查询是一种有效的方法，适用于少许查询。上面的 @Query 注解须要注意的是：

  一、@Query(value = "select u from User u where u.id = ?1 ",nativeQuery = true) 中的 nativeQuery 属性若是设置为 true 时，表示的意思是：能够执行原生sql语句，所谓原生sql，也就是说这段sql拷贝到数据库中，而后把参数值给一下就能运行了，原生的 sql 都是真实的字段，真实的表名。若是设置为 false 时，就不是原生的 sql ，而不是数据库对应的真正的表名，而是对应的实体名，而且 sql 中的字段名也不是数据库中真正的字段名，而是实体的字段名；

  二、nativeQuery 若是不设置时，即 @Query("select u from User u where u.id = ?1 ") ，默认是 false；

  三、 @Query("select u from User u where u.id = ?1 ") 能够写成 @Query("select u from User u where u.id = :id ") 。

  四、如涉及到删除和修改在须要加上@Modifying.也能够根据须要添加 @Transactional对事物的支持，查询超时的设置等。

@NamedQuery查询

  在以上的示例中，为了区分 User 实体类，咱们从新建立一个实体类 UserVo：

package com.yanfei1819.jpademo.entity;
import javax.persistence.*;

/**
 * Created by 追梦1819 on 2019-05-23.
 */
@Entity
@Table(name = "user")
@NamedQuery(name = "findAll",query = "select u from User u")
public class UserVo {
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    private Long id;
    @Column(name = "age")
    private int age;
    @Column(name = "name")
    private String name;
    // get/set 省略
}

在 UserController 中加一个方法：

@Autowired
private EntityManager entityManager;

@ResponseBody
@GetMapping("/queryUserByNameQuery")
public List<UserVo> queryUserByNameQuery(){
    // 经过 @Query 注解查询
    return entityManager.createNamedQuery("findAll").getResultList();
}

  启动程序，访问 http://localhost:8082/queryUserByNameQuery ，可以查询到全部用户：

  再看看控制台打印结果：

  注意一点，若是是多个查询，可使用 @NamedQuerys 。

  笔者其实并不推荐使用这种自定义方法，由于它对实体类的污染很严重。不利于可读性。


总结

  JPA 能够单独使用，只不过 SpringBoot 这个大平台将该技术引入进来。

  JPA也是一个大的分支，细枝末节有不少，做者认为，对于 JPA 的学习，只要关注三个方面：

  1） ORM 映射元数据，支持 XML 和 JDK 注解两种元数据的形式；

  2） 核心的 API；

  3） 查询语言：JPQL。

  固然，若是感兴趣的，能够好好研究一下 JPA 的官方文档，深刻研读一下其源码。此处因为篇幅所限，就不一一阐述。后续有时间会开设一个 JPA 专栏，专门讲述这一大分支，欢迎你们持续关注。

  话分两头，另外一方面，正如前面几章说的，各个 ORM 技术框架各有优缺点，没有一种框架是绝对完美的。技术、框架的选型，不必追求最新，追求最适合便可。
  源码：个人GitHub


参考

  1. spring doc

  2. Spring Data 官网介绍

  3. Spring Data JPA 官网



相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程