hibernate关系映射

最新推荐文章于 2023-03-06 20:04:01 发布
最新推荐文章于 2023-03-06 20:04:01 发布
阅读量498 收藏
点赞数
分类专栏： SSH基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/so_sss/article/details/39229485
版权

[本文中只说明使用Annotaion注解方式配置hibernate关系映射的方法和注意事项]

所谓关系，不是指数据库表与表之间的关系，因为数据库表之间只有主外键关系（数据库设计时一般遵循主键关联和单向外键关联，比较清晰）。

关系映射中的“关系”指的是对象之间的关系，不是继承、实现，而是指对象数量之间的四种关系：一对一，一对多，多对一，多对多。

关系还分为单向和双向之分。例如，一夫一妻，丈夫中有妻子的外键，妻子也有丈夫的外键，就是双向的一对一关系，但数据库有冗余，建立了一个外键即可。所以双向的对象数量之间的关系无论哪一种，在hibernate中必须使用mappedBy指明建立哪一个外键，否则数据库设计不合格，在指明后，生成的数据库与单向一对一生成的数据库无差别。

本例使用Myeclipse自带的Junit4进行测试，使用log4j配置 log4j.logger.org.hibernate.tool.hbm2ddl=debug 查看DDL日志，每次测试时都在hibernate配置文件中hibernate.cfg.xml映射对应的实体类，并设置<property name="hbm2ddl.auto">create</property>，以自动创建数据库表及结构。hibernateUtil包的HibernateUtil.getSessionFactory().getCurrentSession();方法可获取当前Session。

双向关系一般很少用，一对一，多对多关系也很少用，用到的大多数情况下是单向多对一、单向一对多。

单向一对一：

一对一在数据库中该怎么设计？把一个表的id设置为另一个表的外键即可并切只设置一个外键，不需要互相都设置成外键，否则冗余。

所以在一个实体类中加入另一个实体类的对象并在get方法上@OneToOne即可

Husband.java

