美文网首页
【Spring JPA总结】JPA One-To-Many以及M

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

作者: 伊丽莎白2015 | 来源:发表于2023-01-04 22:38 被阅读0次

    【参考】
    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

          本文链接:https://www.haomeiwen.com/subject/machcdtx.html