【参考】
https://hellokoding.com/one-to-many-and-many-to-one-relationship-mapping-in-jpa-and-hibernate/
Spring JPA中一对多和多对一的关联方式,通过使用@OneToMany
和@ManyToOne
有3种实现方式:
数据模型:书店里有很多书,书店和书之前是一对多关系。
image.png
1. @OneToMany
和@ManyToOne
同时使用:双向的关联
@OneToMany
注解是标记在一对多的“一”这一方,即bookStore一方,需要加上mappedBy
属性,表示被映射(因为外键在book表中的book_store_id,而不是在bookStore中),指向的是关系的所有者(即book)表中的属性。
在双向关联中,mappedBy
属性在@OneToMany
中是必须的,如果该属性缺失了,那么JPA会自动创建一张多余的表,叫:book_store_books。
@Entity
@Table(name = "book_store")
public class BookStore {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name;
@OneToMany(mappedBy = "bookStore", cascade = CascadeType.ALL)
private Set<Book> books = new HashSet<>();
}
@ManyToOne
注解是标记在一对多的“多”这一方,即book一方,该表中的book_store_id是外键,所以这里用了@JoinColumn
来表示出来。
@JoinColumn
用来表示外键的列,在双向关联中也可以省略配置,默认情况下,会自动关联到该属性(如这里的bookStore)的主键字段,也可以是table名 + "_" + 主键名,在我们这里即:book_store_id。
- 所以我们的命名方式中,其实这个配置可以省略,
- 但如果我们把这个外键列名改成book_store_id_updated,那么如果省略
@JoinColumn
配置,会报错:
2023-01-03 22:47:18.843 ERROR 22512 --- [ main] o.h.engine.jdbc.spi.SqlExceptionHelper : Unknown column 'book0_.book_store_id' in 'field list'
@Entity
@Table(name = "book")
public class Book {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
private String name;
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "book_store_id")
private BookStore bookStore;
}
【测试a】在一方(bookStore)查询数据:
@Test
public void queryTest() {
BookStore bookStore = bookStoreRepository.findById(1).get();
List<Book> books = bookStore.getBooks();
}
发现先是会查bookStore的表:
select
bookstore0_.id as id1_2_0_,
bookstore0_.name as name2_2_0_
from
relation_study_book_store bookstore0_
where
bookstore0_.id=?
接着要去查bookStore中的bookList数据,即查询book表,会报错:
org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.entity.BookStore.books, could not initialize proxy - no Session
参考:
- https://stackoverflow.com/questions/11746499/how-to-solve-the-failed-to-lazily-initialize-a-collection-of-role-hibernate-ex
- https://javatute.com/hibernate/failed-to-lazily-initialize-a-collection-of-role-could-not-initialize-proxy-no-session/
即:在一方(bookStore)的配置没有指定加载方式,默认的加载方式为fetch = LAZY,因此如同上述的sql,会先查一方的数据(from bookStore),但是再获取多方(book)的时候session已经关闭了,因此报错。
解决的办法:
- 办法1:将fetch方式改为EAGER:
@OneToMany(mappedBy = "bookStore", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<Book> books = new HashSet<>();
这样就不会分两次加载了(LAZY的模式是当getBooks()被调用的时候才会去查询book表),而改为EAGER后,会使用left outer join一次性取出bookStore和books的数据,sql(省略select后面的列):
select ...
from book_store bookstore0_
left outer join book books1_ on bookstore0_.id=books1_.book_store_id
where bookstore0_.id=?
- 办法2:在获取数据的时候,将查询bookStore和getBooks()放在同一个transactional里,这样在同一个方法内,session不会close:
@Transactional
@Test
public void queryTest() {
BookStore bookStore = bookStoreRepository.findById(1).get();
List<Book> books = bookStore.getBooks();
}
这样,因为fetch方式仍然为LAZY,所以还是会分两个sql查询数据,sql(省略部分select的列):
select ...
from book_store bookstore0_
where bookstore0_.id=?
select
books0_.book_store_id as book_sto3_1_0_,
books0_.id as id1_1_0_,
books0_.id as id1_1_1_,
books0_.book_store_id as book_sto3_1_1_,
books0_.name as name2_1_1_
from
book books0_
where
books0_.book_store_id=?
【测试b】在多方(book)中查询数据,也可以加上@Transactional,或者在@ManyToOne
上不要标fetch=LAZY(默认为EAGER)。如果是LAZY,那么会通过left outer join一次性查出book数据和bookStore数据。
【测试c】在一方(bookStore)中插入数据,可以同时插入两张表的数据,会先尝试插入bookStore的数据,然后是两条book的数据:
@Test
public void saveTest() {
BookStore bookStore = BookStore.builder().name("store a").build();
Set<Book> bookList = new HashSet<>();
bookList.add(Book.builder().name("book a").bookStore(bookStore).build());
bookList.add(Book.builder().name("book b").bookStore(bookStore).build());
bookStore.setBooks(bookList);
bookStoreRepository.save(bookStore);
}
【测试d】在多方(book)中插入数据,可以同时插入两张表的数据,需要先调用bookStore的save:
@Test
public void saveTest() {
BookStore bookStore = BookStore.builder().name("store a").build();
Set<Book> bookList = new HashSet<>();
bookStore.setBooks(bookList);
bookStoreRepository.save(bookStore);
Book book = Book.builder().name("book a").bookStore(bookStore).build();
bookRepository.save(book);
}
【测试e】在一方(bookStore)中删除数据,可以同时删除两张表的数据。
【测试f】在多方(book)中删除数据,只会删除book表的数据,这也很好理解,因为bookStore中可能还会有别的book关联着。
2. 使用 @ManyToOne
进行单向关联
因为是单向关联,所以bookStore中就只有自己的id, name属性,并不会有books属性。
在多方(book)中,会通过@ManyToOne
声明bookStore,@JoinColumn
表示外键,即本表的列的名字。如果想要省略,规则在#1中有介绍。
@Entity
@Table(name = "book")
public class Book {
...
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "book_store_id")
private BookStore bookStore;
}
【测试a】在一方(bookStore)中查询,因为没有books属性,只能查到它自己的数据。
【测试b】在多方(book)中查询,因为是LAZY加载,所以是分两个sql:
@Transactional
@Test
public void test() {
Book book = bookRepository.findById(1).get();
BookStore bookStore = book.getBookStore();
}
select
book0_.id as id1_1_0_,
book0_.book_store_id as book_sto3_1_0_,
book0_.name as name2_1_0_
from
book book0_
where
book0_.id=?
select
bookstore0_.id as id1_2_0_,
bookstore0_.name as name2_2_0_
from
book_store bookstore0_
where
bookstore0_.id=?
【测试c】在一方(bookStore)中尝试插入数据,只能插入它自己的数据。
【测试d】在多方(book)中尝试插入数据,需要两个repository同时合作,能插入两张表的数据:
@Test
public void saveTest() {
BookStore bookStore = BookStore.builder().name("store a").build();
bookStoreRepository.save(bookStore);
Book book = Book.builder().name("book a").bookStore(bookStore).build();
bookRepository.save(book);
}
【测试e】在一方(bookStore)中尝试删除数据,会删除自己的数据。
bookStore:
image.png
book:
image.png
同时多方(book)中的外键还存着它的id,所以在多方查询数据的时候会报错:
javax.persistence.EntityNotFoundException: Unable to find com.entity.BookStore with id 1
【测试f】在多方(book)中尝试删除数据,和上述的双向关联一样,只能删除book自己的数据(因为bookStore中可能还存在别的关联,因为不会删除一方的数据)。
3. 使用 @OneToMany进行单向关联
@OneToMany
放在一方(即bookStore)方,在#1中因为是双向的,所以@JoinColumn
放在多方,表示book.book_store_id是个外键。
而@OneToMany
要单向关联的话,就不能用mappedBy了(表示被关联,因为没有别的关联在这里)。
需要在一方用@JoinColumn
来表示外键,这个是必须要的,如果缺失,JPA会新创建一张叫book_store_book的表。
@Entity
@Table(name = "relation_study_book_store")
public class BookStore {
...
@OneToMany(cascade = CascadeType.ALL)
@JoinColumn(name = "book_store_id")
private Set<Book> books = new HashSet<>();
}
【测试a】在一方(bookStore)中插入数据,会插入两张表的数据:
@Test
public void saveTest() {
BookStore bookStore = BookStore.builder().name("store a").build();
Set<Book> bookList = new HashSet<>();
bookList.add(Book.builder().name("book a").build());
bookList.add(Book.builder().name("book b").build());
bookStore.setBooks(bookList);
bookStoreRepository.save(bookStore);
}
【测试b】在多方(book)中插入数据,只会插入book本身的数据。
【测试c】在一方(bookStore)中查询,可以查到两张表的数据:
- 如果是fetch=EAGER,那么会用left outer join一起返回数据。
- 如果是fetch=LAZY,那么在查询的时候需要加上@Transactional,确保第一个查询后不会使session关闭,这时候会先查询bookStore的数据,调用了getBooks()后才会按需查询book list的数据。
【测试d】在多方(book)查询数据,只会查询到自己的数据(因为book中没有bookStore的关联)。
【测试e】在一方(bookStore)中删除数据,可以同时删除两张表的数据。
【测试f】在多方(book)中删除数据,只会删除本表的数据。
网友评论