hibernate 单向关联双向关联

有两个对象a，b，单向关联就是a中有关系属性，b中没有或者b中有关系属性，而a中没有。双向关联就是ab中都有关系属性，我比较喜欢单向关联，双向的太麻烦了

一段时间没用~不知道记的清楚不了~

数据库都一样~程序不一样~

比如 A B~ 无论你是单项还是双向~你B表里都有个字段以A表 ID或其他什么做为外键~

如果只单向关联~A one to many B~ 当hibernate查询A的时候回自动加载相关的B~ 用A.getBorder()之类的就能得到B~（看你设置的方法是什么就是什么~打比方是getBorder()）

当查询B的时候~不会加载A~也就是说从B中是读不到A的~没有B.getAorder()之类的方法在B类里~

双向关联就是~查询A会自动加载B~用A类相应方法得到A类相应的B类~

同时查询B也会自动加载A类~用B类相应方法得到B类相应的A类~

差不多就这样~

　　单向关联双向关联2007-10-24 21:18                当使用单向关联时，由父类管理关联关系，子类无法管理，而这时，父亲知道自己的儿子，但是，从儿子对象不知道父亲是谁。
单向关联时，只指定<one-to-many>
当使用双向关联时，关联关系的管理可以通过inverse指定，这时，儿子能清楚的知道自己的父亲是谁。双向关联时，还要指定<many-to-one>
               使用双向关联和单向关联的区别就是我在上面提到的呀。
Cascade属性是来控制进行级联操作的。从父类这边，父亲知道自己的孩子是谁，可以进行级联操作，但从子类那边，它是不清楚自己的父亲是谁的，所以，不能进行级联操作的。
              使用双向关联和单向关联的区别就是我在上面提到的呀。
Cascade属性是来控制进行级联操作的。从父类这边，父亲知道自己的孩子是谁，可以进行级联操作，但从子类那边，它是不清楚自己的父亲是谁的，所以，不能进行级联操作的。

              按常理来论，关联都应该是双向的，那么单向关联是什么呢？什么时候应该使用单向关联，什么时候应该使用双向关联？
              hibernate_reference：确实如此，hibernate 建议用双向关联。不过，既然存在，就有道理。省点事而已。比如，
     user <--> city ；
     class user{
         city;
    }
    不需要
    class city{
          //    List users;    // this is unnecessary for business , 不需要 .
    }
    对象层不需要，persistance 层当然不需要了。就省了吧。

两个类如下:::
   public    class    Person    {
   private    String    id;
   private    String    name;
   private    String    email;
                     //对应的get/set方法
   }


   public    class    Author    {
   private    String    id;
   private    String    alias;
   private    Person    person;
                     //对应的get/set方法
   }
   person.hbm.xml如下
   <hibernate-mapping>
   <class    name="com.hibernate.Person"    table="person">
   <id    name="id"    type="string">
   <generator    class="uuid.hex"/>
   </id>

   <property    name="name"/>
   <property    name="email"/>
   </class>
   </hibernate-mapping>

   author.hbm.xml如下:
   <hibernate-mapping>
   <class    name="com.hibernate.Author"    table="author">
   <id    name="id"    column="id">
   <generator    class="foreign">
   <param    name="property">person</param>
   </generator>
   </id>
   <property    name="alias"    type="string"/>
   <one-to-one    name="person"    class="com.hibernate.Person"    cascade="all"    constrained="true"/>
</class>
   </hibernate-mapping>

A.     首先我在MYSQL中建立USER的表：
CREATE TABLE USER (
    USER_ID VARCHAR(10) NOT NULL PRIMARY KEY,
    NAME VARCHAR(16) NOT NULL
    );
建立ROOM表：
CREATE TABLE ROOM(
    ROOM_ID VARCHAR(10)NOT NULL PRIMARY KEY,
    ADDRESS VARCHAR(32) NOT NULL);
B.     建立每个表对应的实体：
首先是user表对应的实体
    package com.po;
public class User {
     private long id;
     private String name;
     private house room;

     public long getId() {
         return id;
     }
     public void setId(long id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public house getRoom() {
         return room;
     }

     public void setRoom(house room) {
         this.room = room;
     }
}
接着是ROOM表对应的实体：
Package com.po;
public class Room {
    private long id;
    private String address;
    private person user;

    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public person getUser() {
          return user;
    }
    public void setUser(person user) {
        this.user = user;
    }
}
C.     与之两个表对应的XML配置文件:
User的配置文件：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
     PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
" http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>
     <class name="com.po.User" table="USER">
         <id name="id" column="USER_ID" unsaved-value="0">
             <generator class="increment"/>
         </id>
         <property name="name">
             <column name="NAME" length="16" not-null="true"/>
         </property>
         <one-to-one name="room"
                     class="com.po.Room"
                     cascade="all"/>
     </class>
</hibernate-mapping>
Room的配置文件:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
     PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
1. " http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>
     <class name="com.po..Room" table="ROOM">
    <id name="id" column="ROOM_ID" unsaved-value="0">
             <generator class="foreign">
                 <param name="property">user</param>
             </generator>
         </id>
         <property name="address" type="string"/>
         <one-to-one name="user"
                     class="com.po.User"
                     constrained="true"/>
     </class>
</hibernate-mapping>
    在这里注意一下，我们使用的是one to one 映射，一般One to One映射有两种实现的方式，一种是是通过外键参考，也就是在多对一的时候中可以限制为多对一为一对多，那个时候只要在<many-to-one>的many方加上unique=”true”就可以，具体的在以后讨论。在这里我们仅仅讨论One To One的那种情况，我们需要在Room的One To One的时候使用constrained="true"，表示Room的主键参考User的主键。在这个地方，开始的时候我没有弄明白，后来参考了这些属性的解释说明才明白。大家可以看一下，Room的id要多了几个属性，现在我就每个属性说一下他的运用：
在<id></id>中 name: 标识属性的名字。Column:对应数据库中的列，unsaved-value: 默认为null, 一个特定的标识属性值，用来标志该实例是刚刚创建的，尚未保存。这可以把这种实例和从以前的session中装载过（可能又做过修改--译者注）但未再次持久化的实例区分开来。重要的是<generator></<generator>这个属性，class=”forgign”,表示使用另外一个相关联的对象的标识符。<param name="property">user</param>表示要关联的实体。
D.     测试往数据库中插入数据的程序：
    import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;
public class HibernateTest {
public static void main(String[] args) throws HibernateException {
         SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

         Room room = new Room();
         room.setAddress("NTU-M8-419");

         User user1 = new User();
         user1.setName("bush");

         user1.setRoom(room);
         room.setUser(user1);

         Session session = sessionFactory.openSession();
         Transaction tx= session.beginTransaction();
         session.save(user1);

         tx.commit();
         session.close();

         sessionFactory.close();
     }
}