Spring Data JPA 之 一對一，一對多，多對多 關係對映

xxc1605629895發表於2018-06-10
Spring

 

一、@OneToOne關係對映

JPA使用@OneToOne來標註一對一的關係。

實體 People ：使用者。

實體 Address：家庭住址。

People 和 Address 是一對一的關係。

這裡用兩種方式描述JPA的一對一關係。

一種是通過外來鍵的方式(一個實體通過外來鍵關聯到另一個實體的主鍵)；

另外一種是通過一張關聯表來儲存兩個實體一對一的關係。

 

1、通過外來鍵的方式

people 表（id，name，sex，birthday，address_id）

address 表（id，phone，zipcode，address）

 

People.java

  1. @Entity
  2. public class People {
  4.     @Id
  5.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  6.     @Column(name = "id", nullable = false)
  7.     private Long id;//id
  9.     @Column(name = "name", nullable = true, length = 20)
  10.     private String name;//姓名
  12.     @Column(name = "sex", nullable = true, length = 1)
  13.     private String sex;//性別
  15.     @Column(name = "birthday", nullable = true)
  16.     private Timestamp birthday;//出生日期
  18.     @OneToOne(cascade=CascadeType.ALL)//People是關係的維護端，當刪除 people，會級聯刪除 address
  19.     @JoinColumn(name = "address_id", referencedColumnName = "id")//people中的address_id欄位參考address表中的id欄位
  20.     private Address address;//地址
  22. }

關聯的實體的主鍵一般是用來做外來鍵的。但如果此時不想主鍵作為外來鍵，則需要設定referencedColumnName屬性。當然這裡關聯實體(Address)的主鍵 id 是用來做主鍵，所以這裡第20行的 referencedColumnName = "id" 實際可以省略。

 

 

Address.java

  1. @Entity
  2. public class Address {
  4.     @Id
  5.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  6.     @Column(name = "id", nullable = false)
  7.     private Long id;//id
  9.     @Column(name = "phone", nullable = true, length = 11)
  10.     private String phone;//手機
  12.     @Column(name = "zipcode", nullable = true, length = 6)
  13.     private String zipcode;//郵政編碼
  15.     @Column(name = "address", nullable = true, length = 100)
  16.     private String address;//地址
  18.     //如果不需要根據Address級聯查詢People，可以註釋掉
  19. //    @OneToOne(mappedBy = "address", cascade = {CascadeType.MERGE, CascadeType.REFRESH}, optional = false)
  20. //    private People people;
  21. }

 

2、通過關聯表的方式來儲存一對一的關係。

people 表（id，name，sex，birthday）

