hibernate的关联关系（一对多）及各异常的解决方法

最新推荐文章于 2023-01-15 08:33:05 发布
最新推荐文章于 2023-01-15 08:33:05 发布
阅读量335 收藏
点赞数 1
文章标签： hibernate 数据库 mysql java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/men_ma/article/details/107607142
版权

转载请标明出处：https://blog.csdn.net/men_ma/article/details/106847165.
本文出自 不怕报错 就怕不报错的小猿猿 的博客

hibernate的关联关系（一对多）及各异常的解决方法

前言

博主前面的博客有说过hibernate是一个OM框架，它的核心思想是以面向对象的思想去操作数据库，在表与表之间存在关系，因为有的有外键，如果是多对多的关系，那么表与表之间有一个中间表，那么它是不是要利用hibernate的框架源来进行一个描述，这个描述呢就是我们的关联，在maven项目基础上实现这个关联关系

本次目标

对两张关联表进行级联增加、级联删除及懒加载查询，结果及编码过程如下步骤

1.什么是关联（association）

关联指的是类之间的引用关系。如果类A与类B关联，那么被引用的类B将被定义为类A的属性
例如：

class B{
private String name;
private List bs = new arraylist();
}
public class A{
private B b = new B;
public A(){}
}

2.关联的分类

种类
一对一
一对多/多对一
多对多

关联是有方向的：可以理解为在A类中有类B，在B类中有类A，比如一个订单中有多个订单项，在订单项中有一个订单

3.需要用到的类介绍（基于maven项目之上）

在这里插入图片描述

4.用到的数据库中的表字段及实体类

订单表（t_hibernate_order）的数据库列字段：
在这里插入图片描述
实体类–》表
属性–》字段
订单表Order.java实体类：

/**
 * 数据库订单表的实体类
 * @author Administrator
 *2020年7月26日16:40:14
 */
public class Order {
	
	private Integer orderId;
	private String orderNo;
	private List<OrderItem> orderItems=new ArrayList<>();//多个订单项，与订单项表建立关系
	private Integer ininChildren=1;//1代表开启懒加载，0代表关闭懒加载
	public Integer getIninChildren() {
		return ininChildren;
	}
	public void setIninChildren(Integer ininChildren) {
		this.ininChildren = ininChildren;
	}
	public Integer getOrderId() {
		return orderId;
	}
	public List<OrderItem> getOrderItems() {
		return orderItems;
	}
	public void setOrderItems(List<OrderItem> orderItems) {
		this.orderItems = orderItems;
	}
	public void setOrderId(Integer orderId) {
		this.orderId = orderId;
	}
	public String getOrderNo() {
		return orderNo;
	}
	public void setOrderNo(String orderNo) {
		this.orderNo = orderNo;
	}
	public Order(Integer orderId, String orderNo) {
		super();
		this.orderId = orderId;
		this.orderNo = orderNo;
	}
	public Order() {
		super();
	}
	@Override
	public String toString() {
		return "Order [orderId=" + orderId + ", orderNo=" + orderNo + ", orderItems=" + orderItems + "]";
	}
	
	
}

订单项表（t_hibernate_order_item）的数据库列字段：
在这里插入图片描述
实体类–》表
属性–》字段
订单项表OrderItem.java实体类：

/**
 * 数据库订单项的实体类
 * @author 晴sister
 *2020年7月26日16:44:12
 */
public class OrderItem {
		
	private Integer orderItemId;
	private Integer productId;
	private Integer quantity;
	private Integer oid;
	private Order order;//一个订单，与订单表建立关系
	public Order getOrder() {
		return order;
	}
	public void setOrder(Order order) {
		this.order = order;
	}
	public Integer getOrderItemId() {
		return orderItemId;
	}
	public void setOrderItemId(Integer orderItemId) {
		this.orderItemId = orderItemId;
	}
	public Integer getProductId() {
		return productId;
	}
	public void setProductId(Integer productId) {
		this.productId = productId;
	}
	public Integer getQuantity() {
		return quantity;
	}
	public void setQuantity(Integer quantity) {
		this.quantity = quantity;
	}
	public Integer getOid() {
		return oid;
	}
	public void setOid(Integer oid) {
		this.oid = oid;
	}
	@Override
	public String toString() {
		return "OrderItem [orderItemId=" + orderItemId + ", productId=" + productId + ", quantity=" + quantity
				+ ", oid=" + oid + ", order=" + order + "]";
	}
	public OrderItem(Integer orderItemId, Integer productId, Integer quantity, Integer oid) {
		super();
		this.orderItemId = orderItemId;
		this.productId = productId;
		this.quantity = quantity;
		this.oid = oid;
	}
	public OrderItem() {
		super();
	}
}

