一对一关联映射

Hibernate中实现一对一映射有基于外键的方式和基于主键的方式。由于基于主键方式的映射在实现删除等操作时存在的问题且不够灵活，一般建议使用基于外键的方式实现。

以个人与身份证的关系为例(主要看映射文件的配置和实体类)：

基于外键的方式(只有有外键方可以维护关联关系):


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

package test.hibernate.hbmOneToOne;

public class Person {

    private Integer id;

    private String name;

    private IDCard idCard;

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public IDCard getIdCard() {

        return idCard;

    }

    public void setIdCard(IDCard idCard) {

        this.idCard = idCard;

    }

    @Override

    public String toString() {

        // TODO Auto-generated method stub

        return "[Person:id=" + id + ",name=" + name + "]";

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

package test.hibernate.hbmOneToOne;

public class IDCard {

    private Integer id;

    private String IDNumber;

    private Person person;

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getIDNumber() {

        return IDNumber;

    }

    public void setIDNumber(String iDNumber) {

        IDNumber = iDNumber;

    }

    public Person getPerson() {

        return person;

    }

    public void setPerson(Person person) {

        this.person = person;

    }

    @Override

    public String toString() {

        // TODO Auto-generated method stub

        return "[IDCard:id="+id+",IDNumber="+IDNumber+"]";

    }

}

Person.hbm.xml


1

2

3

4

5

6

7

8

9

10

11

12

13

14

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="test.hibernate.hbmOneToOne">

    <class name="Person" table="person">

        <id name="id" type="integer" column="id">

            <generator class="native" />

        </id>

        <property name="name" />

        <one-to-one name="idCard" class="IDCard" property-ref="person"></one-to-one>

    </class>

</hibernate-mapping>

IDCard.hbm.xml


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="test.hibernate.hbmOneToOne">

    <class name="IDCard" table="idCard">

        <id name="id" type="integer" column="id">

            <generator class="native" />

        </id>

        <property name="IDNumber" />

        <many-to-one name="person" class="Person" column="personId" unique="true">

        </many-to-one>

    </class>

</hibernate-mapping>

测试类


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

package test.hibernate.hbmOneToOne;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.junit.Test;

public class App {

    private static SessionFactory sessionFactory = new Configuration()//

            .configure()//

            .addClass(Person.class)// 添加Hibernate实体类（加载对应的映射文件）

            .addClass(IDCard.class)//

            .buildSessionFactory();

    @Test

    public void testSave() throws Exception {

        Session session = sessionFactory.openSession();

        session.beginTransaction();

        // --------------------------------------------

        // 构建对象

        Person person = new Person();

        person.setName("张三");

        IDCard idCard = new IDCard();

        idCard.setIDNumber("377489392002121X");

        // 关联起来

        person.setIdCard(idCard);

        idCard.setPerson(person);

        // 保存

        session.save(person);

        session.save(idCard);

        // --------------------------------------------

        session.getTransaction().commit();

        session.close();

    }

    @Test

    public void testGet() throws Exception {

        Session session = sessionFactory.openSession();

        session.beginTransaction();

        // 获取数据

        Person person = (Person) session.get(Person.class, 2);

        System.out.println(person);

        System.out.println(person.getIdCard());

        IDCard idCard = (IDCard) session.get(IDCard.class, 2);

        System.out.println(idCard);

        System.out.println(idCard.getPerson());

        session.getTransaction().commit();

        session.close();

    }

    // 解除关联关系,从有外键方

    @Test

    public void testRemoveRelation() throws Exception {

        Session session = sessionFactory.openSession();

        session.beginTransaction();

        // --------------------------------------------

        IDCard idCard = (IDCard) session.get(IDCard.class, 1);

        idCard.setPerson(null);

        // --------------------------------------------

        session.getTransaction().commit();

        session.close();

    }

    // 删除，只能做有外键方到无外键方的单向关联

    @Test

    public void testDelete() throws Exception {

        Session session = sessionFactory.openSession();

        session.beginTransaction();

        // --------------------------------------------

        // Person person=(Person) session.get(Person.class, 2);

        // session.delete(person);//删除失败，有personId外键，抛出异常

        IDCard idCard = (IDCard) session.get(IDCard.class, 3);

        session.delete(idCard);// 卡删了，人还在

        // --------------------------------------------

        session.getTransaction().commit();

        session.close();

    }

}

基于主键的方式（双方都不可以维护关联关系,映射文件配置有所不同）：

Person.hbm.xml


1

2

3

4

5

6

7

8

9

10

11

12

13

14

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="test.hibernate.hbmOneToOne2">

    <class name="Person" table="person2">

        <id name="id" type="integer" column="id">

            <generator class="native" />

        </id>

        <property name="name" />

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

    </class>

</hibernate-mapping>

IDCard.hbm.xml


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="test.hibernate.hbmOneToOne2">

    <class name="IDCard" table="idCard2">

        <id name="id" type="integer" column="id">

            <!--

            当使用基于主键的一对一映射时，有外键方的主键

            生成策略 一定要是foreign。

            参数property:生成主键值时所根据的对象。

             -->

            <generator class="foreign">

                <param name="property">person</param>

            </generator>

        </id>

        <property name="IDNumber" />

        <!-- constrained外键约束 -->

        <one-to-one name="person" class="Person" constrained="true">

        </one-to-one>

    </class>

</hibernate-mapping>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

package test.hibernate.hbmOneToOne2;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.junit.Test;

public class App {

    private static SessionFactory sessionFactory = new Configuration()//

            .configure()//

            .addClass(Person.class)// 添加Hibernate实体类（加载对应的映射文件）

            .addClass(IDCard.class)//

            .buildSessionFactory();

    @Test

    public void testSave() throws Exception {

        Session session = sessionFactory.openSession();

        session.beginTransaction();

        // --------------------------------------------

        // 构建对象

        Person person = new Person();

        person.setName("张三");

        IDCard idCard = new IDCard();

        idCard.setIDNumber("377489392002121X");

        // 关联起来

        person.setIdCard(idCard);

        idCard.setPerson(person);

        // 保存

//      session.save(person);

        session.save(idCard);

        // --------------------------------------------

        session.getTransaction().commit();

        session.close();

    }

    // 解除关联关系

    @Test

    public void testRemoveRelation() throws Exception {

        Session session = sessionFactory.openSession();

        session.beginTransaction();

        // --------------------------------------------

//      IDCard idCard = (IDCard) session.get(IDCard.class, 1);

//      idCard.setPerson(null);//抛异常

        

        Person person=(Person) session.get(Person.class, 3);

        person.setIdCard(null);//数据库中的数据没有改变

        // --------------------------------------------

        session.getTransaction().commit();

        session.close();

    }

    // 删除

    @Test

    public void testDelete() throws Exception {

        Session session = sessionFactory.openSession();

        session.beginTransaction();

        // --------------------------------------------

//      IDCard idCard = (IDCard) session.get(IDCard.class, 2);

//      session.delete(idCard);//正常

        

        Person person=(Person) session.get(Person.class, 3);

        session.delete(person);//抛异常，id作为外键

        // --------------------------------------------

        session.getTransaction().commit();

        session.close();

    }

}
时间： 2024-10-23 17:33:37

一对一关联映射的相关文章

006——hibernate一对一关联映射

一对一关联映射有两种方式:主键关联和外键关联 以夫妻为例(Husband----Wife) 单向关联实体类: Husband.java package com.java.hibernate; public class Husband { private int id; private String name; private Wife wife; public Wife getWife() { return wife; } public void setWife(Wife wife) { thi

【SSH之旅】一步步学习Hibernate框架（二）：一对一关联映射中的主键关联

一对一的映射在对象模型中是经常见到的,主要是将对象模型转换为关系模型就必须在映射文件中进行配置,重点是<one-to-one>标签的使用,有两种方式,第一是主键关联,第二是唯一外键关联,现在先来看第一种方式. 一对一的关联映射中的主键关联,就是说两个对象具有相同的主键值,以表明它们之间的一一对应的关系,数据库表不会有额外的字段来维护它们之间的关系,仅仅是通过表的主键来关联. 上图的Person类和IdCard类之间是一一对应关系,一个人就只能有一个身份证,一个身份证只能对应一个人,那么身份证的

【Hibernate】——一对一关联映射

两个对象之间如果是一对一的关系,如Person-IdCard.在Hibernate中有两种策略可以实现一对一的关联映射: 主键关联:即让两个对象具有相同的主键值,以表明它们之间的一一对应的关系:数据库表不会有额外的字段来维护它们之间的关系,仅通过表得主键来关联. 唯一外键关联:外键关联,本来是用于多对一的配置,但是如果加上唯一的限制之后,也可以用来表示一对一关联关系: 而每种策略又分为两种方向的对应关系,即单向一对一关系和双向一对一关系.分类的原因一般是由需求决定的,单双向是站在不同的角度去看人

mybatis 一对一关联映射实例

在实际项目开发中,经常存在一对一的关系,如一个人对应一张身份证信息,这就是一对一的关系.下面是一个简单的实例: 1.建表过程我就省略了,主要是一张Person表,一张IDCard表,其相关属性见步骤2Pojo类属性所示: 2.建立一个Person对象和一个IDCard对象: mybatis/pri/xiaoyang/otot/pojo/IDCard.java 1 public class IDCard implements Serializable { 2 private int id; //

java之hibernate之基于外键的双向一对一关联映射

这篇讲解 基于外键的双向一对一关联映射 1.考察如下信息,人和身份证之间是一个一对一的关系.表的设计 2.类结构 Person.java public class Person implements Serializable{ private int id; private String name; private IdCard idCard; public Person() { } public Person(String name) { super(); this.name = name;

Hibernate中一对一关联映射/组件映射

Hibernate映射:一对一关联 1.按照外键映射 2.按照主键映射 组件映射 下面以员工账号表和员工档案表(员工账号和档案表之间是一对一的关系)为例,介绍这两种映射关系,并使用这两种 映射方式分别完成以下持久化操作 (1)保存员工档案的同时分配给员工一个账号 (2)加载员工档案的同时加载账号信息 一:按照外键映射

Hibernate一对一关联映射配置

一.一对一关联 Hibernate提供了两种映射一对一关联关系的方式:按照外键映射和按照主键映射.下面以员工账号和员工档案表为例,介绍这两种映射方式,并使用这两种映射方式分别完成以下持久化操作: (1)保存员工档案的同时分配给员工一个账号. (2)加载员工档案的同时加载账号信息. 按照外键映射: 关系图: ①创建实体类:Resume.Users 并封装属性 public class Resume { //档案id private Integer resid; //档案名称 private Str

论坛：一对一关联映射/单向关联/两个类间，可以有两个（多个）关联关系/content为大文本类型/

>>单向:只写一端的映射属性,另一端不写(有一端用不着);双向:两端都写映射属性 >>一对一关联有两类:一类基于主键的(一般不使用),一类基于外键的(重点学习): 外键:是一个普通字段,该字段的值是另一张表的主键.比如,A表中的一个字段,是B表的主键,那他就可以是A表的外键. 外键可以重复, 可以是空值.与主键唯一非空区别: 一对一:即在多的一方,外键上添加<many to one name="" colum="" class=&quo

Hibernate之实现一对一关联映射关系

Hibernate中实现一对一映射有基于外键的方式和基于主键的方式.由于基于主键方式的映射在实现删除等操作时存在的问题且不够灵活,一般建议使用基于外键的方式实现. 以个人与身份证的关系为例(主要看映射文件的配置和实体类): 基于外键的方式: package test.hibernate.hbmOneToOne; public class Person { private Integer id; private String name; private IDCard idCard; public