&lt property name="name" column="name" not-null="true" unique="false"/ &gt
 &lt one-to-one name="person" class="Person" cascade="all" constrained="true" / &gt
 &lt /class &gt
 &lt /hibernate-mapping &gt

 这里指明了id的generator是一个外键，和person相关联。然后指定一个one-to-one关系，不难理解是不是？Hibernate的确很符合我们的思维习惯。需要提醒的是，这种关联关系是单向的，Person并不需要去指定Spouse。

 下面来操作这两个类：

 /*
 * Created on 2004-4-20
 */
 package org.bromon.zizz;
 import net.sf.hibernate.*;
 import net.sf.hibernate.cfg.*;
 import net.sf.hibernate.tool.hbm2ddl.*;
 /**
 * @author Bromon
 */
 public class OperateSpouse
 {
 public static void main(String args[])
 {
  try
  {
   Configuration cfg=new Configuration().addClass(Spouse.class);
   cfg.addClass(Person.class);
   SessionFactory factory=cfg.buildSessionFactory();
   new SchemaExport(cfg).create(true,true);
   Session session=factory.openSession();
 
   Person person=new Person();
   person.setName("bromon");
   person.setEmail("bromon@163.com");
 
   Spouse spouse=new Spouse();
   spouse.setName("who");
   spouse.setPerson(person);
  
   Transaction ts=session.beginTransaction();
   session.save(person);
   session.save(spouse);
   ts.commit();
   session.close();
  }catch(Exception e)
  {
   System.out.println(e);
  }
 }
 }

 这个例子和第一篇中的例子非常相似。OK，执行一下，然后看看zizz数据库，搞掂。

Many-to-One关系

 很明显一对多或者多对一关系是关系数据库中非常常见的现象，下面通过父亲-儿子的例子来演示一对多关系，多对一关系是类似的，不过在我们的这个例子中不宜采用，否则会带来伦理学上的问题。

 首先定义Child类：
 /*
  * Created on 2004-5-8
  */
 package org.bromon.zizz;

 /**
  * @author Bromon
  */
 public class Child
 {
  private int id;
  private String name;
  private int fatherId;
  private Person father;

  public Child(){}
 
  /**
   * @return
   */
  public Person getFather()
  {
   return father;
  }

  /**
   * @return
   */
  public int getFatherId()
  {
   return fatherId;
  }

  /**
   * @return
   */
  public int getId()
  {
   return id;
  }

  /**
   * @return
   */
  public String getName()
  {
   return name;
  }

  /**
   * @param person
   */
  public void setFather(Person p)
  {
   father = p;
  }

  /**
   * @param i
   */
  public void setFatherId(int i)
  {
   fatherId = i;
  }

  /**
   * @param i
   */
  public void setId(int i)
  {
   id = i;
  }

  /**
   * @param string
   */
  public void setName(String string)
  {
   name = string;
  }

 }

 这里的fatherId是外键，关联person表的id字段。

 下面是映射文件Child.hbm.xml：
 &lt ?xml version="1.0"? &gt
 &lt !DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
        "' target=_blank &gthttp://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" &gt 

 &lt hibernate-mapping package="org.bromon.zizz" &gt
  &lt class name="Child" table="child" lazy="true" &gt
   &lt id name="id" type="integer" unsaved-value="null" &gt
    &lt column name="id" sql-type="int" not-null="true"/ &gt
    &lt generator class="identity"/ &gt
   &lt /id &gt
       
   &lt property name="name" column="name" not-null="true" unique="false"/ &gt
   &lt many-to-one name="father" column="fatherid" / &gt
      
  &lt /class &gt
 &lt /hibernate-mapping &gt
 需要注意的是fatherId并没有做为一个property被映射，而是在many-to-one声明中使用。

 需要对Person..java做修改，添加以下代码：

 import java.util.*;

 private Set children=new HashSet();
 /**
 * @return
 */
 public Set getChildren()
 {
  return children;
 }
 /**
 * @param set
 */
 public void setChildren(Set set)
 {
  children = set;
 }

 然后修改Person.hbm.xml，对添加的代码做映射：

 &lt set name="books" lazy="true" inverse="true" cascade="all"  &gt
  &lt key column="fatherid"/ &gt
  &lt one-to-many class="Child" / &gt
 &lt /set &gt

 这里的key column是child表的外键，inverse需要指定为true。

 下面做操作一下，功能是查询person表中id=1的记录，作为小孩的父亲，然后给child表添加一条新记录。

 /*
  * Created on 2004-5-8
  */
 package org.bromon.zizz;
 import net.sf.hibernate.*;
 import net.sf.hibernate.cfg.*;
 import net.sf.hibernate.tool.hbm2ddl.*;
 /**
  * @author Bromon
  */
 public class OperateChild
 {
  /**
   * @param args
   */
  public static void main(String args[])
  {
   try
   {
    Configuration cfg = new Configuration().addClass(Person.class);
    cfg.addClass(Child.class);
    SessionFactory sessions = cfg.buildSessionFactory();
    new SchemaExport(cfg).create(true, true);
    Session session = sessions.openSession();
   
    Child c=new Child();
   
    /*Query q=session.createQuery("from org.bromon.zizz.Person as p where p.id=1");
    Person p=(Person)q.list().get(0);*/
   
    Person p=(Person)session.find("from org.bromon.zizz.Person as p where p.id=?",new Integer(1),Hibernate.INTEGER).get(0);
    System.out.println(p.getName());
    c.setName("andy");
    c.setFather(p);
   
    Transaction ts = session.beginTransaction();
    session.save(c);
    ts.commit();
    session.close();
   } catch (Exception e)
   {
    System.out.println(e);
   }
  }
 }

 被注释掉的部分是HQL的另外一种查询方法。在这个例子中可以看出对象的查询非常容易，不需要自己再去封装数据，修改和删除对象也很容易：

 //得到一个对象
 Query q=session.createQuery("from org.bromon.zizz.Person as p where p.id=1");
 Person p=(Person)q.list().get(0);

 //修改数据
 p.setName(“Mr Smith”);

 //保存数据
 session.save(p);
 session.flush();

 //删除数据
 session.delete(p);
 session.flush();

上一页  [1] [2]