Hibernate和JPA使用连接表处理多对一映射

2023-11-03 17:08
文章标签 使用 连接 hibernate 映射 jpa 表处理

本文主要是介绍Hibernate和JPA使用连接表处理多对一映射，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

 

在项目中，原有的持久化操作时使用JPA进行的，通过注解多对一映射被映射成中间表和两个数据库表，其代码如下：

  1. import javax.persistence.Column;
  2. import javax.persistence.Entity;
  3. import javax.persistence.GeneratedValue;
  4. import javax.persistence.GenerationType;
  5. import javax.persistence.Id;
  6. import javax.persistence.NamedQueries;
  7. import javax.persistence.NamedQuery;
  8. import javax.persistence.Table;
  10. /**
  11.  * 产品实体类
  12.  * @author 李文锴
  13.  */
  14. @Entity
  15. @Table(name = "yunda_product")
  16. @NamedQueries({
  17.     @NamedQuery(name = "getProduct", query = "SELECT p FROM OrderProduct AS p"),
  18.     @NamedQuery(name = "getProductByName", query = "SELECT p FROM OrderProduct AS p WHERE p.name=:name")
  19. })
  20. public class OrderProduct implements java.io.Serializable {
  22.     private static final long serialVersionUID = 1L;
  23.     /**
  24.      * 货物id
  25.      */
  26.     @Id
  27.     @GeneratedValue(strategy = GenerationType.AUTO)
  28.     private Long id;
  29.     /**
  30.      * 货物名称
  31.      */
  32.     @Column(name = "p_name", length = 80, nullable = false)
  33.     private String name;
  34.     /**
  35.      * 货物类型
  36.      */
  37.     @Column(name = "p_type", length = 80, nullable = false)
  38.     private String type;
  39.     /**
  40.      * 货物数量
  41.      */
  42.     @Column(name = "p_quantity", nullable = false)
  43.     private int quantity;
  45.     public OrderProduct() {
  46.     }
  48.     public OrderProduct(String name, String type, int quantity) {
  49.         setName(name);
  50.         setType(type);
  51.         setQuantity(quantity);
  52.     }
  54.     public Long getId() {
  55.         return id;
  56.     }
  58.     public void setId(Long id) {
  59.         this.id = id;
  60.     }
  62.     public String getName() {
  63.         return name;
  64.     }
  66.     public void setName(String name) {
  67.         this.name = name;
  68.     }
  70.     public int getQuantity() {
  71.         return quantity;
  72.     }
  74.     public void setQuantity(int quantity) {
  75.         this.quantity = quantity;
  76.     }
  78.     public String getType() {
  79.         return type;
  80.     }
  82.     public void setType(String type) {
  83.         this.type = type;
  84.     }
  86.     @Override
  87.     public boolean equals(Object obj) {
  88.         if (obj == null) {
  89.             return false;
  90.         }
  91.         if (getClass() != obj.getClass()) {
  92.             return false;
  93.         }
  94.         final OrderProduct other = (OrderProduct) obj;
  95.         if ((this.name == null) ? (other.name != null) : !this.name.equals(other.name)) {
  96.             return false;
  97.         }
  98.         if ((this.type == null) ? (other.type != null) : !this.type.equals(other.type)) {
  99.             return false;
  100.         }
  101.         if (this.quantity != other.quantity) {
  102.             return false;
  103.         }
  104.         return true;
  105.     }
  107.     @Override
  108.     public int hashCode() {
  109.         int hash = 7;
  110.         hash = 61 * hash + (this.name != null ? this.name.hashCode() : 0);
  111.         hash = 61 * hash + (this.type != null ? this.type.hashCode() : 0);
  112.         hash = 61 * hash + this.quantity;
  113.         return hash;
  114.     }
  115. }

 

  1. import java.util.Date;
  2. import java.util.Set;
  3. import javax.persistence.CascadeType;
  4. import javax.persistence.Column;
  5. import javax.persistence.Entity;
  6. import javax.persistence.GeneratedValue;
  7. import javax.persistence.GenerationType;
  8. import javax.persistence.Id;
  9. import javax.persistence.JoinColumn;
  10. import javax.persistence.JoinTable;
  11. import javax.persistence.OneToMany;
  12. import javax.persistence.Table;
  13. import javax.persistence.Temporal;
  15. /**
  16.  * 存储订单实体类，其中和产品实体进行关联
  17.  * @author 李文锴
  18.  */
  19. @Entity
  20. @Table(name = "stock_order")
  21. public class StockOrder implements java.io.Serializable {
  23.     private static final long serialVersionUID = 1L;
  24.     /**
  25.      * 订单id
  26.      */
  27.     @Id
  28.     @GeneratedValue(strategy = GenerationType.AUTO)
  29.     private Long id;
  30.     /**
  31.      * 客户编号
  32.      */
  33.     @Column(name = "customer_no", length = 20, nullable = false)
  34.     private String customerNO;
  35.     /**
  36.      * 客户名称
  37.      */
  38.     @Column(name = "customer_name", length = 80, nullable = false)
  39.     private String customerName;
  40.     /**
  41.      * 产品
  42.      */
  43.     @OneToMany(cascade = CascadeType.ALL)
  44.     @JoinTable(name = "stock_order_product", joinColumns = {@JoinColumn(name = "stock_order_id")}, inverseJoinColumns = {@JoinColumn(name = "product_id")})
  45.     private Set<OrderProduct> prdoucts;
  46.     /**
  47.      * 到达日期
  48.      */
  49.     @Column(name = "arrival_date", nullable = false)
  50.     @Temporal(javax.persistence.TemporalType.DATE)
  51.     private Date arrivalDate;
  53.     public StockOrder() {
  54.     }
  56.     public StockOrder(String customerNO, String customerName, Set<OrderProduct> prdoucts, Date arrivalDate) {
  57.         setCustomerNO(customerNO);
  58.         setCustomerName(customerName);
  59.         setPrdoucts(prdoucts);
  60.         setArrivalDate(arrivalDate);
  61.     }
  63.     public Date getArrivalDate() {
  64.         return arrivalDate;
  65.     }
  67.     public void setArrivalDate(Date arrivalDate) {
  68.         this.arrivalDate = arrivalDate;
  69.     }
  71.     public String getCustomerNO() {
  72.         return customerNO;
  73.     }
  75.     public void setCustomerNO(String customerNO) {
  76.         this.customerNO = customerNO;
  77.     }
  79.     public Long getId() {
  80.         return id;
  81.     }
  83.     public void setId(Long id) {
  84.         this.id = id;
  85.     }
  87.     public Set<OrderProduct> getPrdoucts() {
  88.         return prdoucts;
  89.     }
  91.     public void setPrdoucts(Set<OrderProduct> prdoucts) {
  92.         this.prdoucts = prdoucts;
  93.     }
  95.     public String getCustomerName() {
  96.         return customerName;
  97.     }
  99.     public void setCustomerName(String customerName) {
  100.         this.customerName = customerName;
  101.     }
  103.     @Override
  104.     public boolean equals(Object obj) {
  105.         if (obj == null) {
  106.             return false;
  107.         }
  108.         if (getClass() != obj.getClass()) {
  109.             return false;
  110.         }
  111.         final StockOrder other = (StockOrder) obj;
  112.         if ((this.customerNO == null) ? (other.customerNO != null) : !this.customerNO.equals(other.customerNO)) {
  113.             return false;
  114.         }
  115.         if ((this.customerName == null) ? (other.customerName != null) : !this.customerName.equals(other.customerName)) {
  116.             return false;
  117.         }
  118.         if (this.prdoucts != other.prdoucts && (this.prdoucts == null || !this.prdoucts.equals(other.prdoucts))) {
  119.             return false;
  120.         }
  121.         if (this.arrivalDate != other.arrivalDate && (this.arrivalDate == null || !this.arrivalDate.equals(other.arrivalDate))) {
  122.             return false;
  123.         }
  124.         return true;
  125.     }
  127.     @Override
  128.     public int hashCode() {
  129.         int hash = 5;
  130.         hash = 59 * hash + (this.customerNO != null ? this.customerNO.hashCode() : 0);
  131.         hash = 59 * hash + (this.customerName != null ? this.customerName.hashCode() : 0);
  132.         hash = 59 * hash + (this.prdoucts != null ? this.prdoucts.hashCode() : 0);
  133.         hash = 59 * hash + (this.arrivalDate != null ? this.arrivalDate.hashCode() : 0);
  134.         return hash;
  135.     }
  136. }
  1. import java.util.Date;
  2. import java.util.Set;
  3. import javax.persistence.CascadeType;
  4. import javax.persistence.Column;
  5. import javax.persistence.Entity;
  6. import javax.persistence.GeneratedValue;
  7. import javax.persistence.GenerationType;
  8. import javax.persistence.Id;
  9. import javax.persistence.JoinColumn;
  10. import javax.persistence.JoinTable;
  11. import javax.persistence.OneToMany;
  12. import javax.persistence.Table;
  13. import javax.persistence.Temporal;
  15. /**
  16.  * 运输订单实体类，并于产品实体进行关联
  17.  * @author 李文锴
  18.  */
  19. @Entity
  20. @Table(name = "trans_order")
  21. public class TransOrder implements java.io.Serializable {
  23.     private static final long serialVersionUID = 1L;
  24.     /**
  25.      * 订单id
  26.      */
  27.     @Id
  28.     @GeneratedValue(strategy = GenerationType.AUTO)
  29.     private Long id;
  30.     /**
  31.      * 客户编号
  32.      */
  33.     @Column(name = "customer_no", length = 20, nullable = false)
  34.     private String customerNO;
  35.     /**
  36.      * 客户名称
  37.      */
  38.     @Column(name = "customer_name", length = 80, nullable = false)
  39.     private String customerName;
  40.     /**
  41.      * 产品
  42.      */
  43.     @OneToMany(cascade = CascadeType.ALL)
  44.     @JoinTable(name = "trans_order_product", joinColumns = {@JoinColumn(name = "trans_order_id")}, inverseJoinColumns = {@JoinColumn(name = "product_id")})
  45.     private Set<OrderProduct> prdoucts;
  46.     /**
  47.      * 其实地址
  48.      */
  49.     @Column(name = "start_address", length = 80, nullable = false)
  50.     private String startAddress;
  51.     /**
  52.      * 目的地址
  53.      */
  54.     @Column(name = "end_address", length = 80, nullable = false)
  55.     private String endAddress;
  56.     /**
  57.      * 运输日期
  58.      */
  59.     @Column(name = "trans_date", nullable = false)
  60.     @Temporal(javax.persistence.TemporalType.DATE)
  61.     private Date transportationDate;
  63.     public TransOrder() {
  64.     }
  66.     public TransOrder(String customerNO, String customerName, Set<OrderProduct> prdoucts, String startAddress, String endAddress, Date transportationDate) {
  67.         setCustomerNO(customerNO);
  68.         setCustomerName(customerName);
  69.         setPrdoucts(prdoucts);
  70.         setStartAddress(startAddress);
  71.         setEndAddress(endAddress);
  72.         setTransportationDate(transportationDate);
  73.     }
  75.     public Date getTransportationDate() {
  76.         return transportationDate;
  77.     }
  79.     public void setTransportationDate(Date transportationDate) {
  80.         this.transportationDate = transportationDate;
  81.     }
  83.     public String getCustomerNO() {
  84.         return customerNO;
  85.     }
  87.     public void setCustomerNO(String customerNO) {
  88.         this.customerNO = customerNO;
  89.     }
  91.     public Long getId() {
  92.         return id;
  93.     }
  95.     public void setId(Long id) {
  96.         this.id = id;
  97.     }
  99.     public Set<OrderProduct> getPrdoucts() {
  100.         return prdoucts;
  101.     }
  103.     public void setPrdoucts(Set<OrderProduct> prdoucts) {
  104.         this.prdoucts = prdoucts;
  105.     }
  107.     public String getCustomerName() {
  108.         return customerName;
  109.     }
  111.     public void setCustomerName(String customerName) {
  112.         this.customerName = customerName;
  113.     }
  115.     public String getEndAddress() {
  116.         return endAddress;
  117.     }
  119.     public void setEndAddress(String endAddress) {
  120.         this.endAddress = endAddress;
  121.     }
  123.     public String getStartAddress() {
  124.         return startAddress;
  125.     }
  127.     public void setStartAddress(String startAddress) {
  128.         this.startAddress = startAddress;
  129.     }
  131.     @Override
  132.     public boolean equals(Object obj) {
  133.         if (obj == null) {
  134.             return false;
  135.         }
  136.         if (getClass() != obj.getClass()) {
  137.             return false;
  138.         }
  139.         final TransOrder other = (TransOrder) obj;
  140.         if ((this.customerNO == null) ? (other.customerNO != null) : !this.customerNO.equals(other.customerNO)) {
  141.             return false;
  142.         }
  143.         if ((this.customerName == null) ? (other.customerName != null) : !this.customerName.equals(other.customerName)) {
  144.             return false;
  145.         }
  146.         if (this.prdoucts != other.prdoucts && (this.prdoucts == null || !this.prdoucts.equals(other.prdoucts))) {
  147.             return false;
  148.         }
  149.         if ((this.startAddress == null) ? (other.startAddress != null) : !this.startAddress.equals(other.startAddress)) {
  150.             return false;
  151.         }
  152.         if ((this.endAddress == null) ? (other.endAddress != null) : !this.endAddress.equals(other.endAddress)) {
  153.             return false;
  154.         }
  155.         if (this.transportationDate != other.transportationDate && (this.transportationDate == null || !this.transportationDate.equals(other.transportationDate))) {
  156.             return false;
  157.         }
  158.         return true;
  159.     }
  161.     @Override
  162.     public int hashCode() {
  163.         int hash = 3;
  164.         hash = 79 * hash + (this.customerNO != null ? this.customerNO.hashCode() : 0);
  165.         hash = 79 * hash + (this.customerName != null ? this.customerName.hashCode() : 0);
  166.         hash = 79 * hash + (this.prdoucts != null ? this.prdoucts.hashCode() : 0);
  167.         hash = 79 * hash + (this.startAddress != null ? this.startAddress.hashCode() : 0);
  168.         hash = 79 * hash + (this.endAddress != null ? this.endAddress.hashCode() : 0);
  169.         hash = 79 * hash + (this.transportationDate != null ? this.transportationDate.hashCode() : 0);
  170.         return hash;
  171.     }
  172. }

 

