SpringData JPA 快速入门案例详解

SpringData JPA

JPA 简介：

JPA（Java Persistence API）是 Java 持久层规范，定义了一些列 ORM 接口，它本身是不能直接使用的，因为接口需要实现才能使用，Hibernate 框架就是实现 JPA 规范的框架。

SpringData JPA 简介

Spring Data JPA 是 Spring 框架提供的对 JPA 规范的抽象，通过约定的命名规范完成持久层接口的编写，在不需要实现接口的情况下，就可以实现对数据库的操作。简单理解就是通过 Spring Data JPA，你只需要定义接口而不需要实现，就能完成 CRUD 操作。

Spring Data JPA 本身并不是一个具体实现，它只是一个抽象层，底层还是需要 Hibernate 这样的 JPA 实现来提供支持。

Spring Data JPA 是一个全自动化的 ORM 框架，底层是 Hibernate 框架提供支持，开发者只需要调用接口方法即可，不必关心 SQL 语句和结果集的解析，非常方便

1. 添加 pom.xml 依赖

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

2. 配置数据源

/src/main/resources/application.properties 配置文件中

## 配置数据源
spring:datasource:url: jdbc:mysql://127.0.0.1:3306/wdzldb?useSSL=false&serverTimezone=Asia/Shanghaiusername: rootdriver-class-name: com.mysql.cj.jdbc.Driverpassword: rootjpa:show-sql: trueproperties:hibernate:format_sql: true  # 格式化SQL# 生成SQL 驼峰命名属性，默认加下划线的情况，下面配置可以去掉下划线。hibernate:naming:physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

3. 编写实体类

注意：这里使用的注解和 SpringData JDBC 的不同，属性名出现驼峰命名的，也会默认映射为 book_name 的形式，此时需要通过 @Column 注解来映射。也可以在配置文件中统一配置关闭下划线。

注意：常见错误

Caused by: java.lang.IllegalArgumentException: Not a managed type: class com.wdzl.pojo.Bookat org.hibernate.metamodel.internal.MetamodelImpl.managedType(MetamodelImpl.java:582)at org.hibernate.metamodel.internal.MetamodelImpl.managedType(MetamodelImpl.java:85)

原因：实体类没有指定@Entry 注解。添加注解后，会显示编译错误，要求必须指定主键 @Id

主键需要指定主键生成策略，否则默认的是

GenerationType strategy() default GenerationType.AUTO;

默认的策略是序列，应用于 Oracle 数据库

package com.wdzl.pojo;import lombok.Data;import javax.persistence.*;
import java.util.Date;@Data
@Entity  //要求必须有@Id
public class Book {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)@Column(name="bookid")private Integer bookId;@Column(name="bookname")private String bookName;private Float price;@Columnprivate Date pubdate;private String author;
}

4. 编写持久层接口

注意：这里继承的接口是 JpaRepository

在 JpaRepository 接口中包含了继承的 CRUD 方法，如果需要组合条件查询，可以遵循 “约定大于配置” 策略，实现组合条件查询。

注意异常：

Caused by: java.lang.IllegalArgumentException: Not a managed type: class java.lang.Objectat org.hibernate.metamodel.internal.MetamodelImpl.managedType(MetamodelImpl.java:582) ~[hibernate-core-5.4.32.Final.jar:5.4.32.Final]at org.hibernate.metamodel.internal.MetamodelImpl.managedType(MetamodelImpl.java:85) ~[hibernate-core-5.4.32.Final.jar:5.4.32.Final]

原因：没有指定泛型： extends JpaRepository<Book,Integer>

IBookDao 类代码如下：

下面方法通过默认约定名来实现