4.代码实现

4.1 三大配置文件（一个实体类对应一个配置文件，再加上主配置文件，各配置文件中注释打的比较详细了）

订单类的配置文件（Order.hbm.xml）：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.xiaoqing.three.entity.Order" table="t_hibernate_order">
		<id name="orderId" type="java.lang.Integer" column="order_id">
			<generator class="increment" />
		</id>
		<property name="orderNo" type="java.lang.String" column="order_no">
		</property>
		<!-- 需要在映射文件中进行关联关系的维护  这里描述的是一对多的关系：一个订单中有多个订单项  -->
		<!-- 不同的集合用不同的标签： 
			list集合：<bag>
			set集合：<set>
		-->
		 <!-- lazy="false"：是否加载懒加载
		 	   name:映射文件实体类的集合属性
		 	  cascade：标明级联操作
		 	  inverse：是否执行级联操作
		  --> 
		<bag lazy="false" name="orderItems" cascade="save-update" inverse="true">
		<!--column：从表的外键  -->
			<key column="oid"></key>
			<!-- 查询从表数据，然后形成list集合填充到orderItem属性中 -->
			<one-to-many class="com.xiaoqing.three.entity.OrderItem"/>
			<!--
				从上配置可以得到sql语句为
					select * from t_hibernate_order_item where oid=1
			  -->
		</bag>
	</class>

</hibernate-mapping>

订单项类的配置文件（OrderItem.hbm.xml）：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.xiaoqing.three.entity.OrderItem" table="t_hibernate_order_item">
		<id name="orderItemId" type="java.lang.Integer" column="order_item_id">
			<generator class="increment" />
		</id>
		<property name="productId" type="java.lang.Integer" column="product_id">
		</property>
		<property name="quantity" type="java.lang.Integer" column="quantity">
		</property>
		<property name="oid" type="java.lang.Integer" column="oid" insert="false" update="false">
		</property>
		
		<!-- 需要在映射文件中进行关联关系的维护  这里描述的是多对一的关系 ：多个订单项只有一个订单 -->
		<!-- Repeated column in mapping for entity: com.xiaoqing.three.entity.OrderItem column: oid (should be mapped with insert="false" update="false") -->
		<many-to-one name="order" class="com.xiaoqing.three.entity.Order" column="oid">
		
		</many-to-one>
		
	</class>
</hibernate-mapping>

主配置文件（hibernate.cfg.xml）：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

	
	<hibernate-configuration>
		<session-factory>
				<!-- 1. 数据库相关 -->
			<!-- |||| -->
			<!-- 连接账户名称 -->
			<property name="connection.username">root</property>
			<!-- 连接账户密码 -->
			<property name="connection.password">123</property>
			<!-- 连接的绝对路径 -->
			<property name="connection.url">jdbc:mysql://localhost:3306/t243?useUnicode=true&amp;characterEncoding=UTF-8&amp;userSSL=false</property>
			<!-- 驱动的绝对路径 -->
			<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
			<!-- 数据库方言配置 -->
			<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
	
			<!-- 配置本地事务（No CurrentSessionContext configured!）
				这个属性的作用:这样配置是本地jdbc事务配置,你通过getCurrentSession创建的session会绑定到当前线程
			 -->
			<property name="hibernate.current_session_context_class">thread</property>
	
			<!-- 2. 调试相关 -->
			<!-- show_sql:hibernate 运行过程是否展示自动生成的SQL代码 -->
			<property name="show_sql">true</property>
			<!-- format_sql:是否规范化输出SQL代码  -->
			<property name="format_sql">true</property>
			
			<!-- 3. 添加实体映射文件 -->
			<mapping resource="com/xiaoqing/one/entity/User.hbm.xml"/>
			<!--主键生成策略  -->
			<mapping resource="com/xiaoqing/two/entity/Student.hbm.xml"/>
			<mapping resource="com/xiaoqing/two/entity/Worker.hbm.xml"/>
			<!--一对多关联关系  -->
			<mapping resource="com/xiaoqing/three/entity/Order.hbm.xml"/>
			<mapping resource="com/xiaoqing/three/entity/OrderItem.hbm.xml"/>
		</session-factory>
	</hibernate-configuration>

