Hibernate第六篇【多对多映射、一对一映射】

时间：2021-06-29 10:04:07

前言

前面已经讲解了一对多和多对一的映射是怎么配置了，也讲解了inverse和cascade属性对关联关系的影响，本博文讲解多对多的映射和一对一的映射！

多对多映射

需求：一个项目由多个员工开发，一个员工开发多个项目

设计数据库表

一般地，如果是多对多的映射，我们都会使用一张中间表来保存它们的关联关系….

Hibernate第六篇【多对多映射、一对一映射】

设计实体

我们在设计实体的时候，一般是核心数据表对应一个JavaBean实体【中间表并不是核心数据表】，那么我们将会设计两个JavaBean对象

Hibernate第六篇【多对多映射、一对一映射】

project.java



package zhongfucheng.many2many;

import java.util.HashSet;

import java.util.Set;

/**

 * Created by ozc on 2017/5/7.

 */

public class Project {

    private int projectId;

    private String projectName;

    //使用Set集合与developer实体维护关系

    private Set<Developer> developers = new HashSet<>();

    public int getProjectId() {

        return projectId;

    }

    public void setProjectId(int projectId) {

        this.projectId = projectId;

    }

    public String getProjectName() {

        return projectName;

    }

    public void setProjectName(String projectName) {

        this.projectName = projectName;

    }

    public Set<Developer> getDevelopers() {

        return developers;

    }

    public void setDevelopers(Set<Developer> developers) {

        this.developers = developers;

    }

}

developer.java



package zhongfucheng.many2many;

import java.util.HashSet;

import java.util.Set;

/**

 * Created by ozc on 2017/5/7.

 */

public class Developer {

    private int developerId;

    private String developerName;

    //使用Set集合来维护与Project关系

    private Set<Project> projects = new HashSet<>();

    public int getDeveloperId() {

        return developerId;

    }

    public void setDeveloperId(int developerId) {

        this.developerId = developerId;

    }

    public String getDeveloperName() {

        return developerName;

    }

    public void setDeveloperName(String developerName) {

        this.developerName = developerName;

    }

    public Set<Project> getProjects() {

        return projects;

    }

    public void setProjects(Set<Project> projects) {

        this.projects = projects;

    }

}

映射配置文件

以项目映射文件为例：我们不急着写，首先来分析一下关键点……想要在多对多映射中产生正确的关联关系，下面几步必不可少：

  • 配置映射集合的属性(developers)
  • 映射集合对应的中间表(developer_project)
  • 中间表的外键字段(project_id)
  • 集合元素的类型(Developer)
  • 中间表另外的外键字段(developer_id)

Project和Developer的映射文件都需要这几个关键步骤

Project映射文件

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

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

        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--在domain包下-->

<hibernate-mapping package="zhongfucheng.many2many">

    <class name="Project" table="Project">

        <!--映射主键-->

        <id name="projectId" column="projectId">

            <generator class="native"></generator>

        </id>

        <!--映射普通字段-->

        <property name="projectName" column="projectName"></property>

        <!--映射多对多的关系-->

        <!--Set的属性名称为developers，对应developer_project表-->

        <set name="developers" table="developer_project">

            <!--对应developer_project表的外键列-->

            <key column="project_id"></key>

            <!--集合的类型和developer_project表的另一个外键列-->

            <many-to-many column="developer_id" class="Developer"></many-to-many>

        </set>

    </class>

</hibernate-mapping>

Developer映射文件



<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

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

        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--在domain包下-->

<hibernate-mapping package="zhongfucheng.many2many">

    <class name="Developer" table="Developer">

        <!--映射主键-->

        <id name="developerId" column="developerId">

            <generator class="native"></generator>

        </id>

        <!--映射普通字段-->

        <property name="developerName" column="developerName"></property>

        <!--映射多对多的关系-->

        <!--Set的属性名称为developers，对应developer_project表-->

        <set name="projects" table="developer_project">

            <!--对应developer_project表的外键列-->

            <key column="developer_id"></key>

            <!--集合的类型和developer_project表的另一个外键列-->

            <many-to-many column="project_id" class="Project"></many-to-many>

        </set>

    </class>

</hibernate-mapping>

测试



package zhongfucheng.many2many;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

import org.hibernate.classic.Session;

/**

 * Created by ozc on 2017/5/6.

 */

public class App2 {

