單向的多對一映射：

分析與用法：

在UML 中,關聯是有方向的：

以 Customer 和Order爲例：一個用戶能發出多個訂單,而一個訂單隻能屬於一個客戶.從Order到Customer的關聯是多對一關聯;而從Customer到Order是一對多關聯

兩個簡單的持久化類：

Customer：

public class Customer {

	private Integer customerId;
	private String customerName;

	public Integer getCustomerId() {
		return customerId;
	}

	public void setCustomerId(Integer customerId) {
		this.customerId = customerId;
	}

	public String getCustomerName() {
		return customerName;
	}

	public void setCustomerName(String customerName) {
		this.customerName = customerName;
	}

}

Order：

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

	public Integer getOrderId() {
		return orderId;
	}

	public void setOrderId(Integer orderId) {
		this.orderId = orderId;
	}

	public String getOrderName() {
		return orderName;
	}

	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}

	public Customer getCustomer() {
		return customer;
	}

	public void setCustomer(Customer customer) {
		this.customer = customer;
	}
}

hbm.xml的配置：

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.atguigu.hibernate.entities.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.atguigu.hibernate.entities.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>
        
		<span style="color:#FF0000;"><!-- 
			映射多對一的關聯關係。 使用 many-to-one 來映射多對一的關聯關係 
			name: 多這一端關聯的一那一端的屬性的名字
			class: 一那一端的屬性對應的類名
			column: 一那一端在多的一端對應的數據表中的外鍵的名字
		--></span>
		<many-to-one name="customer" class="Customer" column="CUSTOMER_ID"></many-to-one>

    </class>
</hibernate-mapping>

測試例子：

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

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);
	}

}

雙向一對多映射

分析與用法：

注意：

兩個簡單的持久化類：

Order.java（沒有改變，可參照上面）

Customer.java（多了一個Order類型的Set集合）：

import java.util.HashSet;
import java.util.Set;

public class Customer {

	private Integer customerId;
	private String customerName;
	
	/*
	 * 1. 聲明集合類型時, 需使用接口類型, 因爲 hibernate 在獲取
	 * 集合類型時, 返回的是 Hibernate 內置的集合類型, 而不是 JavaSE 一個標準的
	 * 集合實現. 
	 * 2. 需要把集合進行初始化, 可以防止發生空指針異常
	 */
	private Set<Order> orders = new HashSet<>();

	public Integer getCustomerId() {
		return customerId;
	}

	public void setCustomerId(Integer customerId) {
		this.customerId = customerId;
	}

	public String getCustomerName() {
		return customerName;
	}

	public void setCustomerName(String customerName) {
		this.customerName = customerName;
	}

	public Set<Order> getOrders() {
		return orders;
	}

	public void setOrders(Set<Order> orders) {
		this.orders = orders;
	}
	
	

}

hbm.xml的配置：

Order.hbm.xml（沒有改變，可參照上面）

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.atguigu.hibernate.entities.n21.both">
    
    <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 對多的那個集合屬性 -->
       <span style="color:#FF0000;"> <!-- set: 映射 set 類型的屬性, table: set 中的元素對應的記錄放在哪一個數據表中. 該值需要和多對一的多的那個表的名字一致 -->
        <!-- inverse: 指定由哪一方來維護關聯關係. 通常設置爲 true, 以指定由多的一端來維護關聯關係 -->
        <!-- cascade 設定級聯操作. 開發時不建議設定該屬性. 建議使用手工的方式來處理 -->
        <!-- order-by 在查詢時對集合中的元素進行排序, order-by 中使用的是表的字段名, 而不是持久化類的屬性名  -->
        <set name="orders" table="ORDERS" inverse="true" order-by="ORDER_NAME DESC"></span>
        	<!-- 執行多的表中的外鍵列的名字 -->
        	<key column="CUSTOMER_ID"></key>
        	<!-- 指定映射類型 -->
        	<one-to-many class="Order"/>
        </set>
        
    </class>
    
</hibernate-mapping>

測試例子：

