Hibernate关联关系

最新推荐文章于 2020-07-29 10:36:35 发布
最新推荐文章于 2020-07-29 10:36:35 发布
阅读量245 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuxuchuan/article/details/79063959
版权

一、在hibernate中，包含的关联关系包括单向多对多，单向一对多，单向多对一，单向一对一，双向多对多，双向多对一，双向一对一

1、双向多对多

     

import java.io.Serializable;
import java.util.Date;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Entity
@Table(name = "student")
public class Student implements Serializable {
	private static final long serialVersionUID = 2524659555729848644L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	private String name;
	private Date birthday;
	private int sex;
	private String address;
	@ManyToMany(cascade = CascadeType.ALL)
	@JoinTable(name = "t_teacher_student", joinColumns = @JoinColumn(name = "student_id"), inverseJoinColumns = @JoinColumn(name = "teacher_id"))
	private Set<Teacher> teacherList;

}

import java.io.Serializable;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Entity
@Table(name = "teacher")
public class Teacher implements Serializable {
	private static final long serialVersionUID = 2297316923535111793L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	private String name;
	private int sex;
	@ManyToMany(mappedBy = "teacherList", cascade = CascadeType.ALL)
	private Set<Student> studentList;
}


2、单向多对多

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;

@Entity
public class Teacher {
	@Id
	@GeneratedValue
	private int id;
	@Column(length = 20)
	private String name;
	@ManyToMany
	@JoinTable(name = "tea_stu", joinColumns = {
			@JoinColumn(name = "teacher_id", referencedColumnName = "id") }, inverseJoinColumns = {
					@JoinColumn(name = "student_id", referencedColumnName = "id") })
	private Set<Student> students = new HashSet<Student>();
}

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

@Entity
public class Student {
	@Id
	@GeneratedValue
	private int id;
	private String name;
	private String title;
}


3、单向一对多

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.OrderBy;
import javax.persistence.Table;

/**
 * 
 */
@Entity
@Table(name = "Grade")
public class Grade implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
	private String gname;
	private String gdesc;
	// 在一方定义一个多方的集合
	@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
	@JoinColumn(name = "grade_id")//关联的列，如果不设置，应该会新增一张表作为关联，因为一对多是基于多对多的
	@OrderBy("id ASC")
	private Set<Student> students = new HashSet<>();
}
import java.io.Serializable;

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

/**
 * .
 */
@Entity
@Table(name = "Student")
public class Student implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	private String sname;
	private String sex;

	public Long getId() {
		return id;
	}

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

	public String getSname() {
		return sname;
	}

	public void setSname(String sname) {
		this.sname = sname;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
}
	// 在一方定义一个多方的集合，这样子hibernate会自动新增一个中间表，形式如同多对多
	@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
	private Set<Student> students = new HashSet<>();


4、单向多对一

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

/**
 * 
 */
@Entity
@Table(name = "Student")
public class Student implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	private String sname;
	private String sex;
	@ManyToOne
	@JoinColumn(name = "groupId")
	private Grade grade;

	public Grade getGrade() {
		return grade;
	}

	public void setGrade(Grade grade) {
		this.grade = grade;
	}

	public Long getId() {
		return id;
	}

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

	public String getSname() {
		return sname;
	}

	public void setSname(String sname) {
		this.sname = sname;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
}

import java.io.Serializable;

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

/**
 *
 */
@Entity
@Table(name = "Grade")
public class Grade implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
	private String gname;
	private String gdesc;

	public int getId() {
		return id;
	}

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

	public String getGname() {
		return gname;
	}

	public void setGname(String gname) {
		this.gname = gname;
	}

	public String getGdesc() {
		return gdesc;
	}

	public void setGdesc(String gdesc) {
		this.gdesc = gdesc;
	}

}


5、双向一对多

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

/**
 * 
 */
@Entity
@Table(name = "Student")
public class Student implements Serializable {
	
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	private String name;
	private String sex;
	@ManyToOne
	@JoinColumn(name = "grade_id")
	private Grade grade;
}

import java.io.Serializable;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

/**
 *
 */
@Entity
@Table(name = "Grade")
public class Grade implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
	@OneToMany(cascade = CascadeType.ALL,mappedBy="grade", fetch=FetchType.EAGER)
	private Set<Student> grades;
}


6、单向一对一

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 *
 */
@Entity
@Table(name = "man")
public class Man implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
	@OneToOne(fetch = FetchType.LAZY)
	@JoinColumn(name = "man_id")
	private Head head;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public Head getHead() {
		return head;
	}
	public void setHead(Head head) {
		this.head = head;
	}
}

import java.io.Serializable;

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

/**
 * 
 */
@Entity
@Table(name = "head")
public class Head implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	private String sname;
	private String sex;
	
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}


7、双向一对一

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 *
 */
@Entity
@Table(name = "man")
public class Man implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
	@OneToOne(mappedBy = "man")
	private Head head;
	
}

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 * 
 */
@Entity
@Table(name = "head")
public class Head implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	private String sname;
	private String sex;
	@OneToOne(fetch = FetchType.LAZY)
	@JoinColumn(name = "man_id")
	private Man man;
}


