`
balaschen
  • 浏览: 192343 次
  • 性别: Icon_minigender_1
社区版块
存档分类
最新评论

hibernate复合主键及关联的实现

阅读更多

如果你不得不面对遗留系统老式的数据库复合主键,无法享受逻辑主键(代理主键)带来的幸福生活,那么使用CompositeUserType来处理复合主键是个不错的选择.废话少说,看看如何实现:


/**
 * $Revision: 1.0 $
 * Created: 2008-1-11
 * $Date: 2008-1-11 $
 * 
 * Author: Keven Chen
 */
package com.comwave.ww_oa.webui.org;

import java.io.Serializable;

/**
 * @author Keven Chen
 * @version $Revision 1.0 $
 *
 */
public class UserPositionId implements Serializable {
	private String userId;

	private String posId;
	
	public UserPositionId(){}
	
	public UserPositionId(String userId, String posId) {
		this.userId = userId;
		this.posId = posId;
	}

	public String getPosId() {
		return posId;
	}

	public void setPosId(String posId) {
		this.posId = posId;
	}

	public String getUserId() {
		return userId;
	}

	public void setUserId(String userId) {
		this.userId = userId;
	}

	public int hashCode() {
		final int PRIME = 31;
		int result = 1;
		result = PRIME * result + ((posId == null) ? 0 : posId.hashCode());
		result = PRIME * result + ((userId == null) ? 0 : userId.hashCode());
		return result;
	}

	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		final UserPositionId other = (UserPositionId) obj;
		if (posId == null) {
			if (other.posId != null)
				return false;
		} else if (!posId.equals(other.posId))
			return false;
		if (userId == null) {
			if (other.userId != null)
				return false;
		} else if (!userId.equals(other.userId))
			return false;
		return true;
	}
	
}
 

 

 

/**
 * $Revision: 1.0 $
 * Created: 2008-1-11
 * $Date: 2008-1-11 $
 * 
 * Author: Keven Chen
 */
package com.comwave.ww_oa.webui.org;

import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.engine.SessionImplementor;
import org.hibernate.type.Type;
import org.hibernate.usertype.CompositeUserType;

/**
 * @author Keven Chen
 * @version $Revision 1.0 $
 * 
 */
public class UserPositionIdUserType implements CompositeUserType {

	public Object assemble(Serializable cached, SessionImplementor session, Object owner)
			throws HibernateException {
		return deepCopy(cached);
	}

	public Object deepCopy(Object value) throws HibernateException {
		UserPositionId id = (UserPositionId) value;
		return new UserPositionId(id.getUserId(),id.getPosId());
	}

	public Serializable disassemble(Object value, SessionImplementor session)
			throws HibernateException {
		return (Serializable) deepCopy(value);
	}


	public boolean equals(Object x, Object y) throws HibernateException {
		if (x==y) return true;
		if (x==null || y==null) return false;
		return x.equals(y);
	}

	public String[] getPropertyNames() {
		return new String[] { "userId", "posId" };
	}

	public Type[] getPropertyTypes() {
		return new Type[] { Hibernate.STRING, Hibernate.STRING };
	}

	public Object getPropertyValue(Object component, int property) throws HibernateException {
		UserPositionId id = (UserPositionId) component;
		return property == 0 ? id.getUserId() : id.getPosId();
	}

	public void setPropertyValue(Object component, int property, Object value)
			throws HibernateException {
		UserPositionId id = (UserPositionId) component;
		if (property == 0) {
			id.setUserId((String) value);
		} else {
			id.setPosId((String) value);
		}

	}

	public int hashCode(Object x) throws HibernateException {
		return x.hashCode();
	}

	public boolean isMutable() {
		return true;
	}

	public Object nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
			throws HibernateException, SQLException {
		String userId = (String) Hibernate.STRING.nullSafeGet(rs, names[0]);
		String posId = (String) Hibernate.STRING.nullSafeGet(rs, names[1]);
		return new UserPositionId(userId,posId);
	}

	public void nullSafeSet(PreparedStatement st, Object value, int index,
			SessionImplementor session) throws HibernateException, SQLException {
		UserPositionId id = (UserPositionId) value;
		String userId = (id == null) ? null : id.getUserId();
		String posId = (id == null) ? null :id.getPosId();
		Hibernate.STRING.nullSafeSet(st,userId, index);
		Hibernate.STRING.nullSafeSet(st,posId, index+1);
	}

	public Object replace(Object original, Object target, SessionImplementor session, Object owner)
			throws HibernateException {
		return deepCopy(original); //TODO: improve
	}

	public Class returnedClass() {
		return UserPositionId.class;
	}
}

 

/**
 * $Revision: 1.0 $
 * Created: 2008-1-10
 * $Date: 2008-1-10 $
 * 
 * Author: Keven Chen
 */
package com.comwave.ww_oa.webui.org;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Keven Chen
 * @version $Revision 1.0 $
 * 
 */
public class UserPosition {
	
	private UserPositionId id = new UserPositionId();
	
	private User user;

	private Position postion;

	private UserPosition director;

	private boolean dept_director;

	private boolean unit_director;

	private boolean top_unit_director;
	
	private List underling = new ArrayList();

	public List getUnderling() {
		return underling;
	}

	public void setUnderling(List underling) {
		this.underling = underling;
	}

	public boolean isDept_director() {
		return dept_director;
	}

	public void setDept_director(boolean dept_director) {
		this.dept_director = dept_director;
	}

	public Position getPostion() {
		return postion;
	}

	public void setPostion(Position postion) {
		this.postion = postion;
	}

	public boolean isTop_unit_director() {
		return top_unit_director;
	}

	public void setTop_unit_director(boolean top_unit_director) {
		this.top_unit_director = top_unit_director;
	}

	public boolean isUnit_director() {
		return unit_director;
	}

	public void setUnit_director(boolean unit_director) {
		this.unit_director = unit_director;
	}

	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}

	public UserPosition getDirector() {
		return director;
	}

	public void setDirector(UserPosition director) {
		this.director = director;
	}

	public UserPositionId getId() {
		return id;
	}

	public void setId(UserPositionId id) {
		this.id = id;
	}

	public int hashCode() {
		final int PRIME = 31;
		int result = 1;
		result = PRIME * result + ((id == null) ? 0 : id.hashCode());
		return result;
	}

	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		final UserPosition other = (UserPosition) obj;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		return true;
	}

}

 

<?xml version="1.0"  encoding='UTF-8'?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.comwave.ww_oa.webui.org">
	<class name="UserPosition" table="user_positions">
		<id name="id" type="com.comwave.ww_oa.webui.org.UserPositionIdUserType" unsaved-value="any">
			<column name="userId"/>
			<column name="posId"/>
		</id>
		<property name="dept_director" type="boolean"/>
		<property name="unit_director" type="boolean"/>
		<property name="top_unit_director" type="boolean"/>
		<bag name="underling" inverse="true">
			<key>
				<column name="director_user_id"/>
				<column name="director_pos_id"/>
			</key>
			<one-to-many class="UserPosition"/>
		</bag>
		<many-to-one name="director">
			<column name="director_user_id"/>
			<column name="director_pos_id"/>
		</many-to-one>
	</class>
</hibernate-mapping>
 

使用:和正常的类相同的使用方式

 

public UserPosition getPosition(String userId,String posId) {
		return getPosition(new UserPositionId(userId,posId));
	}
	
	public UserPosition getPosition(UserPositionId id){
		return (UserPosition) getHibernateTemplate().get(UserPosition.class,id);
	}
 
分享到:
评论

相关推荐

    Hibernate复合主键

    "Hibernate复合主键" Hibernate复合主键是指在 Hibernate 框架中使用复合主键来唯一标识一个实体。复合主键是指由多个字段组成的主键,用于唯一标识一个实体。在本例中,我们将通过一个简单的复合主键的做关联类的...

    hibernate复合主键映射

    在Hibernate中,我们可以通过实现`Serializable`接口并使用`@Embeddable`和`@EmbeddedId`注解来定义和管理复合主键。 首先,我们需要创建一个代表复合主键的类。例如,对于订单明细表,我们可以创建一个名为`...

    hibernate 无主键表映射

    这里,`Order`实体类通过`@EmbeddedId`注解关联了`OrderKey`复合主键类。 3. **映射到数据库的SQL语句** 在无主键表映射的情况下,数据库中的表应该没有明确的`PRIMARY KEY`约束,而是依赖于复合主键字段的唯一性。...

    Hibernate复合主键.

    本篇文章将深入探讨Hibernate如何支持和管理复合主键。 一、理解复合主键 在数据库设计中,复合主键是一种特殊情况,当单个字段不能唯一标识表中的每一行时,可以使用两个或多个字段的组合来创建唯一的标识。例如...

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

    在示例中,我们有一个`UserRolePK`类,用于表示用户角色关联的复合主键。这个类需要实现`Serializable`接口,因为所有主键都必须是可序列化的,以便于JPA处理。此外,为了确保两个`UserRolePK`对象是否相等,我们...

    Hibernate学习笔记

    复合主键关联映射则是处理具有多个字段作为主键的表与对象之间的映射。 通过理解这些知识点,开发者可以更有效地利用Hibernate框架来开发复杂的企业级应用,处理数据持久化以及对象和关系数据库之间的映射。...

    hibernate组件之间的关联

    使用 @Embeddable 和 @EmbeddedId 注解可以定义复合主键。 以上就是 Hibernate 组件之间的关联关系及其配置方法的详细介绍。了解并熟练运用这些关联,能够帮助开发者更高效地进行数据库操作,提高代码的可维护性和...

    JPA实体关联(hibernate实现)

    以下将详细解释四种主要的关联类型:复合主键、多对多、一对一和一对多。 1. **复合主键(JPACompositePK)** 在某些情况下,一个实体的主键可能由多个字段组成,这就需要使用复合主键。在JPA中,我们可以创建一个...

    复合主键@IdClass

    本文将详细探讨如何在SSH框架(Spring、Struts、Hibernate)中的实体类使用`@IdClass`注解来定义复合主键,并阐述其使用方法及注意事项。 #### 二、复合主键的定义与应用场景 复合主键是指由两个或两个以上的字段...

    Hibernate_关联关系映射配置

    `@EmbeddedId`用于指定实体的主键类,而`@Embeddable`则用于声明这个类为复合主键类。 六、延迟加载(Lazy Loading) Hibernate提供了延迟加载机制,可以按需加载关联对象,以提高性能。默认情况下,`@ManyToOne`...

    hibernate结构框架及组要实现类的深入分析

    SimpleValue 用于简单属性或单一主键,Collection 描述集合关系,Component 处理复合主键,ToOne 表示一对一关联。 **总结** Hibernate 结构框架的核心在于对象-关系映射,通过配置文件和映射文件实现数据库操作的...

    Hibernate 的关联映射

    - 使用外键:Hibernate支持实体间的外键关联,但也可以通过复合主键或联合主键实现。 - 级联操作:`cascade`属性可以配置为SAVE_UPDATE、PERSIST、MERGE、REMOVE等,决定操作一个实体时是否也影响关联的实体。 - ...

    Hibernate关联映射

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

    Hibernate表间关联ppt课件.ppt

    8. 复合主键(Composite Key): 当表使用多列作为主键时,需要创建一个专门的类来封装这些主键列,并在映射文件中使用`&lt;composite-id&gt;`标签定义。 9. 实践案例: - 一对多:报销与报销项。 - 多对多:订单与...

    Hibernate入门(代码+笔记)

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

    hibernate 3.6 中文 chm

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

Global site tag (gtag.js) - Google Analytics