Hibernate关联关系

最新推荐文章于 2024-07-21 16:40:08 发布
最新推荐文章于 2024-07-21 16:40:08 发布
阅读量99 收藏
点赞数
分类专栏： Hibernate 文章标签： hibernate struts spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53151031/article/details/120841343
版权

目录

一、一对多的配置

二、懒加载

三、一对多的自关联

四、多对多的配置

一、一对多的配置：

          一对多的配置就是一个对应多个，例如：在订单表和订单项表中，一个订单有多个订单项，但是一个订单项只对应一个订单。

配置（user.hbm.xml）：

实体类：在order中包含了orderitems这个属性，就是实现一对多的路径

package com.zking.two.entity;

import java.util.HashSet;
import java.util.Set;

public class Order {
//	create table t_hibernate_order
//	(
//	  order_id int primary key auto_increment,
//	  order_no varchar(50) not null
//	);
	private Integer orderId;
	private String orderNo;
	
	//注意：变量属性一定用接口进行接受
	private Set<OrderItem> orderItems = new HashSet<>();
	
	private Integer initOrderItems = 0;//0代表懒加载，1代表强制加载
	
	
	public Integer getInitOrderItems() {
		return initOrderItems;
	}
	public void setInitOrderItems(Integer initOrderItems) {
		this.initOrderItems = initOrderItems;
	}
	public Set<OrderItem> getOrderItems() {
		return orderItems;
	}
	public void setOrderItems(Set<OrderItem> orderItems) {
		this.orderItems = orderItems;
	}
	public Integer getOrderId() {
		return orderId;
	}
	public void setOrderId(Integer orderId) {
		this.orderId = orderId;
	}
	public String getOrderNo() {
		return orderNo;
	}
	public void setOrderNo(String orderNo) {
		this.orderNo = orderNo;
	}
	
}

orderItems：

package com.zking.two.entity;

public class OrderItem {
//	create table t_hibernate_order_item
//	(
//	  order_item_id int primary key auto_increment,
//	  product_id int not null,
//	  quantity int not null,
//	  oid int not null,
//	  foreign key(oid) references t_hibernate_order(order_id)
//	);
	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;
	}
	
}

运行结果：

 

二、懒加载

         1.定义：懒加载可以这样理解，只加载某一项东西，其他的东西不会加载

         2、操作：在我们进行项目的操作时候，就会想到，当自己把订单的id查出来之后，改订单id下面的对应的订单项会不会也同样出来。

OrderItemsDao：

public class OrderDaoTest {
	private OrderDao orderDao = new OrderDao();

	/**
	 * org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.zking.two.entity.Order.orderItems, could not initialize proxy - no Session
	 * 1.正常查询
	 * 2.懒加载异常错误
	 * 3.性能调优
	 */
	@Test
	public void testGet() {
		Order order = new Order();
		order.setOrderId(7);
		order.setInitOrderItems(1);
		Order o = this.orderDao.get(order);
		System.out.println(o.getOrderNo());
		System.out.println(o.getOrderItems());
	}

会出现的懒加载错误：

代码：

public class OrderDaoTest {
	private OrderDao orderDao = new OrderDao();

	/**
	 * org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.zking.two.entity.Order.orderItems, could not initialize proxy - no Session
	 * 1.正常查询
	 * 2.懒加载异常错误
	 * 3.性能调优
	 */
	@Test
	public void testGet() {
		Order order = new Order();
		order.setOrderId(7);
		//order.setInitOrderItems(1);强行加载的代码注释
		Order o = this.orderDao.get(order);
		System.out.println(o.getOrderNo());
		System.out.println(o.getOrderItems());
	}

错误图示：

解决办法就是强行加载，或者将下面要执行代码注释掉。

三、一对多的自关联

        1、定义：一对多的自关联就好比做树形菜单的时候，就会出现一个最大的节点，下面会有很多的子节点。

        2、实操：

实体类：

package com.zking.two.entity;

import java.util.HashSet;
import java.util.Set;

public class TreeNode {
	private Integer nodeId;
	private String nodeName;
	private Integer treeNodeType;
	private Integer position;
	private String url;
	private TreeNode parent;
	private Set<TreeNode> children = new HashSet<TreeNode>();
	private Integer initChildren = 0;

