一、一对多关联关系

1.单向n-1

• 单向n-1关联只需从n的一端可以访问1的一端

• Hibernate使用<many-to-one>元素来映射多对一关联关系

<!-- 
     映射多对一的关联关系。 使用 many-to-one 来映射多对一的关联关系 
     name: 多这一端关联的一那一端的属性的名字
     class: 一那一端的属性对应的类名
     column: 一那一端在多的一端对应的数据表中的外键的名字
-->
​
<many-to-one name="" class="" column=""/>

• 实例：

Customer.java

public class Customer {
​
    private Integer customerId;
    private String customerName;
}

Order.java

public class Order {
    
    private Integer orderId;
    private String orderName;
}

Customer.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
​
<hibernate-mapping>
    
    <class name="com.yfy.hibernate.entity.n21.Customer" table="CUSTOMERS">
    
        <id name="customerId" type="java.lang.Integer">
            <column name="CUSTOMER_ID" />
            <generator class="native" />
        </id>
    
        <property name="customerName" type="java.lang.String">
            <column name="CUSTOMER_NAME" />
        </property>
        
    </class>
    
</hibernate-mapping>

Order.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
​
<hibernate-mapping package="com.yfy.hibernate.entity.n21">
​
    <class name="Order" table="ORDERS">
​
        <id name="orderId" type="java.lang.Integer">
            <column name="ORDER_ID" />
            <generator class="native" />
        </id>
        
        <property name="orderName" type="java.lang.String">
            <column name="ORDER_NAME" />
        </property>
        
        <many-to-one name="customer" class="Customer" column="CUSTOMER_ID"></many-to-one>
​
    </class>
</hibernate-mapping>

HibernateTest.java

public class HibernateTest {
​
    private SessionFactory sessionFactory;
    private Session session;
    private Transaction transaction;
    
    @Before
    public void init(){
        Configuration configuration = new Configuration().configure();
        ServiceRegistry serviceRegistry = 
                new ServiceRegistryBuilder().applySettings(configuration.getProperties())
                                            .buildServiceRegistry();
        sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        
        session = sessionFactory.openSession();
        transaction = session.beginTransaction();
    }
    
    @After
    public void destroy(){
        transaction.commit();
        session.close();
        sessionFactory.close();
    }
​
​
    @Test
    public void testDelete(){
        //在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象
        Customer customer = (Customer) session.get(Customer.class, 1);
        session.delete(customer); 
    }
    
    @Test
    public void testUpdate(){
        Order order = (Order) session.get(Order.class, 1);
        order.getCustomer().setCustomerName("AAA");
    }
    
    @Test
    public void testMany2OneGet(){
        //1. 若查询多的一端的一个对象, 则默认情况下, 只查询了多的一端的对象. 而没有查询关联的
        //1 的那一端的对象!
        Order order = (Order) session.get(Order.class, 1);
        System.out.println(order.getOrderName()); 
        
        System.out.println(order.getCustomer().getClass().getName());
​
        session.close();
​
        //2. 在需要使用到关联的对象时, 才发送对应的 SQL 语句.
        Customer customer = order.getCustomer();
        System.out.println(customer.getCustomerName());
​
        //3. 在查询 Customer 对象时, 由多的一端导航到 1 的一端时,
        //若此时 session 已被关闭, 则默认情况下
        //会发生 LazyInitializationException 异常
        
        //4. 获取 Order 对象时, 默认情况下, 其关联的 Customer 对象是一个代理对象!
        
    }
    
    @Test
    public void testMany2OneSave(){
        Customer customer = new Customer();
        customer.setCustomerName("BB");
        
        Order order1 = new Order();
        order1.setOrderName("ORDER-3");
        
        Order order2 = new Order();
        order2.setOrderName("ORDER-4");
        
        //设定关联关系
        order1.setCustomer(customer);
        order2.setCustomer(customer);
        
        //执行  save 操作: 先插入 Customer, 再插入 Order, 3 条 INSERT
        //先插入 1 的一端, 再插入 n 的一端, 只有 INSERT 语句.
//      session.save(customer);
//      
//      session.save(order1);
//      session.save(order2);
        
        //先插入 Order, 再插入 Customer. 3 条 INSERT, 2 条 UPDATE
        //先插入 n 的一端, 再插入 1 的一端, 会多出 UPDATE 语句!
        //因为在插入多的一端时, 无法确定 1 的一端的外键值. 所以只能等 1 的一端插入后, 再额外发送 UPDATE 语句.
        //推荐先插入 1 的一端, 后插入 n 的一端
​
        session.save(order1);
        session.save(order2);
​
        session.save(customer);
    }
}

