[原创]java WEB学习笔记82：Hibernate学习之路---映射 一对多关联关系，配置，CRUD方法测试及注意点

本博客的目的：①总结自己的学习过程，相当于学习笔记 ②将自己的经验分享给大家，相互学习，互相交流，不可商用

内容难免出现问题，欢迎指正，交流，探讨，可以留言，也可以通过以下方式联系。

本人互联网技术爱好者，互联网技术发烧友

微博：伊直都在0221

QQ：951226918

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1.一对多关联关系

　　1）在领域模型中, 类与类之间最普遍的关系就是关联关系.

　　2）在 UML 中, 关联是有方向的：以 Customer 和 Order 为例： 一个用户能发出多个订单, 而一个订单只能属于一个客户. 从 Order 到 Customer 的关联是多对一关联; 而从 Customer 到 Order 是一对多关联

　　　　- 单向关联

　　

package com.jason.hibernate.entities.n21;

import hibernate.helloworld.News;
import hibernate.helloworld.Pay;
import hibernate.helloworld.Worker;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.sql.Blob;
import java.sql.Connection;
import java.sql.Date;
import java.sql.SQLException;

import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.jdbc.Work;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.omg.CORBA.ORB;

public class HibernateTest {

private SessionFactory sessionFactory;
private Session session;
private Transaction transaction;
@Test
public void test() {

// 1. 创建一个SessionFatory 对象
SessionFactory sessionFactory = null;

// 1) 创建Configuration 对象：对应hibernate 的基本配置信息 和 对象关系映射信息
Configuration configuration = new Configuration().configure();

// 2) 创建一个ServiceRegistry 对象：hibernate 4.x 新天添加的对象。
// hibernate 的任何配置 和 服务都需要在该对象中注册后才有效
ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
.applySettings(configuration.getProperties())
.buildServiceRegistry();

// sessionFactory = configuration.buildSessionFactory();
sessionFactory = configuration.buildSessionFactory(serviceRegistry);

// 2. 创建一个session 对象
Session session = sessionFactory.openSession();

// 3. 开启事物
Transaction transaction = session.beginTransaction();

// 4.执行保存操作
News news = new News("java", "jason", new Date(
new java.util.Date().getTime()));
session.save(news);

// 5.提交事物
transaction.commit();
// 6.关闭session
session.close();
// 7.关闭SessionFactory 对象
sessionFactory.close();
}

// 创建上述三个对象
@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("tom2");

}
@Test
public void testManyToOneGet(){
//1.若查询n 的一端的对象，则默认情况下，只查询了n 的一端的对象，而没有查询关联的1 端的对象
//延迟加载
Order order = (Order) session.get(Order.class, 1);
System.out.println(order);

//2.在需要使用到关联的对象，才发送对应的sql 语句
Customer customer = order.getCustomer();
System.out.println(customer);

//3.获取order对象，默认情况，其关联的Customer 对象是一个代理对象
}

@Test
public void testManyToOneSave(){
Customer customer = new Customer();
customer.setCustomerName("tom");

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 语句
//因为在插入n 的一端，无法确定1 的一端的外键，所以只能等1 的一端出入后，再额外的发送update 语句

session.save(order1);
session.save(order2);
session.save(customer);

}

}

HibernateTest

说明：
　　1.在 n 端的 .hbm.xml　中映射关联关系

<!-- 映射 多对一 关联关系 -->
<!--
name: 'n'端 关联 '1'端的属性的名字
class: '1'端 属性对应的类名
colum: '1'端  在 'n'端 对应的数据表中的外键的名字
-->
<many-to-one name="customer" class="Customer">
<column name="CUSTOMER_ID" />
</many-to-one>

　　2.方法注意点：
　　　　

@Test
public void testManyToOneGet(){
//1.若查询n 的一端的对象，则默认情况下，只查询了n 的一端的对象，而没有查询关联的1 端的对象
//延迟加载
Order order = (Order) session.get(Order.class, 1);
System.out.println(order);

//2.在需要使用到关联的对象，才发送对应的sql 语句
Customer customer = order.getCustomer();
System.out.println(customer);

//3.获取order对象，默认情况，其关联的Customer 对象是一个代理对象
}

@Test
public void testManyToOneSave(){
Customer customer = new Customer();
customer.setCustomerName("tom");

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 语句
//因为在插入n 的一端，无法确定1 的一端的外键，所以只能等1 的一端出入后，再额外的发送update 语句

session.save(order1);
session.save(order2);
session.save(customer);

}