Hibernate(六)一对多映射(多对一)

一、Hinbernate中持久化类的关联关系

在数据库中，表表之间是通过外键关联的，在程序中是要转化为持久化类也就是(JAVA Bean)来实例的。

但在Hibernater中持久化的之间的映射关系，不是通外键建立关联，而是通过属性.主要有以下几种

一对一，
一对多(多对一)
多对多

关联方向：

单向关联
双向关联

二、一对多单向关联关系

2.1、建立数据库表

班级表，和学生表，学生生通过班级表中的，班级编号为外键

--班级表
create table grade
(
       gid       number           primary key,  --班级ID
       gname     varchar2(50),                  --班级名称
       gdesc     varchar2(50)                   --班级介绍
);
--学生表
create table student
(
       sid       number           primary key,  --主键ID学生ID
       sname     varchar2(20),            --学生姓名
       sex       varchar2(20),            --学生性别
       gid       number           references grade(gid) ---外键班级ID
);

2.2、建立持久化类和映射配置文件

班级和学生类

package entity;

import java.util.HashSet;
import java.util.Set;

/*
 * 班级类
 */
public class Grade implements java.io.Serializable {

    // Fields
    private static final long serialVersionUID = 1L;
    private int gid;
    private String gname;
    private String gdesc;
    private Set<Student> students = new HashSet<Student> ();

    // Constructors

    /** default constructor */
    public Grade() {
    }

    /** minimal constructor */
    public Grade(int gid) {
        this.gid = gid;
    }

    /** full constructor */
    public Grade(int gid, String gname, String gdesc, Set<Student> students) {
        this.gid = gid;
        this.gname = gname;
        this.gdesc = gdesc;
        this.students = students;
    }

    // Property accessors

    public int getGid() {
        return this.gid;
    }

    public void setGid(int gid) {
        this.gid = gid;
    }

    public String getGname() {
        return this.gname;
    }

    public void setGname(String gname) {
        this.gname = gname;
    }

    public String getGdesc() {
        return this.gdesc;
    }

    public void setGdesc(String gdesc) {
        this.gdesc = gdesc;
    }

    public Set<Student> getStudents() {
        return this.students;
    }

    public void setStudents(Set<Student> students) {
        this.students = students;
    }

}

学生类

package entity;

/*
 * 学生类
 */
public class Student implements java.io.Serializable {

    // Fields

    private static final long serialVersionUID = 1L;
    private int sid;

    private String sname;
    private String sex;

    // Constructors

    /** default constructor */
    public Student() {
    }

    /** minimal constructor */
    public Student(int sid) {
        this.sid = sid;
    }

    /** full constructor */
    public Student(int sid, String sname, String sex ) {

        this.sid = sid;

        this.sname = sname;
        this.sex = sex;
    }

    // Property accessors

