hibernate注解之实体属性OneToOne 单双向关联（三）

最新推荐文章于 2023-01-06 16:10:30 发布
最新推荐文章于 2023-01-06 16:10:30 发布
阅读量678 收藏
点赞数
分类专栏： hibernate学习笔记 文章标签： Annotations hibernate 一对一 onetoone
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/asd2523011/article/details/40460291
版权

一对一(One-to-one)
 
使用@OneToOne注解可以建立实体bean之间的一对一的关联. 一对一关联有三种情况： 一是关联的实体都共享同样的主键, 二是其中一个实体通过外键关联到另一个实体的主键
(注意要模拟一对一关联必须在外键列上添加唯一约束). 三是通过关联表来保存两个实体之间的连接关系 (注意要模拟一对一关联必须在每一个外键上添加唯一约束).

首先,我们通过共享主键来进行一对一关联映射:
我们用丈夫和妻子的关系来形容这种关系。
1.关联实体共享主键
官方文档解释
@Entity
public class Body {
    @Id
    public Long getId() { return id; }

    @OneToOne(cascade = CascadeType.ALL)
    @PrimaryKeyJoinColumn
    public Heart getHeart() {
        return heart;
    }
    ...
}
           
@Entity
public class Heart {
    @Id
    public Long getId() { ...}
}

自己的例子：共享主键的话，主体的id需要是外键。

package com.unicom.oneToone;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;
import javax.persistence.CascadeType;

import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;

/*
 * @author huzhen
 */
@Entity
@Table(name = "t_husband")
public class Husband implements Serializable {
	private static final long serialVersionUID = 1L;
	public String id;
	public String name;
	public int age;
	public Wife wife;

	@Id
	@GeneratedValue(generator = "indent")
	@GenericGenerator(name = "indent", strategy = "foreign", parameters = { @Parameter(name = "property", value = "wife") })
	@Column(length = 32)
	public String getId() {
		return id;
	}

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

	@Column(length = 32)
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@OneToOne(cascade = CascadeType.ALL)
	@PrimaryKeyJoinColumn
	// @JoinColumn(name="wife_idss")
	public Wife getWife() {
		return wife;
	}

	public void setWife(Wife wife) {
		this.wife = wife;
	}

}

 

wife的class 的id就用uuid，hibernate自动生成吧。

package com.unicom.oneToone;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

/*
 * @author huzhen
 */
@Entity
@Table(name = "t_wife")
public class Wife implements Serializable {
	public String id;
	public String name;
	public String distnes;

	@Id
	@GeneratedValue(generator = "indent")
	@GenericGenerator(name = "indent", strategy = "uuid")
	public String getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getDistnes() {
		return distnes;
	}

	public void setDistnes(String distnes) {
		this.distnes = distnes;
	}

}
package com.unicom.oneToone;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;

/*
 * @author huzhen
 */
public class Test {
	public void insert() {
		Configuration config = new AnnotationConfiguration();
		config.configure();
		SessionFactory sessionFactory = config.buildSessionFactory();
		Session session = sessionFactory.getCurrentSession();
		session.beginTransaction();
		Husband hus = new Husband();
		hus.setName("huzhen");
		hus.setAge(25);
		Wife wf = new Wife();
		wf.setName("zhulinan");
		wf.setDistnes("very likily");
		hus.setWife(wf);
		session.save(hus);
		session.getTransaction().commit();

	}

	public void find() {
		Configuration config = new AnnotationConfiguration();
		config.configure();
		SessionFactory sessionFactory = config.buildSessionFactory();
		Session session = sessionFactory.getCurrentSession();
		session.beginTransaction();
		// Criteria cri=session.createCriteria(Husband.class);
		//
		// List
    
    
     
      list=cri.list();
		// for (Husband hus:list){
		// System.out.println(hus.getWife().getId());
		// }
		Husband hus = (Husband) session.get(Husband.class,
				"8ab8dab2493afcbb01493afcbc920001");
		System.out.println(hus.getWife().getId());
		session.getTransaction().commit();
	}

