Hibernate中联合主键映射时有一个也是外键的一种解决方法

最新推荐文章于 2018-06-06 15:16:58 发布
最新推荐文章于 2018-06-06 15:16:58 发布
阅读量112 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/airship/blog/830027
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

一个联合主键的问题，困扰了我很久，最后发现《Hibernate in Action》里有讲到，因为在实际环境中老是报错，也不知配置的对不对，然后回家写了一个DEMO，发现可以保存。
表结构大致如下：
ITEM(ID,NAME)其中id是PK
CATEGORY(ID,NAME)，其中ID是PK
CATEGORY_ITEM(ITEM_ID,CATEGORY_ID,THIRD_ID,ADDED_DATE),其中ITEM_ID,CATEGORY_ID分别是ITEM和CATEGORY的外键，而他们与THIRD_ID一起组成CATETORY_ITEM表的联合主键。
下面给出具体实现：
一、Item.java

/**
* @author Terrence
*
*/ 
public class Item implements Serializable { 
 
    /**
     *
     */ 
    private static final long serialVersionUID = 1L; 
    private Integer id; 
    private String name; 
    private Set<CategorizedItem> categorizedItems = new HashSet<CategorizedItem>(); 
    /**
     *
     */ 
    public Item() { 
        super(); 
    } 
    /**
     * @return the id
     */ 
    public Integer getId() { 
        return id; 
    } 
    /**
     * @param id the id to set
     */ 
    public void setId(Integer id) { 
        this.id = id; 
    } 
    /**
     * @return the name
     */ 
    public String getName() { 
        return name; 
    } 
    /**
     * @param name the name to set
     */ 
    public void setName(String name) { 
        this.name = name; 
    } 
    /**
     * @return the categorizedItems
     */ 
    public Set<CategorizedItem> getCategorizedItems() { 
        return categorizedItems; 
    } 
    /**
     * @param categorizedItems the categorizedItems to set
     */ 
    public void setCategorizedItems(Set<CategorizedItem> categorizedItems) { 
        this.categorizedItems = categorizedItems; 
    } 
     
     
}

二、Category.java

/**
* @author Terrence
*
*/ 
public class Category implements Serializable { 
 
    /**
     *
     */ 
    private static final long serialVersionUID = 1L; 
    private Integer id; 
    private String name; 
    private Set<CategorizedItem> categorizedItems = new HashSet<CategorizedItem>(); 
     
    public Category() { 
        super(); 
    } 
    /**
     * @return the id
     */ 
    public Integer getId() { 
        return id; 
    } 
    /**
     * @param id the id to set
     */ 
    public void setId(Integer id) { 
        this.id = id; 
    } 
    /**
     * @return the name
     */ 
    public String getName() { 
        return name; 
    } 
    /**
     * @param name the name to set
     */ 
    public void setName(String name) { 
        this.name = name; 
    } 
    /**
     * @return the categorizedItems
     */ 
    public Set<CategorizedItem> getCategorizedItems() { 
        return categorizedItems; 
    } 
    /**
     * @param categorizedItems the categorizedItems to set
     */ 
    public void setCategorizedItems(Set<CategorizedItem> categorizedItems) { 
        this.categorizedItems = categorizedItems; 
    } 
     
     
}

三、CategorizedItem.java

/**
* @author Terrence
*
*/ 
public class CategorizedItem implements Serializable { 
     
    /**
     *
     */ 
    private static final long serialVersionUID = 1L; 
    public static class Id implements Serializable { 
 
        /**
         *
         */ 
        private static final long serialVersionUID = 1L; 
        private Integer thirdId; 
        private Integer categoryId; 
        private Integer itemId; 
        /**
         *
         */ 
        public Id() { 
            super(); 
        } 
         
        /**
         * @return the thirdId
         */ 
        public Integer getThirdId() { 
            return thirdId; 
        } 
 
        /**
         * @param thirdId the thirdId to set
         */ 
        public void setThirdId(Integer thirdId) { 
            this.thirdId = thirdId; 
        } 
 
