在前文hibernate之5.many2one单向提到多对多关系,表结构设计是基于中间表来实现,

以下以用户与角色(多对多)为例,在Hibernate是怎样操作的

表结构设计:

类图:

CRUD;

Student

  1. package com.demo.model;
  2.  
  3. import java.io.UnsupportedEncodingException;
  4. import java.util.Set;
  5.  
  6. /**学生信息
  7. * @author wobendiankun
  8. *2014-10-19 下午08:54:29
  9. */
  10. public class Student {
  11. private int studentId ;
  12. private String studentName ;
  13. private int age;
  14. private Set<Certificate> certificates ;
  15. private User user;
  16. public int getStudentId() {
  17. return studentId;
  18. }
  19. public void setStudentId(int studentId) {
  20. this.studentId = studentId;
  21. }
  22. public String getStudentName() {
  23. return studentName;
  24. }
  25. public void setStudentName(String studentName) {
  26. this.studentName = studentName;
  27. }
  28. public int getAge() {
  29. return age;
  30. }
  31. public void setAge(int age) {
  32. this.age = age;
  33. }
  34. @Override
  35. public String toString() {
  36. String str="";
  37. if(studentName!=null){
  38. try {
  39. str=new String(studentName.getBytes("UTF-8"));
  40. } catch (UnsupportedEncodingException e) {
  41. e.printStackTrace();
  42. }
  43. }
  44. return "Student [studentId=" + studentId + ", studentName="
  45. + str + ", age=" + age + "]";
  46. }
  47. public Set<Certificate> getCertificates() {
  48. return certificates;
  49. }
  50. public void setCertificates(Set<Certificate> certificates) {
  51. this.certificates = certificates;
  52. }
  53. public User getUser() {
  54. return user;
  55. }
  56. public void setUser(User user) {
  57. this.user = user;
  58. }
  59.  
  60. }

Role

  1. package com.demo.model;
  2.  
  3. import java.util.Set;
  4.  
  5. /**角色信息
  6. * @author wobendiankun
  7. *2014-11-2 下午08:29:54
  8. */
  9. public class Role {
  10. /**
  11. * 角色id
  12. */
  13. private int roleId;
  14. /**
  15. * 角色名称
  16. */
  17. private String roleName;
  18.  
  19. public Role() {
  20. }
  21.  
  22. public Role(int roleId) {
  23. this.roleId = roleId;
  24. }
  25.  
  26. public Role(String roleName) {
  27. this.roleName = roleName;
  28. }
  29.  
  30. private Set<User> users;
  31. public int getRoleId() {
  32. return roleId;
  33. }
  34. public void setRoleId(int roleId) {
  35. this.roleId = roleId;
  36. }
  37. public String getRoleName() {
  38. return roleName;
  39. }
  40. public void setRoleName(String roleName) {
  41. this.roleName = roleName;
  42. }
  43. public Set<User> getUsers() {
  44. return users;
  45. }
  46. public void setUsers(Set<User> users) {
  47. this.users = users;
  48. }
  49.  
  50. }

配置:

Role.hbm.xml

  1. <?
  2.  
  3. xml version="1.0"?>
  4. <!DOCTYPE hibernate-mapping PUBLIC
  5. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  6. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  7.  
  8. <hibernate-mapping >
  9.  
  10. <class name="com.demo.model.Role" table="t_role">
  11. <id name="roleId" column="role_id">
  12. <generator class="sequence">
  13. <param name="sequence">SEQ_T_ROLE</param>
  14. </generator>
  15. </id>
  16. <property name="roleName" column="role_name" />
  17. <set name="users" table="t_user_role" lazy="extra">
  18. <key column="role_id"></key>
  19. <many-to-many class="com.demo.model.User" column="user_id"></many-to-many>
  20. </set>
  21. </class>
  22. </hibernate-mapping>

<set name="users" table="t_user_role" lazy="extra">

<key column="role_id"></key>

<many-to-many class="com.demo.model.User" column="user_id"></many-to-many>

</set>

set元素的table属性::指中间表名

key元素的column属性:指表t_role在中间表中的关联字段

many-to-many元素的class属性:指set中的元素类型  ,column:User实体映射表t_user在中间表的关联字段

