技术教程 编程教程 Hibernate关联关系配置(一对多,一对一,多对多) 正文

Hibernate关联关系配置(一对多,一对一,多对多)

2023-05-16,,

一对多

创建两个类  Manager(一这一端) Worker(多这一端)  即一个经理下有多个员工

package com.hibernate.n21;

import java.util.HashSet;

import java.util.Set;

public class Manager {

    private Integer mgrId;

    private String mgrName;

    /*

     * 1. 声明集合类型时, 需使用接口类型, 因为 hibernate 在获取

     * 集合类型时, 返回的是 Hibernate 内置的集合类型, 而不是 JavaSE 一个标准的

     * 集合实现.

     * 2. 需要把集合进行初始化, 可以防止发生空指针异常

     */

    private Set<Worker> workers = new HashSet<>();

    public Integer getMgrId() {

        return mgrId;

    }

    public void setMgrId(Integer mgrId) {

        this.mgrId = mgrId;

    }

    public String getMgrName() {

        return mgrName;

    }

    public void setMgrName(String mgrName) {

        this.mgrName = mgrName;

    }

    public Set<Worker> getWorkers() {

        return workers;

    }

    public void setWorkers(Set<Worker> workers) {

        this.workers = workers;

    }

}

package com.hibernate.n21;

public class Worker {

    private Integer id;

    private String name;

    private Manager manager;

    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 Manager getManager() {

        return manager;

    }

    public void setManager(Manager manager) {

        this.manager = manager;

    }

    @Override

    public String toString() {

        return "Worker [id=" + id + ", name=" + name + ", manager=" + manager + "]";

    }

}

xml文件

<!--1这一端-->

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

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

<!-- Generated 2017-8-10 7:47:59 by Hibernate Tools 3.4.0.CR1 -->

<hibernate-mapping>

    <class name="com.hibernate.n21.Manager" table="MANAGER">

        <id name="mgrId" type="java.lang.Integer">

            <column name="MGR_ID" />

            <generator class="native" />

        </id>

        <property name="mgrName" type="java.lang.String">

            <column name="MGR_NAME" />

        </property>

        <!-- 映射 1 对多的那个集合属性 -->

        <!-- set: 映射 set 类型的属性, table: set 中的元素对应的记录放在哪一个数据表中. 该值需要和多对一的多的那个表的名字一致 -->

        <!-- inverse: 指定由哪一方来维护关联关系. 通常设置为 true, 以指定由多的一端来维护关联关系 -->

        <!-- order-by 在查询时对集合中的元素进行排序, order-by 中使用的是表的字段名, 而不是持久化类的属性名  -->

        <set name="workers" table="WORKER" inverse="true">

        <!-- 执行多的表中的外键列的名字 -->

            <key>

                <column name="MGR_ID" />

            </key>

            <!-- 指定映射类型 -->

            <one-to-many class="com.hibernate.n21.Worker" />

        </set>

    </class>

</hibernate-mapping>
<!--多这端-->

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

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

<!-- Generated 2017-8-10 7:47:59 by Hibernate Tools 3.4.0.CR1 -->

<hibernate-mapping>

    <class name="com.hibernate.n21.Worker" table="WORKER">

        <id name="id" type="java.lang.Integer">

            <column name="ID" />

            <generator class="native" />

        </id>

        <property name="name" type="java.lang.String">

            <column name="NAME" />

        </property>

        <!--

            映射多对一的关联关系。 使用 many-to-one 来映射多对一的关联关系

            name: 多这一端关联的一那一端的属性的名字

            class: 一那一端的属性对应的类名

            column: 一端对应的数据表中的外键的名字

        -->

        <many-to-one name="manager" class="com.hibernate.n21.Manager" fetch="join">

            <column name="MGR_ID" />

        </many-to-one>

    </class>

</hibernate-mapping>

测试代码

package com.hibernate.n21;

import static org.junit.Assert.*;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

import org.hibernate.service.ServiceRegistry;