        /**
         * @return the categoryId
         */ 
        public Integer getCategoryId() { 
            return categoryId; 
        } 
        /**
         * @param categoryId the categoryId to set
         */ 
        public void setCategoryId(Integer categoryId) { 
            this.categoryId = categoryId; 
        } 
        /**
         * @return the itemId
         */ 
        public Integer getItemId() { 
            return itemId; 
        } 
        /**
         * @param itemId the itemId to set
         */ 
        public void setItemId(Integer itemId) { 
            this.itemId = itemId; 
        } 
        /* (non-Javadoc)
         * @see java.lang.Object#hashCode()
         */ 
        @Override 
        public int hashCode() { 
            return this.categoryId.hashCode()+this.itemId.hashCode(); 
        } 
        /* (non-Javadoc)
         * @see java.lang.Object#equals(java.lang.Object)
         */ 
        @Override 
        public boolean equals(Object obj) { 
            if(obj!=null&&obj instanceof Id){ 
                Id that = (Id)obj; 
                return this.categoryId.equals(that.categoryId)&&this.itemId.equals(that.itemId); 
            }else{ 
                return false; 
            } 
        } 
         
    } 
     
    private Id id = new Id(); 
    private Date dateAdded; 
    private Item item; 
    private Category category; 
    /**
     *
     */ 
    public CategorizedItem() { 
        super(); 
    } 
    /**
     * @return the id
     */ 
    public Id getId() { 
        return id; 
    } 
    /**
     * @param id the id to set
     */ 
    public void setId(Id id) { 
        this.id = id; 
    } 
    /**
     * @return the dateAdded
     */ 
    public Date getDateAdded() { 
        return dateAdded; 
    } 
    /**
     * @param dateAdded the dateAdded to set
     */ 
    public void setDateAdded(Date dateAdded) { 
        this.dateAdded = dateAdded; 
    } 
    /**
     * @return the item
     */ 
    public Item getItem() { 
        return item; 
    } 
    /**
     * @param item the item to set
     */ 
    public void setItem(Item item) { 
        this.item = item; 
        this.id.itemId = item.getId(); 
        item.getCategorizedItems().add(this); 
    } 
    /**
     * @return the category
     */ 
    public Category getCategory() { 
        return category; 
    } 
    /**
     * @param category the category to set
     */ 
    public void setCategory(Category category) { 
        this.category = category; 
        this.id.categoryId = category.getId(); 
        category.getCategorizedItems().add(this); 
    } 
    /**
     * @return the thirdId
     */ 
    public Integer getThirdId() { 
        return this.id.getThirdId(); 
    } 
 
    /**
     * @param thirdId the thirdId to set
     */ 
    public void setThirdId(Integer thirdId) { 
        this.id.thirdId = thirdId; 
    } 
     
}

四、*.hbm.xml,这里节省时间空间写在了一起

<hibernate-mapping package="org.terrence.hrsystem.model"> 
  <class name="Item" table="ITEM"> 
      <id name="id" type="integer" column="ITEM_ID"> 
         <generator class="identity" /> 
      </id> 
      <property name="name" type="string" not-null="true" 
         update="false" column="ITEM_NAME" /> 
      <set name="categorizedItems" cascade="all, delete-orphan" 
         inverse="true" lazy="false"> 
         <key column="ITEM_ID" not-null="true" /> 
         <one-to-many class="CategorizedItem" /> 
      </set> 
   </class> 
 
   <class name="Category" table="CATEGORY"> 
      <id name="id" type="integer" column="CATEGORY_ID"> 
         <generator class="identity" /> 
      </id> 
      <property name="name" type="string" column="CATEGORY_NAME" not-null="true"/> 
      <set name="categorizedItems" cascade="all, delete-orphan" 
         inverse="true" lazy="false"> 
         <key column="CATEGORY_ID" not-null="true" /> 
         <one-to-many class="CategorizedItem" /> 
      </set> 
   </class> 
 

   <class name="CategorizedItem" table="CATEGORIZED_ITEM" mutable="false"> 
     <composite-id name="id" class="CategorizedItem$Id"> 
        <key-property name="thirdId" column="THIRD_ID" type="integer"/> 
        <key-property name="categoryId" column="CATEGORY_ID" 
                type="integer" /> 
        <key-property name="itemId" column="ITEM_ID" type="integer" /> 
     </composite-id> 
     <property name="dateAdded" column="ADDED_ON" type="timestamp" 
            not-null="true" /> 
 
     <many-to-one name="item" class="Item" column="ITEM_ID" 
            not-null="true" insert="false" update="false" /> 
     <many-to-one name="category" class="Category" column="CATEGORY_ID" 
            not-null="true" insert="false" update="false" /> 
   </class> 
