Hibernate关系映射（二）一对一双向外键关联@OneToOne Annotation方式

在上一篇，也就是Hibernate关系映射（一）中已经介绍了一对一单向外键关联，本篇介绍一对一双向外键关联

首先还是来构造一个实际应用的场景，比如实体类车辆（Car），它具有以下属性：Id，品牌（brand），车牌（lisencePlate）；实体类车牌（LisencePlate），它具有以下属性：Id，号码（number），所属车辆（car）。那么车辆和车牌是一对一的关系，一辆车只能有一个车牌，一个车牌也只能属于一辆车，不允许套牌，典型的一对一关系，依然是根据PowerDesigner反向工程反向出来的表结构如图：



car这个表中有一个字段lisencePlate_id作为外键指向了lisence_plate表的主键id字段。

重点内容

看表结构，单向关联的表结构和双向关联的表结构在数据库中的表示是一致的，但是单向关联和双向关联的区别在于，双向关联，你可以用car.getLisencePlate来找到该车辆的车牌，也可以用lisencePlate.getCar来找到该车牌所属车辆，但是单向关联只能从车找到车牌，或者从车牌找到车。

下面是实体类：

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

@Entity
@Table(name="car")
public class Car {

private Integer id;
private String brand;
private LisencePlate lisencePlate;

public Car() {
super();
}

public Car(Integer id, String brand, LisencePlate lisencePlate) {
super();
this.id = id;
this.brand = brand;
this.lisencePlate = lisencePlate;
}

@Id
@GeneratedValue
public Integer getId() {
return id;
}

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

public String getBrand() {
return brand;
}

public void setBrand(String brand) {
this.brand = brand;
}

@OneToOne
public LisencePlate getLisencePlate() {
return lisencePlate;
}

public void setLisencePlate(LisencePlate lisencePlate) {
this.lisencePlate = lisencePlate;
}

}

每一个使用到的标签的含义在上一篇介绍过了，这里不再赘述。

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

@Entity
@Table(name="lisence_plate")
public class LisencePlate {
private Integer id;
private String number;
private Car car;

public LisencePlate() {
super();
}

public LisencePlate(Integer id, String number, Car car) {
super();
this.id = id;
this.number = number;
this.car = car;
}

@Id
@GeneratedValue
public Integer getId() {
return id;
}

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

public String getNumber() {
return number;
}

public void setNumber(String number) {
this.number = number;
}

@OneToOne(mappedBy="lisencePlate")
public Car getCar() {
return car;
}

public void setCar(Car car) {
this.car = car;
}

}

注意：双向关联，那么在车牌类中也需要一个属性，所属车辆（car），设置上get和set方法后，在get方法上有这么一个标签@OneToOne(mappedBy=”lisencePlate”)，@OneToOne表示车牌和车辆也是一对一的关系并且关联上车辆，mappeBy表示被谁映射，并且mappedBy应该存在于“被拥有方”，指向“拥有方”，那么指向拥有方应该指向车辆类，mappedBy=”lisencePlate”表示指向车辆类的lisencePlate属性，表示被lisencePlate属性映射，并且lisencePlate是主导。

重点内容

双向关联必须设置mappedBy

最后在hibernate.cfg.xml配置文件中设置上实体的映射就可以了

<!-- 一对一双向外键关联 -->
<mapping class="com.ht.entity.one2one.bi.fk.Car"/>
<mapping class="com.ht.entity.one2one.bi.fk.LisencePlate"/>

下面来看CRUD的测试，首先测试添加新数据testCreate()方法

import java.util.ArrayList;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import com.ht.entity.one2one.bi.fk.Car;
import com.ht.entity.one2one.bi.fk.LisencePlate;

public class One2OneTest2 {

private static SessionFactory sessionFactory;

@BeforeClass
public static void beforeClass() {
sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
}
@AfterClass
public static void afterClass() {
sessionFactory.close();
}

@Test
public void testCreate(){
Session session = sessionFactory.getCurrentSession();
session.beginTransaction();

Car car = new Car();
car.setBrand("Jeep Grand Cherokee");

LisencePlate lisencePlate = new LisencePlate();
lisencePlate.setNumber("云A 12345");

car.setLisencePlate(lisencePlate);
lisencePlate.setCar(car);

session.save(lisencePlate);
session.save(car);

session.getTransaction().commit();
}

结果如图：

Hibernate:
insert
into
lisence_plate
(number)
values
(?)
Hibernate:
insert
into
car
(brand, lisencePlate_id)
values
(?, ?)

接下来测试数据读取，testRead()方法

@Test
public void testRead(){
Session session = sessionFactory.getCurrentSession();
session.beginTransaction();

Car car = (Car) session.load(Car.class, 1);
System.out.println(car.getBrand()+"  "+car.getLisencePlate().getNumber());

LisencePlate lisencePlate = (LisencePlate) session.load(LisencePlate.class, 1);
System.out.println(lisencePlate.getNumber()+"  "+lisencePlate.getCar().getBrand());

session.getTransaction().commit();
}

这里就体现了双向关联和单向关联的区别，双向关联可以从车辆找到车牌信息，也可以从车牌找到所属车辆的信息。

Hibernate:
select
car0_.id as id2_1_,
car0_.lisencePlate_id as lisenceP3_2_1_,
car0_.brand as brand2_1_,
lisencepla1_.id as id3_0_,
lisencepla1_.number as number3_0_
from
car car0_
left outer join
lisence_plate lisencepla1_
on car0_.lisencePlate_id=lisencepla1_.id
where
car0_.id=?
Hibernate:
select
car0_.id as id2_1_,
car0_.lisencePlate_id as lisenceP3_2_1_,
car0_.brand as brand2_1_,
lisencepla1_.id as id3_0_,
lisencepla1_.number as number3_0_
from
car car0_
left outer join
lisence_plate lisencepla1_
on car0_.lisencePlate_id=lisencepla1_.id
where
car0_.lisencePlate_id=?

Jeep Grand Cherokee  云A 12345
云A 12345  Jeep Grand Cherokee

下面测试修改数据，testUpdate()方法

@Test
public void testUpdate(){
Session session = sessionFactory.getCurrentSession();
session.beginTransaction();

Car car = (Car) session.load(Car.class, 1);
car.setBrand("Jeep大切诺基");

LisencePlate lisencePlate = (LisencePlate) session.load(LisencePlate.class, 1);
lisencePlate.setNumber("云A 66666");

session.saveOrUpdate(car);
session.saveOrUpdate(lisencePlate);

session.getTransaction().commit();
}

结果如下：

Hibernate:
update
lisence_plate
set
number=?
where
id=?
Hibernate:
update
car
set
lisencePlate_id=?,
brand=?
where
id=?

最后是删除操作，testDelete()方法，一样的，如果只是删除车牌，那么就要先解除该车牌和所属车辆之间的约束

@Test
public void testDelete(){
Session session = sessionFactory.getCurrentSession();
session.beginTransaction();

Car car = (Car) session.load(Car.class, 1);

LisencePlate lisencePlate = (LisencePlate) session.load(LisencePlate.class, 1);

car.setLisencePlate(null);
session.delete(lisencePlate);

session.getTransaction().commit();
}

结果如下：

Hibernate:
update
car
set
lisencePlate_id=?,
brand=?
where
id=?
Hibernate:
delete
from
lisence_plate
where
id=?

希望对你所有帮助，下一篇介绍多对一的单向关联

[上一篇 Hibernate关系映射（一）一对一单向外键关联@OneToOne Annotation方式](/article/11175517.html）