hibernate映射

参考：http://www.cnblogs.com/kubixuesheng/p/5300437.html

多对一单向外键关联关系

多对一关联时多方持有一方的引用。比如学生和班级，多个学生对应一个班级。
单向多对一关联中，（1）多方需要持有一方的引用，（2）多方（学生类）需要额外的配置，需要对持有一方引用的注解<many-to-one> （3）多方必须保留一个不带参数的构造器 一方班级类无需做任何多余操作
<many-to-one>具有以下属性：
name：一方的引用名
class：一方对应的持久化类
column：外键的列名
fetch：抓取策略
cascade：级联操作，有以下取值
- all 对所有操作进行级联操作
- save-update执行保存和更新操作时进行级联操作
- delete执行删除操作时进行级联操作
- none对所有操作不进行级联操作

多方：学生类和其对应的hbm.xml（因为hibernate具有二级缓存，缓存会将对象写进缓存，所以一般要实现serializable接口）

public class Student implements Serializable{
    private int sid;
    private String sname;
    private String sex;
    private Grade grade;//持有多方的引用
    public Grade getGrade() {
        return grade;
    }
    public void setGrade(Grade grade) {
        this.grade = grade;
    }
    public int getSid() {
        return sid;
    }
    public void setSid(int sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Student() {
        // TODO Auto-generated constructor stub
    }
    public Student(String sname, String sex) {
        super();
        this.sname = sname;
        this.sex = sex;
    }
}

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="entity.Student" table="student">
        <id name="sid" type="java.lang.Integer">
            <column name="sid" />
            <generator class="increment" />
        </id>
        <property name="sname" type="java.lang.String">
            <column name="sname" length="20" not-null="true"/>
        </property>
        <property name="sex" type="java.lang.String">
            <column name="sex"></column>
        </property>
        <many-to-one name="grade" class="entity.Grade" column="gid" cascade="all"></many-to-one>
    </class>
</hibernate-mapping>

一方：班级类（无需多余定义）

public class Grade implements Serializable {
    private int gid;
    private String gname;
    private String gdesc;
    public int getGid() {
        return gid;
    }
    public void setGid(int gid) {
        this.gid = gid;
    }
    public String getGname() {
        return gname;
    }
    public void setGname(String gname) {
        this.gname = gname;
    }
    public String getGdesc() {
        return gdesc;
    }
    public void setGdesc(String gdesc) {
        this.gdesc = gdesc;
    }
    public Grade(String gname, String gdesc) {
        super();
        this.gname = gname;
        this.gdesc = gdesc;
    }
    public Grade() {
        // TODO Auto-generated constructor stub
    }
}

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="entity.Grade" table="grade">
        <id name="gid" type="java.lang.Integer">
            <column name="gid" />
            <generator class="increment" />
        </id>
        <property name="gname" type="java.lang.String">
            <column name="gname" length="20" not-null="true"/>
        </property>
        <property name="gdesc" type="java.lang.String">
            <column name="gdesc" length="50"></column>
        </property>
    </class>
</hibernate-mapping>

HibernateSessionFactoryUtil类用于获得sessionFactory和获得Session

public class HibernateSessionFactoryUtil {
        private static SessionFactory sessionFactory;
        private static Session session;
        static {
            //创建Configuration对象，读取hibernate.cfg.xml文件，完成初始化
            Configuration cof = new Configuration().configure();
            //ServiceRegistry 是 Service 的注册表, 它为Service提供了一个统一的加载 /初始化 /存放 /获取机制.
            ServiceRegistryBuilder ssrb = new ServiceRegistryBuilder()
                    .applySettings(cof.getProperties());
            ServiceRegistry ssr=ssrb.buildServiceRegistry();
            sessionFactory=cof.buildSessionFactory(ssr);
        }
        public static SessionFactory getSessionFactory(){
            return sessionFactory;
        }

        public static Session getSession(){
            session=sessionFactory.openSession();
            return session;
        }