先要使用Hibernate对其进行映射，由于产生了中间表，所以它的配置文件有些不同，如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  3. <hibernate-mapping>
  4.     <class name="com.yunda.dao.domain.Product" table="yunda_product">
  5.         <id name="id" type="long">
  6.             <generator class="native"/>
  7.         </id>
  8.         <property name="name" column="p_name" type="string" length="80" not-null="true"/>
  9.         <property name="type" column="p_type" type="string" length="80" not-null="true"/>
  10.         <property name="quantity" column="p_quantity" type="integer" length="80" not-null="true"/>
  11.         <!-- 使用join来配置多对一的连接,以table属性来表示连接表的多对一，连接表为stock_order_id -->
  12.         <!-- optional属性表示这是一个外连接,inverse属性可以出现在一端和多端，这里选择出现在多端，效果相同 -->
  13.         <join table="stock_order_product" optional="true" inverse="true">
  14.             <!-- 该key的字段为连接表中的字段，作为外键 -->
  15.             <key column="product_id" />
  16.             <!-- 连接表中配置多对一，对应的字段为stock_order_id -->
  17.             <many-to-one name="stockOrder" column="stock_order_id" not-null="true" />
  18.         </join>
  19.         <!-- 使用join来配置多对一的连接,以table属性来表示连接表的多对一，连接表为trans_order_id -->
  20.         <!-- optional属性表示这是一个外连接,inverse属性可以出现在一端和多端，这里选择出现在多端，效果相同 -->
  21.         <join table="trans_order_product" optional="true" inverse="true">
  22.             <!-- 该key的字段为连接表中的字段，作为外键 -->
  23.             <key column="product_id" />
  24.             <!-- 连接表中配置多对一，对应的字段为trans_order_id -->
  25.             <many-to-one name="transOrder" column="trans_order_id" not-null="true" />
  26.         </join>
  27.     </class>
  28. </hibernate-mapping>

 

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  3. <hibernate-mapping>
  4.     <class name="com.yunda.dao.domain.StockOrder" table="stock_order">
  5.         <id name="id" type="long">
  6.             <generator class="native"/>
  7.         </id>
  8.         <property name="customerNO" column="customer_no" type="string" length="20" not-null="true"/>
  9.         <property name="customerName" column="customer_name" type="string" length="80" not-null="true"/>
  10.         <property name="arrivalDate" column="arrival_date" type="date" not-null="true"/>
  11.         <!-- 通过连接表的一端，因此需要table属性为stock_order_product -->
  12.         <set name="prdoucts" cascade="all" table="stock_order_product" lazy="false">
  13.             <!-- 该key的字段为连接表中的字段，作为外键 -->
  14.             <key column="stock_order_id" />
  15.             <!-- 配置多对多 -->
  16.             <!-- 但是unique属性为true,表示product_id字段为不可重复,保证一对多关系 -->
  17.             <many-to-many class="com.yunda.dao.domain.Product" column="product_id" unique="true" />
  18.         </set>
  19.     </class>
  20. </hibernate-mapping>

 

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  3. <hibernate-mapping>
  4.     <class name="com.yunda.dao.domain.TransOrder" table="trans_order">
  5.         <id name="id" type="long">
  6.             <generator class="native"/>
  7.         </id>
  8.         <property name="customerNO" column="customer_no" type="string" length="20" not-null="true"/>
  9.         <property name="customerName" column="customer_name" type="string" length="80" not-null="true"/>
  10.         <property name="startAddress" column="start_address" type="string" length="80" not-null="true"/>
  11.         <property name="endAddress" column="end_address" type="string" length="80" not-null="true"/>
  12.         <property name="transportationDate" column="trans_date" type="date" not-null="true"/>
  13.         <!-- 通过连接表的一端，因此需要table属性为stock_order_product -->
  14.         <set name="prdoucts" cascade="all" table="trans_order_product" lazy="false">
  15.             <!-- 该key的字段为连接表中的字段，作为外键 -->
  16.             <key column="trans_order_id" />
  17.             <!-- 配置多对多 -->
  18.             <!-- 但是unique属性为true,表示product_id字段为不可重复,保证一对多关系 -->
  19.             <many-to-many class="com.yunda.dao.domain.Product" column="product_id" unique="true" />
  20.         </set>
  21.     </class>
  22. </hibernate-mapping>

 