import org.hibernate.service.ServiceRegistryBuilder;

import org.junit.After;

import org.junit.Before;

public class Test {

    private SessionFactory sessionFactory;

    private Session session;

    private Transaction transaction;

    @Before

    public void init(){

        Configuration configuration = new Configuration().configure();

        ServiceRegistry serviceRegistry =

                new ServiceRegistryBuilder().applySettings(configuration.getProperties())

                                            .buildServiceRegistry();

        sessionFactory = configuration.buildSessionFactory(serviceRegistry);

        session = sessionFactory.openSession();

        transaction = session.beginTransaction();

    }

    @After

    public void destroy(){

        transaction.commit();

        session.close();

        sessionFactory.close();

    }

    @org.junit.Test

    public void test() {

        fail("Not yet implemented");

    }

    @org.junit.Test

    public void testMany2OneGet(){

        //1. 若查询多的一端的一个对象(Worker), 则默认情况下, 只查询了多的一端的对象,不查询一的一端对象(Manager)

        Worker worker = (Worker) session.get(Worker.class, 1);

        System.out.println(worker.getName());

        System.out.println(worker.getManager().getClass());

        //session.close();

        //2. 在需要使用到关联的对象时, 才发送对应的 SQL 语句.

        /*Manager manager = worker.getManager();

        System.out.println(manager.getMgrName());*/ 

        //3. 在查询对象时, 由多的一端导航到 1 的一端时,

        //若此时 session 已被关闭, 会发生 LazyInitializationException 异常

        //4. 获取 Worker 对象时, 默认情况下, 其关联的 Manager对象是一个代理对象!

    }

    @org.junit.Test

    public void testMany2OneSave() {

        Worker worker = new Worker();

        worker.setName("worker-1");

        Worker worker2 = new Worker();

        worker2.setName("worker-2");

        Worker worker3 = new Worker();

        worker3.setName("worker-3");

        System.out.println(worker);

        System.out.println(worker2);

        System.out.println(worker3);

        Manager manager = new Manager();

        manager.setMgrName("MMM");

        //设定关联关系

        worker.setManager(manager);

        worker2.setManager(manager);

        worker3.setManager(manager);

        //先插入 1 的一端, 再插入 n 的一端, 只有 INSERT 语句.

        //反过来插入开始Manner的mgrId未生成会产生update语句

        session.save(manager);

        session.save(worker);

        session.save(worker2);

        session.save(worker3);

    }

}

数据库截图

一对一关系外键

Manager 和  Department  一个经理一个部门

package com.hibernate.n21;

public class Department {

    private Integer deptId;

    private String deptName;

    private Manager mgr;

    public Integer getDeptId() {

        return deptId;

    }

    public void setDeptId(Integer deptId) {

        this.deptId = deptId;

    }

    public String getDeptName() {

        return deptName;

    }

    public void setDeptName(String deptName) {

        this.deptName = deptName;

    }

    public Manager getMgr() {

        return mgr;

    }

    public void setMgr(Manager mgr) {

        this.mgr = mgr;

    }

}

package com.hibernate.n21;

import java.util.HashSet;

import java.util.Set;

public class Manager {

    private Integer mgrId;

    private String mgrName;

    /*

     * 1. 声明集合类型时, 需使用接口类型, 因为 hibernate 在获取

     * 集合类型时, 返回的是 Hibernate 内置的集合类型, 而不是 JavaSE 一个标准的

     * 集合实现.

     * 2. 需要把集合进行初始化, 可以防止发生空指针异常

     */

    private Set<Worker> workers = new HashSet<>();

    private Department dept; //在上面的代码上加了这行

    public Integer getMgrId() {

        return mgrId;

    }

    public void setMgrId(Integer mgrId) {

        this.mgrId = mgrId;

    }

    public String getMgrName() {

        return mgrName;

    }

    public void setMgrName(String mgrName) {

        this.mgrName = mgrName;

    }

    public Set<Worker> getWorkers() {

        return workers;

    }