	public Integer getNodeId() {
		return nodeId;
	}

	public void setNodeId(Integer nodeId) {
		this.nodeId = nodeId;
	}

	public String getNodeName() {
		return nodeName;
	}

	public void setNodeName(String nodeName) {
		this.nodeName = nodeName;
	}

	public Integer getTreeNodeType() {
		return treeNodeType;
	}

	public void setTreeNodeType(Integer treeNodeType) {
		this.treeNodeType = treeNodeType;
	}

	public Integer getPosition() {
		return position;
	}

	public void setPosition(Integer position) {
		this.position = position;
	}

	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public TreeNode getParent() {
		return parent;
	}

	public void setParent(TreeNode parent) {
		this.parent = parent;
	}

	public Set<TreeNode> getChildren() {
		return children;
	}

	public void setChildren(Set<TreeNode> children) {
		this.children = children;
	}

	public Integer getInitChildren() {
		return initChildren;
	}

	public void setInitChildren(Integer initChildren) {
		this.initChildren = initChildren;
	}

//	@Override
//	public String toString() {
//		return "TreeNode [nodeId=" + nodeId + ", nodeName=" + nodeName + ", treeNodeType=" + treeNodeType
//				+ ", position=" + position + ", url=" + url + ", children=" + children + "]";
//	}

	@Override
	public String toString() {
		return "TreeNode [nodeId=" + nodeId + ", nodeName=" + nodeName + ", treeNodeType=" + treeNodeType
				+ ", position=" + position + ", url=" + url + "]";
	}
	

}

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.zking.two.entity.TreeNode" table="t_hibernate_sys_tree_node">
		<id name="nodeId" type="java.lang.Integer" column="tree_node_id">
			<generator class="increment" />
		</id>
		<property name="nodeName" type="java.lang.String"
			column="tree_node_name">
		</property>
		<property name="treeNodeType" type="java.lang.Integer"
			column="tree_node_type">
		</property>
		<property name="position" type="java.lang.Integer"
			column="position">
		</property>
		<property name="url" type="java.lang.String"
			column="url">
		</property>
		
		<many-to-one name="parent" class="com.zking.two.entity.TreeNode" column="parent_node_id"/>
		
		<set name="children" cascade="save-update" inverse="true">
			<key column="parent_node_id"></key>
			<one-to-many class="com.zking.two.entity.TreeNode"/>
		</set>
	</class>
</hibernate-mapping>

Dao方法：

package com.zking.two.dao;

import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.zking.two.entity.TreeNode;
import com.zking.two.util.SessionFactoryUtil;

public class TreeNodeDao {
	public TreeNode load(TreeNode treeNode) {
		Session session = SessionFactoryUtil.getSession();
		Transaction transaction = session.beginTransaction();
		TreeNode t = session.load(TreeNode.class, treeNode.getNodeId());
		if(t != null && new Integer(1).equals(treeNode.getInitChildren())) {
			Hibernate.initialize(t.getChildren());
			Hibernate.initialize(t.getParent());
		}
		transaction.commit();
		session.close();
		return t;
	}
}

运行结果：

四、多对多的配置

          1、定义：多对多就好比现实生活中，一个班级有很多个老师，而那一个老师不止带一个班级，通俗点讲：多对多的配置就是两个一对多的配置。下面有一张示意图帮助理解：

 

例如T269班有两个老师，一个是胡老师，另一个是丁娜老师，而丁娜老师不止接手了T269班，还有T281、T278班。

          2、实操

entity：

package com.zking.two.entity;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

public class Book implements Serializable{
//	book_id int primary key auto_increment,
//	   book_name varchar(50) not null,
//	   price float not null
	private Integer bookId;
	private String bookName;
	private Float price;
	
	private Set<Category> categories = new HashSet<Category>();
	private Integer initCategories = 0;

	public Integer getInitCategories() {
		return initCategories;
	}

	public void setInitCategories(Integer initCategories) {
		this.initCategories = initCategories;
	}

	public Integer getBookId() {
		return bookId;
	}

	public void setBookId(Integer bookId) {
		this.bookId = bookId;
	}

	public String getBookName() {
		return bookName;
	}

	public void setBookName(String bookName) {
		this.bookName = bookName;
	}

	public Float getPrice() {
		return price;
	}