这篇关于Hibernate和JPA使用连接表处理多对一映射的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/339650。

相关文章

Java使用Thumbnailator库实现图片处理与压缩功能

Java使用Thumbnailator库实现图片处理与压缩功能

《Java使用Thumbnailator库实现图片处理与压缩功能》Thumbnailator是高性能Java图像处理库,支持缩放、旋转、水印添加、裁剪及格式转换,提供易用API和性能优化,适合Web应... 目录1. 图片处理库Thumbnailator介绍2. 基本和指定大小图片缩放功能2.1 图片缩放的
阅读更多...
Python使用Tenacity一行代码实现自动重试详解

Python使用Tenacity一行代码实现自动重试详解

《Python使用Tenacity一行代码实现自动重试详解》tenacity是一个专为Python设计的通用重试库,它的核心理念就是用简单、清晰的方式,为任何可能失败的操作添加重试能力,下面我们就来看... 目录一切始于一个简单的 API 调用Tenacity 入门：一行代码实现优雅重试精细控制：让重试按我
阅读更多...
MySQL中EXISTS与IN用法使用与对比分析

MySQL中EXISTS与IN用法使用与对比分析

《MySQL中EXISTS与IN用法使用与对比分析》在MySQL中,EXISTS和IN都用于子查询中根据另一个查询的结果来过滤主查询的记录,本文将基于工作原理、效率和应用场景进行全面对比... 目录一、基本用法详解1. IN 运算符2. EXISTS 运算符二、EXISTS 与 IN 的选择策略三、性能对比
阅读更多...
Redis客户端连接机制的实现方案

