表与表关联多对多

1...表与表之间的关系

一对一： A B 两张表 A表中的每条的记录对应的B的一条记录

　　　：一对一关系实现方式：

1：使用外键关联

　　　 ：场景：使用客户表和客户拓展表

　　　 ：在属性上添加一个@OneToOne代表一个对一个的关系在属性上添加@JoinColumn name 存储外键的字段 referencedColumnNm 对方表的字段名称 (可以省略)

2：使用主键关联，两个表 A B 的主键相同。

　　　：使用@PrimaryKeyJoinColumn 注解不需要配置属性双方都需要添加

一对多： A B 两张表 A表中的每条的记录对应B表中多条的记录 B表中多条的记录对应A表中一条记录

　　　：场景：客户和联系人之间一对多一个客户对应多个联系人

　　　：单方：1 添加一个属性记录多的一方的信息应该是一个集合 hashset 2 在属性上添加一个注解 @OneToMany 3一定是多的一方记录外键参照一的一方的主键

　　　：多方：1 在属性上添加注解 @ManyToOne 2 在属性上添加 @joinColumn 注解

多对多： A B 两张表 A表中的每条的记录对应B表中多条的记录 B表中的每条记录对应A表中的多条记录

　　　：应用场景用户和角色的关系用户角色关系为例 CRM（客户关系管理）

　　多对多使用注解@ManyToMany配置

　　　　 a 在实体中添加一个集合属性

　　　　 b 在属性上添加ManyToMany注解

　　　　 c:@JoinTable 注解配置关联关系

　　　　 name 中间表的名称

　　　　当前表和中间表的映射关系

　　　　对方表和中间映射表的关系

　　　　多对多关系中只能一方维护关联关系另一方放弃维护

　　配置级联操作

　　　　 @ManyToMnay注解中配置cascade属性

关联查询

　　1 使用导航的方式查询重难点

　　　　使用“对象.属性” 进行查询

　　　　对于多的查询默认就是延迟加载添加注解@Transactional

　　　　在OneToMany 注解中需要添加属性 fetch

　　　　值：FetchType.LAZY 延迟加载

　　　　FetchType.EAGER 及时加载

　　　　通过联系人查询客户

　　　　对一的查询默认是及时加载

　　　　也可以配置成延时加载

具体实现：简单案例：

1....pom.xml 与 applicationContext.xml 请看表与表关联一对多表与表关联一对一

2....实体类

User 类

 1 package com.wsc.core.entity;
 2 
 3 import javax.persistence.*;
 4 import java.io.Serializable;
 5 import java.util.HashSet;
 6 import java.util.Set;
 7 
 8 /**
 9  * @version 1.0
10  * @ClassName User
11  * @Description TODO
12  * @Author WSC
13  * @Date 2019/8/21 9:55
14  **/
15 @Entity
16 @Table(name="user")
17 public class User implements Serializable {  //实现序列化
18     @Id
19     @GeneratedValue(strategy = GenerationType.IDENTITY)
20     @Column(name="user_id")
21     private long userId;
22     @Column(name="username")
23     private String username;
24     @Column(name="password")
25     private String password;
26     //多对多关联关系    配置cascade属性
27     // FetchType.LAZY   延迟加载
28     // FetchType.EAGER   及时加载
29     @ManyToMany(cascade = CascadeType.ALL,fetch = FetchType.EAGER)
30 //    注解配置关联关系
31 //    name 中间表的名称
32 //   joinColumns 当前表和中间表的映射关系
33 //   inverseJoinColumns 对方表和中间映射表的关系
34 
35     @JoinTable(name="user_role",joinColumns = @JoinColumn(name="userid",referencedColumnName = "user_id"),
36             inverseJoinColumns = @JoinColumn(name="roleid",referencedColumnName = "role_id"))
37     Set<Role> role=new HashSet<Role>();
38 
39     @Override
40     public String toString() {
41         return "User{" +
42                 "userId=" + userId +
43                 ", username='" + username + '\'' +
44                 ", password='" + password + '\'' +
45                 ", role=" + role +
46                 '}';
47     }
48 
49     public long getUserId() {
50         return userId;
51     }
52 
53     public void setUserId(long userId) {
54         this.userId = userId;
55     }
56 
57     public String getUsername() {
58         return username;
59     }
60 
61     public void setUsername(String username) {
62         this.username = username;
63     }
64 
65     public String getPassword() {
66         return password;
67     }
68 
69     public void setPassword(String password) {
70         this.password = password;
71     }
72 
73     public Set<Role> getRole() {
74         return role;
75     }
76 
77     public void setRole(Set<Role> role) {
78         this.role = role;
79     }
80 }

View Code

