Eat a Mouthful of hibernate (vi)--many-to-many association mappings

Today, there are many-to-many correlation mappings in Hibernate, and many-to-many correlation mappings involve one-way mapping and two-way mapping of 2.

Let's start with a many-to-many correlation example: User and role roles, one user can belong to multiple roles, and one role can have multiple users. This is a typical example of many-to-many associations. The one-way association mapping is only by the A-terminal to operate the B-terminal, B-terminal can not operate the data at the end. The bidirectional correlation mapping is the data at the other end that can be manipulated at both ends of a and b.

First, one-way association mappings, the entity classes are as follows:

2. <span style="font-size:18px" >/**
4. * Student Class
6. * @author Longxuan
8. *
10. */
12. Public class User {
16. private int id;
20. private String name;
24. private set<role> roles;
28. //Omit get and set methods here
30. }
34. /**
36. * Class Category
38. * @author Longxuan
40. *
42. */
44. Public class Role {
48. private int id;
52. private String name;
56. //Omit get and set methods here
58. }
62. </span>

Map file:

2. <span style="font-size:18px"><? XML version="1.0"?>
4. <! DOCTYPE hibernate-mapping Public
6. "-//hibernate/hibernate Mapping DTD 3.0//en"
8. "Http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
10. <hibernate-mapping package="Com.bjpowernode.hibernate">
12. <class name="User" table="T_user">
14. <ID name="id">
16. <generator class="native"/>
18. </ID>
20. <property name="name"/>
22. <set name= "roles" table="T_user_role">
24. <key column="user_id"></key>
26. <many-to-many class="Role" column="Roleid"></many-to-many>
28. </Set>
30. </class>
34. <class name="Role" table="T_role">
36. <ID name="id">
38. <generator class="native"/>
40. </ID>
42. <property name="name"/>
44. </class>
48. </hibernate-mapping></span>

The user class has a set set of role, and the set tag and the Many-to-many tag in the mapping file, so you can manipulate the role by using the user, but you cannot manipulate the data from role. Many-to-many relationship maintenance was used in the third table T_user_role. It holds the primary key for user and role.

Judging from the one-way, many-to-many association mappings above, I can check which roles a user belongs to, but I can't find out which user is in a role. So in order to solve this problem, we adopt bidirectional correlation mapping.

In fact, the two-way correlation mapping is to set a mapping relationship at the 2 end. That is, the set collection of the user is also added in role:

2. <span style="font-size:18px" >/**
4. * Class Category
6. * @author Longxuan
8. *
10. */
12. Public class Role {
16. private int id;
20. private String name;
24. private set<user> users;
28. //Omit get and set methods here
30. }
32. </span>

The role section in the mapping file also needs to be modified accordingly:

2. <span style="font-size:18px"><class name="Role" table="T_role" >
4. <ID name="id">
6. <generator class="native"/>
8. </ID>
10. <property name="name"/>
12. <set name="users" table="T_user_role">
14. <key column="Roleid"></key>
16. <many-to-many class="User" column="user_id"></many-to-many >
18. </Set>
20. </class></span>

It is important to note that the table and two column in the configuration file must be consistent. Otherwise it's going to go wrong. If the table name is different, then 2 intermediate tables will be generated, one with user maintenance and one with role. Because it becomes 2 many-to-many unidirectional association mappings. If the column names are inconsistent, they will be sent out. Or it becomes a 2-to-many one-way association map. At the same time, data redundancy is also occurring.

So the two-way correlation mapping, must ensure that the 2-terminal mapping relationship is set consistent. can be referred to as "bidirectional correlation mapping".

Eat a Mouthful of hibernate (vi)--many-to-many association mappings