Hibernate 的表关系设计

原创 2018年04月16日 20:40:01
  • 标签：
一个Product对应一个Category 

一个Category对应多个Product 

先设置多对一的关系，先准备Category.java和Category.hbm.xml和Category和在hibernate.cfg.xml中增加Category的映射。

为Product.java增加Category属性：

[java] view plain copy
  1. package com.how2java.pojo;    
  2. public class Product {    
  3.     int id;    
  4.     String name;    
  5.     float price;    
  6.     Category category;//增加category属性并增加get和set方法    
  7.     public Category getCategory() {    
  8.         return category;    
  9.     }    
  10.     public void setCategory(Category category) {    
  11.         this.category = category;    
  12.     }    
  13.     public int getId() {    
  14.         return id;    
  15.     }    
  16.     public void setId(int id) {    
  17.         this.id = id;    
  18.     }    
  19.     public String getName() {    
  20.         return name;    
  21.     }    
  22.     public void setName(String name) {    
  23.         this.name = name;    
  24.     }    
  25.     public float getPrice() {    
  26.         return price;    
  27.     }    
  28.     public void setPrice(float price) {    
  29.         this.price = price;    
  30.     }       
  31. }  

在Product.hbm.xml中设置Category 多对一关系：

[html] view plain copy
  1. <?xml version="1.0"?>    
  2. <!DOCTYPE hibernate-mapping PUBLIC    
  3.         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    
  4.         "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">    
  5.     
  6. <hibernate-mapping package="com.how2java.pojo">    
  7.     <class name="Product" table="product_">    
  8.         <id name="id" column="id">    
  9.             <generator class="native">    
  10.             </generator>    
  11.         </id>    
  12.         <property name="name" />    
  13.         <property name="price" />    
  14.         <many-to-one name="category" class="Category" column="cid" /><!--使用many-to-one 标签设置多对一关系 name="category" 对应Product类中的category属性 class="Category" 表示对应Category类 column="cid" 表示指向 category_表的外键 -->    
  15.     </class>    
  16.         
  17. </hibernate-mapping>    

TestHibernate 测试many-to-one关系：

[java] view plain copy
  1. package com.how2java.test;    
  2. import org.hibernate.Session;    
  3. import org.hibernate.SessionFactory;    
  4. import org.hibernate.cfg.Configuration;    
  5. import com.how2java.pojo.Category;    
  6. import com.how2java.pojo.Product;    
  7. public class TestHibernate {    
  8.     public static void main(String[] args) {    
  9.         SessionFactory sf = new Configuration().configure().buildSessionFactory();    
  10.         Session s = sf.openSession();    
  11.         s.beginTransaction();    
  12.         //核心代码，在这个测试例子中，增加了一个新的Category对象"c1" 并将其设置为id=8的product的category    
  13.         Category c =new Category();    
  14.         c.setName("c1");    
  15.         s.save(c);    
  16.         Product p = (Product) s.get(Product.class, 8);    
  17.         p.setCategory(c);    
  18.         s.update(p);    
  19.             
  20.         s.getTransaction().commit();    
  21.         s.close();    
  22.         sf.close();    
  23.     }    
  24. }    

接着实现一对多的关系：Category和Product是一对多的关系。

为Category增加一个Set集合：

[java] view plain copy
  1. package com.how2java.pojo;    
  2. import java.util.Set;    
  3. public class Category {    
  4.     public int getId() {    
  5.         return id;    
  6.     }    
  7.     public void setId(int id) {    
  8.         this.id = id;    
  9.     }    
  10.     public String getName() {    
  11.         return name;    
  12.     }    
  13.     public void setName(String name) {    
  14.         this.name = name;    
  15.     }    
  16.     int id;    
  17.     String name;    
  18.     Set<Product> products;//核心代码，增加一个set集合    
  19.     public Set<Product> getProducts() {    
  20.         return products;    
  21.     }    
  22.     public void setProducts(Set<Product> products) {    
  23.         this.products = products;    
  24.     }    
  25. }    

为Category.hbm.xml增加one-to-many映射：

[html] view plain copy
  1. <?xml version="1.0"?>    
  2. <!DOCTYPE hibernate-mapping PUBLIC    
  3.         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    
  4.         "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">    
  5.     
  6. <hibernate-mapping package="com.how2java.pojo">    
  7.     <class name="Category" table="category_">    
  8.         <id name="id" column="id">    
  9.             <generator class="native">    
  10.             </generator>    
  11.         </id>    
  12.         <property name="name" />    
  13.                 <!--核心代码-->    
  14.         <set name="products" lazy="false"><!--set 用于设置一对多(多对多也是他)关系，也可以用list，设置稍复杂点，这里使用简单的set来入门。name="products" 对应 Category类中的products属性。lazy="false" 表示不使用延迟加载。 -->    
  15.             <key column="cid" not-null="false" /><!-- 表示外键是cid，可以为空-->    
  16.             <one-to-many class="Product" /><!-- 表示一对多所对应的类是Product-->    
  17.         </set>    
  18.                     
  19.     </class>    
  20.         
  21. </hibernate-mapping>    