    public void setWorkers(Set<Worker> workers) {

        this.workers = workers;

    }

    public Department getDept() {

        return dept;

    }

    public void setDept(Department dept) {

        this.dept = dept;

    }

}

xml文件

<!--在部门这端生成外键-->

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

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

<!-- Generated 2017-8-10 9:04:21 by Hibernate Tools 3.4.0.CR1 -->

<hibernate-mapping>

    <class name="com.hibernate.n21.Department" table="DEPARTMENT">

        <id name="deptId" type="java.lang.Integer">

            <column name="DEPTID" />

            <generator class="native" />

        </id>

        <property name="deptName" type="java.lang.String">

            <column name="DEPTNAME" />

        </property>

        <!-- 使用 many-to-one 的方式来映射 1-1 关联关系 -->

        <many-to-one name="mgr" class="com.hibernate.n21.Manager"

            column="MGR_ID" unique="true">

        </many-to-one>

    </class>

</hibernate-mapping>
<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

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

<!-- Generated 2017-8-10 7:47:59 by Hibernate Tools 3.4.0.CR1 -->

<hibernate-mapping>

    <class name="com.hibernate.n21.Manager" table="MANAGER">

        <id name="mgrId" type="java.lang.Integer">

            <column name="MGR_ID" />

            <generator class="native" />

        </id>

        <property name="mgrName" type="java.lang.String">

            <column name="MGR_NAME" />

        </property>

        <!-- 映射 1 对多的那个集合属性 -->

        <!-- set: 映射 set 类型的属性, table: set 中的元素对应的记录放在哪一个数据表中. 该值需要和多对一的多的那个表的名字一致 -->

        <!-- inverse: 指定由哪一方来维护关联关系. 通常设置为 true, 以指定由多的一端来维护关联关系 -->

        <!-- order-by 在查询时对集合中的元素进行排序, order-by 中使用的是表的字段名, 而不是持久化类的属性名  -->

        <set name="workers" table="WORKER" inverse="true">

        <!-- 执行多的表中的外键列的名字 -->

            <key>

                <column name="MGR_ID" />

            </key>

            <!-- 指定映射类型 -->

            <one-to-many class="com.hibernate.n21.Worker" />

        </set>

         <!-- 映射 1-1 的关联关系: 在对应的数据表中已经有外键了, 当前持久化类使用 one-to-one 进行映射 -->

        <!--

            没有外键的一端需要使用one-to-one元素，该元素使用 property-ref 属性指定使用被关联实体主键以外的字段作为关联字段

         -->

          <!-- 在原来的代码上加上一对一关系 -->

        <one-to-one name="dept"

            class="com.hibernate.n21.Department"

            property-ref="mgr">

        </one-to-one>

    </class>

</hibernate-mapping>

Test

@org.junit.Test

    public void testGet(){

        //1. 默认情况下对关联属性使用懒加载

        Department dept = (Department) session.get(Department.class, 1);

        System.out.println(dept.getDeptName()); 

        //2. 会出现懒加载异常的问题.

//        session.close();

        //3. 查询 Manager 对象的连接条件应该是 dept.manager_id = mgr.manager_id

//而不应该是 dept.dept_id = mgr.manager_id所以在xml文件中加入property-ref="mgr"

        Manager mgr = dept.getMgr();

        System.out.println(mgr.getMgrName()); 

    }

    @org.junit.Test

    public void testSave(){

        Department department = new Department();

        department.setDeptName("DEPT-BB");

        Manager manager = new Manager();

        manager.setMgrName("MGR-BB");

        //设定关联关系

        department.setMgr(manager);

        manager.setDept(department);

        //保存操作

        //建议先保存没有外键列的那个对象. 这样会减少 UPDATE 语句

        session.save(manager);

        session.save(department);

    }

基于主键

修改Department的xml即可 (删除Manager xml里的property-ref="mgr")

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

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

<!-- Generated 2017-8-10 9:04:21 by Hibernate Tools 3.4.0.CR1 -->