	public void setPrice(Float price) {
		this.price = price;
	}

	public Set<Category> getCategories() {
		return categories;
	}

	public void setCategories(Set<Category> categories) {
		this.categories = categories;
	}

	@Override
	public String toString() {
		return "Book [bookId=" + bookId + ", bookName=" + bookName + ", price=" + price + "]";
	}

	public Book(Integer bookId, String bookName) {
		super();
		this.bookId = bookId;
		this.bookName = bookName;
	}

	public Book() {
		super();
	}
	
	
}

package com.zking.two.entity;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

public class Category implements Serializable{
//	category_id int primary key auto_increment,
//	   category_name varchar(50) not null
	private Integer categoryId;
	private String categoryName;
	private Set<Book> books = new HashSet<Book>();
	public Integer getCategoryId() {
		return categoryId;
	}
	public void setCategoryId(Integer categoryId) {
		this.categoryId = categoryId;
	}
	public String getCategoryName() {
		return categoryName;
	}
	public void setCategoryName(String categoryName) {
		this.categoryName = categoryName;
	}
	public Set<Book> getBooks() {
		return books;
	}
	public void setBooks(Set<Book> books) {
		this.books = books;
	}
	@Override
	public String toString() {
		return "Category [categoryId=" + categoryId + ", categoryName=" + categoryName + "]";
	}
	
}

dao：

package com.zking.two.dao;

import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.zking.two.entity.Book;
import com.zking.two.entity.Category;
import com.zking.two.util.SessionFactoryUtil;


public class BookDao /*extends BaseDao*/{
	public Integer addBook(Book book) {
		Session session = SessionFactoryUtil.getSession();
		Transaction transaction = session.beginTransaction();
		Integer bid = (Integer) session.save(book);
		transaction.commit();
		session.close();
		return bid;
	}
	
	public Integer addCategory(Category category) {
		Session session = SessionFactoryUtil.getSession();
		Transaction transaction = session.beginTransaction();
		Integer cid = (Integer) session.save(category);
		transaction.commit();
		session.close();
		return cid;
	}
	
	public Category getCategory(Category category) {
		Session session = SessionFactoryUtil.getSession();
		Transaction transaction = session.beginTransaction();
		Category c = session.get(Category.class, category.getCategoryId());
		transaction.commit();
		session.close();
		return c;
	}
	
	public Book getBook(Book book) {
		Session session = SessionFactoryUtil.getSession();
		Transaction transaction = session.beginTransaction();
		Book b = session.get(Book.class, book.getBookId());
		if (b != null && new Integer(1).equals(book.getInitCategories())) {
			Hibernate.initialize(b.getCategories());
		}
		transaction.commit();
		session.close();
		return b;
	}
	
	public void delBook(Book book) {
		Session session = SessionFactoryUtil.getSession();
		Transaction transaction = session.beginTransaction();
		session.delete(book);
		transaction.commit();
		session.close();
	}
	
	public void delCategory(Category category) {
		Session session = SessionFactoryUtil.getSession();
		Transaction transaction = session.beginTransaction();
		Category c = session.get(Category.class, category.getCategoryId());
		if(c!=null) {
			for (Book b : c.getBooks()) {
//				通过在被控方通过主控方来解除关联关系，最后被控方再做删除
				b.getCategories().remove(c);
			}
		}
		session.delete(c);
		transaction.commit();
		session.close();
	}
	
	
	/*
	 * hql讲解用到（需要继承BaseDao）
	 */
	/**
	 * 没有使用BaseDao之前的代码
	 * @param book
	 * @param pageBean
	 * @return
	 */
//	public List<Book> list(Book book, PageBean pageBean) {
//		Session session = SessionFactoryUtil.getSession();
//		Transaction transaction = session.beginTransaction();
//		String hql = "from Book where 1 = 1";
//
//		if (StringUtils.isNotBlank(book.getBookName())) {
//			hql += " and bookName like :bookName";
//		}
//
//		Query query = session.createQuery(hql);
//		
//		if (StringUtils.isNotBlank(book.getBookName())) {
//			query.setParameter("bookName", book.getBookName());
//		}
//
//		if (pageBean != null && pageBean.isPagination()) {
//			query.setFirstResult(pageBean.getStartIndex());
//			query.setMaxResults(pageBean.getRows());
//		}
//		List<Book> list = query.list();
//		transaction.commit();
//		session.close();
//		return list;
//
//	}
	
