hibernate 3

对象关系映射（Object Relational Mapping，简称ORM）是通过使用描述对象和数据库之间映射的元数据，将java程序中的对象自动持久化到关系数据库中。本质上就是将数据从一种形式转换到另外一种形式.
hibernate实现ＯＲＭ主要使用到的文件有：映射类（.Java）、映射文件（.hbm.xml）和数据库配置文件（.properties/.cfg.xml），它们各自的作用如下。

javabean：它是描述数据库表的结构，表中的字段在类中被描述成属性，将来就可以实现把表中的记录映射成为该类的对象了。

      映射文件（*.hbm.xml）:它是指定数据库表和映射类之间的关系，包括映射类和数据库表的对应关系、表字段和类属性类型的对应关系以及表字段和类属性名称的对应关系等。

      Hibernate的描述文件（*.properties/*.cfg.xml）:数据库连接信息、其他参数、映射信息

一对一关系映射

主键关联
即让两个对象具有相同的主键值，以表明它们之间的一一对应的关系；数据库表不会有额外的字段来维护它们之间的关系，仅通过表的主键来关联

---

  public class Group {
    private int id;
    private  String name;

}
public class Person {
    private int id;
    private String name


 <class name="pojo.Person" table="Person">
        <id name="id">
            <!-- foreign生成策略，forgeign会取得另外一个关联对象的标识 -->
            <generator class="foreign">
                <param name="property">pojo.idCard</param>
            </generator>
        </id>
        <property name="name"></property>
        <one-to-one name="id" class="pojo.idCard"  constrained="true"></one-to-one>
    </class>

外键关联
两个实体对象用一个外键来关联
可以用标签来映射，指定多的一端unique为true,
这样就限制了多的一端的多重性为一.

class:
public class Person {  
    private int id;  
    private String name;  
    private IdCard idCard;  
      }
  Person.hbm.xml:
    <many-to-one name="idCard" class="IdCard" column="idCardId" unique="true"></many-to-one>    

缺点:
1）因为多端User不知道Group的存在（也就是User不维护与Group的关系），所以在保存User时，关系字段groupId为null，如果该字段设置为非空，则将无法保存数据。
2）因为User不维护关系，而Group维护关系，Group就会发出多余的update语句，保证Group和User有关系，这样加载Group时才把该Users对应的用户加载上来
多对一关系映射
作用:得到多的同时得到一

Group

public class Group {
    private int id;
    private  String name;
}

user

public class User {
    private int id;
    private String name;
    private  Group group;
}

映射文件

  <class name="pojo.Group" table="t_group">
        <id name="id">
            <generator class="native"></generator>
        </id>
        <property name="name"></property>
    </class>

<class name="pojo.User" table="t_user">
        <id name="id">
            <generator class="native"/>
    </id>
        <property name="name"/>
        <!-- 多对一关系标签：-->
        <many-to-one name="group" class="pojo.Group" column="groupId" cascade="delete"></many-to-one>

    </class>

一对多

作用:得到一的同时,可以拿到多.

public class Group {  
    private int id;  
    private String name;  
    private Set users;  
}


public class User {  
    private int id;  
    private String name;  
  }


<class name="pojo.User" table="t_user">  
        <id name="id">  
            <generator class="native"/>  
        </id>  
        <property name="name"/>  
    </class>  

   <class name="pojo.Group" table="t_group">  
        <id name="id">  
            <generator class="native"/>  
        </id>  
        <property name="name"/>  
        <!-- users属性，表达的是本对象与User的一对多的关系 -->  
        <set name="users">  
             <!--当前表（Group）的主键-->  
            <key column="groupid"/>  
            <one-to-many class="pojo.Group"/>  
        </set>  
    </class>  

双向关联

public class Group {  
    private int id;  
    private String name;  
    private Set users;  
    }
    public class User {  
    private int id;  
    private String name;  
    private Group groups;  
    }
    <class name="pojo.Group" table="t_group">  
        <id name="id">  
            <generator class="native"/>  
        </id>  
        <property name="name"/>  
        <!-- 影响控制反转：inverse="false",多的一端维护关系，让一的一端失效 -->  
        <set name="users" inverse="true">  
            <key column="groupid" not-null="true"/>  
            <one-to-many class="pojo.User"/>  
        </set>  
    </class>

 <class name="pojo.User" table="t_user">  
        <id name="id">  
            <generator class="native"/>  
        </id>  
        <property name="name"/>  
        <!-- groups属性，表达的是本对象与Group的多对一的关系 -->  
        <many-to-one name="groups" class="pojo.Group" column="groupid"/>  

一对多双向关联的映射方式：
1）在一的一端的集合上采用标签，在多的一端加入一个外键
2）在多的一端采用标签
注意：标签和标签加入的字段保持一致，否则会产生数据混乱。
inverse属性：
inverse属性可以用在一对多和多对多双向关联上，inverse属性默认为false，为false表示本端维护关系，如果inverse为true，则本端不能维护关系，会交给另一端维护关系，本端失效。所以一对多关联映射我们通常在多的一端维护关系，让一的一端失效，所以设置为inverse为true。

多对多的配置:
步骤一创建实体和映射:
Student:
public class Student {
    private Integer sid;
    private String sname;
    // 学生选择多门课程.
    private Set<Course> courses = new HashSet<Course>();
...
}

Course:
public class Course {
    private Integer cid;
    private String cname;
    // 课程可以被多个学生选择:
    private Set<Student> students = new HashSet<Student>();
...
}

Student.hbm.xml
<hibernate-mapping>
    <class name="pojo.Student" table="student">
        <id name="sid" column="sid">
            <generator class="native"/>
        </id>
        <property name="sname" column="sname"/>
        <!-- 配置多对多关联关系 -->
        <set name="courses" table="stu_cour">
            <key column="sno"/>
            <many-to-many class="pojo. demo3.Course" column="cno"/>
        </set>
    </class>
</hibernate-mapping>

Course.hbm.xml
<hibernate-mapping>
    <class name="pojo.Course" table="course">
        <id name="cid" column="cid">
            <generator class="native"/>
        </id>

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

        <!-- 配置多对多关联关系映射 -->
        <set name="students" table="stu_cour">
            <key column="cno"/>
            <many-to-many class="pojo.Student" column="sno"/>
        </set>
    </class>
</hibernate-mapping>