add:

  1. </pre><pre name="code" class="java">@Test
  2. <span style="white-space:pre"> </span>public void addTest() {
  3. <span style="white-space:pre"> </span>User user1=new User("李三","111");
  4. <span style="white-space:pre"> </span>User user2=new User("李四","111");
  5. <span style="white-space:pre"> </span>Set<User> users=new HashSet<User>();
  6. <span style="white-space:pre"> </span>users.add(user1);
  7. <span style="white-space:pre"> </span>users.add(user2);
  8. <span style="white-space:pre"> </span>
  9. <span style="white-space:pre"> </span>Role role=new Role("开发组");
  10. <span style="white-space:pre"> </span>role.setUsers(users);
  11. <span style="white-space:pre"> </span>Session session = null;
  12. <span style="white-space:pre"> </span>try {
  13. <span style="white-space:pre"> </span>session = HibernateUtil.openSession();
  14. <span style="white-space:pre"> </span>session.beginTransaction();
  15. <span style="white-space:pre"> </span>session.save(user1);
  16. <span style="white-space:pre"> </span>session.save(user2);
  17. <span style="white-space:pre"> </span>session.save(role);
  18. <span style="white-space:pre"> </span>session.getTransaction().commit();
  19. <span style="white-space:pre"> </span>} catch (Exception e) {
  20. <span style="white-space:pre"> </span>session.getTransaction().rollback();
  21. <span style="white-space:pre"> </span>e.printStackTrace();
  22. <span style="white-space:pre"> </span>} finally {
  23. <span style="white-space:pre"> </span>HibernateUtil.closeSession(session);
  24. <span style="white-space:pre"> </span>}
  25. <span style="white-space:pre"> </span>}

发出sql:

  1. Hibernate: insert into t_user (user_name, password, student_id, user_id) values (?, ?
  2.  
  3. , ?, ?)
  4. Hibernate: insert into t_user (user_name, password, student_id, user_id) values (?, ?, ?
  5.  
  6. , ?
  7.  
  8. )
  9. Hibernate: insert into t_role (role_name, role_id) values (?, ?)
  10. Hibernate: insert into t_user_role (role_id, user_id) values (?, ?
  11.  
  12. )
  13. Hibernate: insert into t_user_role (role_id, user_id) values (?, ?)

load

  1. @Test
  2. public void loadTest(){
  3. Session session = null;
  4. try {
  5. session = HibernateUtil.openSession();
  6. session.beginTransaction();
  7. Role role=(Role)session.load(Role.class,2);
  8. System.out.println("角色名称"+role.getRoleName());
  9. System.out.println("users:"+role.getUsers());
  10. session.getTransaction().commit();
  11. } catch (Exception e) {
  12. session.getTransaction().rollback();
  13. e.printStackTrace();
  14. } finally {
  15. HibernateUtil.closeSession(session);
  16. }
  17. }

发出sql:

  1. Hibernate: select role0_.role_id as role1_3_0_, role0_.role_name as role2_3_0_ from t_role role0_ where role0_.role_id=?
  2. 角色名称开发组
  3. Hibernate: select users0_.role_id as role1_3_1_, users0_.user_id as user2_1_, user1_.user_id as user1_2_0_, user1_.user_name as user2_2_0_, user1_.password as password2_0_, user1_.student_id as student4_2_0_ from t_user_role users0_ inner join t_user user1_ on users0_.user_id=user1_.user_id where users0_.role_id=?
  4. users:[com.demo.model.User@b4be3d, com.demo.model.User@35bb0f]