    public int getSid() {
        return this.sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getSname() {
        return this.sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public String getSex() {
        return this.sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

}

hibernate.cf.xml和班级、学生的配置文件

<?xml version=‘1.0‘ encoding=‘UTF-8‘?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>
    <property name="dialect">
        org.hibernate.dialect.Oracle9Dialect
    </property>
    <property name="connection.url">
        jdbc:oracle:thin:@localhost:1521:orcl
    </property>
    <property name="connection.username">root</property>
    <property name="connection.password">root</property>
    <property name="connection.driver_class">
        oracle.jdbc.OracleDriver
    </property>
    <property name="show_sql">true</property>
    <property name="format_sql">true</property>

    <mapping resource="entity/Grade.hbm.xml" />
    <mapping resource="entity/Student.hbm.xml" />

</session-factory>

</hibernate-configuration>

持久类配置先来学生类

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class name="entity.Student" table="STUDENT" schema="ROOT">
        <id name="sid" type="java.lang.Integer">
            <column name="SID" precision="22" scale="0" />
            <generator class="assigned" />
        </id>
        <property name="sname" type="java.lang.String">
            <column name="SNAME" length="20" />
        </property>
        <property name="sex" type="java.lang.String">
            <column name="SEX" length="20" />
        </property>
    </class>
</hibernate-mapping>

班级类配置

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class name="entity.Grade" table="GRADE" schema="ROOT">
        <id name="gid" type="java.lang.Integer">
            <column name="GID" precision="22" scale="0" />
            <generator class="assigned" />
        </id>
        <property name="gname" type="java.lang.String">
            <column name="GNAME" length="50" />
        </property>
        <property name="gdesc" type="java.lang.String">
            <column name="GDESC" length="50" />
        </property>
        <!--建立set属性，也可以建立list和持久化类中一致就行  -->
        <set name="students">
            <key>
            <!--这里的列是指学生表中的班级编号  -->
                <column name="GID" precision="22" scale="0" />
            </key>
            <!-- 通过class属性指定set的属性 -->
            <one-to-many class="entity.Student" />
        </set>
    </class>
</hibernate-mapping>

测试类

package Test;

import java.util.Set;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import entity.Grade;
import entity.Student;

public class Demo1 {

    /**
     * 测试类
     */
    public static void main(String[] args) {
        save();
         find();
        update();

    }

    public static void save() {
        // 声明班级对象，并赋值
        Grade grade = new Grade();
        grade.setGid(201504);
        grade.setGname("Java一班");
        grade.setGdesc("刚开始学习JAVA");
        // 声明2个学生对象
        Student stu1 = new Student();
        stu1.setSid(201504012);
        stu1.setSname("张三");
        stu1.setSex("男");

        Student stu2 = new Student();
        stu2.setSid(201504013);
        stu2.setSname("李四");
        stu2.setSex("女");

        // 将学生添加到班级
        grade.getStudents().add(stu1);
        grade.getStudents().add(stu2);
        // 建立session
        Session session = new Configuration().configure().buildSessionFactory()
                .openSession();
        // 开始事务
        Transaction transaction = session.beginTransaction();
        // 保存班级
        session.save(grade);
        // 保存学生
        session.save(stu1);
        session.save(stu2);
        // 提交事务
        transaction.commit();
        // 关闭session
        session.close();
    }

    /*
     * 将基中一个学生更改为别一个班级
     */
    public static void update() {
        // 声明班级对象，并赋值
        Grade grade = new Grade();
        grade.setGid(201506);
        grade.setGname("Java二班");
        grade.setGdesc("学习JAVA二年级");
        // 获取一个学生的信息
        // 建立session
        Session session = new Configuration().configure().buildSessionFactory()
                .openSession();
        // 开始事务
        Transaction transaction = session.beginTransaction();
        Student stu1=(Student) session.get(Student.class, 201504013);
        //将学生添加到这个新的班级
        grade.getStudents().add(stu1);
        // 保存班级
        session.save(grade);
        // 保存学生
        session.save(stu1);
        // 提交事务
        transaction.commit();
        // 关闭session
        session.close();
    }

    // 查询班级
    public static void find() {

        // 建立session
        Session session = new Configuration().configure().buildSessionFactory()
                .openSession();
        Grade g = (Grade) session.get(Grade.class, 201504);
        System.out.println("班级信息：" + g.getGid() + "\t" + g.getGname()
                + g.getGdesc());
        // 通过班级获取这个班级的学生信息
        System.out.println("201504班的学生信息如下:");
        Set<Student> set = g.getStudents();
        for (Student stu : set) {
            System.out.println(stu.getSid() + "\t" + stu.getSname() + "\t"
                    + stu.getSex());
        }
    }

}

以上只上单向关联，一般都会有双向关联

同样要在学生类中添加Grade 属性

在学生类的配置文件中配置关联字段

二、建立双向关联

2.1、更改学生类和配置文件

package entity;

/*
 * 学生类
 */
public class Student implements java.io.Serializable {

    // Fields

    private static final long serialVersionUID = 1L;
    private int sid;
    private String sname;
    private String sex;
    //增加班级属性
    private Grade grade;

    // Constructors

    /** default constructor */
    public Student() {
    }

    /** minimal constructor */
    public Student(int sid) {
        this.sid = sid;
    }

    /** full constructor */
    public Student(int sid, String sname, String sex ) {

        this.sid = sid;

        this.sname = sname;
        this.sex = sex;
    }

    // Property accessors

    public int getSid() {
        return this.sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getSname() {
        return this.sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public String getSex() {
        return this.sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }

}

配置文件

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class name="entity.Student" table="STUDENT" schema="ROOT">
        <id name="sid" type="java.lang.Integer">
            <column name="SID" precision="22" scale="0" />
            <generator class="assigned" />
        </id>
        <property name="sname" type="java.lang.String">
            <column name="SNAME" length="20" />
        </property>
        <property name="sex" type="java.lang.String">
            <column name="SEX" length="20" />
        </property>
        <!--配置grade属性  -->
        <many-to-one name="grade" class="entity.Grade">
        <!--指定学生表中的外键  -->
        <column name="GID" />
        </many-to-one>
    </class>
</hibernate-mapping>

2.2、测试类

建立双向关联后，就可以通过学生来获取班级信息

清空数据表中的数据

package Test;

import org.hibernate.Session;
import org.hibernate.cfg.Configuration;

import entity.Student;

public class Demo2 {

    /**
     * 测试类
     */
    public static void main(String[] args) {
　save();
findByStu();
    }

    public static void findByStu(){
        Session session = new Configuration().configure().buildSessionFactory()
                .openSession();
        //获取一个学生的信息 get方法为通过主键查询
        Student stu=(Student) session.get(Student.class, 201504013);
        System.out.println("学生信息:\t"+stu.getSid()+"\t"+stu.getSname()+"\t"+stu.getSex());
        //通过学生信息得到班级信息
        System.out.println("这个学生的班级信息："+stu.getGrade().getGid()+"\t"+stu.getGrade().getGname()+"\t"+stu.getGrade().getGdesc());
    }
}
public static void save() {
// 声明班级对象，并赋值
Grade grade = new Grade();
grade.setGid(201504);
grade.setGname("Java一班");
grade.setGdesc("刚开始学习JAVA");
// 声明2个学生对象
Student stu1 = new Student();
stu1.setSid(201504012);
stu1.setSname("张三");
stu1.setSex("男");
stu1.setGrade(grade);

Student stu2 = new Student();
stu2.setSid(201504013);
stu2.setSname("李四");
stu2.setSex("女");
stu2.setGrade(grade);
// 将学生添加到班级
/*grade.getStudents().add(stu1);
grade.getStudents().add(stu2);*/
// 建立session
Session session = new Configuration().configure().buildSessionFactory()
.openSession();
// 开始事务
Transaction transaction = session.beginTransaction();
// 保存班级
session.save(grade);
// 保存学生
session.save(stu1);
session.save(stu2);
// 提交事务
transaction.commit();
// 关闭session
session.close();
}

三、级联保存和删除

能不能只保存学生时，同时保存班级呢，或者保存班级时，同时保存学生呢

3.1、cascade属性

保存班级时，同时保存学生信息

修改班级配置，在set标签中添加cascade属性,设置为save-update

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class name="entity.Grade" table="GRADE" schema="ROOT">
        <id name="gid" type="java.lang.Integer">
            <column name="GID" precision="22" scale="0" />
            <generator class="assigned" />
        </id>
        <property name="gname" type="java.lang.String">
            <column name="GNAME" length="50" />
        </property>
        <property name="gdesc" type="java.lang.String">
            <column name="GDESC" length="50" />
        </property>
        <!--建立set属性，也可以建立list和持久化类中一致就行  -->
        <set name="students" cascade="save-update">
            <key>
            <!--这里的列是指学生表中的班级编号  -->
                <column name="GID" precision="22" scale="0" />
            </key>
            <!-- 通过class属性指定set的属性 -->
            <one-to-many class="entity.Student" />
        </set>
    </class>
</hibernate-mapping>

测试类

package Test;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import entity.Grade;
import entity.Student;

public class Demo3 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        save();

    }
    public static void save() {
        // 声明班级对象，并赋值
        Grade grade = new Grade();
        grade.setGid(201504);
        grade.setGname("Java一班");
        grade.setGdesc("刚开始学习JAVA");
        // 声明2个学生对象
        Student stu1 = new Student();
        stu1.setSid(201504012);
        stu1.setSname("张三");
        stu1.setSex("男");
        stu1.setGrade(grade);

        Student stu2 = new Student();
        stu2.setSid(201504013);
        stu2.setSname("李四");
        stu2.setSex("女");
        stu2.setGrade(grade);
        // 将学生添加到班级
        grade.getStudents().add(stu1);
        grade.getStudents().add(stu2);
        // 建立session
        Session session = new Configuration().configure().buildSessionFactory()
                .openSession();
        // 开始事务
        Transaction transaction = session.beginTransaction();
        // 保存班级
        session.save(grade);
        // 保存学生
        //session.save(stu1);
        //session.save(stu2);
        // 提交事务
        transaction.commit();
        // 关闭session
        session.close();
    }
}

反之，在学生类的配置文件one-many中添加cascade属性设置为save-update

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class name="entity.Student" table="STUDENT" schema="ROOT">
        <id name="sid" type="java.lang.Integer">
            <column name="SID" precision="22" scale="0" />
            <generator class="assigned" />
        </id>
        <property name="sname" type="java.lang.String">
            <column name="SNAME" length="20" />
        </property>
        <property name="sex" type="java.lang.String">
            <column name="SEX" length="20" />
        </property>
        <!--配置grade属性  -->
        <many-to-one name="grade" class="entity.Grade" cascade="save-update">
        <!--指定学生表中的外键  -->
        <column name="GID" />
        </many-to-one>
    </class>
</hibernate-mapping>

package Test;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import entity.Grade;
import entity.Student;

public class Demo3 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        save();

    }
    public static void save() {
        // 声明班级对象，并赋值
        Grade grade = new Grade();
        grade.setGid(201504);
        grade.setGname("Java一班");
        grade.setGdesc("刚开始学习JAVA");
        // 声明2个学生对象
        Student stu1 = new Student();
        stu1.setSid(201504012);
        stu1.setSname("张三");
        stu1.setSex("男");
        stu1.setGrade(grade);

        Student stu2 = new Student();
        stu2.setSid(201504013);
        stu2.setSname("李四");
        stu2.setSex("女");
        stu2.setGrade(grade);
        // 将学生添加到班级
        grade.getStudents().add(stu1);
        grade.getStudents().add(stu2);
        // 建立session
        Session session = new Configuration().configure().buildSessionFactory()
                .openSession();
        // 开始事务
        Transaction transaction = session.beginTransaction();
        // 保存班级
        //session.save(grade);
        // 保存学生
        session.save(stu1);
        session.save(stu2);
        // 提交事务
        transaction.commit();
        // 关闭session
        session.close();
    }
}

3.2、inverse属性

首先在班级类中设置invers属性为false时，删除班级

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class name="entity.Grade" table="GRADE" schema="ROOT">
        <id name="gid" type="java.lang.Integer">
            <column name="GID" precision="22" scale="0" />
            <generator class="assigned" />
        </id>
        <property name="gname" type="java.lang.String">
            <column name="GNAME" length="50" />
        </property>
        <property name="gdesc" type="java.lang.String">
            <column name="GDESC" length="50" />
        </property>
        <!--建立set属性，也可以建立list和持久化类中一致就行  -->
        <set name="students" cascade="save-update" inverse="false">
            <key>
            <!--这里的列是指学生表中的班级编号  -->
                <column name="GID" precision="22" scale="0" />
            </key>
            <!-- 通过class属性指定set的属性 -->
            <one-to-many class="entity.Student" />
        </set>
    </class>
</hibernate-mapping>

测试类

package Test;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import entity.Grade;
import entity.Student;

public class Demo4 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        delete() ;

    }

    public static void delete() {

        // 建立session
        Session session = new Configuration().configure().buildSessionFactory()
                .openSession();
        // 开始事务
        Transaction transaction = session.beginTransaction();
        // 保存班级
        Grade grade=(Grade) session.get(Grade.class, 201504);
        // 保存学生
        session.delete(grade);
        // 提交事务
        transaction.commit();
        // 关闭session
        session.close();
    }
}