import com.wdzl.pojo.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;import java.util.List;@Repository
public interface IBookDao extends JpaRepository<Book,Integer> {// bookname=?List<Book> findBookByBookName(String bookName);// 等价于 between price ? and ?List<Book> findBookByPriceBetween(Float price1,Float price2);//等价于 price>?List<Book> findBookByPriceAfter(Float price);//bookName like ?  ==='%实%'List<Book> findBookByBookNameContaining(String bookName);//bookName like ?  ==='%实%'List<Book> findBookByBookNameContains(String bookName);// bookName like '%入门'List<Book> findBookByBookNameEndsWith(String bookName);}

也可以通过 HQL 来定义方法的查询，因为 SpringData Jpa 通过 Hibernate 实现的。

//注意下面是 HQL
@Query("from Book where bookName like :bookname and price > :price")
List<Book> findCondtion(String bookname,Float price);

注意：不支持 select *

5. 编写业务类

@Service("bookService")
public class BookService {@Autowiredprivate IBookDao bookDao;public List<Book> queryAll(){return bookDao.findAll(); //这里不同jdbc  这里直接返回 list}public void save(Book book){bookDao.save(book);}public long count(){return bookDao.count();}
}

6. 编写测试类

注意：测试类一定要和启动类同包，这里是代替了启动类

package com.wdzl;import com.wdzl.pojo.Book;
import com.wdzl.service.BookService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.test.context.SpringBootTest;import java.util.Date;@SpringBootTest
@SpringBootApplication //注意这里一定要和被测试类在同包  即启动类的位置
public class TestApplication {@Autowiredprivate BookService bookService;@Testpublic void testQuery(){bookService.queryAll().forEach(book -> System.out.println(book));}@Testpublic void save(){Book book = new Book();book.setPubdate(new Date());book.setBookName("Java入门与提高");book.setPrice(34F);bookService.save(book);  //主键不存在 执行插入}@Testpublic void update(){Book book = new Book();book.setBookId(9);book.setPubdate(new Date());book.setBookName("Java基础入门");book.setPrice(24F);bookService.save(book); //主键存在执行修改}
}

注意：

在执行 save() 保存时，如果设置了主键，则会先进行查询，再根据查询结果来执行操作，如果查询记录存在，则修改。否则不存在则插入。

如果主键策略没有指定自动增长，则在执行 save() 时，必须要设置主键。否则执行失败。

下面是设置了主键，但是数据库表中不存在的执行效果：

先执行了查询，再执行了 insert 插入操作

Hibernate: selectbook0_.bookid as bookid1_0_0_,book0_.author as author2_0_0_,book0_.bookname as bookname3_0_0_,book0_.price as price4_0_0_,book0_.pubdate as pubdate5_0_0_ frombook book0_ wherebook0_.bookid=?
Hibernate: insert intobook(author, bookname, price, pubdate) values(?, ?, ?, ?)

注意：

从上面控制台打印的结果来看，首先底层使用的Hibernate实现，

其次，先根据指定主键执行了查询来判断是否存在记录。

最后因为没有查询到记录，而执行 insert 操作。

7. JpaRepository 中方法详解

1) 接口源码中方法

@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);<S extends T> List<S> saveAllAndFlush(Iterable<S> var1);/** @deprecated */@Deprecateddefault void deleteInBatch(Iterable<T> entities) {  this.deleteAllInBatch(entities);}void deleteAllInBatch(Iterable<T> var1);void deleteAllByIdInBatch(Iterable<ID> var1);void deleteAllInBatch();/** @deprecated */@DeprecatedT getOne(ID var1);T getById(ID var1);<S extends T> List<S> findAll(Example<S> var1);<S extends T> List<S> findAll(Example<S> var1, Sort var2);
}

2) 添加：

public void save(){Book book = new Book();book.setBookName("MySQL性能优化");book.setPrice(45f);bookDao.save(book);
}

3) 修改：

public void update(){Book book = bookDao.getById(25);book.setPubdate(new Date());book.setBookName("MySQL性能优化");book.setPrice(45f);bookDao.save(book);
}

注意：

修改使用save方法，如果新实例化的对象，如果有主键且表中存在，则直接修改操作

如果实例化对象，同时指定主键，但不存在，也会自动插入操作。

但是，如果先查询，再修改，则默认情况下会抛出异常：

org.hibernate.LazyInitializationException: could not initialize proxy [com.wdzl.pojo.Book#25] - no Session

原因是默认使用了延时加载策略，这样在查询后已经关闭了session,但有修改操作了没加载的属性。导致异常。

解决办法：

在实体类上添加注解，关闭延时加载 : @Proxy(lazy = false) 或放入事务单元

@Data
@Entity
@Proxy(lazy = false)
public class Book {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Integer bookId;private String bookName;private Float price;private Date pubdate;private String author;
}

第二种修改方式：使用HQL语句修改，但不支持insert .

注意：事务和允许修改注解 @Transactional 和 @Modifying

@Modifying
@Query("update Book set price=:price where bookId=:bookid") //类名和属性名
@Transactional
int update(Float price,Integer bookid);

4) 删除

源码如下：

@Deprecated
default void deleteInBatch(Iterable<T> entities) {  //已经过时，不用关注this.deleteAllInBatch(entities);
}void deleteAllInBatch(Iterable<T> var1);        //按对象批量删除void deleteAllByIdInBatch(Iterable<ID> var1);    //按主键批量删除void deleteAllInBatch();                        //全部删除

案例应用：