Redis客户端连接机制的实现方案

《Redis客户端连接机制的实现方案》本文主要介绍了Redis客户端连接机制的实现方案,包括事件驱动模型、非阻塞I/O处理、连接池应用及配置优化,具有一定的参考价值,感兴趣的可以了解一下... 目录1. Redis连接模型概述2. 连接建立过程详解2.1 连php接初始化流程2.2 关键配置参数3. 最大连
阅读更多...
使用Python构建智能BAT文件生成器的完美解决方案

使用Python构建智能BAT文件生成器的完美解决方案

《使用Python构建智能BAT文件生成器的完美解决方案》这篇文章主要为大家详细介绍了如何使用wxPython构建一个智能的BAT文件生成器,它不仅能够为Python脚本生成启动脚本,还提供了完整的文... 目录引言运行效果图项目背景与需求分析核心需求技术选型核心功能实现1. 数据库设计2. 界面布局设计3
阅读更多...
使用IDEA部署Docker应用指南分享

使用IDEA部署Docker应用指南分享

《使用IDEA部署Docker应用指南分享》本文介绍了使用IDEA部署Docker应用的四步流程：创建Dockerfile、配置IDEADocker连接、设置运行调试环境、构建运行镜像,并强调需准备本... 目录一、创建 dockerfile 配置文件二、配置 IDEA 的 Docker 连接三、配置 Do
阅读更多...
Android Paging 分页加载库使用实践