	public void delete() {
		Configuration config = new AnnotationConfiguration();
		config.configure();
		SessionFactory sessionFactory = config.buildSessionFactory();
		Session session = sessionFactory.getCurrentSession();
		session.beginTransaction();
		Husband hus = (Husband) session.get(Husband.class,
				"8ab8dab2493afcbb01493afcbc920001");
		Wife wife = (Wife) session.get(Wife.class,
				"8ab8dab2493afcbb01493afcbc920001");
		// session.delete(wife); //ObjectDeletedException deleted object would
		// be re-saved by cascade
		session.delete(hus); // delete susscee
		session.getTransaction().commit();
	}

	public static void main(String[] args) {
		Test ts = new Test();
		ts.delete();
	}

}
package com.unicom.oneToonedouble;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import javax.persistence.CascadeType;

import org.hibernate.annotations.GenericGenerator;

/*
 * @author huzhen
 */
@Entity
@Table(name = "t_husband")
public class Husband implements Serializable {
	public String id;
	public String name;
	public int age;
	public Wife wife;

	@Id
	@GeneratedValue(generator = "indent")
	@GenericGenerator(name = "indent", strategy = "uuid")
	@Column(length = 32)
	public String getId() {
		return id;
	}

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

	@Column(length = 32)
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@OneToOne(cascade = CascadeType.ALL)
	public Wife getWife() {
		return wife;
	}

	public void setWife(Wife wife) {
		this.wife = wife;
	}

}
package com.unicom.oneToonedouble;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

/*
 * @author huzhen
 */
@Entity
@Table(name = "t_wife")
public class Wife implements Serializable {
	public String id;
	public String name;
	public String distnes;
	public Husband husband;

	@Id
	@GeneratedValue(generator = "indent")
	@GenericGenerator(name = "indent", strategy = "uuid")
	public String getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getDistnes() {
		return distnes;
	}

	public void setDistnes(String distnes) {
		this.distnes = distnes;
	}

	@OneToOne(mappedBy = "wife")
	public Husband getHusband() {
		return husband;
	}

	public void setHusband(Husband husband) {
		this.husband = husband;
	}

}
package com.unicom.oneToonedouble;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/*
 * @author huzhen
 */
public class HibernetTest {
	public static SessionFactory sessionFactory;
	public static Session session;

	@Before
	public void opensession() {
		Configuration config = new AnnotationConfiguration();
		config.configure();
		sessionFactory = config.buildSessionFactory();
		session = sessionFactory.getCurrentSession();
		session.beginTransaction();

	}

	@After
	public void closesession() {

		session.getTransaction().commit();
		sessionFactory.close();
	}

	@Test
	public void testinsert() {

		Husband hus = new Husband();
		hus.setName("huzhen");
		hus.setAge(25);
		Wife wf = new Wife();
		wf.setName("zhulinan");
		wf.setDistnes("very likily");
		hus.setWife(wf);
		session.save(hus);

	}

	@Test
	public void delete() {
		Husband hus = (Husband) session.get(Husband.class,
				"8ab8dab2493c932801493c932c020001");
		// Wife wife=(Wife)
		// session.get(Wife.class,"8ab8dab2493c6feb01493c6fef210002");
		// session.delete(wife); //因为被动关联，删除失败
		session.delete(hus); //
	}

}

 

package com.unicom.oneTooneforeign;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

import org.hibernate.annotations.ForeignKey;
import org.hibernate.annotations.GenericGenerator;
/*
 * @author huzhen
 */
@Entity
@Table(name="t_wife")
public class Wife implements Serializable{
	public String id;
	public String name;
	public String distnes;
	@Id
	@GeneratedValue(generator="indent")
	@GenericGenerator(name="indent",strategy="uuid")
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getDistnes() {
		return distnes;
	}
	public void setDistnes(String distnes) {
		this.distnes = distnes;
	}
	

}
package com.unicom.oneTooneforeign;

