映射配置文件中关联关系——一对一

配置一对一的关联关系有两种方式：



package oneToOne;

public class Person {
private int id;
private String name;

private IdCard idCard;
public IdCard getIdCard() {
return idCard;
}
public void setIdCard(IdCard idCard) {
this.idCard = idCard;
}
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;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "[Person:id="+id+",name="+name+"]";
}

}

package oneToOne;

public class IdCard {
private int id;
private String number;

private Person person ; //不能初始化
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}

public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "[IdCard:id="+id+",number="+number+"]";
}

}

1.基于外键的方式

Person.hbm.xml

<?xml version="1.0" encoding="gbk"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--

This mapping demonstrates

(1) a table-per-subclass mapping strategy

(2) a simple component mapping

(3) recursive associations withing an inheritance tree

-->

<hibernate-mapping package="oneToOne">
<!--
name:类名
table:表名
-->
<class name="Person" table="t_person">

<id name="id" >
<generator class="native"/> <!--表示自动增长-->
</id>

<property name="name" type="string" column="name" />

<!--idCard属性，IdCard类型，表达的是本类与IdCard的一对一的关系
采用基于外键的方式 本方无外键方
property-ref属性是对方外键列对应的name
-->
<one-to-one name="idCard" class="IdCard" property-ref="person" />
</class>

</hibernate-mapping>


IdCard.hbm.xml
<?xml version="1.0" encoding="gbk"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--

This mapping demonstrates

(1) a table-per-subclass mapping strategy

(2) a simple component mapping

(3) recursive associations withing an inheritance tree

-->

<hibernate-mapping package="oneToOne">
<!--
name:类名
table:表名
-->
<class name="IdCard" table="t_idcard" >

<id name="id" >
<generator class="native"/> <!--表示自动增长-->
</id>

<property name="number" type="string" column="number" />
<!--person属性，Person类型，表达的是本类与IdCard的一对一的关系
采用基于外键的方式 本方有外键方 实际上是多对一+唯一性约束
-->
<many-to-one name="person" class="Person" column="personId" unique="true"></many-to-one>
</class>

</hibernate-mapping>

package oneToOne;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

public class App {
private static SessionFactory sessionFactory=new Configuration()
.configure()
.addClass(Person.class)
.addClass(IdCard.class)
.buildSessionFactory();
@Test
public void testsave(){
Session session=sessionFactory.openSession();
Transaction tx=session.beginTransaction();

//操作
Person person=new Person();
person.setName("小强");

IdCard idCard=new IdCard();
idCard.setNumber("222434433");

//关联
person.setIdCard(idCard);
idCard.setPerson(person);

session.save(person);
session.save(idCard);

tx.commit();
session.close();
}

@Test
public void testget(){
Session session=sessionFactory.openSession();
Transaction tx=session.beginTransaction();

//操作
//		Person person=(Person) session.get(Person.class, 1);
//		System.out.println(person);
//		System.out.println(person.getIdCard());
IdCard idCard=(IdCard) session.get(IdCard.class, 1);
System.out.println(idCard);
System.out.println(idCard.getPerson());

tx.commit();
session.close();
}

@Test
public void testRemoveRelation(){
Session session=sessionFactory.openSession();
Transaction tx=session.beginTransaction();

//操作
//不能从无外键方解除关系，因为它不维护关系
//		Person person=(Person) session.get(Person.class, 1);
//		person.setIdCard(null);

//从有外键方解除关系可以
IdCard idCard=(IdCard) session.get(IdCard.class, 1);
idCard.setPerson(null);

tx.commit();
session.close();
}

@Test
public void testdelete(){
Session session=sessionFactory.openSession();
Transaction tx=session.beginTransaction();

//操作
//不可以从无外键方删除对象
//		Person person=(Person) session.get(Person.class, 2);
//		session.delete(person);

//可以从有外键方删除对象
IdCard idCard=(IdCard) session.get(IdCard.class, 2);
session.delete(idCard);
tx.commit();
session.close();
}

}

2.基于主键的方式

Person.hbm.xml

<?xml version="1.0" encoding="gbk"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--

This mapping demonstrates

(1) a table-per-subclass mapping strategy

(2) a simple component mapping

(3) recursive associations withing an inheritance tree

-->

<hibernate-mapping package="oneToOne">
<!--
name:类名
table:表名
-->
<class name="Person" table="t_person">

<id name="id" >
<generator class="native"/> <!--表示自动增长-->
</id>

<property name="name" type="string" column="name" />

<!--idCard属性，IdCard类型，表达的是本类与IdCard的一对一的关系
采用基于主键的方式

-->
<one-to-one name="idCard" class="IdCard" />
</class>

</hibernate-mapping>


IdCard.hbm.xml
<?xml version="1.0" encoding="gbk"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--

This mapping demonstrates

(1) a table-per-subclass mapping strategy

(2) a simple component mapping

(3) recursive associations withing an inheritance tree

-->

<hibernate-mapping package="oneToOne">
<!--
name:类名
table:表名
-->
<class name="IdCard" table="t_idcard" >

<id name="id" >
<!--当使用基于主键的一对一映射时，
有外键方的主键生成策略一定要用foreign
参数property：生成主键值是所根据的对象
-->
<generator class="foreign"> <!--表示自动增长-->
<param name="property">person</param>
</generator>
</id>

<property name="number" type="string" column="number" />
<!--person属性，Person类型，表达的是本类与IdCard的一对一的关系
采用基于主键的方式
-->
<one-to-one name="person" class="Person" constrained="true"></one-to-one>
</class>

</hibernate-mapping>

package oneToOne;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

public class App {
private static SessionFactory sessionFactory=new Configuration()
.configure()
.addClass(Person.class)
.addClass(IdCard.class)
.buildSessionFactory();
@Test
public void testsave(){
Session session=sessionFactory.openSession();
Transaction tx=session.beginTransaction();

//操作
Person person=new Person();
person.setName("小红");

IdCard idCard=new IdCard();
idCard.setNumber("2123446980");

//关联
person.setIdCard(idCard);
idCard.setPerson(person);

session.save(person);
session.save(idCard);

tx.commit();
session.close();
}

@Test
public void testget(){
Session session=sessionFactory.openSession();
Transaction tx=session.beginTransaction();

//操作
Person person=(Person) session.get(Person.class, 3);
System.out.println(person);
System.out.println(person.getIdCard());
//		IdCard idCard=(IdCard) session.get(IdCard.class, 3);
//		System.out.println(idCard);
//		System.out.println(idCard.getPerson());

tx.commit();
session.close();
}

@Test
public void testRemoveRelation(){
Session session=sessionFactory.openSession();
Transaction tx=session.beginTransaction();

//操作
//基于主键的一对一映射：不可以从无外键方接触关系
Person person=(Person) session.get(Person.class, 1);
person.setIdCard(null);

//基于主键的一对一映射：不可以从有外键方解除关系
//		IdCard idCard=(IdCard) session.get(IdCard.class, 1);
//		idCard.setPerson(null);

tx.commit();
session.close();
}

@Test
public void testdelete(){
Session session=sessionFactory.openSession();
Transaction tx=session.beginTransaction();

//操作
//无外键方：如果此对象关联到对方，就不可以删除，若果没有关联到对方，就可以直接删除
Person person=(Person) session.get(Person.class, 3);
session.delete(person);

//		//可以从有外键方删除对象
//		IdCard idCard=(IdCard) session.get(IdCard.class, 3);
//		session.delete(idCard);
tx.commit();
session.close();
}

}