【参考】
https://hellokoding.com/one-to-many-and-many-to-one-relationship-mapping-in-jpa-and-hibernate/
Spring JPA中一对多和多对一的关联方式，通过使用@OneToMany和@ManyToOne有3种实现方式：
数据模型：书店里有很多书，书店和书之前是一对多关系。
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：
book：
同时多方（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）中删除数据，只会删除本表的数据。
