原

Hibernate 的表关系设计

2018年04月16日 20:40:01 阅读数：24
个人分类： Hibernate
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_40285302/article/details/79966141

一个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学习笔记十二》学生、课程、分数关系的设计与实现

05-09 1855

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

hibernate 父表子表设计

03-16 778

1.名词介绍           基础父表 形如 java 中的父类           子表 形如 java 中的子类。 注意: 子表不能有和父表相同的字段。 2.设计原因        ... 来自： lswsmj的专栏

Hibernate中多表设计的一对多，多对一的映射文件的配置

11-02 687

一对多（客户表与联系人表为例）： 一对多关系中习惯性的把一方称为主表，把多方称为从表，外键指的是从表中有一列，取值参照主表的主键，这一列就是外键。 举例：一方为客户，多方为联系人 在客户的实体类中需要... 来自： shuaishuaidewo的博客

Java mySql+Hibernate 单表上下级关系数据整理

11-30 211

数据库中基本table表结构 id classname parent_id 1 服装 null 2 男装 1 3 女装... 来自： 小白笔记本

hibernate 表与表之间的关系

03-31 2192

1 一对多1）分类和商品：一个分类里有多个商品，一个商品只能属于一个分类。 2）客户和联系人：一个客户有多个联系人，一个联系人只能属于一个客户。（客户是一，联系人是多）一对多建表是通过外键建立联系。... 来自： only-ring的文档库

hibernate一对多和多对一的整理：《例》部门与员工

05-06 1027

每次遇到这种表与表间的关系时，脑子里就是一团乱麻，这回又用hibernate框架时，我就只知道单表映射生成文件，涉及到关系就懵逼了，而且表间关系又是重点，就不得不又拿起来啃啃看：         h... 来自： qq_33488452的博客

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

06-09 461

hibernate JAVAEE 多对多 来自： 上千主上-贝库塔

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

06-04 2826

hibernate JAVAEE 一对多 来自： 上千主上-贝库塔

Hibernate中的表的多对多关系及操作

01-23 1778

表的多对多关系及操作 多对多的表关系表达 表: 使用中间表,分别引用两方的ID 对象:  两方都使用集合表达 配置: 操作: inverse: 我是否要放弃... 来自： CSDN_HCX的博客

hibernate 自身表关联的多对一,一对多关系的实现

09-19 2092

需求如下: 有一个 来自： fenglvming的专栏

博主推荐

换一批

没有更多推荐了，返回首页
注册