二、如果父类也要加入到映射中，父类需要新增注解如下：

@MappedSuperclass




永兴帝国的征伐时代
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hibernate关联关系
04-03
hibernate关联关系
Hibernate的关联关系
逗逗大魔王的博客
11-23 429
一.什么是hibernate的关联关系hibernate框架是与数据库打交道的，而数据库是存储数据的，有些数据之间有些内在联系，hibernate将对象之间通过某种方式联系起来，世界万物都有联系的，如用户和身份证，你创建了一个用户的一个数据库表，而每个用户要有身份证，所以你还要创建一个装身份证的一个数据库表，但你怎么把它们联系起来，或者说怎么分清楚哪个用户是哪个身份证，这就是我们要学的hiberna
hibernate的关联关系
小七
07-29 134
hibernate的关联关系前言一、什么是关联二、关联的分类创建两张表，生动的来体现一下关联关系 前言 在真实的项目中级联删除是被禁用的，因为级联的关系，就是会把和它有点关系的都会删除 一、什么是关联 关联（association）指是类之间的引用关系，如果类A与类B关联，那么被引用的类B将被定义为类A的属性 二、关联的分类 ①一对一 ②一对多 ③多对一 ④多对多 创建两张表，生动的来体现一下关联关系 -- 订单表(主表) create table t_order_hb ( order_id int p
hibernate关联关系总结
10-14
详细讲解hibernate的关联关系，以及用实例讲解，非常详细
Hibernate 关联关系解除
03-25
NULL 博文链接：https://dreamzhong.iteye.com/blog/1181526
SSH：Hibernate框架（七种关联关系映射及配置详解）
热门推荐
流年少年
11-27 1万+
概念          基本映射是对一个实体进行映射，关联映射就是处理多个实体之间的关系，将关联关系映射到数据库中，所谓的关联关系在对象模型中有一个或多个引用。   分类                                关联关系分为上述七种，但是由于相互之间有各种关系，可以简化，例如：多对一与一对多映射，只是侧重的角度不对而已。
Hibernate关联关系(一对多)
01-19
Hibernate关联关系(一对多)代码的具体实现，包括保存班级；保存学生；保存班级的时候同时保存学生；已经存在一个班级，新建一个学生，并且建立该学生和该班级之间的关系等一对多关系的情况。不足之处还望谅解
hibernate多对一关联关系
10-11
后面的hibernate代码，我会慢慢的上传上去，这些资源都是免费的，希望可以帮到大家。
Hibernate学习笔记（三）——Hibernate的关联关系映射
记录只为更好地前行
09-24 1937
在数据库中存在四种关联关系映射，分别是一对一（one-to-one）、一对多（one-to-many）、多对一（many-to-one）和多对多（many-to-many），其中日常开发中比较常用的是一对多和多对一的映射，那么下面将分别通过几个实例来介绍一下一对多和多对一的映射。 一、一对多关系映射 什么叫做一对多关系映射呢？举个例子，就好比班级和学生，站在班级的角度来看，一个班级包含多个学生
Hibernate关联关系配置(一对多、一对一和多对多)
alva88888888的博客
01-20 256
Hibernate关联关系配置 第一种关联关系：一对多（多对一） "一对多"是最普遍的映射关系，简单来讲就如消费者与订单的关系。 一对多：从消费者角的度来说一个消费者可以有多个订单，即为一对多。 多对一：从订单的角度来说多个订单可以对应一个消费者，即为多对一。 一对多关系在hbm文件中的配置信息： 消费者（一方）： <?xml version="1.0" e...
Java三大框架之——Hibernate关联映射与级联操作
weixin_34320724的博客
11-26 252
什么是Hibernate中的关联映射？ 　　简单来说Hibernate是ORM映射的持久层框架，全称是（Object Relational Mapping），即对象关系映射。 　　它将数据库中的表映射成对应的对象，以对象的形式展现，这样我们就可以通过映射的对象来对数据库中的数据进行间接的操作。 　　关联映射是将数据库中的表映射成与之相对应的对象，当你对这个对象进行操作的时候，Hibernat...
Hibernate的一对多关联关系（单向和双向）
Alan_Xiang的博客
12-04 5258
在领域模型中，类与类之间最普遍的关系就是关联关系。在 UML 中，关联是有方向的。以 Customer 和 Order 为例：一个用户能发出多个订单, 而一个订单只能属于一个客户。从 Order 到 Customer 的关联是多对一关联; 而从 Customer 到 Order 是一对多关联。 　　单向n-1的关联关系　　单向 n-1 关联只需从 n 的一端可以访问 1 的一端。 　　域模型：从
Hibernate关联关系（一对多）
Kobe Bryant
08-04 569
什么是关联(association)
hibernate框架关联关系映射操作
最新发布
05-14
下面是一些常见的Hibernate关联关系映射操作： 1. 一对一映射：在一个实体中定义一个引用另一个实体的属性。可以使用@OneToOne注释来映射一对一关系。 2. 一对多映射：在一个实体中定义一个集合属性，该集合中存储...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值