Hibernate 一对多自关联 多对多

最新推荐文章于 2020-09-21 11:15:38 发布
最新推荐文章于 2020-09-21 11:15:38 发布
阅读量189 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hao_dream_xi/article/details/96345479
版权

Hibernate 一对多自关联 多对多

今天我们要了解的是Hibernate 一对多自关联 与 多对多 首先我们先来了解一对多

一对多：

 1.1 数据库中不能直接映射多对多
      处理：创建一个桥接表(中间表)，将一个多对多关系转换成两个一对多

      注1：数据库多表联接查询
           永远就是二个表的联接查询

           A   B   C  D
              t1   C
                   t2 D
                      t3

      注2：交叉连接
      注3：外连接：left(左)/right(右)/full(左右)
           主从表：连接条件不成立时，主表记录永远保留，与null匹配
		   
		   A	B	AB
		   select * from A,B,AB WHERE A.aID=AB.aID and b.bid = AB.bid
		   where 
		   在hibernate中，你只管查询当前表对象即可，
		   hibernate会自动关联桥表以及关联表查询出关联对象
		   
		   Book	Category Book_category
		   select * from Book b,Book_category bc,category where b.bid = bc.bid and bc.cid = c.cid
		   and bid = 2

数据库内容图片：
在这里插入图片描述
案列：
首先创建实体类（TreeNode.java:）和TreeNode.hbm.xml配置
TreeNode.java:

package com.lihao.four.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;
	//0是懒加载    1是强制加载（子节点）  2是强制加载用户    3、强制加载两个

	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 + "]";
	}
	

}

TreeNode.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.lihao.four.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.lihao.four.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.lihao.four.entity.TreeNode"/>
		</set>
	</class>
</hibernate-mapping>

然后别忘记在核心文件（hibernate.cfg.xml）配置：
hibernate.cfg.xml

	<!-- 一对多的自动关联 -->
		<mapping resource="com/lihao/four/entity/TreeNode.hbm.xml"/>

接着写dao层（TreeNodeDao：）
TreeNodeDao：

package com.lihao.four.dao;

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

import com.lihao.four.entity.TreeNode;
import com.lihao.two.util.SessionFactoryUtils;

public class TreeNodeDao {
	public TreeNode load(TreeNode treeNode) {
		Session session = SessionFactoryUtils.openSession();
		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;
	}
}

写完dao层当然就需要测试到层了就需要些一个（TreeNodeDaoTest:）类来测试
TreeNodeDaoTest:

package com.lihao.four.dao;

import org.junit.Test;

import com.lihao.four.entity.TreeNode;

public class TreeNodeDaoTest {
	private TreeNodeDao treeNodeDao = new TreeNodeDao();

//	@Before
//	public void setUp() throws Exception {
//	}
//
//	@After
//	public void tearDown() throws Exception {
//	}

	@Test
	public void testLoad() {
		TreeNode treeNode = new TreeNode();
		treeNode.setNodeId(6);
		treeNode.setInitChildren(1);
		
		TreeNode t = this.treeNodeDao.load(treeNode);
		System.out.println(t);
		System.out.println(t.getParent());
		System.out.println(t.getChildren());
	}

}

然后效果为下图所示：
在这里插入图片描述
然后一对多就讲完了，接下来向大家介绍的是多对多：
多对多：

 hibernate可以直接映射多对多关联关系(看作两个一对多) 
 多对多关系注意事项
  3.1 一定要定义一个主控方
  3.2 多对多删除
    3.2.1 主控方直接删除
    3.2.2 被控方先通过主控方解除多对多关系，再删除被控方
    3.2.3 禁用级联删除
  3.3 关联关系编辑，不需要直接操作桥接表，hibernate的主控方会自动维护

然后我们用案例来简单说一下多对多：
菜单表
多对多级联查询 书籍表、书籍类别表
基本步骤跟上面一样先首先创建实体类（Book.java 和 Category.java）和 book.hbm.xml 和 category.hbm.xml 配置
Book.java:

