`

Hibernate的复合主键,基于属性的复合主键

HibernateMyeclipseApacheXML 
阅读更多
java 代码
  1. import org.apache.commons.lang.builder.EqualsBuilder;   
  2. import org.apache.commons.lang.builder.HashCodeBuilder;   
  3.   
  4. // default package   
  5.   
  6.     
  7.   
  8. /**  
  9.  * User generated by MyEclipse - Hibernate Tools  
  10.  */  
  11.   
  12. public class User  implements java.io.Serializable {   
  13.   
  14.   
  15.     // Fields       
  16.   
  17.   private String addr;   
  18.      private String name;   
  19.      private String email;   
  20.   
  21.   
  22.     // Constructors   
  23.   
  24.     /** default constructor */  
  25.     public User() {   
  26.     }   
  27.   
  28.        
  29.     /** full constructor */  
  30.     public User(String email) {   
  31.         this.email = email;   
  32.     }   
  33.   
  34.       
  35.     // Property accessors   
  36.   
  37.      
  38.   
  39.     public String getEmail() {   
  40.         return this.email;   
  41.     }   
  42.        
  43.     public void setEmail(String email) {   
  44.         this.email = email;   
  45.     }   
  46.   
  47.   
  48.  public String getAddr() {   
  49.   return addr;   
  50.  }   
  51.   
  52.   
  53.  public void setAddr(String addr) {   
  54.   this.addr = addr;   
  55.  }   
  56.   
  57.   
  58.  public String getName() {   
  59.   return name;   
  60.  }   
  61.   
  62.   
  63.  public void setName(String name) {   
  64.   this.name = name;   
  65.  }   
  66.     
  67.  public boolean equals(Object other) {   
  68.         if ( (this == other ) ) return true;   
  69.    if ( (other == null ) ) return false;   
  70.    if ( !(other instanceof UserId) ) return false;   
  71.    User castOther = ( User ) other;    
  72.            
  73. //   return ( (this.getAddr()==castOther.getAddr()) || ( this.getAddr()!=null && castOther.getAddr()!=null && this.getAddr().equals(castOther.getAddr()) ) )   
  74. //             && ( (this.getName()==castOther.getName()) || ( this.getName()!=null && castOther.getName()!=null && this.getName().equals(castOther.getName()) ) )   
  75. //             && ( (this.getEmail()==castOther.getEmail()) || ( this.getEmail()!=null && castOther.getEmail()!=null && this.getEmail().equals(castOther.getEmail()) ) );   
  76.    return  new EqualsBuilder().append(this.name, castOther.getName())   
  77.                               .append(this.addr, castOther.getAddr())   
  78.                               .append(this.email, castOther.getEmail()).isEquals();   
  79.   }   
  80.      
  81.   public int hashCode() {   
  82.         int result = 17;   
  83.            
  84. //        result = 37 * result + ( getAddr() == null ? 0 : this.getAddr().hashCode() );   
  85. //        result = 37 * result + ( getName() == null ? 0 : this.getName().hashCode() );   
  86. //        result = 37 * result + ( getEmail() == null ? 0 : this.getEmail().hashCode() );   
  87.         return new HashCodeBuilder().append(this.getName()).append(this.getAddr()).append(this.getEmail()).toHashCode();   
  88.   }      
  89.       
  90. }   

 

xml 代码
  1. <hibernate-mapping>  
  2.     <class name="User" table="user" catalog="tie">  
  3.         <composite-id >  
  4.             <key-property name="addr" type="string">  
  5.                 <column name="addr" length="45" />  
  6.             key-property>  
  7.             <key-property name="name" type="string">  
  8.                 <column name="name" length="45" />  
  9.             key-property>  
  10.         composite-id>  
  11.         <property name="email" type="string">  
  12.             <column name="email" length="45" />  
  13.         property>  
  14.     class>  
  15. hibernate-mapping>  

 

  测试下

java 代码
  1. public void testCase(){   
  2.            
  3.         User user = new User();   
  4.         user.setName("mamamm");   
  5.         user.setAddr("china beijiing");   
  6.         user.setEmail("linweihan@163.com");   
  7.            
  8.         Session session = factory.openSession();   
  9.         Transaction tr = session.beginTransaction();   
  10.         session.save(user);   
  11.         tr.commit();   
  12.         session.close();   
  13.     }   
  14.        
  15.     public void testRetrieve(){   
  16.            
  17.         User user = new User();   
  18.         user.setName("mamamm");   
  19.         user.setAddr("china beijiing");   
  20.            
  21.         Session session = factory.openSession();   
  22.         user = (User)session.load(User.class, user);   
  23.         System.out.println(user.getEmail());   
  24.         session.close();   
  25.     }  

 

这里重写equals和hascode方法的时候 ,采用了一个第3方的common-lang包.

分享到：
| commons.lang的使用
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Hibernate中对数据库复合主键的支持.pdf

    在使用复合主键的情况下，通常会基于所有构成主键的属性来重写这些方法。 针对`Person`类的实现，我们可以参考以下示例代码： ```java import java.io.Serializable; public class Person implements ...

    hibernate3 注释生成复合主键或者嵌入式主键的方法及实例.doc

    这篇文档将介绍如何使用Hibernate注解来生成复合主键或嵌入式主键。 复合主键（Composite Key）是指由两个或更多个列共同构成的唯一标识，而嵌入式主键（Embedded Key）则是将主键字段嵌入到实体类内部。在不使用...

    Hibernate入门(代码+笔记)

    **第四部分：Hibernate复合主键** 复合主键在数据库设计中并不罕见，当一个表的主键由两个或更多字段组成时，就需要使用。在Hibernate中，可以使用@EmbeddedId和@IdClass注解来处理复合主键。@EmbeddedId将一个包含...

    Hibernate关联映射

    总结来说，Hibernate的复合主键映射允许我们将由多个属性组成的主键映射到对象上，通过在映射配置文件中使用`&lt;composite-id&gt;`标签，并为每个主键属性创建`&lt;key-property&gt;`。此外，通过创建一个专门的主键类，我们...

    hibernate 3.6 中文 chm

    10. **一对多、多对一、一对一和多对多关系映射**：Hibernate支持多种关联映射，包括集合映射，如List、Set、Map等，以及复合主键的处理。 11. **继承映射**：在Java中，子类可以继承父类。在Hibernate中，这种继承...

    Hibernate Annotations 中文文档

    2.2.6. 映射复合主键与外键 2.2.7. 映射二级表(secondary tables) 2.3. 映射查询 2.3.1. 映射EJBQL/HQL查询 2.3.2. 映射本地化查询 2.4. Hibernate独有的注解扩展 2.4.1. 实体 2.4.2. 标识符 2.4.3. 属性 2.4...

    hibernate源码分析过程

    Hibernate 的基本映射包括 id 算法、复合主键、数据版本并发性控制等。id 算法可以是整型自增、sql server 等数据库的 identity、Oracle 的 sequence、hilo（高低位）算法、uuid、guid、程序赋值等。复合主键可以...

    hibernate教程

    - 复合主键可以通过`@EmbeddedId`和自定义的复合主键类来实现。 - **映射二级表**： - 使用`@SecondaryTables`和`@SecondaryTable`来指定额外的表。 #### 四、Hibernate独有的注解扩展 Hibernate除了支持标准的...

    hibernate-annotations-3.4.0.GA

    4. 新的持久化模型：支持复合主键、级联操作等更复杂的持久化模型。 5. 可配置的延迟加载：通过注解可以控制属性或关联关系的延迟加载行为。 四、实战应用 1. 创建实体类：利用@Entity、@Table、@Id等注解创建符合...

    hibernate教程ppt

    Hibernate支持属性映射、类映射、关联映射（一对一、一对多、多对多），以及继承映射和复合主键映射，实现了灵活的数据操作。 5. **Hibernate的使用**：学习Hibernate时，首先需要下载并配置相关库，创建Hibernate...

    hibernate-annotations-3.4.0.GA.rar

    Hibernate注解是基于Java 5引入的元数据机制，允许在源代码中嵌入元数据信息，用于描述对象如何映射到数据库。例如，`@Entity`注解表示一个类作为数据库中的表，`@Table`定义表名，`@Id`标记主键字段。 2. **实体...

    hibernate annotation 中文文档

    - **2.2.6 映射复合主键与外键** - 使用 `@CompositeId` 和 `@JoinColumns` 来定义复杂的主键和外键映射。 - **2.2.7 映射二级表（secondary tables）** - 有时候需要将实体Bean的部分属性映射到另外一张表上，...

    Hibernate 进阶教程

    10. **其他高级特性**：包括双向关联的维护、集合的有序性和索引、复合主键的处理、子类继承的映射等。 《Hibernate 中文手册 3.5.2.pdf》、《Hibernate 中文手册 3.2.pdf》和《Hibernate 中文手册 3.1.2.pdf》分别...

    hibernate 经典题目 其中包括很多核心的题目

    `&lt;class&gt;`（表示实体类）、`&lt;id&gt;`（表示主键）、`&lt;property&gt;`（表示普通属性）、`&lt;one-to-one&gt;`（一对一关联）、`&lt;many-to-one&gt;`（多对一关联）、`&lt;set&gt;` 或 `&lt;list&gt;`（多对多关系）、`&lt;key&gt;`（描述外键）、`...

    hibernate 中文参考手册

    - **复合主键概念**：解释复合主键的概念。 - **映射配置**：讲解如何在映射文件中配置复合主键。 - **示例代码**：给出具体的复合主键配置示例。 以上内容基于提供的文档摘要进行了详细展开，旨在帮助读者深入了解...

    hibernate框架笔记

    - **复合主键**：使用多个字段组合成主键，适用于某些特殊场景。 #### 七、使用JPA注解配置实体类 JPA (Java Persistence API) 是一种Java EE标准，用于管理Java应用中的关系数据。在Hibernate中使用JPA注解可以...

    Hibernate项目开发宝典源码（完整版）

    - 实体类的设计与映射，包括属性注解、继承、复合主键等。 - Session和Transaction的使用，事务的隔离级别与回滚规则。 - Criteria API和HQL的查询语法，以及SQL的自定义操作。 - 数据库关系映射，如一对一、一对多...

Magicbox
Global site tag (gtag.js) - Google Analytics