HIbernate学习笔记(六) 关系映射之多对多

六、多对多 - 单向

Ø        一般的设计中,多对多关联映射,需要一个中间表

Ø        Hibernate会自动生成中间表

Ø        Hibernate使用many-to-many标签来表示多对多的关联

Ø        多对多的关联映射,在实体类中,跟一对多一样,也是用集合来表示的。

(一) 实例场景:

用户与他的角色(一个用户拥有多个角色,一个角色还可以属于多个用户)

(二) 对象模型:

HIbernate学习笔记(六) 关系映射之多对多

(三) 关系模型:

 
 

HIbernate学习笔记(六) 关系映射之多对多

(四) 实体类

Role实体类:

public class Role {

private int id;

private String name;

public int getId() return id;}

public void setId(int id) {this.id = id;}

public String getName() {return name;}

public void setName(Stringname) {  this.name = name;}}

User实体类:

public class User {

private int id;

private String name;

private Set<User> roles = newHashSet<User>();// Role对象的集合

public int getId() {return id;}

public void setId(int id) {this.id = id;}

public String getName() {return name;}

public void setName(Stringname) {this.name = name;}

public Set<User>getRoles() {return roles;}

public voidsetRoles(Set<User> roles) {this.roles = roles;  }

(五) xml方式:映射

Role映射文件:

<class name="com.wjt276.hibernate.Role" table="t_role">

<id name="id">

<generator class="native"/>

</id>

<property name="name" column="name"/>

</class>

User映射文件:

<class name="com.wjt276.hibernate.User" table="t_user">

<id name="id"column="id">

<generator class="native"/>

</id>

<property name="name"/>

<!--使用<set>标签映射集合(set),标签中的name值为对象属性名(集合roles),而使用table属性是用于生成第三方表名称,例:table="t_user_role",但是第三方面中的字段是自动加入的,作为外键分别指向其它表。

所以表<key>标签设置,例:<key column="userid"/>,意思是:在第三方表(t_user_role)中加入一个外键并且指向当前的映射实体类所对应的表(t_user).使用<many-to-many>来指定此映射集合所对象的类(实例类),并且使用column属性加入一个外键指向Role实体类所对应的表(t_role) -->

<setname="roles" table="t_user_role">

<key column="userid"/>

<many-to-many class="com.wjt276.hibernate.Role" column="roleid"/>

</set>

</class>

(六) annotation注解方式

注意:因为是多对多单向(当然用户拥有多个角色,一个角色也可属性多个用户,但这里角色看不到用户),所以角色只需要正常注解就可以了,

现在要使用@ManyToMany来注解多对多的关系,并使用@JoinTabel来注解第三方表的名称,再使用joinColumns属性来指定当前对象在第三方表中的字段名,并且这个字段会指向当前类相对应的表,最后再用inverseJoinColumns来指定当前类持有引用的实体类在第三方表中的字段名,并且指向被引用对象相对应的表,如下:

@Entity

public class User {

private int id;

private String name;

private Set<User> roles = new HashSet<User>();// Role对象的集合  @Id

@GeneratedValue

public int getId() {return id;}

@ManyToMany

@JoinTable(name="u_r",//使用@JoinTable标签的name属性注解第三方表名称

joinColumns={@JoinColumn(name="userId")},

//使用joinColumns属性来注解当前实体类在第三方表中的字段名称并指向该对象

inverseJoinColumns={@JoinColumn(name="roleId")}

//使用inverseJoinColumns属性来注解当前实体类持有引用对象在第三方表中的字段名称并指向被引用对象表

)

public Set<User> getRoles() {return roles;}

(七) 生成SQL语句

create table t_role (id integer not null auto_increment, namevarchar(255), primary key (id))

create table t_user (id integer not null auto_increment, namevarchar(255), primary key (id))

create table t_user_role (userid integer not null, roleid integer notnull, primary key (userid, roleid))

alter table t_user_role add index FK331DEE5F1FB4B2D4 (roleid), add constraint FK331DEE5F1FB4B2D4 foreign key (roleid) referencest_role (id)

alter table t_user_role add index FK331DEE5F250A083E(userid), add constraint FK331DEE5F250A083E foreign key (userid) referencest_user (id)

注:根据DDL语句可以看出第三方表的主键是一个复合主键(primary key (userid, roleid)),也就是说记录不可以有相同的数据。

(八) 数据库表及结构:

HIbernate学习笔记(六) 关系映射之多对多

(九) 多对多关联映射 单向数据存储:

session = HibernateUtils.getSession();

tx =session.beginTransaction();

Role r1 = new Role();

r1.setName("数据录入人员");

session.save(r1);

Role r2 = new Role();

r2.setName("商务主管");

session.save(r2);

Role r3 = new Role();

r3.setName("大区经理");

session.save(r3);

User u1 = new User();

u1.setName("10");

Set<Role>u1Roles = new HashSet<Role>();

u1Roles.add(r1);

u1Roles.add(r2);

u1.setRoles(u1Roles);

User u2 = new User();

u2.setName("祖儿");

Set<Role>u2Roles = new HashSet<Role>();

u2Roles.add(r2);

u2Roles.add(r3);

u2.setRoles(u2Roles);

User u3 = new User();

u3.setName("成龙");

Set<Role>u3Roles = new HashSet<Role>();

u3Roles.add(r1);

u3Roles.add(r2);

u3Roles.add(r3);

u3.setRoles(u3Roles);

session.save(u1);

session.save(u2);

session.save(u3);

tx.commit();

发出SQL语句:

Hibernate: insert into t_role (name) values (?)

Hibernate: insert into t_role (name) values (?)

Hibernate: insert into t_role (name) values (?)

Hibernate: insert into t_user (name) values (?)

Hibernate: insert into t_user (name) values (?)

Hibernate: insert into t_user (name) values (?)

Hibernate: insert into t_user_role (userid, roleid)values (?, ?)

Hibernate: insert into t_user_role (userid, roleid)values (?, ?)

Hibernate: insert into t_user_role (userid, roleid)values (?, ?)

Hibernate: insert into t_user_role (userid, roleid)values (?, ?)

Hibernate: insert into t_user_role (userid, roleid)values (?, ?)

Hibernate: insert into t_user_role (userid, roleid)values (?, ?)

Hibernate: insert into t_user_role (userid, roleid)values (?, ?)

注:前三条SQL语句,添加Role记录,第三条到第六条添加User,最后7条SQL语句是在向第三方表(t_user_role)中添加多对多关系(User与Role关系)

(十) 多对多关联映射 单向数据加载:

session =HibernateUtils.getSession();

tx =session.beginTransaction();

User user =(User)session.load(User.class, 1);

System.out.println("user.name=" + user.getName());

for(Iterator<Role> iter = user.getRoles().iterator();iter.hasNext();){

Rolerole = (Role) iter.next();

System.out.println(role.getName());

}

tx.commit();

生成SQL语句:

Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_ from t_useruser0_ where user0_.id=?

user.name=10

Hibernate: select roles0_.userid as userid1_, roles0_.roleid as roleid1_,role1_.id as id2_0_, role1_.name as name2_0_ from t_user_role roles0_ leftouter join t_role role1_ on roles0_.roleid=role1_.id where roles0_.userid=?

商务主管

数据录入人员

七、       多对多 - 双向

多对多关联映射 双向 两方都持有对象引用,修改对象模型,但数据的存储没有变化。

(一)     xml方式:映射

再修改映射文件:

<class name="com.wjt276.hibernate.Role" table="t_role">

<id name="id">

<generator class="native"/>

</id>

<property name="name" column="name"/>

<!—order-by 属性是第三方表哪个字段进行排序-->

<set name="users" table="t_user_role"order-by="userid">

<key column="roleid"/>

<many-to-many class="com.wjt276.hibernate.User" column="userid"/>

</set>  </class>

注:数据的存储与单向一样。但一般维护这个多对多关系,只需要使用一方,而使另一方维护关系失效。

总结:

<!— order-by 属性是第三方表哪个字段进行排序-->

<set name="users" table="t_user_role"order-by="userid">

<key column="roleid"/>

<many-to-many class="com.wjt276.hibernate.User" column="userid"/>

</set>

Ø        table属性值必须和单向关联中的table属性值一致

Ø        <key>中column属性值要与单向关联中的<many-to-many>标签中的column属性值一致

Ø        在<many-to-many>中的column属性值要与单向关联中<key>标签的column属性值一致。

(二) annotation注解方式

多对多关联映射 双向 两方都持有对象引用,修改对象模型,但数据的存储没有变化

只需要修改注解映射就可以了。

User实体类注解没有变化和单向一样:

@Entity

public class User {

private int id;

private Set<User> roles = new HashSet<User>();// Role对象的集合  @Id

@GeneratedValue

public int getId() {return id;}

@ManyToMany

@JoinTable(name="u_r",//使用@JoinTable标签的name属性注解第三方表名称

joinColumns={@JoinColumn(name="userId")},//使用joinColumns属性来注解当前实体类在第三方表中的字段名称并指向该对象

inverseJoinColumns={@JoinColumn(name="roleId")}

//使用inverseJoinColumns属性来注解当前实体类持有引用对象在第三方表中的字段名称并指向被引用对象表

)

public Set<User> getRoles() {return roles;}

Role实体类注解也非常的简单:使用@ManyToMany注解,并使用mappedBy属性指定引用对象持有自己的的属性名

@Entity

public class Role {

private int id;

private String name;

private Set<User> users = newHashSet<User>();

@Id

@GeneratedValue

public int getId() {return id;  }

@ManyToMany(mappedBy="roles")

public Set<User>getUsers() {return users;}

public voidsetUsers(Set<User> users) {this.users = users;  }

多对多关联映射 双向 数据加载

session =HibernateUtils.getSession();

tx =session.beginTransaction();

Role role= (Role)session.load(Role.class, 1);

System.out.println("role.name=" + role.getName());

for(Iterator<User> iter = role.getUsers().iterator();iter.hasNext();){

Useruser = iter.next();

System.out.println("user.name=" + user.getName());

}

tx.commit();

生成SQL语句:

Hibernate: select role0_.id as id2_0_, role0_.name as name2_0_ from t_rolerole0_ where role0_.id=?

role.name=数据录入人员

Hibernate: select users0_.roleid as roleid1_, users0_.userid as userid1_,user1_.id as id0_0_, user1_.name as name0_0_ from t_user_role users0_ leftouter join t_user user1_ on users0_.userid=user1_.id where users0_.roleid=?order by users0_.userid

user.name=10

user.name=成龙

上一篇:How to install Wordpress 4.0 on CentOS 7.0


下一篇:VS2012 TFS解决离职后代码遗留未迁入问题