hibernate关联映射

Hibernate关联关系：

1.一对一关联关系实现方式 Users & UserInfo

a.外键关联（唯一） 一对多关系的一个特例

User中属性private UserInfo userInfo;  UserInfo中属性private User user;

User.hbm.xml中配置

<one-to-onename="userInfo" class="com.oracle.model.UserInfo"/>

UserInfo.hbm.xml中配置<!-- 配置多对1 属性 且唯一 -->

<many-to-one lazy="false" fetch="join"name="user" unique="true"  class="com.oracle.model.User">

   <column name="userId" />

</many-to-one>

b.共享主键关联   //可以单独操作一张表，也可同时操作多张表

UserInfo中属性private User user;

UserInfo.hbm.xml中配置

<id name="id"type="java.lang.Integer">

     <generatorclass="foreign"> //处理外键

         <paramname="property">user</param> //user为userinfo类 中的User  </generator>                                  属性，作为外键的一中处理方式

     </id>

<!-- 设置1对1的属性 -->

<one-to-one foreign-key="id" name="user" class="com.oracle.model.User"/>

2.一对多关联关系实现方式 Categories & Products

a.单向关联 *****    不推荐使用

//一个类型下包含多件商品  Category类中（主控方）

private Set<Product> products = new HashSet<Product>();

<!--配置1对多 -->Category类中配置 Product中不做处理  

<setname="products" table="tab_products">

     <key column="categoryId"/><!--作为Product外键-->

     <one-to-manyclass="com.oracle.model.Product"/>

</set>

先执行Category的插入，然后插入product，但是插入时外键没有被插入，所以数据库表的外键不能使唯一性，最后执行的update操作，更新product中的外键

b.双向关联

<set name=“items" inverse="true"cascade=“all">

<key column=“order_id"></key>

<one-to-many class=“com.oracle.entity.Item"/>

</set>

<many-to-onename="order" column="order_id" ></many-to-one>

inverse属性，反转，用来指定关联关系的方向，指定由谁来负责关系的维护，inverse=false的一方负责关系的维护，one-to-many关系中，将many一方设为关系维护方（inverse=false），有助于性能的改善

3.多对一关联关系实现方式 Categories & Products

单向的多对一 *****

 <!-- 配置多对1 -->     private Category category;//外键

<many-to-onename="category" class="com.oracle.model.Category">

    <column name="categoryId"/>

</many-to-one>    

双向的多对一：

order.setAddr(addr);

addr.setOrder(order);

s.save(order); 或 s.save(addr);均可以

多对一，在多的一方配置即可。

在添加子类和父类的同时，父类和子类都要持久化。

Category category = newCategory();

Product p1 = new Product();

Product p2 = new Product();

//设置产品类型

p1.setCategory(category);

p2.setCategory(category);

session.save(category);

session.save(p1);

session.save(p2);

4.自身多对一或一对多category(id,name,description,pid);

在Category类中

private Category category;//外键

private Set<Category>categories = new HashSet<Category>();//外键

<many-to-onename="category" class="com.oracle.model.Category">

     <column name="pid"/>

</many-to-one>

<setname="categories" inverse="true">

     <key column="pid"/>

     <one-to-manyclass="com.oracle.model.Category"/>

</set>

// 获取类别

Category category =(Category) session.get(Category.class, 1);

//获取子类别，直接根据当前类别获得他的子类别

Set<Category>categories = category.getCategories();

1：添加到某一父类别下，先获得父类别，然后设置父类别，最后持久化该类。

先执行查询，然后再插入

2：当添加到不存在的父类别下时，会出错

3：先添加父类别，后添加子类

4：在commit后，可以根据子类获得父类

在commit之前，修改对象属性值，不用update

5多对多（student & course）

//对多对需要一个中间表tab_enrollments

//sid，cid为tab_enrollments中的外键

只需要配置一方，配置两方同理。在持久化时，都需要持久化

//一个学员可以选修多门课程

private Set<Course> courses = new HashSet<Course>();

<set name="courses"table="tab_enrollments">

      <keycolumn="sid" />

      <many-to-manyclass="com.oracle.model.Course" column="cid"/>

 </set>

//创建一个学员对象

Student student = new Student();

//创建课程对象

Course c1 = new Course();

Course c2 = new Course();

Course c3 = new Course();

//学员选修课程

student.getCourses().add(c1);

student.getCourses().add(c2);

student.getCourses().add(c3);

session.save(student);

session.save(c1);

session.save(c2);

session.save(c3);