个人中心
gpt4 book ai didi

详解hibernate双向多对多关联映射XML与注解版

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 26 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章详解hibernate双向多对多关联映射XML与注解版由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

双向多对多关联映射原理

假设，一个员工可能有多个角色，一个角色可能有多个员工，从员工或角色的角度看，这就是多对多的关系，不管从哪一个角度看，都是多对多的联系。多对多关联映射关系一般采用中间表的形式来实现，即新增一种包含关联双方主键的表。实现多对多关联关系，在数据库底层通过添加中间表指定关联关系，而在hibernate框架在双方的实体中添加一个保存对方的集合，在双方的映射文件中使用<set>元素和<many-to-many>元素进行关联关系的配置.

如下图所示:

详解hibernate双向多对多关联映射XML与注解版

(1)XML版 。

Role类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package Hibernate_demo1.Demo15.Entity;
 
import java.util.Set;
 
public class Role {
   
   private String id;
   private String rame;
   private Set<User> users;
   
   
   public String getId() {
     return id;
   }
   public void setId(String id) {
     this .id = id;
   }
   public String getRame() {
     return rame;
   }
   public void setRame(String rame) {
     this .rame = rame;
   }
   public Set<User> getUsers() {
     return users;
   }
   public void setUsers(Set<User> users) {
     this .users = users;
   }
}

User类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package Hibernate_demo1.Demo15.Entity;
 
import java.util.Set;
 
public class User {
 
   private String id;
   private String uname;
   private Set<Role> roles;
 
   
 
   public String getId() {
     return id;
   }
   public void setId(String id) {
     this .id = id;
   }
   public String getUname() {
     return uname;
   }
   public void setUname(String uname) {
     this .uname = uname;
   }
   public Set<Role> getRoles() {
     return roles;
   }
   public void setRoles(Set<Role> roles) {
     this .roles = roles;
   }
   
   
}

Role.hbm.xml映射类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<? xml version = "1.0" ?> 
<!DOCTYPE hibernate-mapping PUBLIC  
   "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
< hibernate-mapping > 
   < class name = "Hibernate_demo1.Demo15.Entity.Role" table = "role" > 
     < id name = "id" type = "java.lang.String" > 
       < column name = "id" />
       < generator class = "uuid" > 
       </ generator > 
     </ id > 
     < property name = "rame" column = "rname" />
     
     < set name = "users" table = "user_role" > 
       < key column = "roleid" ></ key > 
       < many-to-many class = "Hibernate_demo1.Demo15.Entity.User" column = "userid" ></ many-to-many > 
     </ set > 
   </ class > 
</ hibernate-mapping > 

User.hbm.xml映射类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<? xml version = "1.0" ?> 
<!DOCTYPE hibernate-mapping PUBLIC  
   "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
< hibernate-mapping > 
   < class name = "Hibernate_demo1.Demo15.Entity.User" table = "user" > 
     < id name = "id" > 
       < generator class = "uuid" > 
       </ generator > 
     </ id > 
     
     < property name = "uname" column = "uname" /> 
      
      < set name = "roles" table = "user_role" >
       < key column = "userid" />
       < many-to-many class = "Hibernate_demo1.Demo15.Entity.Role" column = "roleid" />  
     </ set >
   </ class > 
</ hibernate-mapping > 

测试类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
package Hibernate_demo1.Demo15;
 
import java.util.HashSet;
import java.util.Set;
 
import org.hibernate.Session;
 
import Hibernate_demo1.Demo15.Entity.Role;
import Hibernate_demo1.Demo15.Entity.User;
import Hibernate_demo1.Demo15.Util.HibernateUtils;
 
 
 
public class App 
{
   public static void main( String[] args )
   {
     
     Session session = null ;
     try { 
        
       session = HibernateUtils.getSession();
       session.beginTransaction(); 
       
 
       Role r1 = new Role();
       r1.setRame( "数据录入人员" );
       session.save(r1);
       
       Role r2 = new Role();
       r2.setRame( "商务主管" );
       session.save(r2);
       
       Role r3 = new Role();
       r3.setRame( "商务经理" );
       session.save(r3);
       
       Role r4 = new Role();
       r4.setRame( "项目会计" );
       session.save(r4);
       
       User u1 = new User();
       u1.setUname( "张三" );
       Set<Role> u1Roles = new HashSet<Role>();
       u1Roles.add(r1);
       u1Roles.add(r2);
       u1.setRoles(u1Roles);
       session.save(u1);
       
       User u2 = new User();
       u2.setUname( "李四" );
       Set<Role> u2Roles = new HashSet<Role>();
       u2Roles.add(r1);
       u2Roles.add(r2);
       u2Roles.add(r3);
       u2.setRoles(u2Roles);
       session.save(u2);
       
       User u3 = new User();
       u3.setUname( "王五" );
       Set<Role> u3Roles = new HashSet<Role>();
       u3Roles.add(r3);
       u3Roles.add(r4);
       u3.setRoles(u3Roles);
       session.save(u3);
       
       
       session.getTransaction().commit(); 
     } catch (Exception e){ 
       e.printStackTrace(); 
       session.getTransaction().rollback(); 
     } finally { 
       HibernateUtils.closeSession(session); 
     }
   }
}