    public static void main(String[] args) {

        /*

        *

        *

        *     Project   Developer

              电商系统

                             曹吉

                             王春

               OA系统

                             王春

                             老张

            */

        //创建对象

        Developer cj = new Developer();

        Developer wc = new Developer();

        Developer lz = new Developer();

        Project ds = new Project();

        Project oa = new Project();

        //设置对象的数据

        cj.setDeveloperName("曹吉");

        wc.setDeveloperName("王春");

        lz.setDeveloperName("老张");

        oa.setProjectName("OA系统");

        ds.setProjectName("电商系统");

        //使用Project来关联数据【在多对多中，一样的】

        oa.getDevelopers().add(wc);

        oa.getDevelopers().add(lz);

        ds.getDevelopers().add(cj);

        ds.getDevelopers().add(wc);

        //获取加载配置管理类

        Configuration configuration = new Configuration();

        //加载User的映射文件！

        configuration.configure().addClass(Developer.class).addClass(Project.class);

        //创建Session工厂对象

        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session对象

        Session session = factory.openSession();

        //使用Hibernate操作数据库，都要开启事务,得到事务对象

        Transaction transaction = session.getTransaction();

        //开启事务

        transaction.begin();

        //在Project映射文件中设置级联保存了

        session.save(oa);

        session.save(ds);

        //提交事务

        transaction.commit();

        //关闭Session

        session.close();

    }

}

执行了9条SQL语句，数据库中的记录也是正确的。

Hibernate第六篇【多对多映射、一对一映射】

一对一的映射

需求：用户与身份证信息..一个用户对应一个身份证

数据库表设计

对于数据库表设计我们有两种方式

  • 第一种：在身份证的数据表中设置一个外键来维护用户的关系，这个外键也应该是唯一的【一个用户对应一张身份证】
  • 第二种：在身份证的数据表中使用主键+外键的方式来维护用户的关系。

Hibernate第六篇【多对多映射、一对一映射】

设计实体

idCard.java

package zhongfucheng.one2one;

/**

 * Created by ozc on 2017/5/7.

 */

public class IdCard {

    private int idCardId;

    private String idCardName;

    //维护与用户之间的关系

    private User user ;

    public int getIdCardId() {

        return idCardId;

    }

    public void setIdCardId(int idCardId) {

        this.idCardId = idCardId;

    }

    public String getIdCardName() {

        return idCardName;

    }

    public void setIdCardName(String idCardName) {

        this.idCardName = idCardName;

    }

    public User getUser() {

        return user;

    }

    public void setUser(User user) {

        this.user = user;

    }

}

User.java

package zhongfucheng.one2one;

/**

 * Created by ozc on 2017/5/7.

 */

public class User {

    private int userId;

    private String userName;

    //维护与身份证一对一的关系

    private IdCard idCard ;

    public int getUserId() {

        return userId;

    }

    public void setUserId(int userId) {

        this.userId = userId;

    }

    public String getUserName() {

        return userName;

    }

    public void setUserName(String userName) {

        this.userName = userName;

    }

    public IdCard getIdCard() {

        return idCard;

    }

    public void setIdCard(IdCard idCard) {

        this.idCard = idCard;

    }

}

第一种方式映射文件

我们有两种方式来设计数据库中的表实现一对一的关系，首先我们来挑比较熟悉的外键方式来写映射文件

user映射文件



<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

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

        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="zhongfucheng.one2one">

    <class name="User" table="User">

        <!--映射主键-->

        <id name="userId" column="userId">

            <generator class="native"></generator>

        </id>

        <!--映射普通字段-->

        <property name="userName" column="userName"></property>

        <!--

            User是没有外键字段的表

                一对一的关系的属性名称name是idCard

                类型是IdCard

        -->

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

    </class>

</hibernate-mapping>

idCard映射文件



<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

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

        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="zhongfucheng.one2one">

    <class name="IdCard" table="IdCard">

        <!--映射主键-->

        <id name="idCardId" column="idCardId">

            <generator class="native"></generator>

        </id>

        <!--映射普通字段-->

        <property name="idCardName" column="idCardName"></property>

        <!--idCart是有外键的表，要把字段映射成外键，用的是manyToOne-->

        <!--

            外键的属性name是user

            对应表的字段是userId

            属性的类型是User

            该字段需要唯一性 unique

        -->

        <many-to-one name="user" column="user_id" class="User" unique="true" cascade="save-update"></many-to-one>

    </class>