2.双向1-n

• 双向1-n需要在1的一端可以访问n的一端，反之亦然

• Hibernate使用<set>元素来映射set类型的属性

<set name="orders">
    <key column="customer_id"></key>
    <one-to-many class="Order"/>
</set>

• 当Session从数据库中加载Java集合时，创建的是Hibernate内置集合类的实例，因此在持久化类中定义集合属性时必须把属性声明为Java接口类型

  • Hibernate的内置集合类具有集合代理功能，支持延迟检索策略

• 在定义集合属性时，通常把它初始化为集合实现类的一个实例，这样可以提高程序的健壮性，避免NullPointerException

• 实例

Customer.java

public class Customer {
​
    private Integer customerId;
    private String customerName;
    
    /*
     * 1. 声明集合类型时, 需使用接口类型, 因为 hibernate 在获取
     * 集合类型时, 返回的是 Hibernate 内置的集合类型, 而不是 JavaSE 一个标准的
     * 集合实现. 
     * 2. 需要把集合进行初始化, 可以防止发生空指针异常
     */
    private Set<Order> orders = new HashSet<>();
}

Order.java

public class Order {
    
    private Integer orderId;
    private String orderName;
    
    private Customer customer;
}

Customer.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
​
<hibernate-mapping package="com.yfy.hibernate.entity.n21">
    
    <class name="Customer" table="CUSTOMERS">
    
        <id name="customerId" type="java.lang.Integer">
            <column name="CUSTOMER_ID" />
            <generator class="native" />
        </id>
    
        <property name="customerName" type="java.lang.String">
            <column name="CUSTOMER_NAME" />
        </property>
        
        <!-- 映射 1 对多的那个集合属性 -->
        <!-- set: 映射 set 类型的属性, table: set 中的元素对应的记录放在哪一个数据表中. 该值需要和多对一的多的那个表的名字一致 -->
        <!-- inverse: 指定由哪一方来维护关联关系. 通常设置为 true, 以指定由多的一端来维护关联关系 -->
        <!-- cascade 设定级联操作. 开发时不建议设定该属性. 建议使用手工的方式来处理 -->
        <!-- order-by 在查询时对集合中的元素进行排序, order-by 中使用的是表的字段名, 而不是持久化类的属性名  -->
        <set name="orders" table="ORDERS" inverse="true" order-by="ORDER_NAME DESC">
            <!-- 执行多的表中的外键列的名字 -->
            <key column="CUSTOMER_ID"></key>
            <!-- 指定映射类型 -->
            <one-to-many class="Order"/>
        </set>
        
    </class>
    
</hibernate-mapping>

其余同1对多的代码。。。

二、多对多关联关系

1.单向n-n

• n-n的关联必须使用连接表

• 与1-n类似，必须为set集合元素添加key子元素，集合中的元素使用many-to-many

Category.java

public class Category {
​
    private Integer id;
    private String name;
    
    private Set<Item> items = new HashSet<>();
｝

Item.java

public class Item {
​
    private Integer id;
    private String name;
    
    private Set<Category> categories = new HashSet<>();
}

Category.hbm.xml

        <!-- table: 指定中间表 -->
        <set name="items" table="CATEGORIES_ITEMS">
            <key>
                <column name="C_ID" />
            </key>
            <!-- 使用 many-to-many 指定多对多的关联关系. column 执行 Set 集合中的持久化类在中间表的外键列的名称  -->
            <many-to-many class="Item" column="I_ID"></many-to-many>
        </set>

2.双向n-n

• 双向n-n关联需要两端都使用集合属性

• 双向n-n关联必须使用连接表

• 集合属性增加key子元素映射外键列，many-to-many子元素关联实体类

• 对于双向n-n关联，必须把其中一端的inverse设置为true，否则两端都维护关联关系可能会造成主键冲突

Item.hbm.xml

  <set name="categories" table="CATEGORIES_ITEMS" inverse="true">
            <key column="I_ID"></key>
            <many-to-many class="Category" column="C_ID"></many-to-many>
        </set>