hibernate多对多的关系

1. 数据库的多对多

1.1 数据库中不能直接映射多对多
处理：创建一个桥接表(中间表)，将一个多对多关系转换成两个一对多
注意：
数据库多表联接查询
永远就是二个表的联接查询

2. hibernate的多对多

2.1 hibernate可以直接映射多对多关联关系(看作两个一对多)

3. 多对多关系注意事项

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

4.上课案例

4.1 一对多的自关联
实体类treeNode

package com.xfz.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;

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

在核心配置文件中配置

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

dao方法

package com.xfz.four.dao;

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

import com.xfz.four.entity.TreeNode;
import com.xfz.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;
	}
}

测试方法

package com.xfz.four.dao;

import org.junit.Test;

import com.xfz.four.entity.TreeNode;

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

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

	/**
	 * 注意：
	 *    1. 这个在Vue的后台要用
	 *    2. 只能加载出直系亲属（父节点跟子节点  就是三级）
	 */
	@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());
	}

}

测试结果展示：

4.2 多对多关联关系
创建实体类Book

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

配置实体映射文件

<?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.xfz.four.entity.Book" table="t_hibernate_book">
		<!-- <cache usage="read-only" region="com.zking.five.entity.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>
		
		<!-- 
			set标签：
				table:指的是中间表
				name:指的是实体类中的关联属性
				cascade:指的是级联新增以及级联修改
				inverse:中间表的数据维护交给那个实体类来控制，
						inverse的字面意思是反方，默认inverse等于true，
						那也就意味着默认由对方来控制中间表数据的维护
			key标签：
				column:当前映射类Book对应的表t_hibernate_book的主键，在中间表的外键
			many-to-many标签：
				column:当前映射类关联属性对应的类的主键，在中间表的外键
				class:当前映射类关联属性对应的类的全路径名
		 -->
		
		<set table="t_hibernate_book_category" name="categories" cascade="save-update" inverse="true">
			<!-- one -->
			<key column="bid"></key>
			<!-- many -->
			<many-to-many column="cid" class="com.xfz.four.entity.Category"></many-to-many>
		</set>
	</class>
</hibernate-mapping>

Category

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

配置实体映射文件

<?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>
	<!-- 
		hibernate中多对多的底层原理：
			1. 建模得到了sessionfactory工厂
			2. sessionfactory中包含两个多对多的关系映射文件，那么就可以通过流加载那两个映射文件
				这里以com/xfz/four/entity/Category.hbm.xml，加载完后可以对其建模
			3. 可以拿到com.xfz.four.entity.Category以及表t_hibernate_category
				通过t_hibernate_category以及下例的column列段可以多生态生成sql语句
				select category_id,category_name form t_hibernate_category where category_id=?(5)
				查询结果：5  a1
				Category c=Class.forName("com.zking.four.entity.Category")
				Filed categoryNameField=c.getClass().getDecafiedld("categoryName")
				categoryNameField.setAccessable(true);
				categoryNameField.set(c,"a1")
				同理
				categoryIdField.set(c,5)
				那也就意味着当前c实例中所有属性值赋值完毕
			4. 同样对此文件com/xfz/four/entity/Category.hbm.xml建模，可以得到
				中间表t_hibernate_book_category
				以及关联属性的全路径名com.xfz.four.entity.Book	
				自然形成一个sql语句
				select cid,bid from t_hibernate_book_category where cid=?(5)
				5   17   5
				6   20   5
				7   21   5
				8   22   5
				9   24   5
				10  26   5
				select * from t_hibernate_book where book_id in (17,20,...)
				List<Book> books=BaseDao.executeQuery(sql,Book.class,null)
			5. c.setBooks(books)
	 -->
	<class name="com.xfz.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.xfz.four.entity.Book"></many-to-many>
		</set>
	</class>
</hibernate-mapping>

写Dao方法

package com.xfz.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.xfz.four.entity.Book;
import com.xfz.four.entity.Category;
import com.xfz.two.util.SessionFactoryUtils;

import antlr.StringUtils;



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();
	}
	
}

测试dao方法

package com.xfz.four.dao;

import org.junit.Test;

import com.xfz.four.entity.Book;
import com.xfz.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("T237自传2");
		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("c");
		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.hbm.xml inverse=fasle
category.hbm.xml inverse=true
数据添加正常
书籍表、桥接表各新增一条数据


book.hbm.xml inverse=true
category.hbm.xml inverse=false
只有book表中添加数据
原因：当book映射文件中的inverse=false，category映射文件中category=true时，运行代码是两个表中都添加了数据
反之则只有一个表中添加了数据
原因是在dao方法中只有book添加了数据，而在book映射文件中inverse=true是反方维护，而category映射文件中category=false是自身维护
所以只有category能够维护中间表的数据，所以只加了一个表的数据

book.hbm.xml inverse=true
category.hbm.xml inverse=true
只增加书籍表数据
桥接表不加数据
原因：双方都没有去维护关系