        public static void closeSession(Session session){
            if(session!=null)
                session.close();
        }
    }

下面进行测试

public class Test {
    public static void main(String[] args) {
        add();
    }
    public static void add(){
        Grade g=new Grade("java开发","java开发一班");
        Student stu1=new Student("张三","女");
        Student stu2=new Student("李四","男");
        Session session=HibernateSessionFactoryUtil.getSession();
        Transaction tx=session.beginTransaction();
        stu1.setGrade(g);
        stu2.setGrade(g);
        //由于进行了级联操作，只需save学生类，班级类会自动存储
        session.save(stu1);
        session.save(stu2);
        tx.commit();    HibernateSessionFactoryUtil.closeSession(session);
    }

hibernate.cfg.xml加上：

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

执行结果：
控制台输出：
Hibernate: select max(sid) from student
Hibernate: select max(gid) from grade
Hibernate: insert into grade (gname, gdesc, gid) values (?, ?, ?)
Hibernate: insert into student (sname, sex, gid, sid) values (?, ?, ?, ?)
Hibernate: insert into student (sname, sex, gid, sid) values (?, ?, ?, ?)

数据库添加的记录：
student表

grade表

一对多单向外键关联

当类与类建立了关联，程序能很方便的从一个对象导航到另一个或一组与之关联的对象，有了student对象，就可以通过student对象得到grade的信息–student.getGrade()，对于班级对象，如果想要得到学生的信息，怎么办呢？这时候可以反过来控制，一方控制多方，接下来进行一对多单向外键关联

（1）一方持有多方的集合（2）一方的hbm.xml有<set>配置，其含有子标签<one-to-many>和<key>子标签（3）不管是一对多还是多对一，多方都要保留无参构造器

多方：grade增加了Set<Stuent>

public class Grade implements Serializable {
    private int gid;
    private String gname;
    private String gdesc;
    //在一方定义多方的集合
    private Set<Student> students=new HashSet<Student>();
    public int getGid() {
        return gid;
    }
    public void setGid(int gid) {
        this.gid = gid;
    }
    public String getGname() {
        return gname;
    }
    public void setGname(String gname) {
        this.gname = gname;
    }
    public String getGdesc() {
        return gdesc;
    }
    public void setGdesc(String gdesc) {
        this.gdesc = gdesc;
    }
    public Set<Student> getStudents() {
        return students;
    }
    public void setStudents(Set<Student> students) {
        this.students = students;
    }
    public Grade(String gname, String gdesc) {
        super();
        this.gname = gname;
        this.gdesc = gdesc;
    }
    public Grade() {
        // TODO Auto-generated constructor stub
    }
}

Grade.hbm.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="entity.Grade" table="grade">
        <id name="gid" type="java.lang.Integer">
            <column name="gid" />
            <generator class="increment" />
        </id>
        <property name="gname" type="java.lang.String">
            <column name="gname" length="20" not-null="true"/>
        </property>
        <property name="gdesc" type="java.lang.String">
            <column name="gdesc" length="50"></column>
        </property>
      <set name="students" table="student" inverse="false" cascade="save-update">
            <key column="gid"></key>
            <one-to-many class="entity.Student"/>
        </set>
    </class>
    <!-- 添加了set，name表示Grade类中Set变量的名字，table表示对应的数据库中的表，inverse指定关联关系的控制方向，默认由one方控制，也就是在多方的inverse属性，有关这个理解见我另一篇博文 -->

student类不做任何添加，在这里省去
下面执行test

public class Test {
    public static void main(String[] args) {
        add();
    }
    public static void add(){
        Grade g=new Grade("java开发","java开发一班");
        Student stu1=new Student("张三","女");
        Student stu2=new Student("李四","男");
        Session session=HibernateSessionFactoryUtil.getSession();
        Transaction tx=session.beginTransaction();

        g.getStudents().add(stu1);
        g.getStudents().add(stu2);
        session.save(g);
        tx.commit();
        HibernateSessionFactoryUtil.closeSession(session);
    }

控制台输出：
Hibernate: select max(gid) from grade
Hibernate: select max(sid) from student
Hibernate: insert into grade (gname, gdesc, gid) values (?, ?, ?)
Hibernate: insert into student (sname, sex, sid) values (?, ?, ?)
Hibernate: insert into student (sname, sex, sid) values (?, ?, ?)
Hibernate: update student set gid=? where sid=?
Hibernate: update student set gid=? where sid=?

数据库数据也载入正常

总结：多对一的时候，多方设置EAGER（积极加载）,一方设置LAZY（懒加载），也就是说，如果是多对一，多方控制一方，那么多方设置积极加载，一方无需多余配置，反过来，如果是一对多关系，一方控制多方，那么一方设置懒加载，多方无需多余配置，但是不论哪种，多方都显式加上一个不带参数的构造器。（其实对于懒加载与否，这些配置是默认的）

一对多双向关联

其实类似之前的一对一双向外键关联，也是互相持有对方的引用，故也叫双向一对多自身关联。多方持有一方的引用，反过来，一方也持有多方的集合

多对多单向关联

在多对多关联关系中，显然不能互相持有对方主键做外键，那么就需要用到一个新的表作为中间表进行映射

举例：学生和老师
创建表teacher和teachers_students

create table teacher(
    -> tid int primary key,
    -> tname varchar(20));
 create table teachers_students(
    -> sid int not null,
    -> tid int not null);
    alter table teachers_students add primary key (sid,tid);

Student类新增：

public Set<Teacher> getTeachers() {
        return teachers;
    }
    public void setTeachers(Set<Teacher> teachers) {
        this.teachers = teachers;
    }
    public Grade getGrade() {
        return grade;
    }

Student.hbm.xml新增

<!-- table设置中间表 -->
<set name="teachers" table="teachers_students" cascade="all" inverse="false">
<!-- key设置本对象在中间表的外键sid -->
<key column="sid" />
<!-- tid设置对方的表（老师）在中间表的外键tid -->
<many-to-many class="entity.Teacher" column="tid"></many-to-many>
</set>

老师不做多余配置

public class Teacher implements Serializable{
    private int tid;
    private String tname;
    public int getTid() {
        return tid;
    }
    public void setTid(int tid) {
        this.tid = tid;
    }
    public String getTname() {
        return tname;
    }
    public void setTname(String tname) {
        this.tname = tname;
    }
    public Teacher(String tname) {
        super();
        this.tname = tname;
    }
    public Teacher() {
        super();
        // TODO Auto-generated constructor stub
    }
}

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="entity.Teacher" table="teacher">
        <id name="tid" type="java.lang.Integer">
            <column name="tid" />
            <generator class="increment" />
        </id>
        <property name="tname" type="java.lang.String">
            <column name="tname" length="20" not-null="true"/>
        </property>
    </class>
</hibernate-mapping>

测试：

Student s=new Student("学生1","女");
        Set<Teacher> teas=s.getTeachers();
        Teacher t1=new Teacher("张三");
        Teacher t2=new Teacher("李四");
        Teacher t3=new Teacher("王五");
        teas.add(t1);
        teas.add(t2);
        teas.add(t3);
        Session session=HibernateSessionFactoryUtil.getSession();
        Transaction tx=session.beginTransaction();
        session.save(s);
        tx.commit();
    HibernateSessionFactoryUtil.closeSession(session);

控制台输出
Hibernate: select max(sid) from student
Hibernate: select max(tid) from teacher
Hibernate: insert into student (sname, sex, gid, sid) values (?, ?, ?, ?)
Hibernate: insert into teacher (tname, tid) values (?, ?)
Hibernate: insert into teacher (tname, tid) values (?, ?)
Hibernate: insert into teacher (tname, tid) values (?, ?)
Hibernate: insert into teachers_students (sid, tid) values (?, ?)
Hibernate: insert into teachers_students (sid, tid) values (?, ?)
Hibernate: insert into teachers_students (sid, tid) values (?, ?)

数据库存储正常

多对多双向外键关联

和之前的类似，是互相持有对方的集合，双方持有对方的集合对象

Teacher类添加：

    private Set<Student> students=new HashSet<Student>();

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

Teacher.hbm.xml添加

 <set name="students" table="teachers_students" cascade="all" inverse="false">
            <key column="tid"></key>
            <many-to-many class="entity.Student" column="sid"></many-to-many>
        </set>

关联关系的优缺点

用关联关系，就可以直接操作内存中的对象，不用每次都查询数据库，会提高效率；而且域模型真实反映了客观世界的关系，但是缺点就是建立复杂的关联关系会给程序开发带来麻烦，当修改一个对象时，会牵连其它的对象

问题小结

（1）注意在多对一/一对多关系里：多方必须保留一个不带参数的构造器！
（2）如果没有设置级联ALL，那么需要在保存的时候先保存班级，在保存学生，否则出错： object references an unsaved transient instance - save the transient instance before flushing:
（3）多对一时候，多方设置EAGER加载，一对多的时候，一方设置LAZY加载
（4）多对多关联，多方需要保留一个无参构造器。