@Test
	public void testMany2OneSave(){
		Customer customer = new Customer();
		customer.setCustomerName("AA");
		
		Order order1 = new Order();
		order1.setOrderName("ORDER-1");
		
		Order order2 = new Order();
		order2.setOrderName("ORDER-2");
		
		//設定關聯關係
		order1.setCustomer(customer);
		order2.setCustomer(customer);
		
		customer.getOrders().add(order1);
		customer.getOrders().add(order2);
		
		//執行  save 操作: 先插入 Customer, 再插入 Order, 3 條 INSERT, 2 條 UPDATE
		//因爲 1 的一端和 n 的一端都維護關聯關係. 所以會多出 UPDATE
		//可以在 1 的一端的 set 節點指定 inverse=true, 來使 1 的一端放棄維護關聯關係!
		//建議設定 set 的 inverse=true, 建議先插入 1 的一端, 後插入多的一端
		//好處是不會多出 UPDATE 語句
		session.save(customer);
		
//		session.save(order1);
//		session.save(order2);
		
		//先插入 Order, 再插入 Cusomer, 3 條 INSERT, 4 條 UPDATE
//		session.save(order1);
//		session.save(order2);
//		
//		session.save(customer);
	}

@Test
	public void testOne2ManyGet(){
		//1. 對 n 的一端的集合使用延遲加載
		Customer customer = (Customer) session.get(Customer.class, 7);
		System.out.println(customer.getCustomerName()); 
		//2. 返回的多的一端的集合時 Hibernate 內置的集合類型. 
		//該類型具有延遲加載和存放代理對象的功能. 
		System.out.println(customer.getOrders().getClass()); 
		
		//session.close();
		//3. 可能會拋出 LazyInitializationException 異常 
		
		System.out.println(customer.getOrders().size()); 
		
		//4. 再需要使用集合中元素的時候進行初始化. 
	}

基於外鍵映射的1-1關聯關係：

分析與用法：

兩個簡單的持久化類：

Department.java:

public class Department {

	private Integer deptId;
	private String deptName;
	
	private Manager mgr;

	public Integer getDeptId() {
		return deptId;
	}

	public void setDeptId(Integer deptId) {
		this.deptId = deptId;
	}

	public String getDeptName() {
		return deptName;
	}

	public void setDeptName(String deptName) {
		this.deptName = deptName;
	}

	public Manager getMgr() {
		return mgr;
	}

	public void setMgr(Manager mgr) {
		this.mgr = mgr;
	}
}

Manager.java:

public class Manager {

	private Integer mgrId;
	private String mgrName;
	
	private Department dept;

	public Integer getMgrId() {
		return mgrId;
	}

	public void setMgrId(Integer mgrId) {
		this.mgrId = mgrId;
	}

	public String getMgrName() {
		return mgrName;
	}

	public void setMgrName(String mgrName) {
		this.mgrName = mgrName;
	}

	public Department getDept() {
		return dept;
	}

	public void setDept(Department dept) {
		this.dept = dept;
	}
}

hbm.xml的配置：

Manager.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.atguigu.hibernate.one2one.foreign.Manager" table="MANAGERS">
        
        <id name="mgrId" type="java.lang.Integer">
            <column name="MGR_ID" />
            <generator class="native" />
        </id>
        
        <property name="mgrName" type="java.lang.String">
            <column name="MGR_NAME" />
        </property>
        
        <span style="color:#FF0000;"><!-- 映射 1-1 的關聯關係: 在對應的數據表中已經有外鍵了, 當前持久化類使用 one-to-one 進行映射 -->
        <!-- 
        	沒有外鍵的一端需要使用one-to-one元素，該元素使用 property-ref 屬性指定使用被關聯實體主鍵以外的字段作爲關聯字段
         --></span>
        <one-to-one name="dept" 
        	class="com.atguigu.hibernate.one2one.foreign.Department"
        	property-ref="mgr"></one-to-one>
        
    </class>
    
</hibernate-mapping>

Department.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.atguigu.hibernate.one2one.foreign.Department" table="DEPARTMENTS">

        <id name="deptId" type="java.lang.Integer">
            <column name="DEPT_ID" />
            <generator class="native" />
        </id>
        
        <property name="deptName" type="java.lang.String">
            <column name="DEPT_NAME" />
        </property>
		
		<span style="color:#FF0000;"><!-- 使用 many-to-one 的方式來映射 1-1 關聯關係 --></span>
		<many-to-one name="mgr" class="com.atguigu.hibernate.one2one.foreign.Manager" 
			column="MGR_ID" unique="true"></many-to-one>	        
			        
    </class>
</hibernate-mapping>