执行结果

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
Hibernate: 
   insert 
   into
     role
     (rname, id) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     role
     (rname, id) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     role
     (rname, id) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     role
     (rname, id) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user
     (uname, id) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user
     (uname, id) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user
     (uname, id) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user_role
     (userid, roleid) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user_role
     (userid, roleid) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user_role
     (userid, roleid) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user_role
     (userid, roleid) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user_role
     (userid, roleid) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user_role
     (userid, roleid) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user_role
     (userid, roleid) 
   values
     (?, ?)

数据库内容为

user表

详解hibernate双向多对多关联映射XML与注解版

role表

详解hibernate双向多对多关联映射XML与注解版

user_role表

详解hibernate双向多对多关联映射XML与注解版

(2)注解版 。

Role类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package Hibernate_demo1.Demo16.Entity;
 
import java.util.HashSet;
import java.util.Set;
 
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
 
import org.hibernate.annotations.GenericGenerator;
 
@Entity
@Table (name= "role" )
public class Role {
   
   @Id
     @GenericGenerator (name= "uuidGenerator" , strategy= "uuid" )
     @GeneratedValue (generator= "uuidGenerator" )
   private String id;
   
   @Column (name= "rname" )
   private String rame;
   
   @ManyToMany (cascade=CascadeType.REFRESH,mappedBy= "roles" )
   private Set<User> users= new HashSet<User>();
   
   
   
   
   public String getId() {
     return id;
   }
   public void setId(String id) {
     this .id = id;
   }
   public String getRame() {
     return rame;
   }
   public void setRame(String rame) {
     this .rame = rame;
   }
   public Set<User> getUsers() {
     return users;
   }
   public void setUsers(Set<User> users) {
     this .users = users;
   }
}

User类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package Hibernate_demo1.Demo16.Entity;
 
import java.util.HashSet;
import java.util.Set;
 
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
import javax.persistence.JoinColumn;
 
import org.hibernate.annotations.GenericGenerator;
 
@Entity
@Table (name= "user" )
public class User {
 
   @Id
     @GenericGenerator (name= "uuidGenerator" , strategy= "uuid" )
     @GeneratedValue (generator= "uuidGenerator" )
   private String id;
   
   @Column (name= "uname" )
   private String uname;
   
   /*
    * @ManyToMany表示多对多关联，对于这种关联极少数情况会使用级联删除，我这里设置的是级联刷新；
    * 因为有中间表的存在这里使用@JoinTable来设置关联表后面的name配置的是关联表的名称
    * inverseJoinColumn配置的是关系被维护一方主键对应的中间表字段
    * joinColumn配置的是关系维护方主键对应的中间表字段。
    */
   @ManyToMany (cascade=CascadeType.REFRESH)
   @JoinTable (name= "user_role" ,inverseJoinColumns= @JoinColumn (name= "roleid" ),joinColumns= @JoinColumn (name= "userid" ))
   private Set<Role> roles= new HashSet<Role>();
 
   
 
   public String getId() {
     return id;
   }
   public void setId(String id) {
     this .id = id;
   }
   public String getUname() {
     return uname;
   }
   public void setUname(String uname) {
     this .uname = uname;
   }
   public Set<Role> getRoles() {
     return roles;
   }
   public void setRoles(Set<Role> roles) {
     this .roles = roles;
   }
   
   
}

测试类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
package Hibernate_demo1.Demo16;
 
import java.util.HashSet;
import java.util.Set;
 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
 
import Hibernate_demo1.Demo16.Entity.Role;
import Hibernate_demo1.Demo16.Entity.User;
 
 
public class Test {
 
   public static void main(String[] args) {
     
 
     SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory(); 
     Session session = sessionFactory.getCurrentSession(); 
     Transaction tx = session.beginTransaction(); 
     
   
     //创建两个用户
     User us1= new User();
     us1.setUname( "小明" );
     
     User us2= new User();
     us2.setUname( "小黑" );
     
     //创建用户集合
     Set<User> su= new HashSet<User>();
     su.add(us1);
     su.add(us2);
     
     
     //创建两个角色
     Role ro1= new Role();
     ro1.setRame( "程序员" );
     ro1.setUsers(su);
     
     Role ro2= new Role();
     ro2.setRame( "技术经理" );
     ro2.setUsers(su);
     
     
     //创建角色集合
     Set<Role> sr= new HashSet<Role>();
     sr.add(ro1);
     sr.add(ro2);
     
     //往用户添加角色集合
     us1.setRoles(sr);
     us2.setRoles(sr);
     
     //保存用户和角色
     session.save(us1);
     session.save(us2);
     session.save(ro1);
     session.save(ro2);
     
     
     tx.commit();
     session.close();
   }
 
}

执行结果如下

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
Hibernate: 
   insert 
   into
     user
     (uname, id) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user
     (uname, id) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     role
     (rname, id) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     role
     (rname, id) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user_role
     (userid, roleid) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user_role
     (userid, roleid) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user_role
     (userid, roleid) 
   values
     (?, ?)
Hibernate: 
   insert 
   into
     user_role
     (userid, roleid) 
   values
     (?, ?)

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.

原文链接：http://blog.csdn.net/u011781521/article/details/71335507?utm_source=tuicool&utm_medium=referral 。

最后此篇关于详解hibernate双向多对多关联映射XML与注解版的文章就讲到这里了,如果你想了解更多关于详解hibernate双向多对多关联映射XML与注解版的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

26 4 0
文章推荐： Python实现简单网页图片抓取完整代码实例
文章推荐： AspNet Core上实现web定时任务实例
文章推荐： ASP.NET Core Middleware的实现方法详解
文章推荐： 利用numpy实现一、二维数组的拼接简单代码示例
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com