TestHibernate 测试one-to-many关系

[java] view plain copy
  1. package com.how2java.test;    
  2. import java.util.Set;    
  3. import org.hibernate.Session;    
  4. import org.hibernate.SessionFactory;    
  5. import org.hibernate.cfg.Configuration;    
  6. import com.how2java.pojo.Category;    
  7. import com.how2java.pojo.Product;    
  8.      
  9. public class TestHibernate {    
  10.     public static void main(String[] args) {    
  11.         SessionFactory sf = new Configuration().configure().buildSessionFactory();     
  12.         Session s = sf.openSession();    
  13.         s.beginTransaction();    
  14.         //核心代码    
  15.         Category c = (Category) s.get(Category.class, 1);    
  16.         Set<Product> ps = c.getProducts();    
  17.         for (Product p : ps) {    
  18.             System.out.println(p.getName());    
  19.         }    
  20.     
  21.         s.getTransaction().commit();    
  22.         s.close();    
  23.         sf.close();    
  24.     }    
  25. }    

多对多关系的设置：

一种Product可以被多个User购买 

一个User可以购买多种Product 

所以Product和User之间的关系是多对多 many-to-many 

要实现多对多关系，必须有一张中间表 user_product 用于维护 User和Product之间的关系

先准备User.java和User.hbm.xml。

[java] view plain copy
  1. package com.how2java.pojo;    
  2. import java.util.Set;    
  3. public class User {    
  4.     int id;    
  5.     String name;    
  6.     Set<Product> products;    
  7.     public int getId() {    
  8.         return id;    
  9.     }    
  10.     public void setId(int id) {    
  11.         this.id = id;    
  12.     }    
  13.     public String getName() {    
  14.         return name;    
  15.     }    
  16.     public void setName(String name) {    
  17.         this.name = name;    
  18.     }    
  19.     public Set<Product> getProducts() {    
  20.         return products;    
  21.     }    
  22.     public void setProducts(Set<Product> products) {    
  23.         this.products = products;    
  24.     }    
  25. }    
[html] view plain copy
  1. <?xml version="1.0"?>    
  2. <!DOCTYPE hibernate-mapping PUBLIC    
  3.         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    
  4.         "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">    
  5.     
  6. <hibernate-mapping package="com.how2java.pojo">    
  7.     <class name="User" table="user_">    
  8.         <id name="id" column="id">    
  9.             <generator class="native">    
  10.             </generator>    
  11.         </id>    
  12.         <property name="name" />    
  13.                 <!-- 核心代码，products是USer自带，然后再user_product表中，user对应uid，product对应pid-->    
  14.         <set name="products" table="user_product" lazy="false">    
  15.             <key column="uid" />    
  16.             <many-to-many column="pid" class="Product" />    
  17.         </set>            
  18.     </class>      
  19. </hibernate-mapping>    

Product.java增加了对应Users的集合

[java] view plain copy
  1. package com.how2java.pojo;    
  2. import java.util.Set;    
  3. public class Product {    
  4.     int id;    
  5.     String name;    
  6.     float price;    
  7.     Category category;    
  8.     Set<User> users;//增加对应的Users和set方法和get方法    
  9.     public Set<User> getUsers() {    
  10.         return users;    
  11.     }    
  12.     public void setUsers(Set<User> users) {    
  13.         this.users = users;    
  14.     }    
  15.     public Category getCategory() {    
  16.         return category;    
  17.     }    
  18.     public void setCategory(Category category) {    
  19.         this.category = category;    
  20.     }    
  21.     public int getId() {    
  22.         return id;    
  23.     }    
  24.     public void setId(int id) {    
  25.         this.id = id;    
  26.     }    
  27.     public String getName() {    
  28.         return name;    
  29.     }    
  30.     public void setName(String name) {    
  31.         this.name = name;    
  32.     }    
  33.     public float getPrice() {    
  34.         return price;    
  35.     }    
  36.     public void setPrice(float price) {    
  37.         this.price = price;    
  38.     }    
  39.         
  40. }    

Product.hbm.xml的设置同理：

[html] view plain copy
  1. <?xml version="1.0"?>    
  2. <!DOCTYPE hibernate-mapping PUBLIC    
  3.         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    
  4.         "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">    
  5. <hibernate-mapping package="com.how2java.pojo">    
  6.     <class name="Product" table="product_">    
  7.         <id name="id" column="id">    
  8.             <generator class="native">    
  9.             </generator>    
  10.         </id>    
  11.         <property name="name" />    
  12.         <property name="price" />    
  13.         <many-to-one name="category" class="Category" column="cid" />    
  14.         <!-- 核心代码-->    
  15.         <set name="users" table="user_product" lazy="false">    
  16.             <key column="pid" />    
  17.             <many-to-many column="uid" class="User" />    
  18.         </set>                            
  19.     </class>    
  20. </hibernate-mapping>    

