本文主要是介绍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);}
这篇关于SpringData JPA 快速入门案例详解的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!