孙卫琴Hibernate06映射一对多单向关联关系

最新推荐文章于 2021-04-30 17:21:39 发布
原创 最新推荐文章于 2021-04-30 17:21:39 发布 · 1.7k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#hibernate #exception #myeclipse #constructor #session #import

本文介绍在Hibernate中如何通过级联操作实现Order与Customer之间的单向关联自动保存更新。重点展示了如何配置<many-to-one>元素的cascade属性，并通过示例代码演示整个过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 
 映射一对多关联关系
以Customer和Order为例：
一对多：
每个Customer可以有一个或者多个Order，因此Customer中应该有一个集合类型的属性，来引用所有关联的Order对象。
多对一：
Order到Customer的关联为多对一关联，每个Order对象都要有一个Customer对象。在Order中要有一个Customer类型的属性。
如果仅包含Customer到Order或者仅包含Order呆Customer的关联，就叫做单向关联。
同时包含两个关联的就坐双向关联。
第一部分：以Order和Customer为例，介绍如何映射多对一单向关联关系。
这个例子的特点是只在Order中加入Customer属性，建立单向关联。
1 数据库：
alter table ORDERS drop foreign key FK8B7256E516B4891C;
drop table if exists CUSTOMERS;
drop table if exists ORDERS;
create table CUSTOMERS (
   ID bigint not null,
   NAME varchar(15),
   primary key (ID)
);
create table ORDERS (
   ID bigint not null,
   ORDER_NUMBER varchar(15),
   CUSTOMER_ID bigint not null,
   primary key (ID)
);
alter table ORDERS add index FK8B7256E516B4891C (CUSTOMER_ID), add constraint FK8B7256E516B4891C foreign key (CUSTOMER_ID) references CUSTOMERS (ID);
2 类
Customers.java
package mypack;
 
import java.util.HashSet;
import java.util.Set;
 
/**
 *CustomersgeneratedbyMyEclipsePersistenceTools
 */
 
publicclass Customers implements java.io.Serializable {
 
    // Fields
 
    private Long id;
 
    private String name;
 
    // Constructors
 
    /**defaultconstructor*/
    public Customers() {
    }
 
    /**fullconstructor*/
    public Customers(String name) {
       this.name = name;
    }
 
    // Property accessors
 
    public Long getId() {
       returnthis.id;
    }
 
    publicvoid setId(Long id) {
        this.id = id;
    }
 
    public String getName() {
       returnthis.name;
    }
 
    publicvoid setName(String name) {
       this.name = name;
    }
 
}
 
Orders.java
package mypack;
 
/**
 *OrdersgeneratedbyMyEclipsePersistenceTools
 */
 
publicclass Orders implements java.io.Serializable {
 
    // Fields
 
    private Long id;
 
    private Customers customers;
 
    private String orderNumber;
 
    // Constructors
 
    /**defaultconstructor*/
    public Orders() {
    }
 
    /**minimalconstructor*/
    public Orders(Customers customers) {
       this.customers = customers;
    }
 
    /**fullconstructor*/
    public Orders(Customers customers, String orderNumber) {
       this.customers = customers;
       this.orderNumber = orderNumber;
    }
 
    // Property accessors
 
    public Long getId() {
       returnthis.id;
    }
 
    publicvoid setId(Long id) {
       this.id = id;
    }
 
    public Customers getCustomers() {
       returnthis.customers;
    }
 
    publicvoid setCustomers(Customers customers) {
       this.customers = customers;
    }
 
    public String getOrderNumber() {
       returnthis.orderNumber;
    }
 
    publicvoid setOrderNumber(String orderNumber) {
       this.orderNumber = orderNumber;
    }
 
}
 
测试类：
BusinessService.java
package mypack;
 
import java.util.Iterator;
import java.util.List;
 
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
 
import com.sun.org.apache.xpath.internal.operations.Or;
 
import sessionFactory.HibernateSessionFactory;
 
