Hibernate关联关系映射之一对一（主键关联）

在业务成的域模型中，类和类之间最普遍的关系就是关联关系，而关联也是有方向的。

就以例子来说明：一个人对应一张身份证。对其进行增删改。

对于人在数据创建表的时候，我们就给他两个字段，一个是id号，一个就是名字。

那么对于身份证也就是两个字段，一个对应于一个人相同的id号，一个就是身份证码。

1 那么来创建数据库表：

 人为主表，身份证为从表。

create table person(
id bigint primary key auto_increment,
userName varchar(20)
);
 
create table card(
id bigint primary key,
cardNo varchar(18)
);

创建实体类的时候，人要引用身份证卡的信息，同样身份证卡也要引用人这个类。

2 那么来创建实体类：

人：

package com.cy.beans;

import java.io.Serializable;

public class Person implements Serializable {

    private static final long serialVersionUID = 1L;
    private long id;
    private String userName;
    private Card card;// 卡 一对一关联

    public void person() {

    }

    public long getId() {
        return id;
    }

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

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Card getCard() {
        return card;
    }

    public void setCard(Card card) {
        this.card = card;
    }

    @Override
    public String toString() {
        return "Person [id=" + id + ", userName=" + userName + ", card=" + card
                + "]";
    }

}

身份证：

package com.cy.beans;

import java.io.Serializable;

public class Card implements Serializable{

    
    private static final long serialVersionUID = 1L;
    
    private long id;
    private String cardNo;
    private Person person;//人  一对一关联
    
    public Card(){
        
    }
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getCardNo() {
        return cardNo;
    }
    public void setCardNo(String cardNo) {
        this.cardNo = cardNo;
    }
    public Person getPerson() {
        return person;
    }
    public void setPerson(Person person) {
        this.person = person;
    }
    @Override
    public String toString() {
        return "Card [id=" + id + ", cardNo=" + cardNo + ", person=" + person
                + "]";
    }
    

}

 现在创建映射文件

Person.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">
    
    <hibernate-mapping>
    
    <class name="com.cy.beans.Person" table="person" catalog="j2ee">   <!-- catalog数据库 -->
    
              <id name="id" type="java.lang.Long"><!-- 此行的ID，为对象的属性ID -->
                  <column name="id"></column><!-- 此行的ID，为表字段ID -->
                  <generator class="increment"></generator><!-- 给id指定生成策略 -->
              </id>
    
              <property name="userName" type="java.lang.String">
                 <column name="userName"></column>
              </property>
              
         <!--站在主对象的一方来设置级联关系 -->
         <!-- cascade定义的是关系两端对象到对象的级联关系,cascade有四個取值，all，none，save-update，delete
                all : 所有情况下均进行关联操作。 
                none：所有情况下均不进行关联操作。这是默认值。 
                save-update:在执行save/update/saveOrUpdate时进行关联操作。 
                delete：在执行delete时进行关联操作。 -->
        <one-to-one name="card" class="com.cy.beans.Card" cascade="all"></one-to-one>
  
    
    </class>
     
    </hibernate-mapping>

Card.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">
    
    <hibernate-mapping>
    <class name="com.cy.beans.Card" table="card" catalog="j2ee">   <!-- catalog数据库 -->
              <id name="id" type="java.lang.Long"><!-- 此行的ID，为对象的属性ID -->
                 <column name="id"></column><!-- 此行的ID，为表字段ID -->
                   <generator class="foreign"><!-- foreign主键生成器 -->
                       <param name="property">person</param><!--类属性  -->
                   </generator>
              </id>
    
              <property name="cardNo" type="java.lang.String">
                 <column name="cardNo"></column>
              </property>
         <!--站在从对象的一方来设置交出约束  -->
         <!-- name:一对一节点  ，constrained： 约束（必须为true） -->
         <one-to-one name="person"  class="com.cy.beans.Person" constrained="true"></one-to-one>
  
    </class>
    </hibernate-mapping>

 在hibernate.cfg.xml里添加对象xml文件：

1         <mapping resource="com/cy/xmls/Person.hbm.xml"/> 
        <mapping resource="com/cy/xmls/Card.hbm.xml"/> 

 工具类：

package com.cy.tools;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;

/**
 * session工厂的工具类
 * @author acer
 *
 */

public class HibernateUtils {
    
    private static Configuration cfg;
    private static SessionFactory sessionFactory;
    private static ServiceRegistry serviceRegistry;
    
    static{
        
        cfg = new Configuration().configure();
        serviceRegistry = new StandardServiceRegistryBuilder().applySettings(cfg.getProperties()).build();
        sessionFactory = cfg.buildSessionFactory(serviceRegistry);
    
    }
    
    public static SessionFactory getSessionFactory(){
        return sessionFactory;
    }
         
    

}

IPersonDao.java接口，定义方法：

package com.cy.dao;

import java.io.Serializable;

import com.cy.beans.Person;

public interface IPersonDao {
    /**
     * 添加
     * @param p
     */
    public void savePerson(Person p);
    /**
     * 修改
     * @param p
     */
    public void updatePerson(Person p);
    /**
     * 刪除
     * @param p
     */
    public void deletePerson(Person p);
    /**
     * 根据id查询数据
     * @param cls
     * @param pk
     * @return
     */
    public Person getPerson(Class<?> cls,Serializable pk);
    
    public void findPerson(Person p);

}

