`
ninebirds
  • 浏览: 79570 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

hibernate: many-to-many的例子

阅读更多

1.建表

 create   table  student
(sid  varchar ( 32 )  not   null   primary   key ,
 sname  varchar ( 16 ),
 sage  varchar ( 16 ),
)

 create   table  course
(cid  varchar ( 32 )  not   null   primary   key ,
cname  varchar ( 16 )
)

 create   table  student_course_link
(sid  varchar ( 32 )  not   null ,
cid  varchar ( 32 )  not   null ,
 primary   key (sid,cid)
)
 2.写VO
StudentVO
package com.test;
import java.util.Set;
public class Student
{
    private String sid;
    private String sname;
    private String sage;

    private Set course;
    public Student()
    {
    }
   //写上get setCourse vo
package com.test;

import java.util.Set;

public class Course
{
    private String cid;
    private String cname;
    private Set student;
   //写上get set

 

 

写配置文件
Student.hbm.xml
<!---->
<!---->    
Course.hbm.xml
<!---->
<!---->     
接着把下面的hibernate.properties文件拷到classes目录下。。这里用的是mysql
hibernate.query.substitutions true 1, false 0, yes 'Y', no 'N'
## MySQL
hibernate.dialect net.sf.hibernate.dialect.MySQLDialect
hibernate.connection.driver_class org.gjt.mm.mysql.Driver
hibernate.connection.url jdbc:mysql://localhost:3306/wjcms
hibernate.connection.username root
hibernate.connection.password wujun
hibernate.connection.pool_size 1
hibernate.proxool.pool_alias pool1
hibernate.show_sql true
hibernate.jdbc.batch_size 0
hibernate.max_fetch_depth 1
hibernate.cache.use_query_cache true 写测试类了..
package com.test;

xml 代码

 

  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping   
  3.     PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"   
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">  
  5.   
  6. <hibernate-mapping>  
  7.   
  8.     <class name="com.test.Student" table="student" >  
  9.   
  10.         <id name="sid" type="string" unsaved-value="null" >  
  11.             <column name="sid" sql-type="char(32)" not-null="true"/>  
  12.             <generator class="uuid.hex"/>  
  13.         </id>  
  14.   
  15.         <property name="sname">  
  16.             <column name="sname" sql-type="varchar(16)" not-null="true"/>  
  17.         </property>  
  18.   
  19.         <property name="sage">  
  20.             <column name="sage" sql-type="varchar(16)" not-null="true"/>  
  21.         </property>  
  22.   
  23.         <set name="course" table="student_course_link" cascade="all" outer-join="false">  
  24.             <key column="sid"/>  
  25.             <many-to-many class="com.test.Course" column="cid"/>  
  26.         </set>  
  27.       
  28.     </class>  
  29.   
  30. </hibernate-mapping>  

        <id name="sid" type="string" unsaved-value="null"></id>
            

xml 代码

 

  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping   
  3.     PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"   
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">  
  5.   
  6. <hibernate-mapping>  
  7.   
  8.     <class name="com.test.Course" table="course" >  
  9.   
  10.         <id name="cid" type="string" unsaved-value="null" >  
  11.             <column name="cid" sql-type="char(32)" not-null="true"/>  
  12.             <generator class="uuid.hex"/>  
  13.         </id>  
  14.   
  15.         <property name="cname">  
  16.             <column name="cname" sql-type="varchar(16)" not-null="true"/>  
  17.         </property>  
  18.   
  19.         <set name="student" table="student_course_link" lazy="false" cascade="all">  
  20.             <key column="cid"/>  
  21.             <many-to-many class="com.test.Student" column="sid"/>  
  22.         </set>  
  23.       
  24.     </class>  
  25.   
  26. </hibernate-mapping>  

        <id name="cid" type="string" unsaved-value="null"></id>
            <column name="cid" sql-type="char(32)" not-null="true"></column>
            

import net.sf.hibernate.Session;
import net.sf.hibernate.SessionFactory;
import net.sf.hibernate.cfg.Configuration;
import net.sf.hibernate.*;
import java.util.Set;
import java.util.HashSet;
import java.sql.*;
import java.util.List;
import java.util.Iterator;

public class TestManyToMany
{
    SessionFactory sf;
    Session session;
    public TestManyToMany()
    {
        try
        {
            Configuration cfg = new Configuration();
            sf = cfg.addClass(Student.class).addClass(Course.class).buildSessionFactory();
        }
        catch(HibernateException ex)
        {
            ex.printStackTrace();
        }
    }
    public void doCreate()
    {
        try
        {
            session = sf.openSession();

            Student student = new Student();
            student.setSname("小王");
            student.setSage("22");

            Set courseSet = new HashSet();
            Course course = null;
            for(int i=0;i<2;i++)
            {
                course = new Course();
                if(i==0)
                    course.setCname("c++");
                else if(i==1)
                    course.setCname("java");
                courseSet.add(course);
            }
            student.setCourse(courseSet);
           
            session.save(student);
            session.flush();
            session.connection().commit();

        }
        catch(HibernateException ex)
        {
            ex.printStackTrace();
        }
        catch(SQLException ex1)
        {
            ex1.printStackTrace();
        }
        finally
        {
                try{
                    session.close();
                }
                catch(HibernateException ex2){
                }
        }

    }
    public void doQuery()
    {
        try{
            session = sf.openSession();
            Query q = session.createQuery("select s from Student as s");
            List l = q.list();
            Student s = null;
            Course course = null;
            for(int i=0;i             {
                s = (Student)l.get(i);
                System.out.println("姓名: "+s.getSname());
                System.out.println("年龄: "+s.getSage());
                System.out.println("所选的课程:");
                Iterator it = s.getCourse().iterator();
                while(it.hasNext())
                {
                    course = (Course)it.next();
                    System.out.println("课程名: "+course.getCname());
                }


            }

        }
        catch(HibernateException ex){
            ex.printStackTrace();
        }
        finally{
            try{
                session.close();
            }
            catch(HibernateException ex2){
            }
        }
    }
    public static void main(String[] args)
    {
        TestManyToMany t = new TestManyToMany();
        //t.doCreate();
        t.doQuery();
    }
}

 

好。。可以了。。

分享到:
评论

相关推荐

    Hibernate one-to-many / many-to-one关系映射

    "Hibernate one-to-many / many-to-one关系映射"是两个基本的关系类型,用于表示实体间的关联。在这个主题中,我们将深入探讨这两种关系映射的原理、配置和实际应用。 一、一对一(one-to-one)与一对多(one-to-...

    (4)Hibernate中的many-to-one和one-to-many关系

    以下是一个简单的例子,展示了一个班级(Class)与学生(Student)的one-to-many关系,以及学生对班级的many-to-one关系: ```java @Entity public class Class { @Id private Long id; @OneToMany(mappedBy =...

    hibernate many-to-one(多对一)及 cascade(级联).doc

    ### Hibernate Many-to-One (多对一) 及 Cascade (级联) #### 一、Many-to-One(多对一) 在数据库设计中,实体之间的关系主要包括一对一、一对多、多对多等几种类型。而在ORM(对象关系映射)框架Hibernate中,...

    Hibernate Mapping Many-to-One 实例 内附源代码及附件下载

    通过研究这个例子,你可以更深入地理解如何在实际开发中设置和使用Many-to-One关系。 总的来说,Hibernate的Many-to-One映射简化了数据库关系的处理,使得开发者可以专注于业务逻辑,而不是繁琐的SQL操作。通过这个...

    Hibernate应用例子many-to-many

    本示例将详细讲解如何在Hibernate中实现多对多(many-to-many)的关系映射。 在数据库设计中,多对多关系是指两个实体之间存在多个关联,比如学生和课程的关系,一个学生可以选修多门课程,一门课程也可以被多个...

    Hibernate Many-To-Many Mapping Annotations

    在Java的持久化框架Hibernate中,Many-to-Many映射是一种常见的关系模型,它用于表示两个实体类之间多对多的关系。在这个主题中,我们将深入探讨如何使用注解来实现这种映射,以及其背后的数据库原理和实际应用。 ...

    Hibernate实现many-to-many的映射关系

    在本文中,我们将深入探讨如何使用Hibernate来实现多对多(many-to-many)的映射关系。 首先,多对多映射关系通常涉及到两个实体类之间的关联,例如在学生选课的例子中,学生(Student)和课程(Course)之间存在多...

    Hibernate-one-to-many

    本文将深入探讨Hibernate中一对多(One-to-Many)关系的处理方式,特别是通过外键映射和inverse属性的应用场景。 #### 一对多关系概念 一对多关系在数据库设计中非常常见,它指的是一个实体可以与多个其他实体关联...

    Hibernate one-to-many-annotation

    在Hibernate中,`one-to-many`关系是常见的实体间关系之一,表示一个实体可以与多个其他实体相关联。本文将深入探讨`Hibernate one-to-many`注解的使用和实现细节。 ### 一、`@OneToMany`注解概述 `@OneToMany`...

    (5)Hibernate中的many-to-many和并发

    在Java的持久化框架Hibernate中,Many-to-Many关系是一种常见的数据模型,它表示一个实体可以与多个其他实体之间存在关联,反之亦然。这篇博客文章可能会深入探讨如何在Hibernate中处理这种多对多的关系,并可能涉及...

    Many-To-Many_Element.rar_hibernate 多对多

    在Hibernate中,我们可以使用`&lt;many-to-many&gt;`标签来配置多对多映射。下面是一个简单的例子: ```xml &lt;many-to-many column="USER_ID" foreign-key="FK_USER_ROLE" entity-name="com.example.Role" table="USER...

    Hibernate one to many(many to one) 配置

    标题"Hibernate one to many(many to one) 配置"涉及到的是关系型数据库在Java中的持久化框架Hibernate中的两种关联映射关系:一对一(One-to-One)和多对一(Many-to-One)。在数据库设计中,这种关系很常见,例如...

    Hibernate关联关系映射目录

    &lt;many-to-one name="address" column="addressId" unique="true"/&gt; &lt;/hibernate-mapping&gt; ``` --- ##### 2. 一对一主键单向关联 在一对一主键单向关联中,两个实体共享同一个主键。这种方式通常用于当两个实体...

    hibernate中many2many映射

    在Java持久化框架Hibernate中,Many-to-Many(多对多)映射是一种常见的关联关系类型,用于表示两个实体类之间复杂的关系。在本场景中,我们探讨的是如何在Hibernate中配置Many-to-Many映射,并使用MySQL数据库来...

    Hibernate学生-课程-成绩表的例子(many2many)

    在这个“Hibernate学生-课程-成绩表的例子(many2many)”中,我们将探讨如何利用Hibernate处理多对多关联关系,以及相关源码和工具的使用。 多对多关联是数据库设计中常见的关系类型,它表示两个实体之间可以有多个...

    Hibernate性能调优

    - 双向`many-to-one`关联的例子,比如麻将桌上的玩家位置与玩家之间的关系。 #### 三、`one-to-one`关联管理 `one-to-one`关联主要用于表示两个实体之间的一对一关系。 - **定义**:`one-to-one`关联表示两个实体...

    hibernate doc 中文版

    - **Mapping one-to-one and one-to-many associations:** - 映射一对一和一对多关联的方法。 - **自然ID(natural-id):** - 自然标识符的概念及其实现。 以上内容概述了从《hibernate doc 中文版》文档中提取...

Global site tag (gtag.js) - Google Analytics