深入解析Java的Hibernate框架中的一对一关联映射
作者:cxshun 发布时间:2022-08-07 22:23:39
作为一个ORM框架,hibernate肯定也需要满足我们实现表与表之间进行关联的需要。hibernate在关联方法的实现很简单。下面我们先来看看一对一的做法:
不多说了,我们直接上代码:
两个实体类,TUser和TPassport:
public class TUser implements Serializable{
private static final long serialVersionUID = 1L;
private int id;
private int age;
private String name;
private TPassport passport;
//省略Get/Set方法
}
public class TPassport implements Serializable{
private static final long serialVersionUID = 1L;
private int id;
private String serial;
private int expiry;
private TUser user;
//省略Get/Set方法
}
下面我们看一下映射文件有什么不同:
<hibernate-mapping package="org.hibernate.tutorial.domain4">
<class name="TUser" table="USER4">
<id name="id" column="id">
<generator class="native" />
</id>
<property name="name" type="java.lang.String" column="name"/>
<property name="age" type="java.lang.Integer" column="age"/>
<one-to-one name="passport" class="TPassport"
cascade="all" outer-join="true" />
</class>
</hibernate-mapping>
这里我们看到有一个新标签,one-to-one,它表明当前类与所对应的类是一对一的关系,cascade是级联关系,all表明无论什么情况都进行级联,即当对TUser类进行操作时,TPassport也会进行相应的操作,outer-join是指是否使用outer join语句。
我们再看另外一个TPassport的映射文件:
<hibernate-mapping package="org.hibernate.tutorial.domain4">
<class name="TPassport" table="passport4">
<id name="id" column="id">
<generator class="foreign" >
<param name="property">user</param>
</generator>
</id>
<property name="serial" type="java.lang.String" column="serial"/>
<property name="expiry" type="java.lang.Integer" column="expiry"/>
<one-to-one name="user" class="TUser" constrained="true" />
</class>
</hibernate-mapping>
这里我们重点看到generator的class值,它为foreign表明参照外键,而参照哪一个是由param来进行指定,这里表明参照User类的id。而one-to-one标签中多了一个constrained属性,它是告诉hibernate当前类存在外键约束,即当前类的ID根据TUser的ID进行生成。
下面我们直接上测试类,这次测试类没有用JUnit而是直接Main方法来了:
public static void main(String[] args) {
Configuration cfg = new Configuration().configure();
SessionFactory sessionFactory = cfg.buildSessionFactory();
Session session = sessionFactory.openSession();
session.beginTransaction();
TUser user = new TUser();
user.setAge(20);
user.setName("shunTest");
TPassport passport = new TPassport();
passport.setExpiry(20);
passport.setSerial("123123123");
passport.setUser(user);
user.setPassport(passport);
session.save(user);
session.getTransaction().commit();
}
代码很简单,就不说了。我们主要看这里:
session.save(user);
这里为什么我们只调用一个save呢,原因就在我们的TUser映射文件中的cascade属性,它被设为all,即表明当我们对TUser进行保存,更新,删除等操作时,TPassport也会进行相应的操作,所以这里我们不用写session.save(passport)。我们看到后台:
Hibernate: insert into USER4 (name, age) values (?, ?)
Hibernate: insert into passport4 (serial, expiry, id) values (?, ?, ?)
Hibernate: 它打印出两个语句,证明hibernate确定帮我们做了这个工作。
下面我们再来一个测试类,测试查询:
public static void main(String[] args) {
Configuration cfg = new Configuration().configure();
SessionFactory sessionFactory = cfg.buildSessionFactory();
Session session = sessionFactory.openSession();
TUser user = (TUser)session.load(TUser.class,new Integer(3));
System.out.println(user.getName()+":"+user.getPassport().getSerial());
}
这里我们通过查询出TUser类,取到TPassport对象。
我们可以看到hibernate的SQL语句是:
Hibernate:
select tuser0_.id as id0_1_, tuser0_.name as name0_1_, tuser0_.age as age0_1_, tpassport1_.id as id1_0_, tpassport1_.serial as serial1_0_, tpassport1_.expiry as expiry1_0_ from USER4 tuser0_ left outer join passport4 tpassport1_ on tuser0_.id=tpassport1_.id where tuser0_.id=?
我们看到语句当中有left outer join,这是因为我们前面在one-to-one当中设了outer-join="true",我们试着把它改成false,看到SQL语句如下:
Hibernate:
select tuser0_.id as id0_0_, tuser0_.name as name0_0_, tuser0_.age as age0_0_ from USER4 tuser0_ where tuser0_.id=?
Hibernate:
select tpassport0_.id as id1_0_, tpassport0_.serial as serial1_0_, tpassport0_.expiry as expiry1_0_ from passport4 tpassport0_ where tpassport0_.id=?
现在是分成两条来查了,根据第一条查出的ID再到第二条查出来。
也许很多人会问为什么测试的时候不用TPassport查出TUser呢,其实也可以的,因为它们是一对一的关系,谁查谁都是一样的。
外键关联
现在我们看一下通过外键来进行关联的一对一关联。
还是一贯的直接上例子:我们写了两个实体类,TGroup和TUser
public class TGroup implements Serializable{
private static final long serialVersionUID = 1L;
private int id;
private String name;
private TUser user;
//省略Get/Set方法
}
public class TUser implements Serializable{
private static final long serialVersionUID = 1L;
private int id;
private int age;
private String name;
private TGroup group;
//省略Get/Set方法
}
实体类完了我们就看一下映射文件:
<hibernate-mapping package="org.hibernate.tutorial.domain5">
<class name="TUser" table="USER5">
<id name="id" column="id">
<generator class="native" />
</id>
<property name="name" type="java.lang.String" column="name"/>
<property name="age" type="java.lang.Integer" column="age"/>
<many-to-one name="group" class="TGroup" column="group_id" unique="true" />
</class>
</hibernate-mapping>
这里我们看到是用many-to-one标签而不是one-to-one,为什么呢?
这里以前用的时候也没多在注意,反正会用就行,但这次看了夏昕的书终于明白了,实际上这种通过外键进行关联方式只是多对一的一种特殊方式而已,我们通过unique="true"限定了它必须只能有一个,即实现了一对一的关联。
接下来我们看一下TGroup的映射文件:
<hibernate-mapping package="org.hibernate.tutorial.domain5">
<class name="TGroup" table="group5">
<id name="id" column="id">
<generator class="native" />
</id>
<property name="name" type="java.lang.String" column="name"/>
<one-to-one name="user" class="TUser" property-ref="group" />
</class>
</hibernate-mapping>
这里,注意,我们又用到了one-to-one,表明当前的实体和TUser是一对一的关系,这里我们不用many-to-one,而是通过one-to-one指定了TUser实体中通过哪个属性来关联当前的类TGroup。这里我们指定了TUser是通过group属性和Tuser进行关联的。property-ref指定了通过哪个属性进行关联。
下面我们看测试类:
public class HibernateTest {
public static void main(String[] args) {
Configuration cfg = new Configuration().configure();
SessionFactory sessionFactory = cfg.buildSessionFactory();
Session session = sessionFactory.openSession();
session.beginTransaction();
TGroup group = new TGroup();
group.setName("testGroup");
TUser user = new TUser();
user.setAge(23);
user.setName("test");
user.setGroup(group);
group.setUser(user);
session.save(group);
session.save(user);
session.getTransaction().commit();
session.close();
}
}
注意,这次我们的代码中需要进行两次的保存,因为它们对各自都有相应的对应,只保存一个都不会对另外一个有什么操作。所以我们需要调用两次保存的操作。最后进行提交。
hibernate打印出语句:
Hibernate: insert into group5 (name) values (?)
Hibernate: insert into USER5 (name, age, group_id) values (?, ?, ?)
这说明我们正确地存入了两个对象值。
我们写多一个测试类进行查询:
public static void main(String[] args) {
Configuration cfg = new Configuration().configure();
SessionFactory sessionFactory = cfg.buildSessionFactory();
Session session = sessionFactory.openSession();
TUser user = (TUser)session.load(TUser.class,new Integer(1));
System.out.println("From User get Group:"+user.getGroup().getName());
TGroup group = (TGroup)session.load(TGroup.class,new Integer(1));
System.out.println("From Group get User:" + group.getUser().getName());
session.close();
}
我们都可以得到正确的结果,这表明我们可以通过两个对象拿出对方的值,达到了我们的目的。
这个例子中用到的TGroup和TUser只是例子而已,实际上现实生活中的user一般都对应多个group。
猜你喜欢
- ElGamal数字签名,供大家参考,具体内容如下一、实验目的学习ElGamal算法在数字签名方面的使用,掌握教科书版本的ElGamal数字签
- 前言在之前的Spring Boot基础教程系列中,已经通过《Spring Boot中使用@Async实现异步调用》一文介绍过如何使用@Asy
- 如下所示:import org.apache.commons.lang.StringUtils; public class Test {
- 悲观锁、乐观锁简介: 悲观锁:同步操作。即用户A在操作某条数据时,为其上锁,限制其他用户操作,用户A操作完成提交事务后其他用户方可
- 本文实例讲述了Java Swing中JDialog实现用户登陆UI。分享给大家供大家参考,具体如下:JDialog是一种对话框组件,它常常与
- 本文实例讲述了java实现图片写入高清字体及带边框的方法。分享给大家供大家参考。具体实现方法如下:Graphics2D g2=image.c
- ##创建测试类 新建Java工程创建测试类如下代码:(创建文件验证定时器是否执行)package makeFile;import java.
- 前言学过定时任务,但是我忘了,忘得一干二净,害怕,一直听别人说:你写一个定时任务就好了。写个定时任务让他去爬取就行了。我不会,所以现在得补回
- struts2可以非常简单地使用FreeMarker模板作为视图技术,对于传统的jsp页面而言,FreeMarker是一个绝佳的替代方案。除
- 定时任务,是指定一个未来的时间范围执行一定任务的功能。在当前WEB应用中,多数应用都具备任务调度功能,针对不同的语音,不同的操作系统, 都有
- Object是类层次结构的根,每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类构造方法:public Object()回
- 建造者模式(Builder Pattern)使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式,它提供了一种创
- 简单理解泛型泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。通俗点将就是“类型的变量
- 这两种方式也是大家在日常编码工作当中用的比较多的判断方式、之前在使用的时候也没太关注两者在比较不同类型的时候存在哪些区别今天就和大家一起深入
- java "equals"和"==”异同首先简单说一下“equal”和“==”==操作对于基本数据类型比较的是
- 年前无意看到一个用Python写的小桌面程序,可以自动玩扫雷的游戏,觉得挺有意思,决定用C#也做一个。【真实情况
- 程序员日常工作中,发送http请求特别常见。本文以Java为例,总结发送http请求的多种方式。1. HttpURLConnection使用
- [LeetCode] 131.Palindrome Partitioning 拆分回文串Given a string s, par
- Java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码。一、当两个并发线程访问同一个
- 前文本章是关于Java流程控制语句的最全汇总,本篇为汇总上篇。流程是人们生活中不可或缺的一部分,它表示人们每天都在按照一定的流程做事。比如出