写接口实现：PersonDaoImpl.java

package com.cy.dao.impl;

import java.io.Serializable;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.cy.beans.Person;
import com.cy.dao.IPersonDao;
import com.cy.tools.HibernateUtils;

public class PersonDaoImpl implements IPersonDao {

    @Override
    public void savePerson(Person p) {
        //获得Session
        Session session=null;
        Transaction transaction=null;
        
        try {
            session=HibernateUtils.getSessionFactory().openSession();//
            transaction=session.beginTransaction();//开启事务
            session.save(p);//添加
            transaction.commit();//提交事务
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();//回滚事务
        }finally{
            session.close();//关闭session
        }

    }

    @Override
    public void updatePerson(Person p) {
        Session session=null;
        Transaction transaction=null;
        
        try {
            session=HibernateUtils.getSessionFactory().openSession();
            transaction=session.beginTransaction();
            session.update(p);//修改
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();
        }finally{
            session.close();
        }

    }

    @Override
    public Person getPerson(Class<?> cls, Serializable pk) {
        Session session=null;
        Transaction transaction=null;
        Person    person=null;
        try {
            session=HibernateUtils.getSessionFactory().openSession();
            transaction=session.beginTransaction();
            person=(Person) session.get(cls, pk);//根据id查询。pk这里指的就是id
            transaction.commit();
            
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();
        }finally{
            session.close();
        }

        return person;
    }
    @Override
    public void deletePerson(Person p) {
        Session session=null;
        Transaction transaction=null;
        
        try {
            session=HibernateUtils.getSessionFactory().openSession();
            transaction=session.beginTransaction();
            session.delete(p);//删除
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();
        }finally{
            session.close();
        }

    }


    @Override
    public void findPerson(Person p) {

    }

}

 写IPersonServer.java接口

package com.cy.server;

import java.io.Serializable;

import com.cy.beans.Person;

public interface IPersonServer {
    /**
     * 添加
     * @param p
     */
    public void savePerson(Person p);
    /**
     * 修改
     * @param p
     */
    public void updatePerson(Person p);
    /**
     * 刪除
     * @param p
     */
    public void deletePerson(Long id);
    /**
     * 根据id查询
     * @param cls
     * @param pk
     * @return
     */
    public Person getPerson(Class<?> cls,Serializable pk);
    
    public void findPerson(Person p);
}

写PersonServerImpl.java实现；

package com.cy.server.impl;

import java.io.Serializable;

import com.cy.beans.Person;
import com.cy.dao.IPersonDao;
import com.cy.dao.impl.PersonDaoImpl;
import com.cy.server.IPersonServer;

public class PersonServerImpl implements IPersonServer {
    IPersonDao dao = new PersonDaoImpl();

    @Override
    public void savePerson(Person p) {
        dao.savePerson(p);

    }

    @Override
    public void updatePerson(Person p) {
        dao.updatePerson(p);
    }

    @Override
    public void deletePerson(Long id) {
        Person p = dao.getPerson(Person.class, id);
        if (p != null) {
            dao.deletePerson(p);
        }

    }

    @Override
    public Person getPerson(Class<?> cls, Serializable pk) {

        return dao.getPerson(cls, pk);
    }

    @Override
    public void findPerson(Person p) {

    }

}

 写个PersonAction测试；

package com.cy.action;

import com.cy.beans.Card;
import com.cy.beans.Person;
import com.cy.server.IPersonServer;
import com.cy.server.impl.PersonServerImpl;

public class PersonAction {
    public static void main(String[] args) {
        
//        savePerson();    
//        updatePerson();
          deletePerson();
    }

    private static void deletePerson() {
        IPersonServer ps=new PersonServerImpl();
        ps.deletePerson(Long.valueOf(1));
        
        
    }

    private static void updatePerson() {
        IPersonServer ps=new PersonServerImpl();
        Person p=ps.getPerson(Person.class, Long.valueOf(1));
        p.setUserName("小紅");
        ps.updatePerson(p);
        /*Hibernate: //这些hibernate所执行语句    修查询  后修改
            select
                person0_.id as id1_1_0_,
                person0_.userName as userName2_1_0_,
                card1_.id as id1_0_1_,
                card1_.cardNo as cardNo2_0_1_ 
            from
                j2ee.person person0_ 
            left outer join
                j2ee.card card1_ 
                    on person0_.id=card1_.id 
            where
                person0_.id=?
        Hibernate: 
            update
                j2ee.person 
            set
                userName=? 
            where
                id=?
        Hibernate: 
            update
                j2ee.card 
            set
                cardNo=? 
            where
                id=?
*/
        
        
    }

    private static void savePerson() {
        IPersonServer ps=new PersonServerImpl();
        Person p=new Person();
        p.setUserName("小明");        
        Card c=new Card();
        c.setCardNo("511123************");
        //設置相互
        p.setCard(c);
        c.setPerson(p);
        ps.savePerson(p);
        /*Hibernate:   添加时 先查询主表的最大的id，先添加主表，在添加从表。   删除时则是先删除从表，在删除主表。
            select
                max(id) 
            from
                person
        Hibernate: 
            insert 
            into
                j2ee.person
                (userName, id) 
            values
                (?, ?)
        Hibernate: 
            insert 
            into
                j2ee.card
                (cardNo, id) 
            values
                (?, ?)

        
    */
        
    }
}