Role类

 1 package com.wsc.core.entity;
 2 
 3 import javax.persistence.*;
 4 import java.io.Serializable;
 5 import java.util.HashSet;
 6 import java.util.Set;
 7 
 8 /**
 9  * @version 1.0
10  * @ClassName Role
11  * @Description TODO
12  * @Author WSC
13  * @Date 2019/8/21 9:55
14  **/
15 @Entity
16 @Table (name ="role")
17 public class Role implements Serializable {
18     @GeneratedValue(strategy =GenerationType.IDENTITY)
19     @Id
20     @Column(name="role_id")
21     private long roleId;
22     @Column(name="role_name")
23     private String rolename;
24     @Column(name="memo")
25     private String memo;
26     //多对多关联关系    配置cascade属性
27     // FetchType.LAZY   延迟加载
28     // FetchType.EAGER   及时加载
29     @ManyToMany(mappedBy = "role",fetch = FetchType.EAGER)
30     Set<User> user=new HashSet<User>();
31 
32     public long getRoleId() {
33         return roleId;
34     }
35 
36     public void setRoleId(long roleId) {
37         this.roleId = roleId;
38     }
39 
40     public String getRolename() {
41         return rolename;
42     }
43 
44     public void setRolename(String rolename) {
45         this.rolename = rolename;
46     }
47 
48     public String getMemo() {
49         return memo;
50     }
51 
52     public void setMemo(String memo) {
53         this.memo = memo;
54     }
55 
56     public Set<User> getUser() {
57         return user;
58     }
59 
60     public void setUser(Set<User> user) {
61         this.user = user;
62     }
63 
64     @Override
65     public String toString() {
66         return "Role{" +
67                 "roleId=" + roleId +
68                 ", rolename='" + rolename + '\'' +
69                 ", memo='" + memo + '\'' +
70                 ", user=" + user +
71                 '}';
72     }
73 }

View Code

3....接口dao

UserDao类

1 package com.wsc.core.dao;
2 
3 import com.wsc.core.entity.User;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 
6 public interface UserDao extends JpaRepository<User,Long> {
7 }

View Code

RoleDao类

1 package com.wsc.core.dao;
2 
3 import com.wsc.core.entity.Role;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 
6 public interface RoleDao extends JpaRepository<Role,Long> {
7 }

View Code

test类

 1 package com.wsc.core.onetone;
 2 
 3 import com.wsc.core.dao.RoleDao;
 4 import com.wsc.core.dao.UserDao;
 5 import com.wsc.core.entity.Role;
 6 import com.wsc.core.entity.User;
 7 import org.junit.Test;
 8 import org.junit.runner.RunWith;
 9 import org.springframework.beans.factory.annotation.Autowired;
10 import org.springframework.test.annotation.Commit;
11 import org.springframework.test.context.ContextConfiguration;
12 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
13 import org.springframework.transaction.annotation.Transactional;
14 
15 /**
16  * @version 1.0
17  * @ClassName ManyToMany
18  * @Description TODO
19  * @Author WSC
20  * @Date 2019/8/21 10:12
21  **/
22 @RunWith(SpringJUnit4ClassRunner.class)
23 @ContextConfiguration(locations = "classpath:applicationContext.xml")
24 public class ManyToMany  {
25     @Autowired
26     private UserDao userDao;
27     @Autowired
28     private RoleDao roleDao;
29     @Transactional //事务
30     @Commit //提交
31     @Test
32     public void testUserAndRole(){
33 //对象user
34         User user = new User();
35         user.setUsername("admin");
36         user.setPassword("123456");
37 //对象role
38         Role role = new Role();
39         role.setRolename("管理员");
40         role.setMemo("全部管");
41 
42         // 3 配置用户和角色之间的关系
43         user.getRole().add(role);
44         role.getUser().add(user);
45 
46         //4  把用户角色写入数据可
47         userDao.save(user);
48 //        roleDao.save(role);
49     }
50     @Test
51     @Transactional
52     @Commit
53     public void test02(){
54         User user = new User();
55         user.setUsername("迪丽热巴");
56         user.setPassword("123");
57 
58         User user1 = new User();
59         user1.setUsername("宝宝");
60         user1.setPassword("12346");
61 
62         Role role = new Role();
63         role.setRolename("演员");
64 
65         Role role1 = new Role();
66         role1.setRolename("导演");
67 
68 
69         // 3 配置用户和角色之间的关系
70         user.getRole().add(role);
71         user.getRole().add(role1);
72         user1.getRole().add(role);
73         user1.getRole().add(role1);
74         role.getUser().add(user);
75         role.getUser().add(user1);
76         role1.getUser().add(user);
77         role1.getUser().add(user1);
78         //4  把用户角色写入数据可
79         userDao.save(user);
80         userDao.save(user1);
81 
82     }
83 
84     @Transactional
85     @Commit
86     @Test
87     public void deleteUser(){
88         userDao.delete(2l);
89     }
90 }

View Code

posted @ 2019-08-21 21:21 Hi~Hi 阅读(903) 评论(0) 编辑收藏举报

刷新页面返回顶部

Hi~Hi

表与表关联 多对多

公告

表与表关联多对多