结果：发现班级表中的班级已经删除，而学生表中数据没有删除，只是GID字段为NULL

下面将inverse设置为true时，添加新学生，和新的班级

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class name="entity.Grade" table="GRADE" schema="ROOT">
        <id name="gid" type="java.lang.Integer">
            <column name="GID" precision="22" scale="0" />
            <generator class="assigned" />
        </id>
        <property name="gname" type="java.lang.String">
            <column name="GNAME" length="50" />
        </property>
        <property name="gdesc" type="java.lang.String">
            <column name="GDESC" length="50" />
        </property>
        <!--建立set属性，也可以建立list和持久化类中一致就行  -->
        <set name="students" cascade="save-update" inverse="true">
            <key>
            <!--这里的列是指学生表中的班级编号  -->
                <column name="GID" precision="22" scale="0" />
            </key>
            <!-- 通过class属性指定set的属性 -->
            <one-to-many class="entity.Student" />
        </set>
    </class>
</hibernate-mapping>

测试类

package Test;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import entity.Grade;
import entity.Student;

public class Demo4 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        delete() ;

    }

    public static void delete() {

        // 声明班级对象，并赋值
                Grade grade = new Grade();
                grade.setGid(201509);
                grade.setGname("Java三班");
                grade.setGdesc("ASP.NET");
                // 声明2个学生对象
                Student stu1 = new Student();
                stu1.setSid(201509009);
                stu1.setSname("王五");
                stu1.setSex("女");
                stu1.setGrade(grade);

                Student stu2 = new Student();
                stu2.setSid(201509045);
                stu2.setSname("赵六");
                stu2.setSex("女");
                stu2.setGrade(grade);

        // 建立session
        Session session = new Configuration().configure().buildSessionFactory()
                .openSession();
        // 开始事务
        Transaction transaction = session.beginTransaction();

        // 保存学生
        session.save(stu1);
        session.save(stu2);
        // 提交事务
        transaction.commit();
        // 关闭session
        session.close();
    }
}