package com.lihao.four.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();
	}
	
	
}

book.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.lihao.four.entity.Book" table="t_hibernate_book">
		<id name="bookId" type="java.lang.Integer" column="book_id">
			<generator class="increment" />
		</id>
		<property name="bookName" type="java.lang.String"
			column="book_name">
		</property>
		<property name="price" type="java.lang.Float"
			column="price">
		</property>
		
		<!-- 
			table：代表的是中间表
			name：代表的是书籍类的关联属性
			inverse：中间表交于对方维护
			key：当前类对应的表（t_hibernate_book_category）列段在中间表中的外键（bid）
			many-to-many
				column:对应的是上面key查出来中间表（t_hibernate_book_category）的另一个字段（cid），
				当作关联表的主键（category_id）进行查询
				class：上述查出来的主键对应的实体类
				
				inverse="false"
				false我自己来维护这个关联表，true代表将中间表的维护权力交给对方。
				
		 -->
		<set table="t_hibernate_book_category" name="categories" cascade="save-update" inverse="false">
			<!-- one -->
			<key column="bid"></key>
			<!-- many -->
			<many-to-many column="cid" class="com.lihao.four.entity.Category"></many-to-many>
		</set>
	</class>
</hibernate-mapping>

Category.java：

package com.lihao.four.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 + "]";
	}
	
}

category.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.lihao.four.entity.Category" table="t_hibernate_category">
		<id name="categoryId" type="java.lang.Integer" column="category_id">
			<generator class="increment" />
		</id>
		<property name="categoryName" type="java.lang.String"
			column="category_name">
		</property>
		
		<set table="t_hibernate_book_category" name="books" cascade="save-update" inverse="true">
			<key column="cid"></key>
			<many-to-many column="bid" class="com.lihao.four.entity.Book"></many-to-many>
		</set>
	</class>
</hibernate-mapping>

然后是别忘记在核心文件（hibernate.cfg.xml）配置：

<!-- 多对多 -->
		<mapping resource="com/lihao/four/entity/Book.hbm.xml"/>
		<mapping resource="com/lihao/four/entity/Category.hbm.xml"/>

然后是写dao层：
BookDao:

package com.lihao.four.dao;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

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


import com.lihao.four.entity.Book;
import com.lihao.four.entity.Category;
import com.lihao.two.util.SessionFactoryUtils;

public class BookDao {
	public Integer addBook(Book book) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Integer bid = (Integer) session.save(book);
		transaction.commit();
		session.close();
		return bid;
	}
	
	public Integer addCategory(Category category) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Integer cid = (Integer) session.save(category);
		transaction.commit();
		session.close();
		return cid;
	}
	
	public Category getCategory(Category category) {
		Session session = SessionFactoryUtils.openSession();
		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 = SessionFactoryUtils.openSession();
		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 = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		session.delete(book);
		transaction.commit();
		session.close();
	}
	
	public void delCategory(Category category) {
		Session session = SessionFactoryUtils.openSession();
		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();
	}
	
	
	
	
	
}

然后是测试BookDao类里的方法而创建BookDaoTest:
BookDaoTest:

package com.lihao.four.dao;

import org.junit.Test;

import com.lihao.four.entity.Book;
import com.lihao.four.entity.Category;

public class BookDaoTest {
	private BookDao bookDao = new BookDao();

	@Test
	public void testGetBook() {
		Book book = new Book();
		book.setBookId(8);
		book.setInitCategories(1);
		Book b = this.bookDao.getBook(book );
		System.out.println(b.getBookName());
		System.out.println(b.getCategories());
	}
	
	/**
	 * book.hbm.xml	inverse=fasle
	 * category.hbm.xml inverse=true
	 * 数据添加正常
	 * 书籍表、桥接表各新增一条数据
	 */
	@Test
	public void test1() {
		Book book = new Book();
		book.setBookName("狗蛋的爱情故事");
		book.setPrice(10f);
		Category category = new Category();
		category.setCategoryId(5);
//		直接将category对象加入到新建的book中是错误的，因为此时的category是临时态的，hibernate是不会管理的
//		book.getCategories().add(category);
		Category c = this.bookDao.getCategory(category);
		
//		c.getBooks().add(book);
		book.getCategories().add(c);
		this.bookDao.addBook(book);
	}

