`
prizefrigh
  • 浏览: 11168 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

hibernate one to one Annotation

阅读更多
1. 外键单向(unidirectional with foreign key )
create table USERS(
	PK_USER_ID	INT IDENTITY NOT NULL,
	USER_ID		VARCHAR(50)	NOT NULL,
	FK_GROUP_ID	INT	NOT NULL
	
)

create table USER_GROUP(
	PK_GROUP_ID	INT IDENTITY NOT NULL,
	GROUP_NAME		VARCHAR(50)	NOT NULL,
	LAST_UPDATED_BY	VARCHAR(50)	NOT NULL,
	LAST_UPDATED_DATE DATETIME NOT NULL
)


@Entity
@Table(name = "USERS")
public class User {
	private int pkUserId;
	private String userId;
	private Group group;
	
	public User(){}

	@Id
	@GeneratedValue(strategy = IDENTITY)
	@Column(name = "PK_USER_ID", unique = true, nullable = false)
	public int getPkUserId() {
		return pkUserId;
	}
	
	public void setPkUserId(int pkUserId) {
		this.pkUserId = pkUserId;
	}
	
	@Column(name = "USER_ID", unique = true, nullable = false)
	public String getUserId() {
		return userId;
	}

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

	@OneToOne(fetch = FetchType.EAGER)
	@JoinColumn(name = "FK_GROUP_ID")
	public Group getGroup() {
		return group;
	}
}


@Entity
@Table(name = "USER_GROUP")
public class Group {
	private int groupId;
	private String groupName;
	private String lastUpdatedBy;
	private Date lastUpdatedDate;
	
	public Group()
	{
	}

	@Id
	@GeneratedValue(strategy = IDENTITY)
	@Column(name = "PK_GROUP_ID", unique = true, nullable = false)
	public int getGroupId() {
		return groupId;
	}

	public void setGroupId(int groupId) {
		this.groupId = groupId;
	}

	@Column(name = "GROUP_NAME", nullable = true)
	public String getGroupName() {
		return groupName;
	}

	public void setGroupName(String groupName) {
		this.groupName = groupName;
	}

	@Column(name = "LAST_UPDATED_BY", nullable = false)
	public String getLastUpdatedBy() {
		return lastUpdatedBy;
	}

	public void setLastUpdatedBy(String lastUpdatedBy) {
		this.lastUpdatedBy = lastUpdatedBy;
	}

	@Column(name = "LAST_UPDATED_DATE", nullable = false)
	public Date getLastUpdatedDate() {
		return lastUpdatedDate;
	}

	public void setLastUpdatedDate(Date lastUpdatedDate) {
		this.lastUpdatedDate = lastUpdatedDate;
	}

	public String toString() {
		return this.groupId + "\t" + this.groupName + "\t\t" + this.lastUpdatedBy + "\t\t" + this.lastUpdatedDate;
	}
	
	
}






2. 外键双向(bidirectional with  foreign key )
为Group 增加 User 变量
public class Group {
	...........
	private User user;
	

	................
	@OneToOne(mappedBy = "group")
	public User getUser() {
		return user;
	}

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

}


group 是User类中的成员变量名。
mappedBy 作用如下:
引用

In a bidirectional relationship, one of the sides (and only one)
has to be the owner: the owner is responsible for
the association column(s) update.
To declare a side as not responsible
for the relationship,
the attribute mappedBy is used.
mappedBy refers to the property name of
the association on the owner side.

参考:http://docs.jboss.org/ejb3/app-server/HibernateAnnotations/reference/en/html_single/index.html#d0e1517


3. 主键双向(bidirectional  with primary key)
create table BODY(
	PK_BODY_ID	INT IDENTITY NOT NULL,
	LAST_UPDATED_BY	VARCHAR(50)	NOT NULL,
	LAST_UPDATED_DATE DATETIME NOT NULL
)

create table HEART(
	PK_HEART_ID	INT NOT NULL,
	HEART_TYPE		VARCHAR(50)	NOT NULL,
	LAST_UPDATED_BY	VARCHAR(50)	NOT NULL,
	LAST_UPDATED_DATE DATETIME NOT NULL
)


@Entity
@Table(name = "BODY")
public class Body {
	private Long id;
	private String lastUpdatedBy;
	private Date lastUpdatedDate;
	private Heart heart;
	
	public Body(){
	}

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "PK_BODY_ID", unique = true, nullable = false)
	public Long getId() {
		return id;
	}

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

	@OneToOne(cascade = CascadeType.ALL)
	@PrimaryKeyJoinColumn
	public Heart getHeart() {
		return heart;
	}

	public void setHeart(Heart heart) {
		this.heart = heart;
	}

	@Column(name = "LAST_UPDATED_BY", nullable = false)
	public String getLastUpdatedBy() {
		return lastUpdatedBy;
	}

	public void setLastUpdatedBy(String lastUpdatedBy) {
		this.lastUpdatedBy = lastUpdatedBy;
	}

	@Column(name = "LAST_UPDATED_DATE", nullable = false)
	public Date getLastUpdatedDate() {
		return lastUpdatedDate;
	}

	public void setLastUpdatedDate(Date lastUpdatedDate) {
		this.lastUpdatedDate = lastUpdatedDate;
	}
	
	public String toString() {
		return this.getId() + "\t" + this.getLastUpdatedBy() + "\t" + this.getLastUpdatedDate() + "\t" + this.getHeart().getId();
	}
}


@Entity
@Table(name = "HEART")
public class Heart {
	private Long id;
	private String type;
	private String lastUpdatedBy;
	private Date lastUpdatedDate;
	private Body body;

	public Heart() {
	}

	@Id
	@GenericGenerator(
name = "generator", 
strategy = "foreign", 
parameters = @Parameter(
   name = "property", 
   value = "body"))
	@GeneratedValue(generator="generator")
	@Column(name = "PK_HEART_ID", unique = true, nullable = false)
	public Long getId() {
		return id;
	}

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

	@Column(name = "HEART_TYPE", nullable = false)
	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	@Column(name = "LAST_UPDATED_BY", nullable = false)
	public String getLastUpdatedBy() {
		return lastUpdatedBy;
	}

	public void setLastUpdatedBy(String lastUpdatedBy) {
		this.lastUpdatedBy = lastUpdatedBy;
	}

	@Column(name = "LAST_UPDATED_DATE", nullable = false)
	public Date getLastUpdatedDate() {
		return lastUpdatedDate;
	}

	public void setLastUpdatedDate(Date lastUpdatedDate) {
		this.lastUpdatedDate = lastUpdatedDate;
	}

	@OneToOne(cascade = CascadeType.ALL, mappedBy="heart")
	public Body getBody() {
		return body;
	}

	public void setBody(Body body) {
		this.body = body;
	}

	@Override
	public String toString() {
		return this.getId() + "\t" + this.getType();
	}
}




save时, 须调用
b.setHeart(h);
h.setBody(b);

否则会报错
Exception in thread "main" [size=xx-small]org.hibernate.id.IdentifierGenerationException: 
attempted to assign id from null one-to-one property: body[/size]


4. 主键单向没成功
分享到:
评论

相关推荐

    Hibernate one-to-many-annotation

    在Hibernate中,`one-to-many`关系是常见的实体间关系之一,表示一个实体可以与多个其他实体相关联。本文将深入探讨`Hibernate one-to-many`注解的使用和实现细节。 ### 一、`@OneToMany`注解概述 `@OneToMany`...

    hibernate annotation 中文文档

    ### Hibernate Annotation 中文文档知识点概览 #### 一、创建注解项目 ##### 1.1 系统需求 在创建一个使用 Hibernate 注解的项目之前,需要满足一定的系统环境需求,例如支持 Java 的开发环境、JDK 版本、支持 ...

    hibernate annotation帮助文档

    ### Hibernate Annotation 帮助文档知识点总结 #### 1. 创建注解项目 - **系统需求**:在开始创建一个支持 Hibernate 注解的项目之前,需要确保满足以下系统需求: - Java 开发环境(例如 JDK 1.8 或更高版本)。...

    Hibernate ORMapping Annotation XML PDF

    <one-to-one name="student" class="com.zj.hibernate.Student" constrained="true"/> </hibernate-mapping> ``` 以上内容仅覆盖了一对一的几种常见关联方式及其配置方法,接下来还可以进一步探讨其他类型的关系...

    hibernate annotation

    在`Hiberante_annptation.one`和`Hibernate_annotation`这两个文件中,很可能包含了使用Hibernate注解的实例代码。通过阅读和分析这些代码,你可以看到如何将实体类、主键策略、表和字段映射以及关联关系具体实现。...

    hibernate _annotation 注解编程

    - **关联级元数据**:使用 XML 配置文件中的 `<join>` 或 `<one-to-many>` 等元素来覆盖关联级别的元数据。 #### 六、附加模块 - **Bean Validation**: - **集成**:添加 Bean Validation 支持以验证实体的有效...

    Hibernate_Annotation关联映射

    Hibernate Annotation几种关联映射 一对一(One-To-One) 使用@OneToOne注解建立实体Bean之间的一对一关联。一对一关联有三种情况:(1).关联的实体都共享同样的主键,(2).其中一个实体通过外键关联到另一个实体的主键...

    Hibernate一对多(多对一)双向关联(annotation/xml)

    在Java的持久化框架Hibernate中,一对多(Many-to-One)和多对一(One-to-Many)的关系映射是数据库关系模型中的常见关联类型。本文将深入探讨这两种关联方式在使用Hibernate时的配置,包括基于注解(Annotation)和...

    Hibernate+中文文档

    7.4.1. 一对多(one to many) / 多对一(many to one) 7.4.2. 一对一(one to one) 7.5. 使用连接表的双向关联(Bidirectional associations with join tables) 7.5.1. 一对多(one to many) /多对一( many ...

    基于Java的Hibernate MySQL数据持久化示例设计源码

    该示例包含了基于XML和Annotation的Hibernate配置,涵盖了one-to-one、one-to-many、many-to-many映射关系的配置,并提供了独立的测试用例。适合用于学习和实践Java和Hibernate技术,以及开发基于MySQL的数据持久化...

    hibernate4.3.8的annotation及xml的一对多的双向案例

    对于一对多关系,可以使用`<set>`或`<list>`标签来表示集合,同时通过`<many-to-one>`标签定义多的一方与一的一方的关联。 接下来,我们来详细解析这个案例的实现步骤: 1. 创建实体类:用户类(User)和订单类...

    Hibernate- oneToMany using annotation

    在Java的持久化框架Hibernate中,`@OneToMany`注解是用于表示一对多关系的,这种关系常见于数据库设计中的父表与子表之间。在这个主题中,我们将深入探讨如何在实体类中使用`@OneToMany`注解以及其在实际项目中的...

    hibernate3.2中文文档(chm格式)

    7.5.1. 一对多(one to many) /多对一( many to one) 7.5.2. 一对一(one to one) 7.5.3. 多对多(many to many) 7.6. 更复杂的关联映射 8. 组件(Component)映射 8.1. 依赖对象(Dependent objects) ...

    HibernateAPI中文版.chm

    7.5.1. 一对多(one to many) /多对一( many to one) 7.5.2. 一对一(one to one) 7.5.3. 多对多(many to many) 7.6. 更复杂的关联映射 8. 组件(Component)映射 8.1. 依赖对象(Dependent objects) ...

    最全Hibernate 参考文档

    7.4.1. 一对多(one to many) / 多对一(many to one) 7.4.2. 一对一(one to one) 7.5. 使用连接表的双向关联(Bidirectional associations with join tables) 7.5.1. 一对多(one to many) /多对一( many to ...

    Hibernate中文详细学习文档

    7.4.1. 一对多(one to many) / 多对一(many to one) 7.4.2. 一对一(one to one) 7.5. 使用连接表的双向关联(Bidirectional associations with join tables) 7.5.1. 一对多(one to many) /多对一( many ...

    Hibernate 中文 html 帮助文档

    7.5.1. 一对多(one to many) /多对一( many to one) 7.5.2. 一对一(one to one) 7.5.3. 多对多(many to many) 7.6. 更复杂的关联映射 8. 组件(Component)映射 8.1. 依赖对象(Dependent objects) 8.2. 在...

    Hibernate一对一单向外键关联 (联合主键annotation)

    在Java的持久化框架Hibernate中,一对一(One-to-One)关联是常见的关系映射类型,它用于表示两个实体之间存在唯一的对应关系。本篇将详细讲解如何使用Hibernate进行一对一单向外键关联,并且该关联涉及到联合主键的...

    Hibernate教程

    8.4.1. 一对多(one to many) / 多对一(many to one) 8.4.2. 一对一(one to one) 8.5. 使用连接表的双向关联(Bidirectional associations with join tables) 8.5.1. 一对多(one to many) /多对一( many ...

    Hibernate一对多单向关联(annotation/xml)

    在Hibernate的XML映射文件中,我们可以使用`<one-to-many>`和`<many-to-one>`元素来定义关联。 1. **在父类的映射文件中**,使用`<one-to-many>`元素声明一对多关联,并通过`class`属性指定子类的全限定类名。 ```...

Global site tag (gtag.js) - Google Analytics