4.2 DemoDao.java:操作数据库的增删改查

public class DemoDao {
	/**
	 * 为了测试关系型映射文件配置准确
	 * 	讲解insert=false，update=false的用途
	 * @param order
	 * @return
	 */
	public Integer addOrder(Order order) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Integer oid = (Integer)session.save(order);
		transaction.commit();
		session.close();
		return oid;
	}
	
	public Integer addOrderItem(OrderItem orderItem) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Integer otid = (Integer)session.save(orderItem);
		transaction.commit();
		session.close();
		return otid;
	}
	
	
	
	/**
	 * 为了讲解懒加载的问题（hibernate3.0后所有查询方式默认采用的是懒加载方式）
	 * 	1、查单个时存在问题，代理对象已经关闭
	 * 	2、查多个存在问题，有性能的问题
	 * @param order
	 * @return
	 */
	public Order getOrder(Order order) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Order o = session.get(Order.class, order.getOrderId());
		if(o != null && new Integer(0).equals(order.getIninChildren())) {
//			0带不了程序员想要关闭懒加载，也就意味着需要强制关联关系对象
			Hibernate.initialize(o.getOrderItems());
//			System.out.println(o.getOrderItems());
		}
		transaction.commit();
		session.close();
		return o;
	}
	
	public List<Order> getOrderList() {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		List<Order> list = session.createQuery("from Order").list();
		transaction.commit();
		session.close();
		return list;
	}
	
	/**
	 * z主表的数据不能随便删除，得先删除从表中对应信息，才能删除主表的信息。
	 * @param order
	 */
	public void delOrder(Order order) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Order order2 = session.get(Order.class, order.getOrderId());
		for (OrderItem oi : order2.getOrderItems()) {
			session.delete(oi);
		}
		session.delete(order2);
//		session.delete(order);
		transaction.commit();
		session.close();
	}
}

4.3 Junit测试DemoDaoTest.java类

public class DemoDaoTest {
	private DemoDao demoDao=new DemoDao();

	@Test
	public void testAddOrder() {
		Order order=new Order();
		order.setOrderNo("T243");
		OrderItem oi=null;
		for(int i=0;i<3;i++) {
			oi=new OrderItem();
			oi.setProductId(10+i);
			oi.setQuantity(20+i);
			oi.setOrder(order);
			order.getOrderItems().add(oi);
		}
		demoDao.addOrder(order);
	}

	@Test
	public void testAddOrderItem() {
		Order order=new Order();
		order.setOrderId(8);
		OrderItem oi=null;
		for(int i=0;i<3;i++) {
			oi=new OrderItem();
			oi.setProductId(10+i);
			oi.setQuantity(20+i);
			oi.setOrder(order);
			order.getOrderItems().add(oi);
			demoDao.addOrderItem(oi);
		}
		
	}
	
	/**
	 * 关于懒加载的问题
	 * hibernate 之后出现的
	 * 
	 * 异常：failed to lazily initialize a collection of role: 
	 * com.xiaoqing.three.entity.Order.orderItems,
	 *  could not initialize proxy - no Session
	 * 
	 * orderNo数据来源于t_hibernate_order
	 * orderItems 数据来源于t_hibernate_order_item
	 * 
	 * 思考：
	 * 	查一张表的效率高还是两张？
	 * 一张
	 * 
	 * hibernate默认的策略 ：是不查询关联关系对应关联表的数据
	 * 
	 */

