我的hibernate之旅~一对一关系映射

映射原理
两个实体对象之间是一对一的关联映射，即一个对象只能与另外唯一的一个对象相对应。例如：一个人(Person)只有一张身份证(IdCard)。我们看一下这个例子的对象模型，如下图所示：

对象模型

    从上图中可以看出：
    1、一个人只有一张身份证，唯一的一个身份证号，对象之间是一对一的关系；
    2、人(Person)持有身份证(IdCard)的引用，所以，两个对象关系维护由person端决定。
    从对象模型映射成关系模型，有两种方式：主键关联和唯一外键关联，我们继续看下面的内容。

分类：

主键关联：
1、两个实体对象的主键一样，以表明它们之间的一一对应关系；
2、不需要多余的外键字段来维护关系，仅通过主键来关联，即Person的主键要依赖IdCard的主键，他们共用一个主键值。
以上两点恰与唯一外键关联相反。

主键关联的关系模型

代码如下：
1、项目的包和类如图所示：

2、hibernate.cfg.xml代码如上几次一样，不需赘述。

3、Person类的代码

package com.dapeng.domain;

public class Person {

    private int id;
    private String name;
    private IdCard idcard;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public IdCard getIdcard() {
        return idcard;
    }

    public void setIdcard(IdCard idcard) {
        this.idcard = idcard;
    }

}

4、IdCard类的实现

package com.dapeng.domain;

import java.util.Date;

public class IdCard {
    private int id;
    private Date usefulLift;
    private Person person;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }


    public Date getUsefulLift() {
        return usefulLift;
    }

    public void setUsefulLift(Date usefulLift) {
        this.usefulLift = usefulLift;
    }

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }

}

5、Person.hbm.xml的实现

<hibernate-mapping package="com.dapeng.domain">
    <class name="Person">
        <id name="id">
            <generator class="native" />
        id>
        <property name="name" />
        <one-to-one name="idcard"/>
    class>

hibernate-mapping>

6、IdCard.hbm.xml

<hibernate-mapping>
    <class name="com.dapeng.domain.IdCard" table="id_card">
        <id name="id">
            
            <generator class="foreign">
                <param name="property">personparam>
            generator>
        id>
        <property name="usefulLift" column="useful_lift"/>
        <one-to-one name="person" constrained="true"/>
    class>
hibernate-mapping>

7、ExportDB.java（创建表结构）

package com.dapeng.hibernate;

import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;

public class ExportDB {
public static void main(String[] args) {
    Configuration configuration=new Configuration().configure();
    SchemaExport export=new SchemaExport(configuration);
    export.create(true, true);
}
}

8、HIbernateUtil.java的实现

package com.dapeng.hibernate;

import java.io.Serializable;

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

public final class HibernateUtil {
    private static SessionFactory sessionFactory;
    private static ThreadLocal session = new ThreadLocal();

    private HibernateUtil() {
    }

    static {
        Configuration cfg = new Configuration();
        cfg.configure();
        sessionFactory = cfg.buildSessionFactory();
    }

    public static Session getThreadLocalSession() {
        Session s = (Session) session.get();
        if (s == null) {
            s = getSession();
            session.set(s);
        }
        return s;
    }

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

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

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

    public static void add(Object entity) {
        Session s = null;
        Transaction tx = null;
        try {
            s = HibernateUtil.getSession();
            tx = s.beginTransaction();
            s.save(entity);
            tx.commit();
        } finally {
            if (s != null)
                s.close();
        }
    }

    public static void update(Object entity) {
        Session s = null;
        Transaction tx = null;
        try {
            s = HibernateUtil.getSession();
            tx = s.beginTransaction();
            s.update(entity);
            tx.commit();
        } finally {
            if (s != null)
                s.close();
        }
    }

    public static void delete(Object entity) {
        Session s = null;
        Transaction tx = null;
        try {
            s = HibernateUtil.getSession();
            tx = s.beginTransaction();
            s.delete(entity);
            tx.commit();
        } finally {
            if (s != null)
                s.close();
        }
    }

    public static Object get(Class clazz, Serializable id) {
        Session s = null;
        try {
            s = HibernateUtil.getSession();
            Object obj = s.get(clazz, id);
            return obj;
        } finally {
            if (s != null)
                s.close();
        }
    }
}

9、one-to-one.java的实现

package com.dapeng.hibernate;

import java.util.Date;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.dapeng.domain.IdCard;
import com.dapeng.domain.Person;

public class One2One {
    public static void main(String[] args) {
        add();
    }

    static Person add() {
        Session s = null;
        Transaction tx = null;
        try {
            s = HibernateUtil.getSession();
            IdCard idCard = new IdCard();
            idCard.setUsefulLift(new Date());

            Person p = new Person();
            p.setName("p1");
            // p.setIdCard(idCard);

            idCard.setPerson(p);

            tx = s.beginTransaction();
            s.save(p);
            s.save(idCard);
            tx.commit();
            return p;
        } finally {
            if (s != null)
                s.close();
        }
    }
}

10.创建的表结构如下图所示：

11、插入的数据如题所示：

建议

由于一对一主键关联映射具有以下两个缺点：
1、灵活性差，没有办法改成多对一关联映射，不能应变多变的需求；
2、必须先保存关联对象IdCard，之后才能保持Person；
所以，在映射一对一单向关联映射时，我们采用唯一外键关联映射。