Hibernate的多种关系映射（oto、otm、mtm）
前提：使用注解映射
一、一对一（夫妻关系表）
两个表：hus1和wife1表，外键为id，各自有名字hname和wname
映射得到两个类：Hus1和Wife1类
Hus1类（主表）：
package com.weikun.po; import javax.persistence.*; /**
* Created by Administrator on 2018/3/26.
*/
@Entity
public class Hus1 {
private int id;
private String hname;
private Wife1 wife; @Id
@Column(name = "id", nullable = false)
public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} @Basic
@Column(name = "hname", nullable = true, length = 10)
public String getHname() {
return hname;
} public void setHname(String hname) {
this.hname = hname;
} @Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false; Hus1 hus1 = (Hus1) o; if (id != hus1.id) return false;
if (hname != null ? !hname.equals(hus1.hname) : hus1.hname != null) return false; return true;
} @Override
public int hashCode() {
int result = id;
result = 31 * result + (hname != null ? hname.hashCode() : 0);
return result;
} @OneToOne(cascade ={CascadeType.ALL})
@JoinColumn(name = "id", referencedColumnName = "id", nullable = false)
public Wife1 getWife() {
return wife;
} public void setWife(Wife1 wife) {
this.wife = wife;
}
}
Wife1类
package com.weikun.po; import javax.persistence.*; /**
* Created by Administrator on 2018/3/26.
*/
@Entity
public class Wife1 {
private int id;
private String wname;
private Hus1 hus1ById;
private Hus1 hus; @Id
@Column(name = "id", nullable = false)
public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} @Basic
@Column(name = "wname", nullable = true, length = 10)
public String getWname() {
return wname;
} public void setWname(String wname) {
this.wname = wname;
} @Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false; Wife1 wife1 = (Wife1) o; if (id != wife1.id) return false;
if (wname != null ? !wname.equals(wife1.wname) : wife1.wname != null) return false; return true;
} @Override
public int hashCode() {
int result = id;
result = 31 * result + (wname != null ? wname.hashCode() : 0);
return result;
} @OneToOne
@JoinColumn(name = "id", referencedColumnName = "id", nullable = false)
public Hus1 getHus1ById() {
return hus1ById;
} public void setHus1ById(Hus1 hus1ById) {
this.hus1ById = hus1ById;
} @OneToOne(mappedBy = "wife")
public Hus1 getHus() {
return hus;
} public void setHus(Hus1 hus) {
this.hus = hus;
}
}
对两个表进行操作：
package com.weikun.dao; import com.weikun.po.Hus1;
import com.weikun.po.Wife1;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test; /**
* Created by Administrator on 2018/3/26.
*/
public class HusDAOImpl {
private SessionFactory sf=null;
private Configuration configuration=null;
public HusDAOImpl(){
configuration=new Configuration().configure("hibernate.cfg.xml");
sf=configuration.buildSessionFactory();
}
@Test
public void update(){
Session session=sf.openSession();
Transaction trans=session.beginTransaction();
try{
Hus1 hus=session.load(Hus1.class,6);
hus.setHname("C");
hus.getWife().setWname("PS");
session.update(hus); trans.commit();
}catch(Exception e){
trans.rollback();
e.printStackTrace();
}
session.close();
}
@Test
public void del(){ Session session=sf.openSession();
Transaction trans=session.beginTransaction();
try{
Hus1 hus=session.load(Hus1.class,1); session.delete(hus); trans.commit();
}catch(Exception e){
trans.rollback();
e.printStackTrace();
}
session.close();
}
@Test
public void add(){
Session session=sf.openSession();
Transaction trans=session.beginTransaction();
try{
Hus1 hus=new Hus1();
hus.setHname("JAVA");
hus.setId(6); Wife1 wif=new Wife1();
wif.setWname("python");
wif.setId(6);
hus.setWife(wif); wif.setHus(hus); session.save(hus); trans.commit();
}catch(Exception e){
trans.rollback();
e.printStackTrace();
}
session.close(); }
@Test
public void queryById(){
Session session=sf.openSession();
Hus1 hus=session.load(Hus1.class,1);//
System.out.printf("%s-%s",hus.getHname(),hus.getWife().getWname());
Wife1 wife=session.load(Wife1.class,1);//
System.out.printf("%s-%s",wife.getWname(),wife.getHus().getHname());
session.close();
}
}
二、一对多（父子关系表）
两个表：父亲表（father2）、儿子表（son2），外键为fid，父亲表中属性有fid、fname，儿子表中有属性sid、sname、fid
映射得到两个类：Father2和Son2类
Father2类：
package com.weikun.po; import org.hibernate.annotations.Fetch;
import org.hibernate.annotations.FetchMode; import javax.persistence.*;
import java.util.HashSet;
import java.util.Set; /**
* Created by Administrator on 2018/3/26.
*/
@Entity
public class Father2 {
private int fid;
private String fname;
private Set<Son2> sons=new HashSet<Son2>(); @Id
@Column(name = "fid", nullable = false)
public int getFid() {
return fid;
} public void setFid(int fid) {
this.fid = fid;
} @Basic
@Column(name = "fname", nullable = true, length = 10)
public String getFname() {
return fname;
} public void setFname(String fname) {
this.fname = fname;
} @Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false; Father2 father2 = (Father2) o; if (fid != father2.fid) return false;
if (fname != null ? !fname.equals(father2.fname) : father2.fname != null) return false; return true;
} @Override
public int hashCode() {
int result = fid;
result = 31 * result + (fname != null ? fname.hashCode() : 0);
return result;
} @OneToMany(mappedBy = "father",cascade = {CascadeType.ALL})
//@Fetch(FetchMode.JOIN)
public Set<Son2> getSons() {
return sons;
} public void setSons(Set<Son2> sons) {
this.sons = sons;
}
}
Son2类：
package com.weikun.po; import javax.persistence.*; /**
* Created by Administrator on 2018/3/26.
*/
@Entity
public class Son2 {
private int sid;
private String sname;
private Father2 father2ByFid;
private Father2 father2ByFid_0;
private Father2 father; @Id
@Column(name = "sid", nullable = false)
public int getSid() {
return sid;
} public void setSid(int sid) {
this.sid = sid;
} @Basic
@Column(name = "sname", nullable = true, length = 10)
public String getSname() {
return sname;
} public void setSname(String sname) {
this.sname = sname;
} @Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false; Son2 son2 = (Son2) o; if (sid != son2.sid) return false;
if (sname != null ? !sname.equals(son2.sname) : son2.sname != null) return false; return true;
} @Override
public int hashCode() {
int result = sid;
result = 31 * result + (sname != null ? sname.hashCode() : 0);
return result;
} @ManyToOne
@JoinColumn(name = "fid", referencedColumnName = "fid")
public Father2 getFather() {
return father;
} public void setFather(Father2 father) {
this.father = father;
}
}
操作父子关系：
package com.weikun.dao; import com.weikun.po.Father2;
import com.weikun.po.Son2;
import org.hibernate.*;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;
import org.junit.Test; import javax.persistence.Table;
import java.util.List; /**
* Created by Administrator on 2018/3/26.
*/
public class FatherDAOImpl {
private SessionFactory sf=null;
private Configuration configuration=null;
public FatherDAOImpl(){
configuration=new Configuration().configure("hibernate.cfg.xml");
sf=configuration.buildSessionFactory();
}
@Test
public void del(){
Session session=sf.openSession();
Transaction trans=session.beginTransaction();
try {
//Son2 s=session.load(Son2.class,6);
Father2 s=session.load(Father2.class,6);
session.delete(s);
trans.commit();
}catch(Exception e){
trans.rollback();
e.printStackTrace();
} session.close(); } public static void main(String[] args) { }
@Test
public void go(){
Father2 s=query();
s.getSons().forEach(s1->System.out.println(s1.getSname()));
}
public Father2 query(){
Session session=sf.openSession();
Father2 s=null;
try {
//Son2 s=session.load(Son2.class,6);
s=session.get(Father2.class,6);
if(!Hibernate.isInitialized(s.getSons())){//lazy的必须解决方案，访问子表情况
Hibernate.initialize(s.getSons());
}
//s.getSons().forEach(s1->System.out.println(s1.getSname())); }catch(Exception e){ e.printStackTrace();
} session.close();
return s;
}
@Test
public void query2(){
Session session=sf.openSession();
Father2 s=null;
try {
//Son2 s=session.load(Son2.class,6);
Query q=session.createQuery("from Father2 as a ");
q.setLockMode("a", LockMode.UPGRADE_NOWAIT);//强力锁止
q.setCacheable(true);
q.list(); Query q2 =session.createQuery("from Father2 where fid=1");
q2.setCacheable(true);
q2.list(); }catch(Exception e){ e.printStackTrace();
} session.close(); }
@Test
public void query1(){
Session session=sf.openSession(); try {
Son2 s=session.load(Son2.class,6); System.out.println(s.getFather().getFname()); }catch(Exception e){ e.printStackTrace();
} session.close();
}
@Test
public void add(){
Session session=sf.openSession();
Transaction trans=session.beginTransaction();
try {
Father2 f=new Father2();
f.setFid(6);
f.setFname("JASON"); Son2 s=new Son2();
s.setSid(6);
s.setSname("ROSE");
s.setFather(f); Son2 s1=new Son2();
s1.setSid(7);
s1.setSname("MARY");
s1.setFather(f);
f.getSons().add(s);
f.getSons().add(s1);
session.save(f);
trans.commit();
}catch(Exception e){
trans.rollback();
e.printStackTrace();
} session.close();
}
}
三、多对多（老师学生关系）
三个表只映射两个，tea、stu，而管理两个表关系的teastu表不用映射导入
映射tea和stu表得到Stu类和Tea类
Tea类：
package com.weikun.po; import org.hibernate.annotations.Cascade; import javax.persistence.*;
import java.util.HashSet;
import java.util.Set; /**
* Created by Administrator on 2018/3/26.
*/
@Entity
public class Tea {
private int tid;
private String tname;
private Set<Stu> stus=new HashSet<>(); @Id
@Column(name = "tid", nullable = false)
public int getTid() {
return tid;
} public void setTid(int tid) {
this.tid = tid;
} @Basic
@Column(name = "tname", nullable = true, length = 10)
public String getTname() {
return tname;
} public void setTname(String tname) {
this.tname = tname;
} @Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false; Tea tea = (Tea) o; if (tid != tea.tid) return false;
if (tname != null ? !tname.equals(tea.tname) : tea.tname != null) return false; return true;
} @Override
public int hashCode() {
int result = tid;
result = 31 * result + (tname != null ? tname.hashCode() : 0);
return result;
}
@Cascade(value=org.hibernate.annotations.CascadeType.SAVE_UPDATE)
@ManyToMany()
@JoinTable(name = "teastu", catalog = "res", schema = "res", joinColumns = @JoinColumn(name = "tid", referencedColumnName = "tid", nullable = false), inverseJoinColumns = @JoinColumn(name = "sid", referencedColumnName = "sid", nullable = false))
public Set<Stu> getStus() {
return stus;
} public void setStus(Set<Stu> stus) {
this.stus = stus;
}
}
Stu类：
package com.weikun.po; import javax.persistence.*;
import java.util.HashSet;
import java.util.Set; /**
* Created by Administrator on 2018/3/26.
*/
@Entity
public class Stu {
private int sid;
private String sname;
private Set<Tea> teas=new HashSet<>(); @Id
@Column(name = "sid", nullable = false)
public int getSid() {
return sid;
} public void setSid(int sid) {
this.sid = sid;
} @Basic
@Column(name = "sname", nullable = true, length = 10)
public String getSname() {
return sname;
} public void setSname(String sname) {
this.sname = sname;
} @Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false; Stu stu = (Stu) o; if (sid != stu.sid) return false;
if (sname != null ? !sname.equals(stu.sname) : stu.sname != null) return false; return true;
} @Override
public int hashCode() {
int result = sid;
result = 31 * result + (sname != null ? sname.hashCode() : 0);
return result;
} @ManyToMany(mappedBy = "stus")
public Set<Tea> getTeas() {
return teas;
} public void setTeas(Set<Tea> teas) {
this.teas = teas;
}
}
操纵师生关系的类：
package com.weikun.dao; import com.weikun.po.Father2;
import com.weikun.po.Stu;
import com.weikun.po.Tea;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test; /**
* Created by Administrator on 2018/3/26.
*/
public class TeaDAOImpl {
private SessionFactory sf=null;
private Configuration configuration=null;
public TeaDAOImpl(){
configuration=new Configuration().configure("hibernate.cfg.xml");
sf=configuration.buildSessionFactory();
}
@Test
public void del(){
Session session=sf.openSession();
Transaction trans=session.beginTransaction();
try {
Tea t=session.load(Tea.class,6);
session.delete(t);
trans.commit();
}catch(Exception e){
trans.rollback();
e.printStackTrace();
} session.close(); }
@Test
public void add(){
Session session=sf.openSession();
Transaction trans=session.beginTransaction();
try {
Tea t=new Tea();
t.setTid(6);
t.setTname("MARY"); Tea t1=new Tea();
t1.setTid(7);
t1.setTname("NICK"); Stu s1=new Stu();
s1.setSid(10);
s1.setSname("S1");
s1.getTeas().add(t);
s1.getTeas().add(t1); Stu s2=new Stu();
s2.setSid(11);
s2.setSname("S2");
s2.getTeas().add(t);
s2.getTeas().add(t1);
t1.getStus().add(s1);
t1.getStus().add(s2);
t.getStus().add(s1);
t.getStus().add(s2); session.save(t);
session.save(t1);
trans.commit();
}catch(Exception e){
trans.rollback();
e.printStackTrace();
} session.close();
} }
Hibernate的多种关系映射（oto、otm、mtm）的更多相关文章
- Hibernate多对多关系映射(建表)
下边讲述Hibernate多对多关系映射. 多对多关系的表的结构为: 两个实体表,还包含一个关系表,关系表为复合主键,如果要使用Hibernate多对多关系映射,则关系表必须只包含两个字段,如果生成了 ...
- 菜鸟学习Hibernate——多对多关系映射
Hibernate中的关系映射,最常见的关系映射之一就是多对多关系映射例如用户与角色的关系,一个用户对应多个角色,一个角色对应多个用户.如图: Hibernate中如何来映射这两个的关系呢? 下面就为 ...
- 菜鸟学习Hibernate——一对多关系映射
Hibernate中的关系映射,最常见的关系映射之一就是一对多关系映射例如学生与班级的关系,一个班级对应多个学生.如图: Hibernate中如何来映射这两个的关系呢? 下面就为大家讲解一下: 1.创 ...
- hibernate的对象/关系映射结果为空，exists查不到值的问题-20190823
1: hibernate的对象/关系映射 情景:在使用@onetotone/@manytonone时关联结果为空 原因:在使用这个注解的时候,默认的时crossjoin(交叉连接),在进行查询时以及排 ...
- Hibernate多对多关系映射
两张表的多对多关系,在数据库中通常是通过第三张中间表来实现的,第三张中间表放的是两张表各自的主键值,通过主键与主键的对应来体现表直接的关系.比如在权限系统中,一个用户可以拥有多种权限,而一种权限也可以 ...
- Hibernate学习之关系映射（转）
一.一对多 "一对多"是最普遍的映射关系,简单来讲就如消费者与订单的关系.一对多:从消费者角的度来说一个消费者可以有多个订单,即为一对多.多对一:从订单的角度来说多个订单可以对应一 ...
- Hibernate 中对象关系映射（ObjectRelationMapping）
1.什么是对象关系映射? 解析:对象-关系映射(Object Relational Mapping,简称ORM,对象关系映射)是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术. 简单的说, ...
- Hibernate之实体关系映射
延迟加载与即时加载 例如Person类和Email类是一对多关系,如果设为即时加载,当加载Person时,会自动加载Email,如果设置为延迟加载,当第一次调用person.getEmails()时才 ...
- Hibernate：对象关系映射（一对一，一对多，多对一，多对多）
如需转载,请说明出处:http://www.cnblogs.com/gudu1/p/6895610.html Hibernate通过关系映射来表示数据库中表与表之间的关系,关系映射可以通过两种方式:配 ...
随机推荐
- 去哪网实习总结：如何配置数据库连接（JavaWeb）
本来是以做数据挖掘的目的进去哪网的,结构却成了系统开发.. . 只是还是比較认真的做了三个月,老师非常认同我的工作态度和成果. .. 实习立即就要结束了.总结一下几点之前没有注意过的变成习惯和问题,分 ...
- CSDN的技术问题
说CSDN是国内最大最好的技术论坛.预计不会有人反对,可是...CSDN的人,如管理员懂技术吗? 假设您长期在CSDN混.您就会发现他们相当懂得......强奸技术!
- MyEclipse改动内存大小
方式一网上说的(没有測试过): 找到MyEclipse的安装文件夹,一般假设不改动的话默觉得C:\MyEclipse10.1\Genuitec\MyEclipse 10.1有一个myeclipse.i ...
- 2015.04.28,外语,读书笔记-《Word Power Made Easy》 12 “如何奉承朋友” SESSION 36
1. the great and the small 拉丁词语animus(mind的意思),animus和另一个拉丁词根anima(life principle.soul.spirit),是许多单词 ...
- Android::开机自启动C程序【转】
本文转载自:http://blog.csdn.net/Kaiwii/article/details/7681736 之前一篇博文介绍了shell脚本文件的开机启动,地址是http://blog.chi ...
- 【NOI 2002】 银河英雄传说
[题目链接] https://www.luogu.org/problemnew/show/P1196 [算法] 并查集 [代码] #include<bits/stdc++.h> using ...
- Node.js：连接 MongoDB
ylbtech-Node.js:连接 MongoDB 1.返回顶部 1. Node.js 连接 MongoDB MongoDB是一种文档导向数据库管理系统,由C++撰写而成. 本章节我们将为大家介绍如 ...
- Firefox Quantum：开发者版本 推荐
为生民,不谋利 欢迎您使用 Firefox 开发者版本.使用此版本可获得最新功能.高速性能,以及您打造开放 Web 所需的开发工具. https://www.mozilla.org/zh-CN/fir ...
- Win7 disk.sys无法加载的问题
Win7突然无法启动,应该说是启动中卡死,没有别的问题,用安全模式,显示加载disk.sys时卡死.搜索发现很多人遇到这个问题. 实际解决方法是查看数据线,重新插拔,换口,换线. 数据线出现故障往往表 ...
- 优动漫结合Photoshop怎么画草地？
今天继续技法教学~草地的技法,PS教学~但是很简单,都是默认工具,而且是常用工具VS常用设置.你肯定会学会的! 草地教程,就到这里啦!有兴趣的可以尝试画一画哦,想要Get到更多有关优动漫的信息包括软件 ...