	@Test
	public void testGetOrder() {
		Order order=new Order();
		order.setOrderId(10);
		order.setIninChildren(0);
		Order o = this.demoDao.getOrder(order);
		System.out.println(o.getOrderNo());
		System.out.println(o.getOrderItems());
	}
	
	/**
	 * 如果说将懒加载的功能关闭，也就是lazy=false,那么在查询多条订单数的情况下是非常影响性能的
	 * 
	 * 思考：
	 * 		查单个需要关闭懒加载  目的是需要加载出关联表的数据
	 * 		查多个不能关闭懒加载  加载关联表的数据的查询次数过多
	 */
	
	@Test
	public void testGetOrderList() {
		List<Order> orderList = this.demoDao.getOrderList();
		for (Order order : orderList) {
			System.out.println(order.getOrderNo());
//			System.out.println(order.getOrderItems());
		}
	}

	@Test
	public void testDelOrder() {
		Order order=new Order();
		order.setOrderId(5);
		this.demoDao.delOrder(order);
	}

}

4.3.1 Junit测试testAddOrder()增加订单的结果

@Test
	public void testAddOrder() {
		Order order=new Order();
		order.setOrderNo("T243");
		OrderItem oi=null;
		for(int i=0;i<3;i++) {
			oi=new OrderItem();
			oi.setProductId(10+i);
			oi.setQuantity(20+i);
			oi.setOrder(order);
			order.getOrderItems().add(oi);
		}
		demoDao.addOrder(order);
	}

在这里插入图片描述
在这里插入图片描述
数据库中的数据结果：
在这里插入图片描述
在这里插入图片描述

4.3.2 Junit测试testAddOrderItem()增加订单项的结果

	@Test
	public void testAddOrderItem() {
		Order order=new Order();
		order.setOrderId(8);
		OrderItem oi=null;
		for(int i=0;i<3;i++) {
			oi=new OrderItem();
			oi.setProductId(10+i);
			oi.setQuantity(20+i);
			oi.setOrder(order);
			order.getOrderItems().add(oi);
			demoDao.addOrderItem(oi);
		}
		
	}

在这里插入图片描述

4.3.2 Junit测试testGetOrder()查询订单的结果（懒加载）

	/**
	 * 关于懒加载的问题
	 * hibernate 之后出现的
	 * 
	 * 异常：failed to lazily initialize a collection of role: 
	 * com.xiaoqing.three.entity.Order.orderItems,
	 *  could not initialize proxy - no Session
	 * 
	 * orderNo数据来源于t_hibernate_order
	 * orderItems 数据来源于t_hibernate_order_item
	 * 
	 * 思考：
	 * 	查一张表的效率高还是两张？
	 * 一张
	 * 
	 * hibernate默认的策略 ：是不查询关联关系对应关联表的数据
	 * 
	 */

	@Test
	public void testGetOrder() {
		Order order=new Order();
		order.setOrderId(10);
		order.setIninChildren(1);//1代表开启懒加载，0代表关闭懒加载
		Order o = this.demoDao.getOrder(order);
		System.out.println(o.getOrderNo());
		System.out.println(o.getOrderItems());
	}

在这里插入图片描述

4.3.3 Junit测试testGetOrderList()查询订单项的结果（懒加载）

	/**
	 * 如果说将懒加载的功能关闭，也就是lazy=false,那么在查询多条订单数的情况下是非常影响性能的
	 * 
	 * 思考：
	 * 		查单个需要关闭懒加载  目的是需要加载出关联表的数据
	 * 		查多个不能关闭懒加载  加载关联表的数据的查询次数过多
	 */
	
	@Test
	public void testGetOrderList() {
		List<Order> orderList = this.demoDao.getOrderList();
		for (Order order : orderList) {
			System.out.println(order.getOrderNo());
//			System.out.println(order.getOrderItems());
		}
	}

在这里插入图片描述