	/**
	 * 使用BaseDao之后的代码
	 * @param book
	 * @param pageBean
	 * @return
	 */
//	public List<Book> list2(Book book, PageBean pageBean) {
//		Session session = SessionFactoryUtil.getSession();
//		Transaction transaction = session.beginTransaction();
//		String hql = "from Book where 1 = 1";
//		Map<String, Object> map = new HashMap<String, Object>();
//
//		if (StringUtils.isNotBlank(book.getBookName())) {
//			hql += " and bookName like :bookName";
//			map.put("bookName", book.getBookName());
//		}
//		List list = super.executeQuery(session, hql, map, pageBean);
//		transaction.commit();
//		session.close();
//		return list;
//	}
	
	/**
	 * 使用原生SQL
	 * @param book
	 * @param pageBean
	 * @return
	 */
//	public List list3(Book book, PageBean pageBean) {
		String sql = "select b.*,o.* from t_hibernate_book b,t_hibernate_Order o";
//		String sql = "select * from t_hibernate_book";
//		Session session = SessionFactoryUtil.getSession();
//		Transaction transaction = session.beginTransaction();
//		List list = session.createSQLQuery(sql).list();
//		transaction.commit();
//		session.close();
//		return list;
//	}
}

配置：

运行结果：

今天的知识就分享到这了，希望能够帮助到大家。

落日飞行
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hibernate关联关系
04-03
hibernate关联关系
批量替换项目中Hibernate的映射文件（hbm.xml），转换为注解驱动
不贪不念，不念不忘
08-28 487
前段时间公司架构调整优化，为了适应后期采用springboot，微服务的架构，需要先将项目里之前的hbm映射文件替换为注解驱动，为此写了一个批量处理的工具，但是不同项目或者hbm.xml文件的标签，属性很多，可能不是所有的都能覆盖掉，可以供参考： package com; import java.io.File; import java.io.FileOutputStream; import j...
hibernate关联关系总结
10-14
Hibernate关联关系是Java持久化框架Hibernate中的核心概念，它允许我们在数据库中建立对象之间的关系映射，以便在程序中操作对象时，可以自动处理与数据库的交互。本篇将深入探讨Hibernate的四种主要关联关系：一对...
Hibernate 关联关系解除
03-25
一、Hibernate关联关系介绍 在Hibernate中，关联关系主要包括以下几种： 1. 一对一(OneToOne)：一个实体对应另一个实体的唯一实例。 2. 一对多(OneToMany)：一个实体可以与多个其他实体相关联。 3. 多对一...
hibernate关联关系实例
10-11
在这个“hibernate关联关系实例”中，我们将深入探讨四种基本的关联关系：一对一（One-to-One）、一对多（One-to-Many）、多对一（Many-to-One）以及多对多（Many-to-Many），同时也会涉及Hibernate查询语言（HQL）...
深入探索Stage #2：属性中的XSS注入技术
weixin_43822401的博客
06-04 650
在Web安全的学习旅程中，XSS（跨站脚本）注入是一个不可忽视的话题。"XSS Challenges"闯关游戏的Stage #2专为进阶学习者设计，专注于属性中的XSS注入技术。本文将详细介绍这一阶段的实操过程和关键概念。
OAuth2.0 or Spring Session or 单点登录流程
qq_53374893的博客
07-20 300
一句话精辟解释： 在过滤器放行的时候，偷偷的把原生的 request 和 response 对象换成了它的实现，也就是 调用getSession 的时候拿到的 其实是对redis 操作的Session。但其他的操作还是使用原生的，只不过重写的方法，调用的是子类的，也就是往 redis 里放入 Session，把原生的操作给替换了！分布式Session原理，使用子域名，的时候放入父域名的 JsessionId 然后将这个ID 的所存的内容放入Redis ，这样实现不同域名共享同一sessionID.
Spring纯注解开发
Admans的专栏
07-18 836
Spring3.0引入了纯注解开发的模式，框架的诞生是为了简化开发，那注解开发就是简化再简化。Spring的特性在整合MyBatis方面体现的淋漓尽致哦注解开发前，配置Bean时是在xml里将class分别写在Bean标签里，然后起id，就像这样注解开发后，配置Bean时首先将xml里的标签删掉，然后在类上添加@Component注解即可在xml文件中来写一个扫描包的注解标签，对象就装进IOC容器里了component-scan:component意为组件，scan意为扫描。
SpringBoot整合SSE，实现后端主动推送DEMO
zjy660358的专栏
07-17 376
说起服务端主动推送，大家第一个想到的一定是WEBSOCKET。作为软件工程师，不能无脑使用一种技术，要结合实际情况，择优选取。SSE（Server-Sent Events）相比于WEBSOCKET1、轻量化、兼容性 基于传统的HTTP协议，所以浏览器兼容性比较好2、 只支持单向通讯。（服务器->客户端）
SpringBoot集成EasyExcel实现模板写入多个sheet导出
LynneZoe的博客
07-18 389
SpringBoot集成EasyExcel实现模板写入多个sheet导出。
Spring3(代理模式 Spring1案例补充 Aop 面试题)
qq_52897007的博客
07-17 1231
为其他对象提供一种代理以控制对这个对象的访问。
SpringBoot new方式创建出来的类对象 @Value()注入的问题
阿潘是个程序猿的博客
07-18 327
ew方式创建出来的类对象获取springboot配置文件属性
Springboo3中使用虚线程
java scala
07-19 337
Java中的虚线程类似Go中的协程，简单来说可以通过同步编程的方式来达到异步编程模式的效果，
手写简易版Spring IOC容器02【学习】
weixin_44794897的博客
07-19 554
其中applyPropertyValues用于从beanDefinition中读取属性的配置信息然后通过BeanUtil(hutool-all中提供的类)为其赋值@Overridetry {// 创建bean实例Class<?if (null!break;// 设置属性值try {// 从beanDefinition中获取property通过Resource获取文件流。
Spring-使用
weixin_61094678的博客
07-17 325
众所周知，Spring是一个包含了众多工具的IoC容器。既然是容器就必然包含两个最基本的功能：将对象存储到容器中，从容器中将对象取出来故本篇文章 将讲述如何在Spring中，如何创建，存储，获取并使用Bean对象。
【OAuth2系列】集成微信小程序登录到 Spring Security OAuth 2.0
最新发布
c18213590220的博客
07-21 1057
本文将详细介绍如何在 Spring Security OAuth 2.0 中扩展支持微信小程序登录，通过自定义授权方式实现无缝登录。
0711springNews新闻系统管理 实现多级评论
weixin_45939821的博客
07-19 961
实现链表，通过一个父评论可以找到它对应的所有子孙评论。
Springboot项目远程部署gitee仓库（docker+Jenkins+maven+git）
wumingzei的博客
07-18 2043
首先，帮我们把构建打包好的jar包发送到目标服务器上，然后连接我们的目标服务器去执行启动项目的命令（java -jar xxx,jar > /dev/null &）！​ 修改实例代码，然后推送到远程仓库，查看Jenkins控制台的构建，第一次因为要下载相关的镜像所以会比较慢。# 这是一个坑点 ssh远程执行命令的时候，被远程机器的有些环境变量是无法获取的，比如java环境信息，所以java命令执行不出来！项目在第一次打包构建时有点慢，因为要下载相关Maven依赖，别急，去喝口水走走！
springboot助农管理系统lw源码调试讲解
u014445459的博客
07-19 830
在系统将要投入使用前，需要进行的一个必不可少的工作环节就是系统测试。测试人员通过系统测试工作，验证在系统的使用过程中，界面环境是否整洁友好，用户账号信息是否安全可靠，性能方面是否稳定健壮，功能方面是否符合用户需要等。系统测试不仅需要找出系统运行中会出现的问题，还需要分析产生这些问题的原因，并且找到解决这些问题的方法[21]。系统测试主要分为黑盒测试和白盒测试[22]。黑盒测试即功能测试，其主要是站在使用者的角度对系统进行测试。
hibernate框架关联关系映射操作
05-14
下面是一些常见的Hibernate关联关系映射操作： 1. 一对一映射：在一个实体中定义一个引用另一个实体的属性。可以使用@OneToOne注释来映射一对一关系。 2. 一对多映射：在一个实体中定义一个集合属性，该集合中存储...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值