address 表 (id，phone，zipcode，address）

people_address (people_id，address_id)

只需要建立 People 和 Address 兩個實體

 

People.java

  1. @Entity
  2. public class People {
  4.     @Id
  5.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  6.     @Column(name = "id", nullable = false)
  7.     private Long id;//id
  9.     @Column(name = "name", nullable = true, length = 20)
  10.     private String name;//姓名
  12.     @Column(name = "sex", nullable = true, length = 1)
  13.     private String sex;//性別
  15.     @Column(name = "birthday", nullable = true)
  16.     private Timestamp birthday;//出生日期
  18.     @OneToOne(cascade=CascadeType.ALL)//People是關係的維護端
  19.     @JoinTable(name = "people_address",
  20.             joinColumns = @JoinColumn(name="people_id"),
  21.             inverseJoinColumns = @JoinColumn(name = "address_id"))//通過關聯表儲存一對一的關係
  22.     private Address address;//地址
  24. }

 

Address.java

不變

 

二、@OneToMany 和 @ManyToOne

實體 Author：作者。

實體 Article：文章。

Author 和 Article 是一對多關係(雙向)。那麼在JPA中，如何表示一對多的雙向關聯呢？

JPA使用@OneToMany和@ManyToOne來標識一對多的雙向關聯。一端(Author)使用@OneToMany,多端(Article)使用@ManyToOne。

在JPA規範中，一對多的雙向關係由多端(Article)來維護。就是說多端(Article)為關係維護端，負責關係的增刪改查。一端(Author)則為關係被維護端，不能維護關係。

一端(Author)使用@OneToMany註釋的mappedBy="author"屬性表明Author是關係被維護端。

多端(Article)使用@ManyToOne和@JoinColumn來註釋屬性 author,@ManyToOne表明Article是多端，@JoinColumn設定在article表中的關聯欄位(外來鍵)。

 

Author.java

  1. @Entity
  2. public class Author {
  4.     @Id // 主鍵
  5.     @GeneratedValue(strategy = GenerationType.IDENTITY) // 自增長策略
  6.     private Long id; //id
  8.     @NotEmpty(message = "姓名不能為空")
  9.     @Size(min=2, max=20)
  10.     @Column(nullable = false, length = 20)
  11.     private String name;//姓名
  13.     @OneToMany(mappedBy = "author",cascade=CascadeType.ALL,fetch=FetchType.LAZY)
  14.     //級聯儲存、更新、刪除、重新整理;延遲載入。當刪除使用者，會級聯刪除該使用者的所有文章
  15.     //擁有mappedBy註解的實體類為關係被維護端
  16.      //mappedBy="author"中的author是Article中的author屬性
  17.     private List<Article> articleList;//文章列表
  20. }

 

Article.java

  1. @Entity
  2. public class Article {
  5.     @Id
  6.     @GeneratedValue(strategy = GenerationType.IDENTITY) // 自增長策略
  7.     @Column(name = "id", nullable = false)
  8.     private Long id;
  10.     @NotEmpty(message = "標題不能為空")
  11.     @Size(min = 2, max = 50)
  12.     @Column(nullable = false, length = 50) // 對映為欄位，值不能為空
  13.     private String title;
  15.     @Lob  // 大物件，對映 MySQL 的 Long Text 型別
  16.     @Basic(fetch = FetchType.LAZY) // 懶載入
  17.     @NotEmpty(message = "內容不能為空")
  18.     @Size(min = 2)
  19.     @Column(nullable = false) // 對映為欄位，值不能為空
  20.     private String content;//文章全文內容
  23.     @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional=false)//可選屬性optional=false,表示author不能為空。刪除文章，不影響使用者
  24.     @JoinColumn(name="author_id")//設定在article表中的關聯欄位(外來鍵)
  25.     private Author author;//所屬作者
  28. }

 

最終生成的表結構

article 表(id，title，conten，author_id)

author 表(id，name)

 

三、多對多 @ManyToMany

實體 User：使用者。

實體 Authority：許可權。

使用者和許可權是多對多的關係。一個使用者可以有多個許可權，一個許可權也可以被很多使用者擁有。

JPA中使用@ManyToMany來註解多對多的關係，由一個關聯表來維護。這個關聯表的表名預設是：主表名+下劃線+從表名。(主表是指關係維護端對應的表,從表指關係被維護端對應的表)。這個關聯表只有兩個外來鍵欄位，分別指向主表ID和從表ID。欄位的名稱預設為：主表名+下劃線+主表中的主鍵列名，從表名+下劃線+從表中的主鍵列名。

 

需要注意的：

1、多對多關係中一般不設定級聯儲存、級聯刪除、級聯更新等操作。

2、可以隨意指定一方為關係維護端，在這個例子中，我指定 User 為關係維護端，所以生成的關聯表名稱為： user_authority，關聯表的欄位為：user_id 和 authority_id。

3、多對多關係的繫結由關係維護端來完成，即由 User.setAuthorities(authorities) 來繫結多對多的關係。關係被維護端不能繫結關係，即Game不能繫結關係。

4、多對多關係的解除由關係維護端來完成，即由Player.getGames().remove(game)來解除多對多的關係。關係被維護端不能解除關係，即Game不能解除關係。

5、如果 User 和 Authority 已經繫結了多對多的關係，那麼不能直接刪除 Authority，需要由 User 解除關係後，才能刪除 Authority。但是可以直接刪除 User，因為 User 是關係維護端，刪除 User 時，會先解除 User 和 Authority 的關係，再刪除 Authority。

 