	/**
	 * book.hbm.xml	inverse=true
	 * category.hbm.xml inverse=true
	 * 只增加书籍表数据
	 * 桥接表不加数据
	 * 原因：双方都没有去维护关系
	 */
	@Test
	public void test2() {
		Book book = new Book();
		book.setBookName("叶沟子");
		book.setPrice(10f);
		Category category = new Category();
		category.setCategoryId(5);
		Category c = this.bookDao.getCategory(category);
		
		book.getCategories().add(c);
		this.bookDao.addBook(book);
//		c.getBooks().add(book);
	}
	
	
}

最后我讲解一下多对多的流程：

流程：已查询book_id=8圣虚这本书为例
				1、通过建模反射自动生成sql，可以拿到book_id=8这条记录的基本信息{book_id=8，book_name=圣虚,price=40}
				2、	book_id=8-》bid=8去查询中间表t_hibernate_book_category，
					拿到了cid=8，9
				3、	cid=8，9-》t_hibernate_category的category_id=8，9
				4、拿到了当前book实例对应的category的集合
				5、最终{book_id=8，book_name=圣虚,price=40}
				-》{book_id=8，book_name=圣虚,price=40,categories=[{......},{.......}]}

今天就简单介绍在这里了。下期再见。

浩梦溪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hibernate中的自关联
浪丶荡
03-14 1248
hibernate中的自关联 之前做过一个项目，里面有这样一个关系的存在——车间与班组，班组隶属于车间，一个车间包含一个或多个班组，当时设计时统一用Unit对象表示public class Unit {//部门类 private Integer unitId; private String unitName; private Unit unit;//上级部门 } 感觉没毛病，
Hibernate 的一对多自关联
zimuliusu的博客
10-27 458
关于查询权限菜单的加载一般有两种方法： 1，直接查询出全部的菜单加载到浏览器页面 2，类似于Hibernate中的懒加载，第一次加载一级节点与二级节点， 当点击二级节点再去后台查询三级节点用于浏览器的展示 实体类 package com.more.entity; import java.util.ArrayList; import java.util.List; public class ...
Hibernate自关联关系
04-18 173
Hibernate自关联关系业务逻辑：书籍的种类，本身是自关联的关系，如下图所示： 所有书籍：历史书籍音乐书籍           钢琴书籍烹饪书籍           美食书籍  1.     Books类的源程序Books.javapackage mypack; import java.util.Set;import ja
hibernate自身一对多和自身多对多映射详解
都市桃源
04-09 2999
有时候我们使用对象时可能涉及到自身关联,但部分操作和普通对象映射无异,但是还是有些细微的差异,这里我们来探讨一下详细解释都在代码中: 自身一对一关联,这里采用上下级部门映射: Department对象: public class Department { private Integer id; private String name; private Department pare
hibernate一对多关联映射学习小结
08-29
Hibernate一对多关联映射学习小结 Hibernate是一种流行的Java持久层框架，它提供了强大的对象关系映射（ORM）功能，能够将Java对象与关系数据库中表之间建立映射关系。Hibernate的关联映射是其核心功能之一，可以将...
java Hibernate 一对多自身关联问题
09-06
在问题描述中，我们遇到的是一个关于Hibernate一对多自身关联的问题，特别是在Struts框架中使用FormBean时出现的异常行为。 首先，让我们来理解一下问题的核心部分。在Struts中，FormBean默认的Scope是Session，这...
Hibernate多对一单项关联
08-29
Hibernate多对一单项关联 Hibernate多对一单项关联是指在对象模型中，一个对象实体维护着另一个对象实体的引用关系，这种关系在数据库中对应着外键关联。下面我们将详细介绍Hibernate多对一单项关联的概念、映射...
Hibernate一对多关联双向关联代码实现分享
09-04
在关系型数据库中，一对多关联是指一个表的记录可以对应另一个表的多个记录。在Hibernate中，这种关系可以通过在实体类和映射文件中设置相应的属性来实现。具体到双向关联，意味着在两个关联的实体类中，每个实体都...
hibernate多对一单向关联关系实现源码
10-08
这里包含了hibernate多对一单向关联关系实现源码，希望对你有用。
hibernate自身关联一对多实例(树形结构)
04-14
NULL 博文链接：https://fangguanhong.iteye.com/blog/1735492
《hibernate一对多的自关联》
ZYJL的博客
12-03 109
1.entity package com.zy.four.entity; import java.util.HashSet; import java.util.Set; public class TreeNode { // tree_node_id int primary key auto_increment, ...
数据库实体之间的关联关系：一对一、一对多、多对多
热门推荐
Feike
10-23 7万+
数据库实体间有三种关联关系：一对一，一对多，多对多。一对一实例：一个学生只有个身份证编号。 一对多实例：一个班级有多个学生。 多对多实例：多对多就是双向一对多，一个学生可以选择多门课，一门课也有多名学生。 1.一对多关系处理：我们以学生和班级之间的关系来说明一对多的关系处理方法。 假设现有基本表学生表（学号，姓名，……），班级表（班级号，备注信息，……）。 方法一：新增一个关系表，用来表示学生与班级
多对多关联映射
ChambersC的博客
10-17 693
Hibernate多对多关联映射
MyBatis 关联查询（一对多 & 多对一）
abc5232033的博客
01-13 2万+
1、一对多 举个例子：一个国家有很多人。一对多 1）表结构 -- 国家country CREATE TABLE `country` ( `cid` int(5) NOT NULL AUTO_INCREMENT, `cname` varchar(20) NOT NULL, PRIMARY KEY (`cid`) ) ENGINE=InnoDB AUTO_INCREMENT=1
django一对多、多对多模型、自关联的建立
小宝儿的学习之路
05-21 978
文章目录django模型 数据库设计学习：一对多模型一对多的查询：多对多模型自关联模型 django模型 数据库设计学习： 作用：设计的好，会清晰，且易于理解，后续开发也事半功倍，易于维护 基本原则： 一对一的表，两表的属性实际上完全可以合并成一个表，共用一个主键即可； 一对多的表，可以设中间关联表，也可以将关联表并入“多”这头；若设独立关联表，则可引入“多”这头的主键作为其主键，也可另立主键并将“一”和“多”两表的主键作为关联表的外键； 多对多的表，则必须设中间关联表，关联表设独立主键，并引入
（十七）Mybatis自关联查询一对多查询
秦怀杂货店
07-16 1781
注：代码已托管在GitHub上，地址是：https://github.com/Damaer/Mybatis-Learning ，项目是mybatis-13-oneself-one2many，需要自取，需要配置maven环境以及mysql环境(sql语句在resource下的test.sql中)，觉得有用可以点个小星星，小菜鸟在此Thanks~ 所谓自关联查询，是指自己既然充当一方，又充当多方。比如...
关于flask中第三方表多对多自关联的关系
m0_48106473的博客
09-21 383
关于flask中第三方表多对多自关联的关系 目的：实现一张表的多对多自关联 自己理解的引用和反向引用： 引用：从表查主表，多查少 反向引用：主表查重表，少查多 模型类： ORM（对象关系模型） from dao import db # db是 flask_sqlalchemy下的SQLAlchemy对象 # 详细的数据库连接以后写 class User(db.Model): id = db.Column(db.INTEGER, primary_key=True, autoincre
hibernate 一对多注解
最新发布
07-28
更多关于Hibernate一对多注解的详细信息可以参考\[1\]中提供的链接。 #### 引用[.reference_title] - *1* *2* [Hibernate 中一对多的 注解 问题](https://blog.csdn.net/CapMiachael/article/details/51537867)...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值