publicclass BusinessService {
 
    public List findOrdersByCustomer(Customers customer) throws Exception {
 
       Session session = null;
       Transaction tr = null;
       try {
           session = HibernateSessionFactory.getSession();
           tr = session.beginTransaction();
 
           Query query = session
                  .createQuery("from Orders as o where o.customers.id="
                         + customer.getId());
           List orders = query.list();
           tr.commit();
 
           return orders;
       } catch (Exception e) {
           // TODO: handle exception
           if (tr != null) {
              tr.rollback();
           }
           throw e;
       } finally {
           session.close();
       }
    }
 
    public Customers findCustomer(Long customer_id) throws Exception {
       Session session = null;
       Transaction tr = null;
       try {
 
           session = HibernateSessionFactory.getSession();
           tr = session.beginTransaction();
           Customers customer = (Customers) session.load(Customers.class,
                  customer_id);
           tr.commit();
           return customer;
       } catch (Exception e) {
           // TODO: handle exception
           if (tr != null) {
              tr.rollback();
           }
           throw e;
       } finally {
           session.close();
       }
    }
 
    publicvoid saveCustomerAndOrder() throws Exception {
       Session session = null;
       Transaction tr = null;
       try {
           session = HibernateSessionFactory.getSession();
           tr = session.beginTransaction();
 
           Customers customer = new Customers("zhang");
           session.save(customer);
 
           Orders order1 = new Orders(customer, "order1");
           Orders order2 = new Orders(customer, "order2");
           session.save(order1);
           session.save(order2);
           tr.commit();
       } catch (Exception e) {
           // TODO: handle exception
           if (tr != null) {
              tr.rollback();
           }
           throw e;
       } finally {
           session.close();
       }
    }
 
    publicvoid saveCustomerAndOrdeWithCascader() throws Exception {
       Session session = null;
       Transaction tr = null;
       try {
           session = HibernateSessionFactory.getSession();
           tr = session.beginTransaction();
 
           Customers customer = new Customers("zhang");
           // session.save(customer);//映射文件中加入cascade="save-update"
 
           Orders order1 = new Orders(customer, "order1");
           Orders order2 = new Orders(customer, "order2");
           session.save(order1);
           session.save(order2);
           tr.commit();
       } catch (Exception e) {
           // TODO: handle exception
           if (tr != null) {
              tr.rollback();
           }
           throw e;
       } finally {
           session.close();
       }
    }
 
    publicvoid printOrders(List orders) {
       for (Iterator it = orders.iterator(); it.hasNext();) {
           Orders order = (Orders) it.next();
           System.out.println("OrderNumber of "
                  + order.getCustomers().getName() + " :"
                  + order.getOrderNumber());
       }
    }
 
    publicvoid test() throws Exception {
       saveCustomerAndOrder();
       saveCustomerAndOrdeWithCascader();
       Customers customer = findCustomer(new Long(1));
       List orders = findOrdersByCustomer(customer);
       printOrders(orders);
    }
 
    /**
     *@paramargs
     *@throwsException
     */
    publicstaticvoid main(String[] args) throws Exception {
       // TODO Auto-generated method stub
 
       BusinessService b = new BusinessService();
       b.test();
    }
 
}
3 映射文件：
Customers.hbm.xml
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="mypack.Customers" table="customers"
       catalog="onetomany" lazy="false">
       <id name="id" type="java.lang.Long">
           <column name="ID" />
           <generator class="increment" />
       </id>
       <property name="name" type="java.lang.String">
           <column name="NAME" length="15" />
       </property>
    </class>
</hibernate-mapping>
Orders.hbm.xml
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="mypack.Orders" table="orders" catalog="onetomany">
       <id name="id" type="java.lang.Long">
           <column name="ID" />
           <generator class="increment" />
       </id>
       <many-to-one name="customers" class="mypack.Customers"
           fetch="select" cascade="save-update">
           <column name="CUSTOMER_ID" not-null="true" />
       </many-to-one>
       <property name="orderNumber" type="java.lang.String">
           <column name="ORDER_NUMBER" length="15" />
       </property>
    </class>
</hibernate-mapping>
 