User.java

  1. @Entity
  2. public class User {
  4.     @Id
  5.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  6.     private Long id;
  8.     @NotEmpty(message = "賬號不能為空")
  9.     @Size(min=3, max=20)
  10.     @Column(nullable = false, length = 20, unique = true)
  11.     private String username; // 使用者賬號，使用者登入時的唯一標識
  13.     @NotEmpty(message = "密碼不能為空")
  14.     @Size(max=100)
  15.     @Column(length = 100)
  16.     private String password; // 登入時密碼
  18.     @ManyToMany
  19.     @JoinTable(name = "user_authority",joinColumns = @JoinColumn(name = "user_id"),
  20.     inverseJoinColumns = @JoinColumn(name = "authority_id"))
  21.     //1、關係維護端，負責多對多關係的繫結和解除
  22.     //2、@JoinTable註解的name屬性指定關聯表的名字，joinColumns指定外來鍵的名字，關聯到關係維護端(User)
  23.     //3、inverseJoinColumns指定外來鍵的名字，要關聯的關係被維護端(Authority)
  24.     //4、其實可以不使用@JoinTable註解，預設生成的關聯表名稱為主表表名+下劃線+從表表名，
  25.     //即表名為user_authority
  26.     //關聯到主表的外來鍵名：主表名+下劃線+主表中的主鍵列名,即user_id
  27.     //關聯到從表的外來鍵名：主表中用於關聯的屬性名+下劃線+從表的主鍵列名,即authority_id
  28.     //主表就是關係維護端對應的表，從表就是關係被維護端對應的表
  29.     private List<Authority> authorityList;
  31. }

注意：如註釋中所言，上面的第20-21行的@JoinTable可以省略，預設可以生成

 

Authority.java

  1. @Entity
  2. public class Authority {
  4.     @Id
  5.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  6.     private Integer id;
  8.     @Column(nullable = false)
  9.     private String name; //許可權名
  11.     @ManyToMany(mappedBy = "authorityList")
  12.     private List<User> userList;
  14. }

 

測試 新增

  1. @SpringBootTest
  2. @RunWith(SpringRunner.class)
  3. public class UserRepositoryTest {
  6.     @Autowired
  7.     private UserRepository userRepository;
  9.     @Autowired
  10.     private AuthorityRepository authorityRepository;
  12.     @Test
  13.     public void saveAuthority() {
  14.         Authority authority = new Authority();
  15.         authority.setId(1);
  16.         authority.setName("ROLE_ADMIN");
  17.         authorityRepository.save(authority);
  18.     }
  20.     @Test
  21.     public void saveUser() {
  22.         User user = new User();
  23.         user.setUsername("admin");
  24.         user.setPassword("123456");
  25.         Authority authority = authorityRepository.findById(1).get();
  26.         List<Authority> authorityList = new ArrayList<>();
  27.         authorityList.add(authority);
  28.         user.setAuthorList(authorityList);
  29.         userRepository.save(user);
  30.     }
  32. }

先執行 saveAuthority 新增一條許可權記錄，

然後執行 saveUser 新增一條使用者記錄，與此同時，user_authority 表中也自動插入了一條記錄

 

測試 刪除

刪除使用者

  1. @SpringBootTest
  2. @RunWith(SpringRunner.class)
  3. public class UserRepositoryTest {
  6.     @Autowired
  7.     private UserRepository userRepository;
  9.     @Test
  10.     public void deleteUser() {
  11.         userRepository.deleteById(1L);
  12.     }
  14. }

user 表中刪除一條記錄，同時 user_authority 能夠級聯刪除一條記錄

 

 

參考：http://www.cnblogs.com/luxh/archive/2012/05/30/2527123.html

 

 

再次更新

其中 @OneToMany  和 @ManyToOne 用得最多，這裡再補充一下

 

關於級聯，一定要注意，要在關係的維護端，即 One 端。

比如 作者和文章，作者是One，文章是Many；文章和評論，文章是One，評論是Many。

cascade = CascadeType.ALL 只能寫在 One 端，只有One端改變Many端，不準Many端改變One端。

特別是刪除，因為 ALL 裡包括更新，刪除。

如果刪除一條評論，就把文章刪了，那算誰的。所以，在使用的時候要小心。一定要在 One 端使用。

舉例

One 端

 

Spring Data JPA 之 一對一，一對多，多對多 關係對映

 

Many 端

Spring Data JPA 之 一對一，一對多，多對多 關係對映

 

本文轉自：Spring Data JPA 之 一對一，一對多，多對多 關係對映 | 言曌部落格

相關文章