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
                 (?, ?)

     */

     }
 }