hibernate学习（2）：多表设计及inverse和cascade属性的使用

前言

实际开发中往往将数据库设计成多表形式，关于多表的介绍请看本人博客：多表之间的关系。本文介绍hibernate中如何用面向对象语言来表示多表之间的关系，以及inverse和cascade属性的使用。

正文

一，一对多（多对一）关系的表达
需要在“一”的一方使用Set集合来存放“多”的一方的对象。且需要在“多”的一方引用“一”的一方的对象。比如“客户”和“订单”两张表。

由上图看出，hibernate中一对多的关系是由javabean中各自保有对方实例，以及在配置文件中相互引用来体现的。

下面介绍配置文件中“set”标签中的inverse和cascade属性。
1，inverse属性：意为“是否将维护关系的权利交给对方”，怎么理解呢？比如，我们实例化一个Customer对象，和两个Order对象。那么，双方都可以来维护关系：
a，coustomer来维护关系：customer1.getOrders().add(order1); customer1.getOrders().add(order2);
b，order来维护关系：order1.setCustomer(customer1); order2.setCustomer(customer1);
也就是说，双方都有维护关系的功能，然而，hibernate框架默认双方都维护关系，这样就产生了多余的update语句，可能使系统性能降低。于是就规定，通常让“一”的一方交出权利（即设置inverse=’true’），让“多”的一方来维护关系。这样，就能减少代码量，提升性能。

2，cascade属性：意为“级联操作”，就是在操作一方的同时，将引起的另一方操作也保存。如：只需要保存用户，那么跟用户相关的订单也保存。或者删除用户，跟用户有关的订单也一并删除。
级联操作有下面4种取值：
save-update：级联保存,级联修改. 保存A时,同时保存B.
（1）delete：删除A，同时删除B，AB都不存在
（2）delete-orphan：孤儿删除，解除关系，同时将B删除，A存在的。
如果需要配置多项，使用逗号分隔。
（3）all : save-update 和 delete 整合
（4）all-delete-orphan : 三个整合

下面是测试一对多的代码：

package com.jimmy.test;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.junit.Test;

import com.jimmy.domain.Customer;
import com.jimmy.domain.Order;
import com.jimmy.utils.HibernateUtils;

public class TestDemo2 {
    /**
     * 增
     */
    @Test
    public void test1(){
        Session session = HibernateUtils.openSession();
        try {
            session.beginTransaction();
            //----------开启事务
            Customer customer1 = new Customer();
            customer1.setName("jimmy");
            customer1.setGender("男");

            Order order1 = new Order();
            order1.setName("apple");
            order1.setPrice(12.22);

            Order order2 = new Order();
            order2.setName("banana");
            order2.setPrice(23.22);

            customer1.getOrders().add(order1);
            customer1.getOrders().add(order2);

            session.save(customer1);        
            //----------提交事务
            session.getTransaction().commit();                 //持久态
        } catch (HibernateException e) {
            e.printStackTrace();
//          transaction.rollback();
        } finally{
            session.close();                      //游离态
        }
    }
    /**
     * 删
     */
    @Test
    public void test2(){
        Session session = HibernateUtils.openSession();
        try {
            session.beginTransaction();
            //----------开启事务
            Customer cc = (Customer) session.get(Customer.class, 1);
            session.delete(cc);     
            //----------提交事务
            session.getTransaction().commit();                 //持久态
        } catch (HibernateException e) {
            e.printStackTrace();
//          transaction.rollback();
        } finally{
            session.close();            //游离态
        }
    }
}

二，多对多关系的表达
多对多的表达，将每个类都用Set来引用对方的实例即可。比如学生和课程就是多对多的关系。

在mysql中，需要再建一张表来存双方的外键，在hibernate中就不必再创建该表的实体类啦，而是双方的“set”标签中增加“table”属性，使各方外键映射到该表。

同样也有inverse和cascade属性的使用。

下面是测试代码：

package com.jimmy.test;

import org.hibernate.Transaction;
import org.hibernate.classic.Session;
import org.junit.Test;

import com.jimmy.domain.Course;
import com.jimmy.domain.Student;
import com.jimmy.utils.HibernateUtils;

public class TestDemo1 {
    @Test
    public void test1(){
        Session session = HibernateUtils.openSession();
        Transaction ts = null;
        try {
             ts = session.beginTransaction();
             //----------------
             Student student1 = new Student();
             student1.setName("angela");
             student1.setGender("女");

             Course course1 = new Course();
             course1.setName("yuwen");
             course1.setScore(98);

             Course course2 = new Course();
             course2.setName("shuxue");
             course2.setScore(96);

             student1.getScores().add(course1);
             student1.getScores().add(course2);

             session.save(student1);
             //----------------
             ts.commit();
        } catch (Exception e) {
            ts.rollback();
        } finally{
            session.close();
        }
    }
}

总结

使用hibernate设计表，流程相对固定，多加练习为益。