hibernate它 10.many2many单向的更多相关文章

  1. hibernate一对一外键单向关联

    关联是类(类的实例)之间的关系,表示有意义和值得关注的连接. 本系列将介绍Hibernate中主要的几种关联映射 Hibernate一对一主键单向关联Hibernate一对一主键双向关联Hiberna ...

  2. hibernate一对一主键单向关联

    关联是类(类的实例)之间的关系,表示有意义和值得关注的连接. 本系列将介绍Hibernate中主要的几种关联映射 Hibernate一对一主键单向关联Hibernate一对一主键双向关联Hiberna ...

  3. Hibernate的关联映射——单向1-N关联

    Hibernate的关联映射--单向1-N关联 单向1-N关联的持久化类里需要使用集合属性.因为1的一端需要访问N的一端,而N的一端将以集合(Set)形式表现.从这个意义上来看,1-N(实际上还包括N ...

  4. Hibernate的关联映射——单向1-1关联

    Hibernate的关联映射--单向1-1关联 对于单向的1-1关联关系,需要在持久化类里增加代表关联实体的成员变量,并为该成员变量添加setter方法和getter方法.从持久化类的代码上看,单向1 ...

  5. Hibernate的关联映射——单向N-1关联

    Hibernate的关联映射--单向N-1关联 N-1是非常常见的关联关系,最常见的父子关系也是N-1关联,单向的N-1关联只需从N的一端可以访问1的一端. 为了让两个持久化类能够支持这种关联映射,程 ...

  6. hibernate之关于一对一单向,双向关联映射

    [hibernate]之关于一对一单向,双向关联映射 首先我们来看,Hibernate官方对于一对一单向关联的解释: 基于外键关联的单向一对一关联和单向多对一关联差点儿是一样的. 唯一的不同就是单向一 ...

  7. 【SSH进阶之路】Hibernate映射——多对一单向关联映射(四)

    [SSH进阶之路]Hibernate基本原理(一) ,小编介绍了Hibernate的基本原理以及它的核心,採用对象化的思维操作关系型数据库. [SSH进阶之路]Hibernate搭建开发环境+简单实例 ...

  8. hibernate它5.many2one单向

    关系数据库表之间的关系: 1 正确 1 1 正确 许多 许多 正确 许多 表间关系设计 基于主键关联 基于外键关联 基于中间表 1 对 1关系实现: 基于主键关联 基于外键关联 基于中间表 1 对 多 ...

  9. 【SSH系列】Hibernate映射-- 多对一单向关联映射

    在hibernate中非常重要的就是映射,在前面的博文中,小编简单的介绍了基本映射,基本映射是对一个实体进行映射,关联映射就是处理多个实体之间的关系,将关联关系映射到数据库中,所谓的关联关系在对象模型 ...

随机推荐

  1. JAVA邮件收发实现(待)

    http://blog.csdn.net/ycg01/article/details/1394465

  2. maven仓库总结,maven私服搭建

    配置pom.xml依赖包时在这里找包的描述: http://search.maven.org/#browse 以java为根目录. mvn archtype:generate -DgroupId=zt ...

  3. C++用于修饰的keyword

    1.const修饰指针 (1)const int *p=&x:不可改动*p的内容,但能够让指针p指向还有一个地址,和int const *p一样 (2)int *const p=&x: ...

  4. Struts开发问题集锦

    在struts2de 1.6以前版本,都是用<s:datepicker>标签来获取时间,1.8后可以用struts-dojo.plugin里的<sx:datetimepicker&g ...

  5. 依赖注入(DI)

    依赖注入(DI)   IoC主要体现了这样一种设计思想:通过将一组通用流程的控制从应用转移到框架之中以实现对流程的复用,同时采用“好莱坞原则”是应用程序以被动的方式实现对流程的定制.我们可以采用若干设 ...

  6. Windows Phone开发(48):不可或缺的本地数据库

    原文:Windows Phone开发(48):不可或缺的本地数据库 也许WP7的时候,是想着让云服务露两手,故似乎并不支持本地数据库,所有数据都上传上"云"数据库中.不过呢,在SD ...

  7. Windows Phone开发(38):动画之PointAnimation

    原文:Windows Phone开发(38):动画之PointAnimation PointAnimation也是很简单的,与前面说到的两个Animation是差不多的,属性也是一样的,如By.Fro ...

  8. c语言移位操作

    应该先看看C语言是指所有的位二进制算术位计算.即使输入的是十进制的数,在存储器存储为二进制形式. “<<”使用方法: 的格式是:a<<m,a和m式,要求m>=0. 功能: ...

  9. Java中动态代理技术生成的类与原始类的区别 (转)

    用动态代理的时候,对它新生成的类长什么样子感到好奇.有幸通过一些资料消除了心里的疑惑. 平时工作使用的Spring框架里面有一个AOP(面向切面)的机制,只知道它是把类重新生成了一遍,在切面上加上了后 ...

  10. WEB网站性能优化

    最近做了一个WEB现场.幸运的是,一开始.但后来越来越慢,特别是在调试模式,,这肯定是我们的代码有问题.但是即使业务不是非常复杂的也非常慢,我们就想当然的觉得我们的代码没问题,可最后证明还是我们的代码 ...