结果发现，我并没有用班级添加学生，也没有保存班级，只是保存了学生，班级信息一起保存了

时间： 2024-10-10 05:38:15

Hibernate(六)一对多映射(多对一)的相关文章

一口一口吃掉Hibernate（六）——多对多关联映射

今天来说说hibernate中的多对多关联映射,多对多关联映射涉及到单向映射和双向映射2种. 首先举个多对多关联例子:用户User和角色Role,一个用户可以属于多个角色,一个角色可以有多个用户.这就是典型的多对多关联的例子.而单向关联映射则是只能由A端去操作B端,B端不能操作A端的数据.而双向关联映射则是A,B两端都可以操作另一端的数据. 先说单向关联映射,实体类如下: <span style="font-size:18px">/** * 学生类 * @author Lo

hibernate进阶--一对多映射配置

hibernate作为一款优秀的ORM框架,广受大家喜爱,也被Java社区公认为持久层的首选.虽然jdbc为Java数据库操作带来了诸多便利,但是并没有统一SQL语句的写法,而且具体操作数据库的代码也足够复杂,且存在大量重复.所以有了ORM框架,让Java程序员可以从 SQL语句中解放,Hibernate就是其中的翘楚.Hibernate将JDBC进一步的封装了,在SQL的可移植性方面表现优秀,并且使 Hibernate程序代码足够简化. ORM(对象关系映射)是面向对象程序员在代码的编写过程

【Hibernate步步为营】--多对多映射详解

上篇文章详细讨论了一对多映射,在一对多映射中单向的关联映射会有很多问题,所以不建议使用如果非要采用一对多的映射的话可以考虑使用双向关联来优化之间的关系,一对多的映射其实质上是在一的一端使用<many-to-one>标签来标明它们之间的关系,另外还需要在一的一端的对象中使用set标明集合映射. 一.单向多对多仍然按照前几篇的文章格式来讨论,首先来看对象之间的关系,单向的多对多关系是两个对象之间发生的,比如在人和职位之间,一个人可以有多个职位,而且一个职位也可以由多人来负责,所以它们之间就形成了

Hibernate ManyToOne Mappings 多对一关联映射

Hibernate框架的使用步骤: 1.创建Hibernate的配置文件(hibernate.cfg.xml) 2.创建持久化类,即其实例需要保存到数据库中的类(Employee.java) 3.创建对象-关系映射文件(Employee.hbm.xml) 4.通过Hibernate API编写访问数据库的代码例子:多个员工对应一个地址. 一.创建hibernate.cfg.xml 配置文件: 注意数据库名.用户名.密码是否填写正确. <?xml version="1.0" en

Hibernate 单向/双向多对多

Hibernate的多对多从单向和双向来分就是单向多对多和双向多对多两种. Hibernate的双向多对多先来说一下什么是多对多的关系,举个例子,老师和学生,老师有语文老师,数学老师,英语老师等等,学生可以是1班的学生也可以是2班的学生,对于每个学生而言,他有多个老师给他讲课,而对于每一个老师而言,他要授课的学生也有很多,像这样的情况就可以描述成多对多了.即两个表之间,每一个表中的记录都对应另一个表的部分或全部记录的集合,这种情况就是多对多关系,而单向多对多与双向多对多的不同在于单向只是一方的

Hibernate映射关系-多对多

接着上几篇博客,hibernate的映射关系,今天我们说说基本关系的最后一种:多对多. 一 .多对多关系现象:多对多关系,在生活中很常见,就那学生与选修课之间的关系,一个学生可以选择多门选修课,而每个选修课又可以被多名学生选择.还有就是一个用户可以有多个角色,一个角色可以有多个人,等等这样的例子很多. hibernate实现:多对多关联关系采用第三张表的方式来实现,将多对多转化为两个一对多. 当然,多对多也是有方向的.拿用户--角色来画类图. 1.单向关联--用户关联角色多对多关系在hbm文

hibernate建表多对多建表

Student.java 1 package cn.itcast.hiberate.sh.domain; 2 3 import java.util.Set; 4 5 public class Student { 6 private Long sid; 7 private String sname; 8 private String description; 9 Set<Course> courses; 10 11 12 public Set<Course> getCourses()

--------------Hibernate学习(四) 多对一映射和一对多映射

现实中有很多场景需要用到多对一或者一对多,比如上面这两个类图所展现出来的,一般情况下,一个部门会有多名员工,一名员工只在一个部门任职. 多对一关联映射在上面的场景中,对于Employee来说,它跟Department的关系就是多对一. 先写实体类 Employee.java package entity; public class Employee { public int id; public String name; public Department department; public

SSH学习六 Hibernate 一对多多对一的双向映射

其实就是前面两个的结合 Student里面有Teacher类作为成员,映射文件加上对teacherid的外键参照 Teacher里面有Student的Set,映射文件有set标签,里面声明one-to-many以及key 结合http://blog.csdn.net/u011026968/article/details/47154059 http://blog.csdn.net/u011026968/article/details/47156979 即可版权声明:本文为博主原创文章,未经博主允