</hibernate-mapping>

测试

要使用IdCart来维护User的关联关系。

  • 如果使用User来维护idCart的关联关系，idCart的外键列是为NULL的，因为重头到尾我们都没有给它赋值
  • 而使用IdCart来维护User，是外键值是根据User的主键id来生成的


package zhongfucheng.one2one;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

import org.hibernate.classic.Session;

/**

 * Created by ozc on 2017/5/6.

 */

public class App3 {

    public static void main(String[] args) {

        //创建对象

        User user = new User();

        IdCard idCard = new IdCard();

        //设置对象的数据

        user.setUserName("你好");

        idCard.setIdCardName("身份证001");

        //一对一关联数据

        idCard.setUser(user);

        //获取加载配置管理类

        Configuration configuration = new Configuration();

        //加载User的映射文件！

        configuration.configure().addClass(User.class).addClass(IdCard.class);

        //创建Session工厂对象

        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session对象

        Session session = factory.openSession();

        //使用Hibernate操作数据库，都要开启事务,得到事务对象

        Transaction transaction = session.getTransaction();

        //开启事务

        transaction.begin();

        //保存对象的数据,idCard配置文件使用级联保存

        session.save(idCard);

        //提交事务

        transaction.commit();

        //关闭Session

        session.close();

    }

}

Hibernate第六篇【多对多映射、一对一映射】

第二种方式映射文件

因为IdCart使用userId作为了主键，因此需要在JavaBean中配置多一个属性UserId…其他的都不用变



    private int userId;

    public int getUserId() {

        return userId;

    }

    public void setUserId(int userId) {

        this.userId = userId;

    }

在Hibernate第三篇讲解配置的时候，在generator节点下还有一个属性没有讲解，也就是foreign属性…现在来填坑了..

Hibernate第六篇【多对多映射、一对一映射】

idCard映射文件

idCart的映射文件主要在于:将主键也映射成外键来使用，这就需要用到foreign属性值了

使用<one-to-one>标签来配置基于主键的映射



<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

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

        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="zhongfucheng.one2one2.one2one">

    <class name="IdCard" table="IdCard">

        <!--映射主键-->

        <id name="userId" column="userId">

            <!--

                做主键的同时也做外键

                外键的类型名称为user

            -->

            <generator class="foreign">

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

            </generator>

        </id>

        <!--映射普通字段-->

        <property name="idCardName" column="idCardName"></property>

        <property name="idCardId" column="idCartId"></property>

        <!--

            有外键的一方：

                基于主键映射，使用oneToOne

                constrained="true"  指定在主键上添加外键约束

        -->

        <one-to-one name="user" class="User" constrained="true"></one-to-one>

    </class>

</hibernate-mapping>

user映射文件



<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

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

        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="zhongfucheng.one2one2.one2one">

    <class name="User" table="User">

        <!--映射主键-->

        <id name="userId" column="userId">

            <generator class="native"></generator>

        </id>

        <!--映射普通字段-->

        <property name="userName" column="userName"></property>

        <!--

            User是没有外键字段的表

            一对一的关系的属性名称name是idCard

            类型是IdCard

        -->

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

    </class>

</hibernate-mapping>

测试



package zhongfucheng.one2one2.one2one;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

import org.hibernate.classic.Session;

/**

 * Created by ozc on 2017/5/6.

 */

public class App4 {

    public static void main(String[] args) {

        //创建对象

        User user = new User();

        IdCard idCard = new IdCard();

        //设置对象的数据

        user.setUserName("你好3");

        idCard.setIdCardName("身份证003");

        idCard.setIdCardId(4235);

        //一对一关联数据

        idCard.setUser(user);

        //获取加载配置管理类

        Configuration configuration = new Configuration();

        //加载User的映射文件！

        configuration.configure().addClass(User.class).addClass(IdCard.class);

        //创建Session工厂对象

        SessionFactory factory = configuration.buildSessionFactory();

        //得到Session对象

        Session session = factory.openSession();

        //使用Hibernate操作数据库，都要开启事务,得到事务对象

        Transaction transaction = session.getTransaction();

        //开启事务

        transaction.begin();

        //保存对象的数据,idCard配置文件使用级联保存

        session.save(idCard);

        //提交事务

        transaction.commit();

        //关闭Session

        session.close();

    }

}

Hibernate第六篇【多对多映射、一对一映射】

相关文章