//批量删除，
// 生成SQL: Hibernate: delete from Book where bookId in (? , ? , ? , ?)
public void delByBatch(){List<Integer> ids = Arrays.asList(3,23,12,45);bookDao.deleteAllByIdInBatch(ids);
}

也可以使用 HQL语句来删除，也需要事务支持。

@Modifying
@Query("delete from Book where bookName=:bookName")
@Transactional
int delete(String bookName);

也支持按约定规则命名方式来删除，注意：也需要事务支持

@Transactional
void deleteBookByAuthor(String author);
// between 
List<Book> findBooksByPriceBetween(Float min,Float max);
// 模糊查询 like 语句
List<Book> findBooksByBookNameLike(String bookName);

生成 SQL如下：

Hibernate: select book0_.bookId as bookid1_0_, book0_.author as author2_0_, book0_.bookName as bookname3_0_, book0_.price as price4_0_, book0_.pubdate as pubdate5_0_ from Book book0_ where book0_.author=?
Hibernate: delete from Book where bookId=?

从上面可以看出，在删除时，先做查询，再做删除。如果查询不到，则不执行删除操作；

5) 查询

 List<T> findAll();                                //查询全部List<T> findAll(Sort var1);                    //排序查询List<T> findAllById(Iterable<ID> var1);        //按多个主键查询T getById(ID var1);<S extends T> List<S> findAll(Example<S> var1);  // 条件查询<S extends T> List<S> findAll(Example<S> var1, Sort var2);

条件查询：

//条件查询
public void findBookByExample(){Book book = new Book();book.setBookName("Java");book.setPrice(23f);book.setBookId(23);Example<Book> bookExample = Example.of(book);bookDao.findAll(bookExample);
}

排序：

//可以按指定属性排序
public void querySort(){//Order.desc()|asc()分别指定降序和升序Sort price = Sort.by(Sort.Order.desc("price"));List<Book> all = bookDao.findAll(price);all.forEach(System.out::println);
}

分页：

public void queryByPage(){//分页查询 第一个参数：页号（从0开始），第二参数：每页显示记录数Pageable pageable = PageRequest.of(2,2);bookDao.findAll(pageable).forEach(System.out::println);
}

6) 多对一和一对多

下面配置多对一关联关系。图书类关联依赖作者类。

注意：不使用@Data 为了避免 toString()，在双向多对一时，产生死循环。

图书类：

@Getter
@Setter
@Entity
//@Proxy(lazy = false)
public class Book {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Integer bookId;private String bookName;private Float price;private Date pubdate;
//    private String author;
//@JoinColumn(name="author") //关联的外键@ManyToOne(fetch = FetchType.LAZY)private Author author;
}

作者类：

@Entity(name="usertbl")
@Getter
@Setter
public class Author {@Idprivate Integer userid;private String username;private String email;@OneToMany(mappedBy = "author",fetch = FetchType.LAZY)private Set<Book> books = new HashSet<>();
}

图书关联查询作者：

    @Transactionalpublic void manyToOne(){Book book = bookDao.getById(22);System.out.println(book.getBookName()+"=="+book.getAuthor());}

作者关联查询图书：

@Transactional
public void query(){Author author = authorDao.findAuthorByUserid(5);Set<Book> books = author.getBooks();books.forEach(s-> System.out.println(s.getBookName()));
}

常见错误：

org.hibernate.LazyInitializationException: could not initialize proxy [com.wdzl.pojo.Book#22] - no Session

原因：

默认关联对象是延时加载的，在查询对象后默认关闭session，在后面使用到关联属性或对象时，再去查询时，已经不存在session可用了。所以抛出异常。

解决办法：

可以使用事务，让整个方法在一个事务单元中，使用完毕后再自动关闭session.

7）HQL

HQL（Hibernate Query Language）是 Hibernate 框架提供的面向对象的查询语言，它是 SQL 的一个超集，主要用来与关系型数据库进行交互，但它使用的是面向对象的方式来表达查询。HQL 查询的对象不再是数据库表，而是实体类及其属性。

/*** HQL*/
@Repository
public interface IBookDao extends JpaRepository<Book,Integer> {//支持HQL
//    @Query("select book from Book book")@Query("from Book")List<Book> queryAllBook();@Query("select bookId,bookName,author from Book")List<Object[]> queryAll();/*** 如果要修改，需要添加注解 @Modifying  @Transactional* @param price* @param bookid* @return*/@Modifying@Query("update Book set price=:price where bookId=:bookid")@Transactionalint update(Float price,Integer bookid);@Modifying@Query("delete from Book where bookName=:bookName")@Transactionalint delete(String bookName);@Transactionalvoid deleteBookByBookName(String bookname);}