`

hibernate - 多对多关联关系

阅读更多

多对多关联关系:本质上就是两个一对多的关系,

例如:一个学生可以选择多门课程。一门课程可以被很多学生选择。

体现在代码中如下;学生类:

 

Java代码 
  1. <span style="white-space: pre;">  </span>private String id;//学生id  
  2.     private String name;//学生姓名  
  3.     private Set<Course> course;//学生选择的课程集合  
  4.     public String getId() {  
  5.         return id;  
  6.     }  
  7.     public void setId(String id) {  
  8.         this.id = id;  
  9.     }  
  10.     public String getName() {  
  11.         return name;  
  12.     }  
  13.     public void setName(String name) {  
  14.         this.name = name;  
  15.     }  
  16.     public Set<Course> getCourse() {  
  17.         return course;  
  18.     }  
  19.     public void setCourse(Set<Course> course) {  
  20.         this.course = course;  
  21.     }  
课程类:

 

 

Java代码 
  1. <span style="white-space: pre;">  </span>private String id;//课程id  
  2.     private String name;//课程名称  
  3.     private Set<Student> student;//学生集合  
  4.     public String getId() {  
  5.         return id;  
  6.     }  
  7.     public void setId(String id) {  
  8.         this.id = id;  
  9.     }  
  10.     public String getName() {  
  11.         return name;  
  12.     }  
  13.     public void setName(String name) {  
  14.         this.name = name;  
  15.     }  
  16.     public Set<Student> getStudent() {  
  17.         return student;  
  18.     }  
  19.     public void setStudent(Set<Student> student) {  
  20.         this.student = student;  
  21.     }  
关键就是两个映射文件了。

 

student.hbm.xml映射文件

 

Java代码 
  1. <span style="white-space: pre;">  </span><class name="com.test.bean1.Student" table="student">  
  2.         <id name="id" column="id" type="string">  
  3.             <generator class="uuid"/>  
  4.         </id>  
  5.         <property name="name" column="name" type="string"/>  
  6.         <set name="course" table="student_course" cascade="save-update" >  
  7.             <key column="student_id"/><!-- 这个student_id是中间关联表的id,根据这个id可以关联到student表 -->  
  8.             <!-- class:表示关联的类型。column:表示根据course_id可以关联到course表 -->  
  9.             <many-to-many class="com.test.bean1.Course" column="course_id" />  
  10.         </set>  
  11.     </class>  
course.hbm.xml映射文件;

 

 

Java代码 
  1. <class name="com.test.bean1.Course" table="course">  
  2.         <id name="id" column="id" type="string">  
  3.             <generator class="uuid"/>  
  4.         </id>  
  5.         <property name="name" column="name" type="string"/>  
  6.         <!-- 这里的配置和上面的一样,有一点就是inverse为true;表示对方维护这种关联关系。为false:表示主动方;由主动方维护这种关联关系 -->  
  7.         <set name="student" table="student_course" cascade="save-update" inverse="true" >  
  8.             <key column="course_id"/>  
  9.             <many-to-many class="com.test.bean1.Student" column="student_id"  />  
  10.         </set>  
  11.     </class>  
最后来个测试吧:

 

 

Java代码 
  1.         Session session=sessionfactory.openSession();  
  2.         Transaction tx=null;  
  3. //      Student student=new Student();  
  4. //      student.setName("zhangsan");  
  5. //      student.setCourse(new HashSet<Course>());  
  6. //        
  7. //      Course course=new Course();  
  8. //      course.setName("英语");  
  9. //      course.setStudent(new HashSet<Student>());  
  10. //      //添加记录  
  11. //      student.getCourse().add(course);  
  12. //      course.getStudent().add(student);  
  13. //        
  14.         try {  
  15.             tx=session.beginTransaction();  
  16.             //查询到张三学生。没用延迟加载。所以把对应的课程表的信息也查出来了。  
  17.             Student student=(Student)session.get(Student.class"4028ab81385bdd9b01385bdd9d030001");  
  18.             //查询到数学这门课程  
  19. //          Course course=(Course)session.get(Course.class, "4028ab81385be0c001385be0c2db0002");  
  20.             //删除信息  
  21. //          student.getCourse().remove(course);  
  22.               
  23.             //已经查询到了张三的信息。和数学课程的信息。所以可以讲数学这门课程让张三选中  
  24. //          student.getCourse().add(course);  
  25. //          course.getStudent().add(student);  
  26.               
  27.             //遍历张三学生的所选课程  
  28.             Set<Course> course=student.getCourse();  
  29.             for(Iterator<Course> iter=course.iterator();iter.hasNext();){  
  30.                 System.out.println(iter.next().getName());  
  31.             }  
  32.             tx.commit();  
  33.         } catch (Exception e) {  
  34.             if(null!=tx)  
  35.                 tx.rollback();  
  36.             e.printStackTrace();  
  37.         }finally{  
  38.             session.close();  
  39.         }  
省略了获取session的代码了。

 

9
10
分享到:
评论
1 楼 youc3576 2012-07-08  
来个完整版的么 哥们

相关推荐

    Hibernate-extensions 完整安装包

    除了上述特性,Hibernate-Extensions还提供了其他实用功能,如批量操作支持、动态实体、多对多关联的级联操作等。批量操作可以大大提高数据库操作的效率,动态实体则允许在运行时动态创建和操作实体类,多对多关联的...

    hibernate-release-5.2.10

    7. **关联映射**:包括一对一(@OneToOne)、一对多(@OneToMany)、多对一(@ManyToOne)、多对多(@ManyToMany)关系的映射,方便处理对象间的关联关系。 8. **延迟加载**:Hibernate的懒加载策略可以在需要时才...

    Hibernate ORM - 一对多双向关联关系

    标题“Hibernate ORM - 一对多双向关联关系”指的是在数据库建模中,Hibernate ORM(对象关系映射)框架如何处理一个实体类(如User)与多个实体类(如Article)之间的关系。在这种关系中,一个用户可以拥有多个文章...

    hibernate-core 核心jar包

    Hibernate 是一个开源的对象关系映射(ORM)框架,它允许Java开发者将数据库操作与业务对象进行解耦,简化了数据库编程。`hibernate-core`是Hibernate的核心库,包含了执行ORM功能所需的主要组件。 在Hibernate-...

    hibernate-jpa-2.1-api-1.0.0.final.jar.zip

    `hibernate-jpa-2.1-api-1.0.0.final.jar`是Hibernate对JPA 2.1规范的实现库,它使得开发者能够使用Hibernate的高效功能同时遵循JPA规范。 **1. Hibernate与JPA的关系** Hibernate最初作为一个独立的ORM框架,后来...

    HIBERNATE - 符合Java习惯的关系数据库持久化

    2. **集合映射**:通过一对多、多对一、多对多等关联关系,将集合属性与数据库表建立联系。 3. **排序集合**:对于需要按特定顺序存储的集合,可以使用排序集合(Sorted Collection)。 4. **双向关联**:在实体类...

    hibernate-5.2.15. 最新jar包

    8. **延迟加载(Lazy Loading)**:Hibernate可以实现属性或关联关系的延迟加载,只有在真正需要时才从数据库中获取数据,避免了内存占用过多。 9. **增强型实体**:Hibernate 5引入了代理实体(Enhanced Entity)...

    Hibernate-annotations-3.4最新版本

    在关联关系的处理上,Hibernate-annotations同样提供了丰富的注解。比如,@OneToOne、@OneToMany、@ManyToOne和@ManyToMany分别用于表示一对一、一对多、多对一和多对多的关系。这些注解允许我们轻松地定义实体之间...

    hibernate-annotations-3.4.0.GA

    6. @ManyToOne、@OneToOne、@OneToMany、@ManyToMany:定义不同类型的关联关系,如一对一、一对多、多对多。 7. @JoinColumn:用于关联关系中指定外键字段的属性。 8. @Temporal:用于日期时间类型的字段,支持...

    最新 hibernate-release-4.2.13.Final.tgz

    2. 探索映射:深入理解实体类与数据库表之间的映射机制,包括一对一、一对多、多对一、多对多关系的配置。 3. 深入查询:掌握HQL和Criteria API的高级用法,如分页、排序、子查询等。 4. 事务管理:了解Hibernate的...

    Middlegen-Hibernate-r5

    例如,复杂的关联关系或特殊的数据库类型可能需要开发者手动调整生成的元数据文件。此外,随着JPA(Java Persistence API)和Spring Data的流行,Middlegen的角色逐渐被取代,更多开发者选择使用这些现代的解决方案...

    hibernate-common-annotations.jar

    6. @OneToMany、@ManyToOne、@OneToOne、@ManyToMany:表示不同类型的关联关系,如一对一、一对多、多对多。 7. @JoinColumn:用于指定关联字段在表中的具体列名。 8. @Temporal:处理日期和时间类型的字段,如...

    Hibernate ORM - 一对一主键关联关系

    在Hibernate中,一对一的主键关联关系可以通过以下几种方式配置: 1. **注解配置**: 使用`@OneToOne`注解来声明一对一关系,同时通过`@PrimaryKeyJoinColumn`注解指定共享的主键列。例如: ```java @Entity ...

    hibernate-distribution-3.3.2.GA-dist

    7. **关联映射**:支持一对一、一对多、多对一和多对多等各种关联关系的映射,使得对象间的关联关系能够自然地反映到数据库中。 8. **延迟加载**:Hibernate的懒加载策略能有效减少数据库交互,只有在真正需要时才...

    hibernate-release-5.0.7.Final.zip

    讲师深入讲解了如何使用5.0.7.Final版本进行实际项目开发,包括实体类设计、配置文件设置、CRUD操作、关联映射、查询优化等关键知识点,旨在帮助学员快速掌握Hibernate的精髓。 5. 学习资源 包含的"0.txt"可能是一...

    hibernate-release-5.3.2.Final

    Hibernate ORM,作为Java领域最著名的对象关系映射框架之一,自诞生以来就深受开发者喜爱。2018年7月5日,Hibernate发布了其最新版本——5.3.2.Final,带来了诸多改进和新特性,为开发者提供了更为高效、稳定的持久...

    hibernate多对一单向关联关系实现源码

    在Java的持久化框架Hibernate中,多对一(ManyToOne)关联关系是一种常见的对象关系映射(ORM)场景。这种关系通常出现在一个实体类拥有多条与另一个实体类相关的记录,而另一个实体类可能只有一条对应的记录。例如...

    Hibernate ORM - 多对多双向连接表关联关系

    本文将深入探讨Hibernate ORM中的一个关键概念——多对多双向连接表关联关系。这种关联关系在实际业务场景中非常常见,比如用户与角色、课程与学生等例子,都需要用到多对多的关系来描述它们之间的复杂联系。 首先...

    hibernate-orm-master.zip

    Hibernate支持多种关联映射,包括一对一(@OneToOne)、一对多(@OneToMany)、多对一(@ManyToOne)和多对多(@ManyToMany)。这些关联可以通过定义外键或使用中间表来实现,使得对象间的复杂关系得以轻松处理。 ...

    hibernate-mapping参数详解

    `cascade`参数可以设置为`all`、`none`、`save-update`、`delete`等值,控制何时对关联对象执行相同的操作。例如,`none`意味着没有级联操作,而`all`则会在任何操作中都进行级联。 5. `unsaved-value`:这个属性...

Global site tag (gtag.js) - Google Analytics