Android Paging 分页加载库使用实践

《AndroidPaging分页加载库使用实践》AndroidPaging库是Jetpack组件的一部分,它提供了一套完整的解决方案来处理大型数据集的分页加载,本文将深入探讨Paging库... 目录前言一、Paging 库概述二、Paging 3 核心组件1. PagingSource2. Pager3.
阅读更多...
python使用try函数详解

python使用try函数详解

《python使用try函数详解》Pythontry语句用于异常处理,支持捕获特定/多种异常、else/final子句确保资源释放,结合with语句自动清理,可自定义异常及嵌套结构,灵活应对错误场景... 目录try 函数的基本语法捕获特定异常捕获多个异常使用 else 子句使用 finally 子句捕获所
阅读更多...
C++11右值引用与Lambda表达式的使用

C++11右值引用与Lambda表达式的使用

《C++11右值引用与Lambda表达式的使用》C++11引入右值引用,实现移动语义提升性能,支持资源转移与完美转发；同时引入Lambda表达式,简化匿名函数定义,通过捕获列表和参数列表灵活处理变量... 目录C++11新特性右值引用和移动语义左值 / 右值常见的左值和右值移动语义移动构造函数移动复制运算符
阅读更多...
Python对接支付宝支付之使用AliPay实现的详细操作指南

Python对接支付宝支付之使用AliPay实现的详细操作指南

《Python对接支付宝支付之使用AliPay实现的详细操作指南》支付宝没有提供PythonSDK,但是强大的github就有提供python-alipay-sdk,封装里很多复杂操作,使用这个我们就... 目录一、引言二、准备工作2.1 支付宝开放平台入驻与应用创建2.2 密钥生成与配置2.3 安装ali
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2