Spring Data JPA 一对多配置 jpa一对多查询

转载

AIGC创想家 2024-05-19 15:51:02

文章标签 User 表名外键 文章分类 架构后端开发

一、@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 {
3. 
4. @Id
5. @GeneratedValue(strategy = GenerationType.IDENTITY)
6. @Column(name = “id”, nullable = false)
7. private Long id;//id
8. 
9. @Column(name = “name”, nullable = true, length = 20)
10. private String name;//姓名
11. 
12. @Column(name = “sex”, nullable = true, length = 1)
13. private String sex;//性别
14. 
15. @Column(name = “birthday”, nullable = true)
16. private Timestamp birthday;//出生日期
17. 
18. @OneToOne(cascade=CascadeType.ALL)//People是关系的维护端，当删除 people，会级联删除 address
19. @JoinColumn(name = “address_id”, referencedColumnName = “id”)//people中的address_id字段参考address表中的id字段
20. private Address address;//地址
21. 
22. }

关联的实体的主键一般是用来做外键的。但如果此时不想主键作为外键，则需要设置referencedColumnName属性。当然这里关联实体(Address)的主键 id 是用来做主键，所以这里第20行的 referencedColumnName = ”id” 实际可以省略。

Address.java

1. @Entity
2. public class Address {
3. 
4. @Id
5. @GeneratedValue(strategy = GenerationType.IDENTITY)
6. @Column(name = “id”, nullable = false)
7. private Long id;//id
8. 
9. @Column(name = “phone”, nullable = true, length = 11)
10. private String phone;//手机
11. 
12. @Column(name = “zipcode”, nullable = true, length = 6)
13. private String zipcode;//邮政编码
14. 
15. @Column(name = “address”, nullable = true, length = 100)
16. private String address;//地址
17. 
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 {
3. 
4. @Id
5. @GeneratedValue(strategy = GenerationType.IDENTITY)
6. @Column(name = “id”, nullable = false)
7. private Long id;//id
8. 
9. @Column(name = “name”, nullable = true, length = 20)
10. private String name;//姓名
11. 
12. @Column(name = “sex”, nullable = true, length = 1)
13. private String sex;//性别
14. 
15. @Column(name = “birthday”, nullable = true)
16. private Timestamp birthday;//出生日期
17. 
18. @OneToOne(cascade=CascadeType.ALL)//People是关系的维护端
19. @JoinTable(name = “people_address”,
20. @JoinColumn(name=“people_id”),
21. @JoinColumn(name = “address_id”))//通过关联表保存一对一的关系
22. private Address address;//地址
23. 
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 {
3. 4. @Id // 主键
5. @GeneratedValue(strategy = GenerationType.IDENTITY) // 自增长策略
6. private Long id; //id
7. 8. @NotEmpty(message = “姓名不能为空”)
9. @Size(min=2, max=20)
10. @Column(nullable = false, length = 20)
11. private String name;//姓名
12. 13. @OneToMany(mappedBy = “author”,cascade=CascadeType.ALL,fetch=FetchType.LAZY)
14. //级联保存、更新、删除、刷新;延迟加载。当删除用户，会级联删除该用户的所有文章
15.     //拥有mappedBy注解的实体类为关系被维护端
16. //mappedBy=”author”中的author是Article中的author属性
17. private List<Article> articleList;//文章列表
18. 19. 20. }

Article.java

1. @Entity
2. public class Article {
3. 
4. 
5. @Id
6. @GeneratedValue(strategy = GenerationType.IDENTITY) // 自增长策略
7. @Column(name = “id”, nullable = false)
8. private Long id;
9. 
10. @NotEmpty(message = “标题不能为空”)
11. @Size(min = 2, max = 50)
12. @Column(nullable = false, length = 50) // 映射为字段，值不能为空
13. private String title;
14. 
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;//文章全文内容
21. 
22. 
23. @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional=false)//可选属性optional=false,表示author不能为空。删除文章，不影响用户
24. @JoinColumn(name=“author_id”)//设置在article表中的关联字段(外键)
25. private Author author;//所属作者
26. 
27. 
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 {
3. 
4. @Id
5. @GeneratedValue(strategy = GenerationType.IDENTITY)
6. private Long id;
7. 
8. @NotEmpty(message = “账号不能为空”)
9. @Size(min=3, max=20)
10. @Column(nullable = false, length = 20, unique = true)
11. private String username; // 用户账号，用户登录时的唯一标识
12. 
13. @NotEmpty(message = “密码不能为空”)
14. @Size(max=100)
15. @Column(length = 100)
16. private String password; // 登录时密码
17. 
18. @ManyToMany
19. @JoinTable(name = “user_authority”,joinColumns = @JoinColumn(name = “user_id”),
20. @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;
30. 
31. }

注意：如注释中所言，上面的第20-21行的@JoinTable可以省略，默认可以生成

Authority.java

1. @Entity
2. public class Authority {
3. 
4. @Id
5. @GeneratedValue(strategy = GenerationType.IDENTITY)
6. private Integer id;
7. 
8. @Column(nullable = false)
9. private String name; //权限名
10. 
11. @ManyToMany(mappedBy = “authorList”)
12. private List<User> userList;
13. 
14. }

测试添加

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

先运行 saveAuthority 添加一条权限记录，

然后运行 saveUser 添加一条用户记录，与此同时，user_authority 表中也自动插入了一条记录

测试删除

删除用户

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

user 表中删除一条记录，同时 user_authority 能够级联删除一条记录

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。