<hibernate-mapping>

    <class name="com.hibernate.n21.Department" table="DEPARTMENT">

        <id name="deptId" type="java.lang.Integer">

            <column name="DEPT_ID" />

            <!-- 使用外键的方式来生成当前的主键 -->

            <generator class="foreign">

                <!-- property 属性指定使用当前持久化类的哪一个属性的主键作为外键 -->

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

            </generator>

        </id>

        <property name="deptName" type="java.lang.String">

            <column name="DEPTNAME" />

        </property>

        <!-- 使用 many-to-one 的方式来映射 1-1 关联关系 -->

        <!--

        采用 foreign 主键生成器策略的一端增加 one-to-one 元素映射关联属性,

        其 one-to-one 节点还应增加 constrained=true 属性, 以使当前的主键上添加外键约束

        -->

        <one-to-one name="mgr" class="com.hibernate.n21.Manager" constrained="true"></one-to-one>

    </class>

</hibernate-mapping>

多对多

public class Category {

    private Integer id;

    private String name;

    private Set<Item> items = new HashSet<>();

    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 Set<Item> getItems() {

        return items;

    }

    public void setItems(Set<Item> items) {

        this.items = items;

    }

}

public class Item {

    private Integer id;

    private String name;

    private Set<Category> categories = new HashSet<>();

    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 Set<Category> getCategories() {

        return categories;

    }

    public void setCategories(Set<Category> categories) {

        this.categories = categories;

    }

}

@Test

    public void testGet(){

        Category category = (Category) session.get(Category.class, 1);

        System.out.println(category.getName()); 

        //需要连接中间表

        Set<Item> items = category.getItems();

        System.out.println(items.size());

    }

    @Test

    public void testSave(){

        Category category1 = new Category();

        category1.setName("C-AA");

        Category category2 = new Category();

        category2.setName("C-BB");

        Item item1 = new Item();

        item1.setName("I-AA");

        Item item2 = new Item();

        item2.setName("I-BB");

        //设定关联关系

        category1.getItems().add(item1);

        category1.getItems().add(item2);

        category2.getItems().add(item1);

        category2.getItems().add(item2);

        item1.getCategories().add(category1);

        item1.getCategories().add(category2);

        item2.getCategories().add(category1);

        item2.getCategories().add(category2);

        //执行保存操作

        session.save(category1);

        session.save(category2);

        session.save(item1);

        session.save(item2);

    }
<?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="com.hibernate.n2n">

    <class name="Category" table="CATEGORIES">

        <id name="id" type="java.lang.Integer">

            <column name="ID" />

            <generator class="native" />

        </id>

        <property name="name" type="java.lang.String">

            <column name="NAME" />

        </property>

        <!-- table: 指定中间表 -->

        <set name="items" table="CATEGORIES_ITEMS">

            <key>

                <column name="C_ID" />

            </key>

            <!-- 使用 many-to-many 指定多对多的关联关系. column 执行 Set 集合中的持久化类在中间表的外键列的名称  -->

            <many-to-many class="Item" column="I_ID"></many-to-many>

        </set>

    </class>

</hibernate-mapping>
<?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="com.hibernate.n2n">

    <class name="Item" table="ITEMS">

        <id name="id" type="java.lang.Integer">

            <column name="ID" />

            <generator class="native" />

        </id>

        <property name="name" type="java.lang.String">

            <column name="NAME" />

        </property>

        <set name="categories" table="CATEGORIES_ITEMS" inverse="true">

            <key column="I_ID"></key>

            <many-to-many class="Category" column="C_ID"></many-to-many>

        </set>

    </class>

</hibernate-mapping>

Hibernate关联关系配置(一对多,一对一,多对多)的相关教程结束。

《Hibernate关联关系配置(一对多,一对一,多对多).doc》

下载本文的Word格式文档，以方便收藏与打印。

Copyright 2023. 昆居客 - IT编程,互联网信息技术文档大全!