【Spring JPA总结】JPA One-To-Many以及M

2023-01-04 本文已影响0人伊丽莎白2015

【参考】
https://hellokoding.com/one-to-many-and-many-to-one-relationship-mapping-in-jpa-and-hibernate/

Spring JPA中一对多和多对一的关联方式，通过使用@OneToMany和@ManyToOne有3种实现方式：

image.png

数据模型：书店里有很多书，书店和书之前是一对多关系。

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

参考：

即：在一方（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）中删除数据，只会删除本表的数据。

【Spring JPA总结】JPA One-To-Many以及M

1. `@OneToMany`和`@ManyToOne`同时使用：双向的关联

2. 使用 `@ManyToOne`进行单向关联

3. 使用 @OneToMany进行单向关联

猜你喜欢

热点阅读

【Spring JPA总结】JPA One-To-Many以及M

1. @OneToMany和@ManyToOne同时使用：双向的关联

2. 使用 @ManyToOne进行单向关联

3. 使用 @OneToMany进行单向关联

猜你喜欢

热点阅读

1. `@OneToMany`和`@ManyToOne`同时使用：双向的关联

2. 使用 `@ManyToOne`进行单向关联