</hibernate-mapping>

五、测试代码

/**  
* @Title: TestDao.java
* @Package test
* @Description: TODO(用一句话描述该文件做什么)
* @author Terrence.zhung chguxing@163.com  
* @date 2011-3-29 上午02:45:05
* @version V1.0  
*/  
 
package test; 
 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
import org.terrence.hrsystem.dao.CategorizedItemDao; 
import org.terrence.hrsystem.dao.CategoryDao; 
import org.terrence.hrsystem.dao.ItemDao; 
import org.terrence.hrsystem.model.CategorizedItem; 
import org.terrence.hrsystem.model.Category; 
import org.terrence.hrsystem.model.Item; 
 
/**
* @author Terrence
*
*/ 
public class TestDao { 
 
    /**
     * @param args
     */ 
    private static ItemDao itemDao; 
    private static CategoryDao categoryDao; 
    private static CategorizedItemDao  categorizedItemDao; 
    private static ApplicationContext ctx; 
     
    public static void init(){ 
        if(ctx==null){ 
            ctx = new ClassPathXmlApplicationContext(new String[]{"classpath:applicationContext.xml","classpath:daoContext.xml"}); 
        } 
        itemDao = (ItemDao)ctx.getBean("itemDao"); 
        categoryDao = (CategoryDao)ctx.getBean("categoryDao"); 
        categorizedItemDao = (CategorizedItemDao)ctx.getBean("categorizedItemDao"); 
    } 
    public static void main(String[] args) throws Exception { 
        init(); 
        saveItem(); 
        saveCategory(); 
        saveCategoryItem(); 
    } 
     
    public static void saveItem() throws Exception{ 
        Item item = new Item(); 
        item.setName("item2"); 
        itemDao.save(item); 
    } 
     
    public static void saveCategory() throws Exception{ 
        Category category = new Category(); 
        category.setName("category2"); 
        categoryDao.save(category); 
    } 
     
    public static void saveCategoryItem() throws Exception{ 
        Item item = itemDao.get(1); 
        Category category = categoryDao.get(1); 
        CategorizedItem categorizedItem = new CategorizedItem(); 
        categorizedItem.setItem(item); 
        categorizedItem.setCategory(category); 
        categorizedItem.setDateAdded(new java.util.Date()); 
        categorizedItem.setThirdId(5); 
        categorizedItemDao.save(categorizedItem); 
    } 
 
}

六、说明
    因为用了spring，在配置文件配好环境，表可以用hibernate直接生成，不用写SQL语句。

转载于:https://my.oschina.net/airship/blog/830027

