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`关系是常见的实体间关系之一,表示一个实体可以与多个其他实体相关联。本文将深入探讨`Hibernate one-to-many`注解的使用和实现细节。 ### 一、`@OneToMany`注解概述 `@OneToMany`...
### Hibernate Annotation 中文文档知识点概览 #### 一、创建注解项目 ##### 1.1 系统需求 在创建一个使用 Hibernate 注解的项目之前,需要满足一定的系统环境需求,例如支持 Java 的开发环境、JDK 版本、支持 ...
### Hibernate Annotation 帮助文档知识点总结 #### 1. 创建注解项目 - **系统需求**:在开始创建一个支持 Hibernate 注解的项目之前,需要确保满足以下系统需求: - Java 开发环境(例如 JDK 1.8 或更高版本)。...
<one-to-one name="student" class="com.zj.hibernate.Student" constrained="true"/> </hibernate-mapping> ``` 以上内容仅覆盖了一对一的几种常见关联方式及其配置方法,接下来还可以进一步探讨其他类型的关系...
在`Hiberante_annptation.one`和`Hibernate_annotation`这两个文件中,很可能包含了使用Hibernate注解的实例代码。通过阅读和分析这些代码,你可以看到如何将实体类、主键策略、表和字段映射以及关联关系具体实现。...
- **关联级元数据**:使用 XML 配置文件中的 `<join>` 或 `<one-to-many>` 等元素来覆盖关联级别的元数据。 #### 六、附加模块 - **Bean Validation**: - **集成**:添加 Bean Validation 支持以验证实体的有效...
Hibernate Annotation几种关联映射 一对一(One-To-One) 使用@OneToOne注解建立实体Bean之间的一对一关联。一对一关联有三种情况:(1).关联的实体都共享同样的主键,(2).其中一个实体通过外键关联到另一个实体的主键...
在Java的持久化框架Hibernate中,一对多(Many-to-One)和多对一(One-to-Many)的关系映射是数据库关系模型中的常见关联类型。本文将深入探讨这两种关联方式在使用Hibernate时的配置,包括基于注解(Annotation)和...
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 ...
该示例包含了基于XML和Annotation的Hibernate配置,涵盖了one-to-one、one-to-many、many-to-many映射关系的配置,并提供了独立的测试用例。适合用于学习和实践Java和Hibernate技术,以及开发基于MySQL的数据持久化...
对于一对多关系,可以使用`<set>`或`<list>`标签来表示集合,同时通过`<many-to-one>`标签定义多的一方与一的一方的关联。 接下来,我们来详细解析这个案例的实现步骤: 1. 创建实体类:用户类(User)和订单类...
在Java的持久化框架Hibernate中,`@OneToMany`注解是用于表示一对多关系的,这种关系常见于数据库设计中的父表与子表之间。在这个主题中,我们将深入探讨如何在实体类中使用`@OneToMany`注解以及其在实际项目中的...
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) ...
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) ...
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 ...
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 ...
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. 在...
在Java的持久化框架Hibernate中,一对一(One-to-One)关联是常见的关系映射类型,它用于表示两个实体之间存在唯一的对应关系。本篇将详细讲解如何使用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的XML映射文件中,我们可以使用`<one-to-many>`和`<many-to-one>`元素来定义关联。 1. **在父类的映射文件中**,使用`<one-to-many>`元素声明一对多关联,并通过`class`属性指定子类的全限定类名。 ```...