1.单向 n-1 关联只需从 n 的一端可以访问 1 的一端
2.实体类
n端：Order.java
public class Order {
private Integer orderId;
private String orderName;
//在n端的实体类中有1端的类型的属性
private Customer customer;
//省略getter和setter方法
...
}1端：Customer.java
public class Customer {
private Integer customerId;
private String customerName;
//省略getter和setter方法
...
}3.映射文件
n端：Order.hbm.xml
<hibernate-mapping package="com.withXml.manyToone.entity">
<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>
<!-- 在n的一端映射n对1关联关系 -->
<many-to-one name="customer" class="Customer" column="CUSTOMER" cascade="save-update,delete"></many-to-one>
</class>
</hibernate-mapping>1：端Customer.hbm.xml
<hibernate-mapping>
<class name="com.withXml.manyToone.entity.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>
4.配置文件中添加Mapping元素
<!-- 配置映射文件时，这两种方法只能使用其中之一，同时使用会报错 -->
<!--使用配置文件时： 加载映射文件，注意使用的是斜杠作为分割符，有文件的后缀名 -->
<!-- 使用注解时：加载持久化类文件，注意使用的是圆点作为分割符，无文件的后缀名 -->
<mapping resource="com/withXml/manyToone/entity/Customer.hbm.xml"/>
<mapping resource="com/withXml/manyToone/entity/Order.hbm.xml"/>5.CRUD测试
public class TestManyToOne {
//通常生产环境中不会定义Transaction对象 和Session对象为成员变量，因为会出现并发的问题，这是单元测试环境
private SessionFactory sessionFactory;
private Session session;
private Transaction transaction;
/**
* 初始化Session
*/
@Before
public void init(){
//1.获取Configuration 对象
Configuration configuration = new Configuration().configure("hibernate.cfg.xml");
//2.获取ServiceRegistry 对象
ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().
applySettings(configuration.getProperties()).
buildServiceRegistry();
//3.获取SessionFactory 对象，并在ServiceRegistry 对象中注册
sessionFactory = configuration.buildSessionFactory(serviceRegistry);
//4.获取Session 对象
session = sessionFactory.openSession();
//5.开启session事务
transaction = session.beginTransaction();
}
/**
* 关闭Session
*/
@After
public void destroy(){
transaction.commit();
session.close();
sessionFactory.close();
}
/**
* 执行保存操作时，先保存一的一端的对象，在保存多的一端的对象时，只有三条insert语句
* 执行保存操作时，先保存多的一端的对象，在保存一的一端的对象时，有三条insert语句和两条update语句，
*因为在插入多的一端无法确定外键值，所以只能等一的一端插入后，再更新
*/
@Test
public void testManyToOneSave(){
//客户
Customer customer = new Customer();
customer.setCustomerName("CC");
//订单一
Order order = new Order();
order.setOrderName("order-3");
//订单二
Order order2 = new Order();
order2.setOrderName("order-4");
//设定关联关系，从多的一端维护关联关系
order.setCustomer(customer);
order2.setCustomer(customer);
//执行保存操作，先保存一的一端，在保存多的一端，推荐
session.save(customer);
session.save(order);
session.save(order2);
//先保存多的一端，在保存一的一端，不推荐
// session.save(order);
// session.save(order2);
// session.save(customer);
}
/**
* 测试客户和订单之间的单向多对一的关联关系，查找操作
* 若查询多的一端的一个对象，则默认情况下，只查询多的一端的对象，而没有查询关联的对象，即一的一端的对象
*只有需要使用到关联的对象时，才发送相关的SQL语句，这就是Hibernate的懒加载机制
* 若在加载关联的对象时，把session关了，就会出现懒加载异常
*/
@Test
public void testManyToOneGet(){
Order order = (Order) session.get(Order.class, 1);
System.out.println("订单名称：" + order.getOrderName());
String name = order.getCustomer().getCustomerName();
System.out.println("订单：" + order.getOrderName() + "的客户是：" + name);
}
/**
* 测试修改操作
*/
@Test
public void testManyToOneUpdate(){
Order order = (Order) session.get(Order.class, 1);
order.getCustomer().setCustomerName("AAA");
}
/**
* 测试删除操作，删除时，不能从关联的一端进行删除，因为在多的一端的外键引用了一的一端
* 在多对一映射中，无法从1的一端删除，在一对多映射中，可以中1的一端删除记录，
*同时还会强制把n端的外键也删除
*/
@Test
public void testManyToOneDelete(){
//从一的一端，删除记录失败，因为一的一端外键被引用无法删除
// Customer customer = (Customer) session.get(Customer.class, 1);
// session.delete(customer);
//从多的一端删除记录
Order order = (Order) session.get(Order.class, 4);
session.delete(order);
}
/**
* 级联保存
*/
@Test
public void testManyToOneCascadeSave(){
//客户
Customer customer = new Customer();
customer.setCustomerName("CC");
//订单一
Order order = new Order();
order.setOrderName("order-3");
//订单二
Order order2 = new Order();
order2.setOrderName("order-4");
//设定关联关系，从多的一端维护关联关系
order.setCustomer(customer);
order2.setCustomer(customer);
//执行保存操作，先保存一的一端，在保存多的一端，推荐，设置cascade级联属性之后，
//仅只保存多端即可，从而省略1的一端，反之则不行因为没有一对多的的映射
// session.save(customer);
session.save(order);
session.save(order2);
}
}单向n对1
总结：
n端：
①实体类中添加一个1端类型的属性
②映射文件中使用<many-to-one 映射数据库字段
1端：
①普通的javaBean
②映射文件，类属性和数据库字段一一映射即可