Hibernate One-To-One 关联

现实生活中，一对一（One To One）关系的实体比比皆是。比如，人和身份证的关系，人和社会属性的关系等。

在Hibernate中，OneToOne关系分为两种策略：主键关联和唯一外键关联。主键关联，就是两个一对一的实体共用相同的id。比如，人（Person）和身份证（IdCard），将Person的id主键，关联到IdCard的主键。这样，两个实体，就通过主键关联在一起了。唯一外键的含义也很明确。就是在Person实体中定义一个额外的字段，比如card_id,用这个字段外键关联到IdCard的主键id。

下面就让我们看看主键关联：

Person.java

public class Person {
    private Integer id;
    private String name;
    private String sex;
    private Integer age;
    private Idcard idcard;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Idcard getIdcard() {
        return idcard;
    }
    public void setIdcard(Idcard idcard) {
        this.idcard = idcard;
    }

Idcard.java

public class Idcard {
    private Integer id;
    private String cardNum;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getCardNum() {
        return cardNum;
    }
    public void setCardNum(String cardNum) {
        this.cardNum = cardNum;
    }
}

以上是两个实体。

Person.hbm.xml

<!DOCTYPE hibernate-mapping
    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="demo.hibernate.domain">
   <class name="Person">
       <id name="id" unsaved-value="null">
            <!--在单独使用的时候，可以使用序列策略，这里对应的数据库是Oracle，不同的数据库，拥有不同的主键生成策略-->
            <!--<generator class="sequence">-->
                <!--<param name="sequence">seq_person</param>-->
            <!--</generator>-->
            <!--因为人和身份证是一对一关联，避免冗余的数据生成，采用主键相同的策略-->
            <generator class="foreign">
                <param name="property">idcard</param>
            </generator>
       </id>
       <property name="name"/>
       <property name="sex" />
       <property name="age" />
       <!--cascade=all ：在插入一条Person信息的时候，可以插入一条Idcard。constrained=true:因为这里存在一个外键约束，person的主键，关联到idcard的主键-->
       <!--这里lazy=false，这样，在抓取person信息的时候，就同时抓取了idcard。否则，如果lazy=proxy,这也是hibernate默认的抓取方式，这样你在获取person后再获取idcard，就
       会报no Session 异常。在web开发中，可以开启openSessionInView，确保Session的生命周期延续到前台页面，lazy=false,对性能会有影响-->
       <one-to-one name="idcard" cascade="none" constrained="true" lazy="false"></one-to-one>
   </class>
</hibernate-mapping>

Idcard.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="demo.hibernate.domain">
   <class name="Idcard">
       <id name="id" unsaved-value="null">
            <generator class="sequence">
                <param name="sequence">seq_person</param>
            </generator>
       </id>
       <property name="cardNum"/>
   </class>
</hibernate-mapping>

以上是Person.java和Idcard.java对应的映射文件。

public class PersonDao {

    public Integer save(Person person){
        Integer id = null;
        try {
            if(person == null){
                return null;
            }
            Session s = HibernateUtils.getCurrentSession();
            Transaction t = s.beginTransaction();
            id = (Integer)s.save(person);
            t.commit();
        } catch (HibernateException e) {
            throw new RuntimeException("保存person信息失败");
        }finally {
            HibernateUtils.closeSession();
        }
        return id;
    }
    public Person get(int id){
        Person p = null;
        try {
            Session s = HibernateUtils.getCurrentSession();
            p = (Person)s.get(Person.class, id);
            return p;
        } catch (HibernateException e) {
            throw new RuntimeException("获取person信息失败");
        } finally {
            HibernateUtils.closeSession();
        }
    }

    public List<Person> getPersonList(String name){
        List<Person> persons = null;
        try {
            Session s = HibernateUtils.getCurrentSession();
            StringBuilder hql = new StringBuilder("from Person");
            Query q = null;
            if(name != null && !name.isEmpty()){
                hql.append("where name = :name");
                q = s.createQuery(hql.toString());
                q.setParameter("name",name);
            }else {
                q = s.createQuery(hql.toString());
            }
            persons = q.list();
            return persons;
        } catch (HibernateException e) {
            throw new RuntimeException("获取person信息失败");
        } finally {
            HibernateUtils.closeSession();
        }
    }
}

上面是PersonDao.java,封装了对Person实体的基本操作。

public class TestPersonDao {
    static Person person = null;
    static Idcard idcard = null;
    static PersonDao personDao = null;
    static Integer personId = 21;
    @BeforeClass
    public static void init(){
        initOne2One();
    }
    private static void initOne2One(){
        idcard = new Idcard();
        idcard.setCardNum("342401198911045870");
        person = new Person();
        person.setName("new");
        person.setAge(12);
        person.setSex("m");
        person.setIdcard(idcard);
        //这里注意，Person和Idcard是一对一关联。
        //这里，在保存Person的时候，idcard是一个瞬时对象，未持久化。但是，配置的时候，cascade=all，
        //这样，在保存Person对象的时候，hibernate会首先将idcard一并保存。
        personDao = new PersonDao();
    }
    @Test
    public void testSave(){
        personId = personDao.save(person);
        Assert.assertNotNull(personId);
        Integer id1 = personDao.save(null);
        Assert.assertNull(id1);
    }
    @Test
    public void testGet(){
        Person p = personDao.get(personId);
        Assert.assertNotNull(p);
        Assert.assertNotNull(p.getIdcard());
        Assert.assertNotNull(p.getIdcard().getCardNum());
    }
    @Test
    public void testGetPersonList(){
        List<Person> persons = personDao.getPersonList(null);
        //One-To-One:这里，就会出现一个N+1次查询的问题，
        //因为One-To-One关联时，在Idcard中并不存在和person关联的信息，
        //只有先查到person，然后再根据每一个person的id获取到与其关联的idcard。这样总共就做了N+1次查询。
        //这样非常消耗性能
        //@select * from person; 得到10条数据。
        //接下来，做10次循环：@for 1 to 10 do select * from idcard d where d.id = person.id end for;
    }
}

上面是PersonDao的测试类。