測試例子：

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

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 testGet2(){
		//在查詢沒有外鍵的實體對象時, 使用的左外連接查詢, 一併查詢出其關聯的對象
		//並已經進行初始化. 
		Manager mgr = (Manager) session.get(Manager.class, 1);
		System.out.println(mgr.getMgrName()); 
		System.out.println(mgr.getDept().getDeptName()); 
	}
	
	@Test
	public void testGet(){
		//1. 默認情況下對關聯屬性使用懶加載
		Department dept = (Department) session.get(Department.class, 1);
		System.out.println(dept.getDeptName()); 
		
		//2. 所以會出現懶加載異常的問題. 
//		session.close();
//		Manager mgr = dept.getMgr();
//		System.out.println(mgr.getClass()); 
//		System.out.println(mgr.getMgrName()); 
		
		//3. 查詢 Manager 對象的連接條件應該是 dept.manager_id = mgr.manager_id
		//而不應該是 dept.dept_id = mgr.manager_id
		Manager mgr = dept.getMgr();
		System.out.println(mgr.getMgrName()); 
		
		
	}
	
	@Test
	public void testSave(){
		
		Department department = new Department();
		department.setDeptName("DEPT-BB");
		
		Manager manager = new Manager();
		manager.setMgrName("MGR-BB");
		
		//設定關聯關係
		department.setMgr(manager);
		manager.setDept(department);
		
		//保存操作
		//建議先保存沒有外鍵列的那個對象. 這樣會減少 UPDATE 語句
		session.save(department);
		session.save(manager);
		
	}
	
	

}

基於主鍵映射的 1-1

分析與用法：

兩個持久化類不變

hbm.xml的配置：

Manager.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.atguigu.hibernate.one2one.primary.Manager" table="MANAGERS">
        
        <id name="mgrId" type="java.lang.Integer">
            <column name="MGR_ID" />
            <generator class="native" />
        </id>
        
        <property name="mgrName" type="java.lang.String">
            <column name="MGR_NAME" />
        </property>
        
        <one-to-one name="dept" 
        	class="com.atguigu.hibernate.one2one.primary.Department"></one-to-one>
        
    </class>
    
</hibernate-mapping>

Department.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.atguigu.hibernate.one2one.primary">

    <class name="Department" table="DEPARTMENTS">

        <id name="deptId" type="java.lang.Integer">
            <column name="DEPT_ID" />
           <span style="color:#FF0000;"> <!-- 使用外鍵的方式來生成當前的主鍵 -->
            <generator class="foreign"></span>
            	<!-- property 屬性指定使用當前持久化類的哪一個屬性的主鍵作爲外鍵 -->
            	<param name="property">mgr</param>
            </generator>
        </id>
        
        <property name="deptName" type="java.lang.String">
            <column name="DEPT_NAME" />
        </property>
		
		<span style="color:#FF0000;"><!--  
		採用 foreign 主鍵生成器策略的一端增加 one-to-one 元素映射關聯屬性,
		其 one-to-one 節點還應增加 constrained=true 屬性, 以使當前的主鍵上添加外鍵約束
		-->
		<one-to-one name="mgr" class="Manager" constrained="true"></one-to-one></span>
					        
    </class>
</hibernate-mapping>

測試例子：

@Test
	public void testSave(){
		
		Department department = new Department();
		department.setDeptName("DEPT-BB");
		
		Manager manager = new Manager();
		manager.setMgrName("MGR-BB");
		
		//設定關聯關係
		department.setMgr(manager);
		manager.setDept(department);
		
		//保存操作
		//建議先保存沒有外鍵列的那個對象. 這樣會減少 UPDATE 語句
		session.save(department);
		session.save(manager);
		
	}

[學習小結]Hibernate 的幾種映射及映射關係

單向的多對一映射：

分析與用法：

兩個簡單的持久化類：

hbm.xml的配置：

測試例子：

雙向一對多映射

分析與用法：

注意：

兩個簡單的持久化類：

hbm.xml的配置：

測試例子：

基於外鍵映射的1-1關聯關係：

分析與用法：

兩個簡單的持久化類：

hbm.xml的配置：

測試例子：

基於主鍵映射的 1-1

分析與用法：

兩個持久化類不變

hbm.xml的配置：

測試例子：

Spring Cloud 部署時如何使用 Kubernetes 作爲註冊中心和配置中心

[學習小結]Hibernate 的幾種映射及映射關係

Spring MVC--入門

正則表達式的語法與一些例子的總結

Spring註解@Component、@Repository、@Service、@Controller區別

Hibernate的QBC查詢

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結