小结：本例子的重点是级联保存和更新的使用。当建立了Order到Customer的单向关联时，把映射文件中的<many-to-one>的cascade属性设置为save-update，只做保存Order的操作，与Order对应的customer对象就自动被保存了。（前提是在测试的文件中加入了对Order的Customer属性的设置）
 
孙卫琴的《精通JPA与Hibernate》的读书笔记：映射一对多双向关联关系
csdnuserlala的博客
05-04 357
当类与类之间建立了关联，就可以方便地从一个对象导航到另一个或者一组与它关联的对象。例如，对于给定的Order对象，如果想获得与它关联的Customer对象，只要调用如下方法： //从Order对象导航到关联的Customer对象 Customer customer=order.getCustomer(); 在Order类中，用@ManyToOne注解映射customer属性： @ManyToOne(targetEntity =Customer.class) @JoinColumn(name="CU
孙卫琴hibernate source code2
10-28
在IT领域，Hibernate作为一个强大的对象关系映射（ORM）框架，极大地简化了Java开发者与数据库之间的交互。孙卫琴老师的“Hibernate源码解析”系列深入剖析了Hibernate的内部机制，帮助开发者更好地理解和运用这个...
孙卫琴的《精通JPA与Hibernate》读书笔记：对象-关系的映射概念
csdnuserlala的博客
04-30 369
孙卫琴的《精通JPA与Hibernate》读书笔记：对象-关系的映射概念 Java对象和关系数据库存在一些简单的映射关系，比如Customer类与CUSTOMERS表映射，一个Customer对象与CUSTOMERS表中的一条记录映射，Customer类的name属性与CUSTOMERS表的NAME字段映射。 但是，毕竟对象模型与数据库是按照不同的思路建立起来的，因此，在不少情况下，不存在一一对应的关系。比如Java对象之间可以双向关联，而数据库的表之间只有单向的参照关系，而且总是many方参照one方。
攻城狮在路上（壹） Hibernate（五）--- 映射一对多关联关系
05-23 90
关联是有方向的，包含单向关联和双向关联。分别讨论。本文以客户Customer和订单Order来进行讨论:一个Customer有多个Order，每个Order对应一个Customer。 Customer对象代码： public class Customer { 　　private long id; 　　private String name; 　　private...
java逍遥游记 下载_Hibernate逍遥游记 孙卫琴著 PDF下载
weixin_32498069的博客
02-26 210
《Java开发专家•Hibernate逍遥游记(附CD-ROM光盘1张)》Hibernate是非常流行的对象一关系映射工具。《Java开发专家•Hibernate逍遥游记(附CD-ROM光盘1张)》由浅入深地介绍运用目前最成熟的Hibernate3.3 版本进行Java对象持久化的核心技术。《Java开发专家•Hibernate逍遥游记(附CD-ROM光盘1张)》主要介绍通过Hibernate A...
《精通Hibernate：Java对象持久化技术详解》目录
05-20 258
图书信息：孙卫琴 电子工业出版社 第1章 Java应用分层架构及软件模型： 　　1.1 应用程序的分层体系结构 　　　　1.1.1 区分物理层和逻辑层 　　　　1.1.2 软件层的特征 　　　　1.1.3 软件分层的优点 　　　　1.1.4 软件分层的缺点 　　　　1.1.5 Java应用的持久化层 　　1.2 软件的模型 　　　　1.2.1 概念模型 　　　　1.2.2 关系数据模型...
hibernate 笔记
MincludeA的专栏
08-26 460
day1一. hibernate数据持久化组件对象持久化(Object Persistence):把数据保存在永久存储介质中（数据库）         1.为什么要持久化:                 a.内存是暂时存储设备,断电后数据易丢失                 b.网络传输无法传输内存中的对象，需要将对象外化                 c.内存中数据
Hibernate学习笔记
houjie410782的专栏
03-11 322
day1 一. hibernate数据持久化组件 对象持久化(Object Persistence):把数据保存在永久存储介质中（数据库）          1.为什么要持久化:                  a.内存是暂时存储设备,断电后数据易丢失                  b.网络传输无法传输内存中的对象，需要将对象外化                  c.内存中数据
Hibernate 学习笔记
自强不息
10-19 135
原创 hibernate 笔记 收藏 day1 一. hibernate数据持久化组件 对象持久化(Object Persistence):把数据保存在永久存储介质中（数据库） 1.为什么要持久化: a.内存是暂时存储设备,断电后数据易丢失 b.网络传输无法传输内存中的对象...
Hibernate 笔记
Michael Wing's workspace
12-29 648
day1一. hibernate数据持久化组件对象持久化(Object Persistence):把数据保存在永久存储介质中（数据库）         1.为什么要持久化:                 a.内存是暂时存储设备,断电后数据易丢失                 b.网络传输无法传输内存中的对象，需要将对象外化                 c.内存中
Hibernate知识点总结大全
qqq3670279的博客
04-08 387
一. hibernate数据持久化组件 对象持久化(Object Persistence):把数据保存在永久存储介质中（数据库）         1.为什么要持久化:                  a.内存是暂时存储设备,断电后数据易丢失                  b.网络传输无法传输内存中的对象，需要将对象外化                  c.内存中数据查询,组织不方
孙卫琴hibernate sourcecode netstore源码
10-28
在Java开发领域，Hibernate作为一款强大的对象关系映射（ORM）框架，极大地简化了数据库操作。而“孙卫琴精通Hibernate NetStore源码”这一话题，揭示了作者对Hibernate源码的深入理解和实践，尤其是NetStore部分。...
孙卫琴hibernate实战第二版书及源码.part1
01-17
孙卫琴hibernate实战第二版书及源码
孙卫琴hibernate source code3
10-28
4. **Chapter 10 - 对象关系映射与实体管理**：深入理解Hibernate如何将Java对象映射到数据库表，包括实体类的定义、注解配置、XML配置，以及实体之间的关系映射（一对一、一对多、多对一、多对多）。还将涉及懒加载...
孙卫琴Hibernate第二章（hello 例子）
天使
12-17 1702
第二章 Hibernate入门 一 Hello例子：1、 创建数据库： create table CUSTOMERS( ID bigint not null primary key, NAME varchar(15) not null, EMAIL varchar(128)not null, PASSWORD varchar(8)not null, PHONE
孙卫琴Hibernate第四章对象-关系映射基础
天使
12-20 1411
 单个持久化类与单个数据库表之间进行映射的技巧：主要解决以下问题：       持久化类的属性没有相关的setXXX()和getXXX()方法；持久化类的属性在数据库中没有对应的字段，或者数据库中的字段在持久化类中没有对应的属性；控制Hibernate生成的insert和update语句；设置从持久化类映射到数据库表，以及持久化类的属性映射到数据库表的字段的命名策略；一
05映射自然主键(不推荐使用自然主键)
天使
12-23 1209
 一般不提倡用自然主键，而是用代理主键。当无法避免时：look 1 映射单个自然主键 假定在Customer表中没有ID 代理主键，而是以name作为主键。那么Customer类中不必定义id属性，Customer类的OID为name属性。映射文件为：hibernate-mapping>    class name="mypack.Customer" table="cu
孙卫琴hibernate05映射对象标识符
天使
12-23 1078
Hibernate 的内置标识符生成器 1 increment 适用于代理主键，由Hibernate自动一递增的方式生成标识符，每次增加1 2 indentity 适用于代理主键。由底层数据库生成标识符。前提是底层数据库支持自动增长字段类型。 3 sequence 适用于代理主键。Hibernate根据底层数据库的序列来生成标识符。前提条件是底层数据库支持序列。 4 hilo 适用于代理主键。Hi
孙卫琴《Hibernate逍遥游记》源码解析
标题《hibernate逍遥游记》附属光盘之源码所指的是与孙卫琴编写的《hibernate逍遥游记》这本书相关联的一系列源代码。孙卫琴是一位知名的Java图书作者，她的作品往往深入浅出，易于理解。Hibernate作为一个对象关系...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值