4.3.4 Junit测试testDelOrder()删除订单项的结果（先删从表的数据再删主表）


	@Test
	public void testDelOrder() {
		Order order=new Order();
		order.setOrderId(8);
		this.demoDao.delOrder(order);
	}

在这里插入图片描述

数据库中的结果：
在这里插入图片描述
在这里插入图片描述

5.在本次编码中常见的一些异常及解决办法

5.1 异常1：Repeated column in mapping for entity: com.xiaoqing.three.entity.OrderItem column: oid (should be mapped with insert=“false” update=“false”)

解决方式：
在这里插入图片描述

5.2 异常2：Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException: Column ‘oid’ cannot be null

解决方式：
在这里插入图片描述

5.3 异常3：No CurrentSessionContext configured!

解决方式：在主配置hibernate.cfg.xml文件中配置数据库的方言后面加上一行代码

在这里插入图片描述

不怕报错 就怕不报错的小猿猿
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
Spark的五种JOIN策略解析
jmx_bigdata的博客
11-03 1553
JOIN操作是非常常见的数据处理操作，Spark作为一个统一的大数据处理引擎，提供了非常丰富的JOIN场景。本文分享将介绍Spark所提供的5种JOIN策略，希望对你有所帮助。本文主要包括以下内容： 影响JOIN操作的因素 Spark中JOIN执行的5种策略 Spark是如何选择JOIN策略的 影响JOIN操作的因素 数据集的大小 参与JOIN的数据集的大小会直接影响Join操作的执行效率。同样，也会影响JOIN机制的选择和JOIN的执行效率。 JOIN的条件 JOIN的条件会涉及字段之间的逻辑比较。根
java Hibernate 一对多自身关联问题
09-06
在问题描述中，我们遇到的是一个关于Hibernate一对多自身关联的问题，特别是在Struts框架中使用FormBean时出现的异常行为。 首先，让我们来理解一下问题的核心部分。在Struts中，FormBean默认的Scope是Session，这...
Hibernate 一对多配置 级联操作(级联失败问题分析解决)
weixin_33843409的博客
03-16 190
一方： package com.xdfstar.domain; import java.io.Serializable;import java.util.Date;import java.util.HashSet;import java.util.Set; /** * Title. <br> * Description. * <p&gt...
hibernate错误集合
whd51的博客
01-17 176
hibernate错误集合 1.表名没对映射文件应出错：Could not locate field nor getter method for property named 2.数据库配置出错 ：Unable to make JDBC Connection 3.实体类里面多对多集合:new HashSet&amp;lt;User&amp;gt;();:Could not get constructor for ...
replicate join的实现
最新发布
stable_zl的博客
01-15 153
本文介绍了基于复制算法的Join优化的实现
Hadoop MapReduce进阶 使用分布式缓存进行replicated join
jokes000的专栏
12-19 7076
概念： reduce-side join技术是灵活的，但是有时候它仍然会变得效率极低。由于join直到reduce()阶段才会开始，我们将会在网络中传递shuffle所有数据，而在大多数情况下，我们会在join阶段丢掉大多数传递的数据。因此我们期望能够在map阶段完成整个join操作。 主要技术难点： 在map阶段完成join的主要困难就是mapper可能需要与一个它自己不能获得的数据进行j
Hibernate双向一对一关联映射(注解版)
05-05
本主题聚焦于“Hibernate双向一对一关联映射”的注解实现，这是一种高级的数据库设计模式，用于处理两个实体之间一对一的关系。 在Hibernate中，一对一关联映射分为单向和双向。单向一对一映射通常涉及一个实体持有...
Hibernate 一对一关联查询.docx
06-19
在Java的持久化框架Hibernate中，一对一（One-to-One）关联查询是一种常见的关系映射方式，用于表示两个实体之间一对一的依赖关系。这种关联通常在数据库中通过外键或者主键来实现。本文将深入探讨基于外键的一对一...
hibernate一对多关联映射（双向关联）
03-01
在Java的持久化框架Hibernate中，一对多关联映射是一种常见的关系映射方式，它用于表示一个实体（如用户）可以拥有多个子实体（如订单）的情况。在本篇文章中，我们将深入探讨如何实现双向关联的一对多映射，以及在...
hibernate开发一对多和多对一的坑1
08-08
在使用Hibernate进行Java对象关系映射（ORM）开发时，经常会遇到一对多和多对一关系的处理。这些关系在数据库中很常见，比如一个部门可以有多名员工，而每个员工则隶属于一个部门。在本篇文章中，我们将深入探讨在...
Hibernate 多对一连接表单向关联
09-15
在Java的持久化框架Hibernate中，多对一（ManyToOne）关联是常见的关系映射类型，它代表一个实体可以与多个另一个实体相关联。在这种关系中，通常一个实体（"一"端）拥有多个实例，而另一个实体（"多"端）只能对应一...
hibernate03:多对一单向关联、多对一双向关联
08-12
本文主要探讨的是Hibernate中的两种关联关系：多对一单向关联和多对一双向关联。通过理解这两种关联方式，我们可以更好地设计和实现复杂的数据库模型。 首先，我们来看**多对一单向关联**。这种关联意味着一个实体...
传智播客hibernate教程_保存多对一关联关系的更进一步分析
10-26
本教程“传智播客hibernate教程_保存多对一关联关系的更进一步分析”深入探讨了如何在Hibernate中处理多对一的关联关系。这种关联意味着一个实体（多方）可以与多个其他实体（一方）相关联，而每个其他实体只与一个...
hibernate核心,一对多,多对多映射讲解,看了就完全搞明白了
05-30
在本章中，我们将深入探讨Hibernate中的关联映射，包括一对多、多对一以及多对多的关系。这些映射关系对于理解如何在Java应用程序中有效地管理数据库对象至关重要。 首先，我们来解决描述中提到的问题。`...
hibernate多对多关系
10-12
在Java的持久化框架Hibernate中，多对多（Many-to-Many）关系是数据库中常见的关联类型，它表示两个实体类之间可以有多个对应的关系。例如，学生和课程就是一个典型的多对多关系，一个学生可以选修多个课程，而一个...
[Hadoop] 分布式Join : Replicated Join
RangerWolf的专栏
09-25 411
上一篇文章说的ReduceSide Join的一个缺点就是，在map方法之中，只对数据加了tag、提取了groupkey，没有做任何的数据过滤，这样在map-reduce之中的shuffle过程会造成大量的 磁盘IO使得效率降低。   这次使用的是Replicated Join，完成的任务跟上次一样. 它有一个前提：需要关联在一起的两个文件，其中一个文件比较小，至少能放到内存之中。   ...
每个 Spark 工程师都应该知道的五种 Join 策略
过往记忆大数据
09-13 4569
数据分析中将两个数据集进行 Join 操作是很常见的场景。在 Spark 的物理计划（physical plan）阶段，Spark 的 JoinSelection 类会根据 Join h...
REPLICATE函数的一种用法
weixin_30378623的博客
03-18 2103
假设有以下需求：对Production.Suppliers的每个供应商的整数ID生成一个10位数字的字符串，不足10位时前面补0补足10位。 1 SELECT supplierid, 2 RIGHT(REPLICATE('0', 9) + CAST(supplierid AS VARCHAR(10)), 3 10) AS strsupplierid 4 FROM P...
Hibernate4.3在开发中的一些异常总结（持续更新）
武哥聊编程
04-28 3494
这篇文章主要是记录Hibernate在开发中所出现的异常，方便以后查看~ 1.java.lang.NoSuchMethodError:javax.persistence.Table.indexes()[Ljavax/persistence/Index         这个异常是我在对实体类使用注解的时候发生的。从名称上看，是Hibernate做持久化的时候出现的异常，没有指定的方法，而且出现在
Hibernate映射多对多关联关系详解
"这篇资料主要介绍了在Hibernate框架中如何映射多对多关联关系，并提到了hbm2ddl.auto的四个取值含义以及1-1关联的延迟加载策略。" 在Java开发中，Hibernate是一个非常流行的持久化框架，它简化了数据库操作。在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值