package com.ibm.hibernateOneToOne;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
@Entity
public class Husband {
	private int id;
	private String name;
	//加入Wife的对象引用，在数据库生成时Husband表中加入妻子id
	private Wife wife;
	@OneToOne
	//@JoinColumn(name="wifeid")可以改变外键字段名，默认为wife_id
	public Wife getWife() {
		return wife;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

Wife.java 

package com.ibm.hibernateOneToOne;

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

@Entity
public class Wife {
	private int id;
	private String name;
	/*private Husband husband;
	@OneToOne(mappedBy=""wife)//Husband中Wife对象的名字。
	@JoinColumn(name="husband_id")<strong>//指定外键的字段名，默认为husband_id</strong>
	public Husband getHusband() {
		return husband;
	}
	public void setHusband(Husband husband) {
		this.husband = husband;
	}*/
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
单向一对一DDL/双向加mappedBy一对一DDL：

Hibernate: drop table if exists Husband
Hibernate: drop table if exists Wife
Hibernate: create table Husband (id integer not null auto_increment, name varchar(255), wife_id integer, primary key (id))
Hibernate: create table Wife (id integer not null auto_increment, name varchar(255), primary key (id))
Hibernate: alter table Husband add constraint FK_4565w2c4f1cj082spdiok0w6 foreign key (wife_id) references Wife (id)

含有mappedBy=""实体类不再生成外键，表示由对方实体类中的某对象名主导。
Wife中如果去点/**/引用的部分则为双向一对一。

不加mappedBy的双向DDL：

Hibernate: drop table if exists Husband
Hibernate: drop table if exists Wife
Hibernate: create table Husband (id integer not null auto_increment, name varchar(255), wife_id integer, primary key (id))
Hibernate: create table Wife (id integer not null auto_increment, name varchar(255), husband_id integer, primary key (id))
Hibernate: alter table Husband add constraint FK_4565w2c4f1cj082spdiok0w6 foreign key (wife_id) references Wife (id)
Hibernate: alter table Wife add constraint FK_n86d0ervyo0jv9a18yx655329 foreign key (husband_id) references Husband (id)

若不加有冗余，因为只需要一个外键即可确定一对一关系，在OneToOne后加入(mappedBy="wife"),则DDL结果与单向一对一无差别。

为何要用双向：虽然数据库结果一样，但是对象中却是双向的，可从wife得到husband，也可从husband达到wife。



单向多对一：

多对一在数据库中怎么设置？一般在“多”的表中设置一个“少”的一方的外键。反过来会有冗余哦。

所以在"多"的实体类中加入"少"的实体类对象并在get方法上@ManyToOne即可

例如：一个人有多个梦想，一个梦想只能被一个人拥有：

Dream.java

package com.ibm.hibernateManyToOne;

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

@Entity
public class Dream {
	private int id;
	private String dream;
	private Person person;
	@ManyToOne
	@JoinColumn(name="personid")
	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getDream() {
		return dream;
	}
	public void setDream(String dream) {
		this.dream = dream;
	}
}
Person.java 

package com.ibm.hibernateManyToOne;

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

@Entity
public class Person {
	private int id;
	private String name;
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

}
单向多对一DDL：

Hibernate: drop table if exists Dream
Hibernate: drop table if exists Person
Hibernate: create table Dream (id integer not null auto_increment, dream varchar(255), personid integer, primary key (id))
Hibernate: create table Person (id integer not null auto_increment, name varchar(255), primary key (id))
Hibernate: alter table Dream add constraint FK_hg1723l9yhysmlxywmgmdgd39 foreign key (personid) references Person (id)

单向一对多：

数据库怎么设计？与一对多一样，只不过"一"的实体类中需加入Set类型的"多"的实体类。其他都一样。

Person1.java

package com.ibm.hibernateOneToMany;

import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;

@Entity
public class Person1 {
	private int id;
	private String name;
	private Set<Dream1> dream1;
	@OneToMany
	@JoinColumn(name="personid")
	public Set<Dream1> getDream1() {
		return dream1;
	}
	public void setDream1(Set<Dream1> dream1) {
		this.dream1 = dream1;
	}
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

Dream.java 

package com.ibm.hibernateOneToMany;

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

@Entity
public class Dream1 {
	private int id;
	private String dream;
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getDream() {
		return dream;
	}
	public void setDream(String dream) {
		this.dream = dream;
	}
}

单向一对多DDL：(与单向多对一一样，数据库一样)

Hibernate: drop table if exists Dream1
Hibernate: drop table if exists Person1
Hibernate: create table Dream1 (id integer not null auto_increment, dream varchar(255), personid integer, primary key (id))
Hibernate: create table Person1 (id integer not null auto_increment, name varchar(255), primary key (id))
Hibernate: alter table Dream1 add constraint FK_lswteige4aru1ov44wxodqmos foreign key (personid) references Person1 (id)

双向多对一 = 双向一对多：

数据库与单向一对多多对一都一样，只是实体类之间可以相互引用。

dream2.java

package com.ibm.hibernateBi_ManyToOne_OneToMany;

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

@Entity
public class Dream2 {
	private int id;
	private String dname;
	private Person2 person2;
	@ManyToOne
	public Person2 getPerson2() {
		return person2;
	}
	public void setPerson2(Person2 person2) {
		this.person2 = person2;
	}
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getDname() {
		return dname;
	}
	public void setDname(String dname) {
		this.dname = dname;
	}
}

Person2.java 

package com.ibm.hibernateBi_ManyToOne_OneToMany;


import java.util.Set;

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

@Entity
public class Person2 {
	private int id;
	private String name;
	private Set<Dream2> dream2;
	
	@OneToMany(mappedBy="person2")
	public Set<Dream2> getDream2() {
		return dream2;
	}
	public void setDream2(Set<Dream2> dream2) {
		this.dream2 = dream2;
	}
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

双向多对一（也即双向一对多）DDL:(与单向一对多，单向多对一一样，因为数据库设计的都一样)

Hibernate: drop table if exists Dream2
Hibernate: drop table if exists Person2
Hibernate: create table Dream2 (id integer not null auto_increment, dname varchar(255), person2_id integer, primary key (id))
Hibernate: create table Person2 (id integer not null auto_increment, name varchar(255), primary key (id))
Hibernate: alter table Dream2 add constraint FK_5v0q0beloi3kwr4d4ue44kg2e foreign key (person2_id) references Person2 (id)



单向多对多：
数据库设计？生成一个新的中间表，外键是两个表的id，单向所以一个实体类中加另一个实体类的set类型的对象，并在get方法上@ManyToMany

例如：学生与课程，一个学生可以选多个课程，一个课程可以被多个学生选择。

Course.java

package com.ibm.hibernateManyToMany;

import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
@Entity
public class Course {
	private int id;
	private String courseName;
	private Set<Student> student;
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getCourseName() {
		return courseName;
	}
	public void setCourseName(String courseName) {
		this.courseName = courseName;
	}
	@ManyToMany//新生成的表名，当前实体类外键的id名字，另一个实体类外键的id名字
	@JoinTable(name="c_s",
			   joinColumns={@JoinColumn(name="courseid")},
			   inverseJoinColumns={@JoinColumn(name="studentid")})
	public Set<Student> getStudent() {
		return student;
	}
	public void setStudent(Set<Student> student) {
		this.student = student;
	}
}

Student.java 

package com.ibm.hibernateManyToMany;

import java.util.Set;

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

@Entity
public class Student {
	private int id;
	private String name;
	/*
	private Set<Course> course;
	@ManyToMany(mappedBy="student")
	public Set<Course> getCourse() {
		return course;
	}
	public void setCourse(Set<Course> course) {
		this.course = course;
	}
	*/
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}


单向多对多DDL：

Hibernate: drop table if exists Course
Hibernate: drop table if exists c_s
Hibernate: create table Course (id integer not null auto_increment, courseName varchar(255), primary key (id))
Hibernate: create table Student (id integer not null auto_increment, name varchar(255), primary key (id))
Hibernate: create table c_s (courseid integer not null, studentid integer not null, primary key (courseid, studentid))
Hibernate: alter table c_s add constraint FK_sqya4biyhu2bcn3e3o6b6m61l foreign key (studentid) references Student (id)
Hibernate: alter table c_s add constraint FK_p020gm1dfqwc75g7rs9in4126 foreign key (courseid) references Course (id)

双向多对多：去掉Student.java中的/**/注释中的内容，DDL跟单向的一样。只不过Course和Student之间可以引用


总结一下：双向就在两个实体类互相加入对方对象，是"多的一方"则为Set类型，去掉一方的引用则为单向。单向双向生成的数据库表结构完全一致，只不过双向中对象可以相互引用。一般在多的一方加入对象引用，建立外键。



so_sss
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
每次重新部署后hibernate会把数据库里表都drop掉，数据丢失
mine_soul的博客
04-08 2569
项目整合了hibernate和Struts，在做单元测试的时候，每次restart server会重新部署hibernate， 都会把数据库里的表全部drop掉，然后再重新create一遍，浪费时间又丢失数据，很是抓狂。查看了hql执行语句如下：log4j:WARN No appenders could be found for logger (org.jboss.logging). log4j:
Hibernate的关联关系映射
小灰灰的博客
11-26 126
Hibernate的关联关系映射 首先应该考虑两个问题：类如何表示？数据库如何存储？ 一、树形结构关联 在pom.xml文件中引入相关依赖 <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>5.4.23.Final</
hibernate drop table if exists
AEsasasa的博客
03-06 170
update
Hibernate 实体类注解
不务正业的野猴子
10-28 3952
@Entity作用在类上，表示该类是Hibernate 实体类，在创建数据表时会默认使用类名作为新建表的表名。@Entity public class Employee{}@Table作用在类上，定义表的信息。 name属性被用来设置当前表的表名，当我们不想使用类名作为表名而是希望自定义时，我们可以使用这个name属性。 uniqueConstraints属性被用来为当前表提供唯一性约束，可以定
Hibernate关联关系映射
dream_heheda的博客
03-11 163
本文参考 谈一点我对hibernate关联关系映射的看法 Hibernate关联关系映射--级联功能 Hibernate作为持久层框架，初始实现最基本的ORM之外，最重要的就是关系关联映射。通过配置实体间的关联，如one-to-one、one-to-many等，可以实现级联保存，级联更新，级联查询，级联删除等级联操作。在建关联关系表的时候，可以通过设置@OneToOne,@@OneToMany,@@ManyToOne,@ManyToMany的cascade()属性值，来设置关系表之间的级联功能。举例
Hibernate关系映射
06-12
**标题：“Hibernate关系映射”** 在Java世界中，Hibernate是一个强大的对象关系映射（ORM）框架，它允许开发者将数据库操作转化为面向对象的方式，极大地简化了数据持久化的复杂性。"多对一"关系映射是Hibernate...
使用反射模拟实现hibernate
so_sss的专栏
11-05 1562
使用反射机制模拟hibernate
Struts2访问web元素（Request，Session，Application）的四种方式
so_sss的专栏
10-25 1231
Struts2访问web元素（Request，Session，Application）的四种方式
jsp+jdbc+MySQL分页
so_sss的专栏
09-15 1098
jdbc+jsp+MySQL简单分页
hibernate总结
so_sss的专栏
10-23 779
hibernate总结
聊天室、websocket、socket.io、毕业设计.zip
07-27
聊天室、websocket、socket.io、毕业设计.zip
微麦电影购票小程序，分为三部分-小程序端-商家（影院）后台与官方后台.zip
07-27
微麦电影购票小程序，分为三部分-小程序端-商家（影院）后台与官方后台.zip
防盗门进销存管理系统（SDIMS）.zip
07-27
防盗门进销存管理系统（SDIMS）.zip
Matlab实现蝗虫优化算法GOA-CNN-BiLSTM-Mutilhead-Attention多变量时序预测.rar
07-27
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
[毕设]二叉树构建与遍历算法实现.zip
最新发布
07-27
[毕设]二叉树构建与遍历算法实现
Hibernate继承映射策略解析
在Java开发中，Hibernate是一个非常流行的ORM（对象关系映射）框架，它允许开发者使用面向对象的方式来操作数据库。在处理继承关系时，Hibernate提供了多种映射策略来处理对象模型与数据库表之间的关系。 10.1 概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值