weixin_33972649
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hibernate一对一单向外键关联 (联合主键annotation)
04-22
NULL 博文链接：https://cdxs2.iteye.com/blog/1932507
hibernate之复合主键作为外键的相关配置
weixin_30384031的博客
04-14 138
1.首先得有一个复合主键类CompositClassTest存在 CompositClassTest.java package home.yhs.entity; import java.io.Serializable; public class CompositClassTest implements Serializable{ /** * ...
hibernate复合主键同时做外键
weixin_34252686的博客
12-25 150
参考： 1）一个简单的复合主键的做关联类的例子     http://www.iteye.com/topic/8287  
Hibernate复合主键作为外键在关联映射中的配置方法
Richard.Dai的专栏
12-13 1354
在多对多或者其他的关联映射中，当需要将一个复合主键作为外键时，需要对这个外键做特殊的配置，如下面这个例子： SystemPrivilege和SystemPrivilegePK类详细编码参考： Hibernate复合主键的映射方法 PrivilegeGroup类： public class PrivilegeGroup {     private String groupid;
Hibernate教程08_关系映射之联合主键
04-13
例如，在`s2sh_relation05_one2one_uni_fk_composite`的示例中，假设我们有一个`Student`实体和一个`Address`实体，它们之间存在一对一（One-to-One）的关系，并且`Address`使用联合主键。`Address`实体的主键可能...
Hibernate实体对象继承的三种方法
10-19
在Java的持久化框架Hibernate中，实体对象的继承关系映射到数据库是非常关键的一个部分，因为它直接影响到数据存储的结构和查询效率。本篇文章将详细阐述Hibernate中的三种实体继承策略：单表继承（Single Table）、...
hibernate之一对一关联映射
05-29
一对一关联映射在Hibernate中表示两个实体类之间存在一对一的关系，也就是说，每个实体类的对象只对应另一个实体类的一个对象。这种映射关系可以是单向或双向的，并且可以通过外键或者主键来实现。接下来我们将深入...
hibernate 一对一双向带关联表映射练习
03-16
在IT领域，尤其是在Java开发中，Hibernate是一个非常重要的对象关系映射（ORM）框架，它极大地简化了数据库操作。本文将深入探讨“hibernate 一对一双向带关联表映射”的概念及其实践，结合提供的资源...
hibernate 外键做联合主键
u014164005的博客
04-20 717
使用Hibernate的外键作为联合主键： 如：有三张表 product：其字段有 id，proColor，proName。id是主键 orders：字段有 id，amount，date。id是主键 order_details：字段有 proId，orderId，quantity，price。proId和orderId为联合主键，并且proId是product表的外键，orderId是...
hibernate--一对一联合主键外键关联
持之以恒
08-31 307
annotation注解开发： 以person 和 personID为例： Person.java: package com.bean; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.IdClass; import javax.persistence.OneToO
13.hibernate一对一单向联合主键外键关联,jpa映射
iteye_3762的博客
11-24 123
husband表结构: [img]http://dl.iteye.com/upload/attachment/592558/901303de-1794-385a-99ac-4fdbdcbf5a95.jpg[/img] wife表结构: [img]http://dl.iteye.com/upload/attachment/592560/df8fa80d-37a7-3e42-89f7-25c16...
Hibernate复合主键中其中有主键是引用外键情况下的配置方法
02-28 2664
这个有两种配置方式。一种是映射一个也是复合主键一部分的外键列，通过一般的元素，并用insert="false" update="false"禁用该列的任何Hibernate插入或者更新。另一种方式是。下面分别说明两种方式的配置方法。 1、many-to-one方式 假设有两个表USER和DEPARTMENT表。两个表的结构创建SQL语句如下： create table DEPARTMENT
Hibernate配置多个外键做联合主键
李静静
06-06 5180
项目中的vipInfo--cart---cartItem 三个表之间的关系如下vipInfo与cart的关系是一对一所以将它俩的关联表中的主键放在谁那都行。博主为了逻辑上的清晰，我将cart的cartId作为竟为cart表的主键，有为vipId外键，存在vipId的外键约束。因为每个用户都有一个购物车，但是购物车与购物车内的商品关系是m：n，所以这时候需要新建一个联系表cartItem（cartI...
Hibernate多对多中间表有多个字段字段的注解配置方式（一）
qingfeng2556的博客
06-17 1692
Hibernate多对多中间表有多个字段字段的注解配置方式（一）  (2011-10-22 13:33:37) 转载▼ 标签：  hibernate   多对多   中间字段   关系属性   注解配置 分类： Java 一般情况下，多对多的关联关系是需要中间表的； 情况一：如果中
在Hibernate中使用联合主键作为外键
Swing's Way
01-20 3319
        近期遇到一个ORM映射需求，即在“多-多”关系中需要将对应到两端实体的外键作为关系的联合主键，查了N多资料，试了N种方法，终于找到了自认为比较合理的ORM映射方式，在这里贴出来，与大家分享一下。         1、问题描述        这是一个古老的订单问题，涉及到的对象有3个，分别为：订单，订单项，产品。订单与产品间是“多-一”关系，它们间的关系通过订单项来反映：一个
hibernate映射关系——复合主键映射
王勇霞 信息技术提高班九期
01-27 830
由于中间做.Net项目，所以hibernate的博客更新就短篇了，现在让我们接着上篇hibernate的博客来继续hibernate的关系映射，这篇博客介绍的是复合主键映射。      一、复合主键      简单说一下什么是复合主键：在一个表中，一个字段不能唯一标识一行数据的时候，就需要两个及更多的字段来共同确定记录的唯一。这几个字段就是复合主键。      在没有ORM的概念时，
mysql 中两个主键且其中一个是外键的语法怎么写
最新发布
05-02
在 MySQL 中，一个表只能有一个主键，但是可以有多个唯一键，可以将其中一个唯一键作为外键。创建一个包含两个唯一键的表以及一个外键的语法如下： ```sql CREATE TABLE table1 ( id1 INT NOT NULL, id2 INT NOT ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值