單向 n-1

單向 n-1 關聯只需從 n 的一端可以訪問 1 的一端

域模型: 從 Order 到 Customer 的多對一單向關聯需要在Order 類中定義一個 Customer 屬性, 而在 Customer 類中無需定義存放 Order 對象的集合屬性

關系數據模型:ORDERS 表中的 CUSTOMER_ID 參照 CUSTOMER 表的主鍵

Order.hbm.xml

<many-to-one name="customer" class="Customer" column="CUSTOMER_ID"/>

<!--
　　　　　　映射多對一的關聯關系。 使用 many-to-one 來映射多對一的關聯關系
　　　　　　name: 多這一端關聯的一那一端的屬性的名字
　　　　　　class: 一那一端的屬性對應的類名
　　　　　　column: 一那一端在多的一端對應的數據表中的外鍵的名字
-->

測試增刪改查：

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 的那一端的對象!
       1. Order order = (Order) session.get(Order.class, 1);
       1. System.out.println(order.getOrderName()); 
        
       4. System.out.println(order.getCustomer().getClass().getName());
        
       3. session.close();
        
        //2. 在需要使用到關聯的對象時, 才發送對應的 SQL 語句. 
      　2.  Customer customer = order.getCustomer();
      　2.  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);
    }
}

Hibernate單向多對一映射關系（1）