在hibernate.cfg.xml中增加User的映射。

TestHibernate 测试many-to-many关系

首先增加3个用户

然后演示产品1被用户1，2,3购买。

[java] view plain copy
  1. package com.how2java.test;    
  2. import java.util.HashSet;    
  3. import java.util.Set;    
  4. import org.hibernate.Session;    
  5. import org.hibernate.SessionFactory;    
  6. import org.hibernate.cfg.Configuration;    
  7. import com.how2java.pojo.Product;    
  8. import com.how2java.pojo.User;    
  9.       
  10. public class TestHibernate {    
  11.     public static void main(String[] args) {    
  12.         SessionFactory sf = new Configuration().configure().buildSessionFactory();    
  13.         Session s = sf.openSession();    
  14.         s.beginTransaction();    
  15.              
  16.         //增加3个用户    
  17.         Set<User> users = new HashSet();    
  18.         for (int i = 0; i < 3; i++) {    
  19.             User u =new User();    
  20.             u.setName("user"+i);    
  21.             users.add(u);    
  22.             s.save(u);    
  23.         }    
  24.         //产品1被用户1,2,3购买    
  25.         Product p1 = (Product) s.get(Product.class, 1);    
  26.         p1.setUsers(users);    
  27.         s.save(p1);    
  28.         s.getTransaction().commit();    
  29.         s.close();    
  30.         sf.close();    
  31.     }    
  32. }    

阅读全文

hibernate中多表设计

配置实体之间的关联关系 在实际开发中,数据库的表难免会有相互的关联关系,在操作表的时候就有可能会涉及到多张表的操作.例如,商品和分类,用户和订单,订单和商品 要想实现多表映射, 第一步:要先确定...
  • zhangshuhao0101
  • zhangshuhao0101
  • 2017-06-29 15:36:27
  • 179

Hibernate中表与表之间关系的处理（一对多）

hibernate JAVAEE 一对多
  • qq_33248299
  • qq_33248299
  • 2017-06-04 16:16:57
  • 1762

hibernate 表与表之间的关系

1 一对多1）分类和商品：一个分类里有多个商品，一个商品只能属于一个分类。 2）客户和联系人：一个客户有多个联系人，一个联系人只能属于一个客户。（客户是一，联系人是多）一对多建表是通过外键建立联系。...
  • only_ring
  • only_ring
  • 2017-03-31 18:14:29
  • 1272

Hibernate(三)——框架中的关系映射

在设计数据库时我们会考虑，表与表之间的关系，例如我们前边经常提到的一对一，一对多，多对多关系，在数据库中我们通过外键，第三张表等来实现这些关系。而Hibernate时间实体类和数据库中的表进行的映射，...
  • liujiahan629629
  • liujiahan629629
  • 2014-03-18 23:47:53
  • 5842

hibernate 父表子表设计

1.名词介绍           基础父表 形如 java 中的父类           子表 形如 java 中的子类。 注意: 子表不能有和父表相同的字段。 2.设计原因        ...
  • u010142228
  • u010142228
  • 2016-03-16 16:07:54
  • 486

Hibernate/JPA 单表一对多关系映射

这里以组织机构为例：表结构 字段 类型 备注 OrgId...
  • myloon
  • myloon
  • 2007-11-04 13:44:00
  • 2493

javaEE 用户、部门、角色、权限实体的关系设计与hibernate映射配置文件关系总结

文章中的项目文件已经放到Github上，欢迎大家Follow，star， 地址：https://github.com/lawlite19/SmartEducation 一：设计实体，我这里...
  • u013082989
  • u013082989
  • 2016-03-25 21:11:59
  • 5544

Hibernate表关系

Hibernate多对一package Hibernate.entity;public class ClassRoom { private int id; private String...
  • u010504185
  • u010504185
  • 2017-02-27 22:03:35
  • 354

《Hibernate学习笔记十二》学生、课程、分数关系的设计与实现

《Hibernate学习笔记十一》学生、课程、分数关系的设计与实现这个马士兵老师的Hibernate视频学习的一个题目，这里面要用到多对多、多对一的关联关系以及联合主键，因此觉得挺好的，自己写篇博文来...
  • u010412719
  • u010412719
  • 2016-05-09 16:02:58
  • 1496

Hibernate中表的一对一关系

一对一关系 l  情况1：主表的主键，与从表的外键（唯一），形成主外键关系 l  情况2：主表的主键，与从表的主键，形成主外键关系（从表的主键又是外键） 情况一：使用外键 ...
  • CSDN_GIA
  • CSDN_GIA
  • 2017-01-24 11:36:55
  • 1153
收藏助手
不良信息举报
您举报文章：Hibernate 的表关系设计
举报原因：
原因补充：

(最多只允许输入30个字)