前言：使用@OneToOne注解可以建立实体bean之间的一对一的关联. 一对一关联有三种情况： 一是关联的实体都共享同样的主键, 二是其中一个实体通过外键关联到另一个实体的主键 (注意要模拟一对一关联必须在外键列上添加唯一约束). 三是通过关联表来保存两个实体之间的连接关系 (注意要模拟一对一关联必须在每一个外键上添加唯一约束).
(1)共享主键来进行一对一关联映射（单向）
例子：我们用一个男人只有一个妻子为例
import javax.persistence.*;
@Entity
@Table(name = "husband")
public class Husband {
private int id;
private String name;
private Wife wife;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "id")
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name = "name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//记得cascade一定要有哦要不同时保存时不会保存wife对象
@OneToOne(cascade = { CascadeType.ALL })
@PrimaryKeyJoinColumn
public Wife getWife() {
return wife;
}
public void setWife(Wife wife) {
this.wife = wife;
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－
@Entity
@Table(name = "wife")
public class Wife {
private int id;
private String name;
@Id
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name = "name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－
测试方法
public static void installData() {
SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory();
Session session = sf.openSession();
Transaction tx = session.beginTransaction();
Husband husband = new Husband();
husband.setName("丁元伟");
Wife wife = new Wife();
wife.setName("不知道");
husband.setWife(wife);
session.save(husband); //只需保存husband就可以同时保存wife了
tx.commit();
/*Hibernate: 生成的sql语句
insert
into
husband
(id, name)
values
(null, ?)
Hibernate:
select
wife_.id,
wife_.name as name5_
from
wife wife_
where
wife_.id=?
Hibernate:
insert
into
wife
(name, id)
values
(?, ?)*/
}
//查询时只需查询husband就可以把wife也查出来
(2) 主键来进行一对一关联映射（双向）
Husband类不变同上
Wife类有所改变
@Entity
@Table(name = "wife")
public class Wife {
private int id;
private String name;
private Husband husband;
@Id
@GenericGenerator(name = "pkGenerator", strategy = "foreign", parameters = { @Parameter(name = "property", value = "husband") })
@GeneratedValue(generator = "pkGenerator")
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name = "name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToOne(cascade = CascadeType.ALL, mappedBy = "wife")
@PrimaryKeyJoinColumn
public Husband getHusband() {
return husband;
}
public void setHusband(Husband husband) {
this.husband = husband;
}
}
－－－－－－－－－－－－－－－－测试代码save
public static void installData() {
SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory();
Session session = sf.openSession();
Transaction tx = session.beginTransaction();
Husband husband = new Husband();
husband.setName("丁元伟");
Wife wife = new Wife();
wife.setName("不知道");
husband.setWife(wife);//这边得写
wife.setHusband(husband); //这边也得写
session.save(husband); //只需保存husband就可以同时保存wife了
tx.commit();
}
－－－－－－－－－－－－－－－－－find
public static void findDate() {
SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory();
Session session = sf.openSession();
Transaction tx = session.beginTransaction();
/*
因为mappedBy是定义在classes中,即classes类不负责维护级联关系.即维护者是student.所以,
1.要将clsses的数据,赋给student,即用student的setClasses()方法去捆定class数据;
2.在进行数据插入/更新session.save()/session.update()时,最后操作的是student.
*/
/*Husband husband = (Husband) session.get(Husband.class, 1);
System.out.println(husband.getName());
Wife wife = husband.getWife();
System.out.println(wife.getName());*/
//上下都可行
Wife wife = (Wife) session.get(Wife.class, 1);
System.out.println(wife.getName());
Husband husband = wife.getHusband();
System.out.println(husband.getName());
tx.commit();
}
(3)一对一外键双向关联（没有中间表）
@Entity
@Table(name = "husband")
public class Husband {
private int id;
private String name;
private Wife wife;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "id")
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name = "name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//记得cascade一定要有哦要不同时保存时不会保存wife对象
@OneToOne(cascade = CascadeType.ALL, mappedBy = "husband")//必须有cascade
public Wife getWife() {
return wife;
}
public void setWife(Wife wife) {
this.wife = wife;
}
}
---------------------------------------
@Entity
@Table(name = "wife")
public class Wife {
private int id;
private String name;
private Husband husband;
@Id
@Column(name = "id")
@GeneratedValue(strategy = GenerationType.AUTO)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name = "name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToOne(cascade = CascadeType.ALL) //必须有cascade
@JoinColumn(name = "husband_id")
public Husband getHusband() {
return husband;
}
public void setHusband(Husband husband) {
this.husband = husband;
}
}
---------------------------------------
public static void installData() {
SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory();
Session session = sf.openSession();
Transaction tx = session.beginTransaction();
tx.begin();
Husband husband = new Husband();
husband.setName("张三");
Wife wife = new Wife();
wife.setName("如花");
wife.setHusband(husband);
husband.setWife(wife);
session.save(husband);
//或session.save(wife); 但双方得相互设入对方
tx.commit();
}
-------------------------------------
下面查询时如果只查一方都会带出另一方内容（left outer join关联所以得设置为延迟加载）
/*
因为mappedBy是定义在classes中,即classes类不负责维护级联关系.即维护者是student.所以,
1.要将clsses的数据,赋给student,即用student的setClasses()方法去捆定class数据;
2.在进行数据插入/更新session.save()/session.update()时,最后操作的是student.
*/
Husband husband = (Husband) session.get(Husband.class, 1);
System.out.println(husband.getName());
Wife wife = husband.getWife();
System.out.println(wife.getName());
//上下都可行
/*Wife wife = (Wife) session.get(Wife.class, 1);
System.out.println(wife.getName());
Husband husband = wife.getHusband();
System.out.println(husband.getName());*/
4)一对一外键单向关联（没有中间表）
单向关联就是一边不设关联
//这边没有设置关联操作其他的和上面3的一样
@Entity
@Table(name = "husband")
public class Husband {
private int id;
private String name;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "id")
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name = "name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
(5)hibernate 注解一对一关系 关联表关联
请参考
http://gyfbao.blog.sohu.com/166353836.html
测试关联表时如出现下面这个错，需先主键类持久化或保存相对应的另一个非主键类
org.hibernate.PropertyValueException: not-null property references a null or transient value:
分享到：
相关推荐
在一对一的关联关系中，如果两个实体共享同一个主键，那么这种关联被称为共享主键的一对一关联。这意味着这两个实体的表在数据库中通过主键进行连接，一个实体的主键同时也作为另一个实体的外键。 在Hibernate中，...
在Hibernate中，一对一关联可以通过`@OneToOne`注解来实现。这个注解可以放在属性上，表示该属性对应另一个实体的实例。外键通常设置在关系的“从属”一方，也就是依赖于其他实体的一方。 对于联合主键，我们需要...
在Java的持久化框架Hibernate中，一对一双向外键关联是一种常见的关系映射方式，用于表示两个实体类之间一对一的关联关系。在这个场景下，每个实体都有一个引用指向另一个实体，形成双向关联。本篇文章将深入探讨...
本文将深入探讨这两种关联方式在使用Hibernate时的配置，包括基于注解（Annotation）和XML的方式。 1. **一对多关联**（Many-to-One） - 在这种关系中，一个实体可以对应多个其他实体。例如，一个班级可以有多个...
### Hibernate Annotation注解编程知识点详解 #### 一、概述与设置环境 - **概述**：Hibernate 是一个流行的 Java 持久层框架，它提供了一种面向对象的方式来处理数据库操作。Hibernate 支持多种元数据定义方式，...
唯一外键是指在一对一关联中，一方的主键同时也作为另一方的外键，确保两个实体共享同一个ID。这可以通过在没有`@JoinColumn`的情况下让两个实体共享相同的主键生成策略来实现。例如，使用`GenerationType.IDENTITY`...
本篇将详细讲解如何使用Hibernate实现多对多单向关联，包括注解（Annotation）和XML配置方式。 一、多对多关联的基本概念 多对多关联意味着一个实体可以与多个其他实体关联，反之亦然。例如，学生和课程的关系，一...
本文将深入探讨如何使用Hibernate注解实现基于外键的一对多双向关联。我们将通过具体实例来解析这个主题，并结合源码分析其工作原理。 首先，我们要明白一对多关联意味着一个实体可以拥有多个关联的实体。在数据库...
在Hibernate 3.x版本中，引入了Annotation注解，这是一种元数据的方式，可以替代XML配置文件来描述对象与数据库表之间的映射关系。 **Hibernate Annotation注解** 在Hibernate 3.x之前，对象到数据库的映射通常...
Hibernate 3是Hibernate ORM框架的一个重要版本，它引入了许多新特性，如对JPA（Java Persistence API）的支持，以及对注解的广泛使用。这一版本的更新使得Hibernate更加易于使用，同时也提高了代码的可读性和可维护...
### Spring_Hibernate_JAVAX_Annotation 注解详解 #### 一、概述 本文将详细介绍与SSH（Spring+Struts+Hibernate）开发相关的注解。这些注解覆盖了多个领域，如AspectJ、Batch处理、Spring框架本身的功能（包括...
标题“Hibernate distribution and annotation”涉及到的是Hibernate ORM框架的一个特定版本及其相关的注解功能。Hibernate是一个流行的Java对象关系映射（ORM）工具，它允许开发者使用面向对象的编程模型来操作...
使用@OneToOne注解建立实体Bean之间的一对一关联。一对一关联有三种情况：(1).关联的实体都共享同样的主键，(2).其中一个实体通过外键关联到另一个实体的主键(注意要模拟一对一关联必须在外键列上添加唯一约束)，(3)...
Hibernate Annotation是Hibernate框架的一个重要特性，它允许开发者直接在Java类上使用注解来定义对象的数据库映射，从而避免了传统的XML配置文件。这种做法提高了代码的可读性和维护性，同时也使得开发流程更为简洁...
这里，Person和Address类共享同一主键`PERSON_ID`，表明它们一对一关联。 2. **单方外键关联（Unidirectional Foreign Key Join）** 在单方外键关联中，一个实体通过外键字段引用另一个实体。配置如下： ```xml ...
在Hibernate中，注解（Annotation）是一种声明式的方法，用于配置实体类、属性以及它们与数据库表之间的映射关系。本文将深入探讨“最全的Hibernate Annotation API文档”中的关键知识点。 一、实体类（Entity） 在...
- **2.2.5.1 一对一（One-to-one）**：使用 `@OneToOne` 注解来定义两个实体Bean之间的一对一关联关系。 - **2.2.5.2 多对一（Many-to-one）**：使用 `@ManyToOne` 注解来定义多对一的关联关系。 - **2.2.5.3 ...
在"ssh2 Annotation注解 框架+oracle"的场景下，我们将深入探讨SSH2框架如何结合注解和Oracle数据库进行应用开发。 **Spring Annotation注解** Spring框架允许开发者使用注解来声明Bean、依赖注入、事务管理等。...