import java.beans.ConstructorProperties;
import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;
import javax.persistence.CascadeType;

import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;
/*
 * @author huzhen
 */
@Entity
@Table(name="t_husband")
public class Husband implements Serializable{
	public String id;
	public String name;
	public int age;
	public Wife wife;
	@Id
	@GeneratedValue(generator="indent")
	@GenericGenerator(name="indent",strategy="uuid")
	@Column(length=32)
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	@Column(length=32)
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@OneToOne(cascade=CascadeType.ALL)
	@JoinColumn(name="wife_idss")
	public Wife getWife() {
		return wife;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
	
	

}
package com.unicom.oneTooneforeign;

import java.util.List;
import java.util.UUID;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
/*
 * @author huzhen
 */
public class HibernetTest {
	public static SessionFactory sessionFactory;
	public static Session session;

	@Before
	public void opensession() {
		Configuration config = new AnnotationConfiguration();
		config.configure();
		sessionFactory = config.buildSessionFactory();
		session = sessionFactory.getCurrentSession();
		session.beginTransaction();


	}

	@After
	public void closesession() {

		session.getTransaction().commit();
	}

	@Test
	public void testinsert() {

		Husband hus = new Husband();
		hus.setName("huzhen");
		hus.setAge(25);
		Wife wf = new Wife();
		wf.setName("zhulinan");
		wf.setDistnes("very likily");
		hus.setWife(wf);
		session.save(hus);

	}
	
	@Test
	public void delete()
	{
		Husband hus=(Husband) session.get(Husband.class, "8ab8dab2493c783501493c78366b0001");
	    Wife wife=(Wife) session.get(Wife.class,"8ab8dab2493c6feb01493c6fef210002");
		//session.delete(wife); //因为被动关联，删除失败
	    session.delete(hus);    //
	}

}
 
 
 
配置文件：（配置文件只在这里给出，下面的一对多，多对一的配置文件只需在上面做小小的改动即可，改动的地方就是mapping）
  
<span style="font-size:18px;"><script src="https://code.youkuaiyun.com/snippets/496943.js"></script></span>

@OneToOne         建立实体 bean 之间的一对一的关联

cascade                  级联策略，即，当对主对象做某种操作时，是否对其相关联的子对象也做相对应的操作。它有5个值可选，分别是 :

             CascadeType.PERSIST ： 级联新建

             CascadeType.REMOVE  :  级联删除

             CascadeType.REFRESH ： 级联刷新

             CascadeType.MERGE   ： 级联更新

             CascadeType.ALL     ： 囊括以上四项

fetch                        抓取策略，它有2个值可选，分别是 :

             FetchType.LAZY   :   延迟抓取

             FetchType.EAGER  :   立即抓取

Tips :       延迟抓取数据能够保证应用只有在需要的时候才去数据库抓取相应的数据记录，这样能够避免过多，

             或过早的加载数据库表中的数据，从而减少应用内存的开销。

@JoinColumn     该注解与@Column 注解用法有点相似，可以通过name来指定联接列的名称，如果没有该注解没有被声明，

             默认的联接列名称是 : 关联的类的短类名(首字母小写，不带包名)_id。

@OneToOne         建立实体 bean 之间的一对一的关联

cascade                  级联策略，即，当对主对象做某种操作时，是否对其相关联的子对象也做相对应的操作。它有5个值可选，分别是 :

             CascadeType.PERSIST ： 级联新建

             CascadeType.REMOVE  :  级联删除

             CascadeType.REFRESH ： 级联刷新

             CascadeType.MERGE   ： 级联更新

             CascadeType.ALL     ： 囊括以上四项

fetch                        抓取策略，它有2个值可选，分别是 :

