hibernate关联关系（一对多，多对多）

一对多的关联配置

数据库：主表从表，通过外键关联

one-to-many

many-to-one

类：

class A{

B b；

}

class B{

}

实体类包含了订单集合的属性

订单项来说它一定属于某个订单

配置 order.hbm.xml

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

对于订单来说属于一对多使用标签one-to-many class为订单项的全限定名

name属性是属性名 key表示外键列

与order.hbm.xml相反 many-to-one标签

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

攋加载

orderDao

public class OrderDao {
   public Order get(Order order) {
       Session session = SessionFactoryUtil.getSession();
       Transaction transaction = session.beginTransaction();
       Order o = session.get(Order.class, order.getOrderId());
//       并且想要查询出关联的订单项的数据是，采用强制加载
       if(o != null && new Integer(1).equals(order.getInitOrderItems())) {
           Hibernate.initialize(o.getOrderItems());
       }

       transaction.commit();
       session.close();
       return o;
   }

orderDaoTest调用查询方法

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

会报异常

需要强制加载与该订单关联的订单项数据

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

结果

默认为懒加载的原因：

只需要订单表的数据时，也会将订单项表的数据查出来，此时用到的sql语句量是庞大的

所以默认为懒加载，需要订单项时将order实体类的initOrderItems字段改为1就好

一对多的自关联

实体类

package com.hmf.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 children = new HashSet();
   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 getChildren() {
       return children;
   }

   public void setChildren(Set 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 + "]";
   }


}

做映射位置

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">





                  column="tree_node_name">

                  column="tree_node_type">

                  column="position">

                  column="url">

dao

package com.hmf.two.dao;

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

import com.hmf.two.entity.TreeNode;
import com.hmf.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;
   }
}

调用方法

package com.hmf.two.dao;

import org.junit.Test;

import com.hmf.two.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/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">






                  column="book_name">

                  column="price">

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">





                  column="category_name">

inverse属性为反转，数据的维护

false表示中间表的数据由自己维护

true表示中间表的数据由对方维护

两表一定是一个为true一个为false

table：中间表

name：关联属性

key：当前表的主键在关联表的外键

bookdao

package com.hmf.two.dao;

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

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

public class BookDao {
   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();
   }




//   public List 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 list = query.list();
//       transaction.commit();
//       session.close();
//       return list;
//
//   }


//   public List list2(Book book, PageBean pageBean) {
//       Session session = SessionFactoryUtil.getSession();
//       Transaction transaction = session.beginTransaction();
//       String hql = "from Book where 1 = 1";
//       Map map = new HashMap();
//
//       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;
//   }


//   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;
//   }
}

bookdaotest

package com.hmf.two.dao;

import org.junit.Test;

import com.hmf.two.entity.Book;
import com.hmf.two.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());
   }


   @Test
   public void test1() {
       Book book = new Book();
       book.setBookName("bbbb");
       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);
   }


   @Test
   public void test2() {
       Book book = new Book();
       book.setBookName("dddd");
       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);
   }
}

hibernate关联关系（一对多，多对多）

Java相关栏目本月热门文章