             FetchType.LAZY   :   延迟抓取

             FetchType.EAGER  :   立即抓取

Tips :       延迟抓取数据能够保证应用只有在需要的时候才去数据库抓取相应的数据记录，这样能够避免过多，

             或过早的加载数据库表中的数据，从而减少应用内存的开销。

@JoinColumn     该注解与@Column 注解用法有点相似，可以通过name来指定联接列的名称，如果没有该注解没有被声明，

             默认的联接列名称是 : 关联的类的短类名(首字母小写，不带包名)_id。

 

mappedBy :

    相当于 xml 方式配置的 inverse = "true"，表示将表间关联的这种关系的维护交给对方，对方才是关系的真正维护者，拥有主导权。

    在双向关联中，有且仅有一端是作为主体( owner )端存在，主体端负责维护联接列。对于不需要维护这种关系的从表则通过 mappedBy 属性进行声明。

    最后不必也不能再在被关联端(owned side)定义联接列了，因为已经在主体端进行了声明.

 
通过关联表来保存两个实体之间的连接关系，这个感觉冗余一个表没什么性能改善，就不介绍了。

 

hibernate annotation 双向 one-to-one 注解
weixin_30588675的博客
06-10 81
环境： Hibernate 3.3.1 Maven 3.0.4 MySQL 5.5.13 Myeclipse 8.6.1 建表语句： DROP TABLE IF EXISTS `t_card`; CREATE TABLE `t_card` ( `cardId` int(10) unsigned NOT NULL AUTO_INCREMENT, ...
hibernate关联映射(注解) —— 基于主键的双向一对一关联映射(@OneToOne)
R15的博客
06-21 587
hibernate基于注解的一对多关联使用@OneToOne注解。 注意：需要引入的为： javax.persistence.OneToOne 维护端(有外键方)： @Id @GenericGenerator(name = "pkGenerator", strategy = "foreign", parameters = { @Parameter(name = "propert...
hibernate 一对一外键关联映射_双向
majinfei的专栏
11-17 652
public class User {  private int id;  private String username;  private IdCard idCard; ｝   public class IdCard {    private int id;  private String cardNO;  private User user; ｝         
Hibernate @OneToOne -- 1
endercc的专栏
12-30 436
class Person @OneToOne public IDCard getIdcard() { return idcard; } class IDCard table person CREATE TABLE `person` ( `id` varchar(32) NOT NULL, `createDate` datetime DEFAULT NULL, `mod
Hibernate双向一对一关联映射(注解版)
05-05
本主题聚焦于“Hibernate双向一对一关联映射”的注解实现，这是一种高级的数据库设计模式，用于处理两个实体之间一对一的关系。 在Hibernate中，一对一关联映射分为单向和双向。单向一对一映射通常涉及一个实体持有...
Hibernate注解实现一对一双向关联关系配置
- `mappedBy`：指定关系的反向属性名，用于双向关联时，表示关系是由对方的实体维护的。 - `cascade`：配置级联操作，用于定义在当前操作中对关联实体的级联操作。常见的级联选项包括`CascadeType.ALL`、`...
Hibernate注解 关联关系映射注解.docx
06-19
对于自关联，即一个实体类实例可以关联自身，我们同样可以使用`@ManyToOne`或`@OneToOne`注解，根据实际需求选择合适的关联类型，并通过`mappedBy`来定义关联路径。 在多对一的关联关系中，我们通常在“一”的那...
hibernate一对一之唯一外键关联（双向关联）
03-28
双向关联需要在双方实体类上都添加注解，并通过`mappedBy`属性指定关联的另一方。 ```java @Entity public class Person { @OneToOne(mappedBy = "person") private IdCard idCard; } @Entity public class...
Hibernate Annotation 共享主键一对一双向关联
04-09
当我们在Hibernate中保存`Person`或`Profile`时，由于设置了双向关联，Hibernate会自动处理两个实体之间的关联，确保数据的一致性。`CascadeType.ALL`表示所有操作（包括保存、更新、删除）都会级联到对方实体。 ...
Hibernate-----@OneToOne
hekewangzi
07-23 299
Hibernate-----@OneToOne
hibernate注解之外键关联表（@OneToOne）
iteye_15129的博客
01-06 1251
笔者在使用hibernate注解时需要建一个表关联 通过本次建表收获了一些意外的心得 1、在使用@OneToOne注解时数据库相应表中不必有外键2、注解必须写在一致的位置上，即要么全写在实体的字段上，要么全部写在get方法上 3、当要做冗余时；即在数据字段中要多建一个所参考的外键表的主键字段需要设置其中一个字段为不可写和不可更新 一般console报错误为：Repeated column...
学习hibernate_02_双向onetoone注解
onezg的专栏
01-24 380
有了上一篇onetomany manyone的基础，onetoone理解起来就很容易了。简单地整理一下。 用人和身份证的关系来说事。1. 数据库表人和身份证表（person表、card表），每个表都有一个关联对方主键的字段。2. JavaBeanPerson.java@OneToOne(cascade = CascadeType.ALL) @JoinColumn(name = "cid") priv
Hibernate 多表关联 @OneToOne
学习使我快乐，每天都在进步！
05-09 1600
继上次集成hibernate-JPA后，多表关联还是一个待解决的问题：参考文档：1：jboss参考文档下面开始表演：@OneToOne是什么：描述表与表之间的一种一对一对应关系@JoinColumn是什么：关联列@OneToOne(fetch=FetchType.LAZY,cascade=CascadeType.ALL) @JoinColumn(name="roleId",insertable=f...
hibernate 一对一(One-to-One)
xx510long的博客
03-23 481
一对一（one-to-one）实例（Person-IdCard） 一对一的关系在数据库中表示为主外关系．例如．人和身份证的关系．每个人都对应一个身份证号．我们应该两个表．一个是关于人信息的表（Person）．别外一个是身份证相关信息的表(id_card)．id_card表的主键对应该Person表的主键id，也是Person表的外键．有人才能有身份证．所以此例中Person是主表，id_card...
Hibernate关系映射--单向一对一@OneToOne
路在路上的博客
08-23 1035
1.无连接表的单向一对一 单向一对一与单向多对一很相似 需要在一的一方添加注解@OneToOne @JoinColumn（name=""，unique=true) 因为是一对一，所有要unique=true主要代码及例子 在一的一方添加注解@OneToOne(cascade={CascadeType.ALL}) @JoinColumn(name="",unique=true)
hibernate关系映射--双向一对一@OneToOne
路在路上的博客
08-23 5324
1.基于外键的双向一对一 基于外键的双向一对一，外键可以存放在任意一端，只需在外键表的那端添加注解@OneToOne，@JoinColumn在主表中也应添加注解@OneToOne，同时设置mappedBy属性（放弃控制关联关系，否则会生成额外的关联关系，引起性能下降）主要代码及例子 从表@OneToOne(cascade={CascadeType.ALL}) @JoinColu
(10)hibernate中OneToOne双向
HZPHYT的博客
10-12 385
首先在person类加入idcard: public class Person { private int id; private String name; private IdCard idcard; public IdCard getIdcard() { return idcard; } public void setIdcard(IdCard idcard) { this.idc...
hibernate的OneToOne映射
justlpf的专栏
01-06 911
这里的name=“student_relation_id”， 指的当前表的字段，referencedColumnName = "teacher_relation_id"是关联表的字段，推荐要加上@NotFound(action = NotFoundAction.IGNORE)，这时一定是@OneToOne(fetch = FetchType.EAGER)，否则有会警告。mappedBy="card"说明在两个关联的实体Bean中，person这一端是关系的拥有者，person一方的表中生成到关联类的外键。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值