Hibernate 框架映射关联关系

最新推荐文章于 2023-09-25 16:13:30 发布

caoyue_new

最新推荐文章于 2023-09-25 16:13:30 发布

阅读量336

点赞数

分类专栏： Hibernate 框架文章标签： hibernate 框架

本文链接：https://blog.csdn.net/caoyue_new/article/details/53407869

版权

Hibernate 框架专栏收录该内容

7 篇文章 0 订阅

订阅专栏

单向多对一关联关系

Hibernate 使用 <\many-to-one> 元素来映射多对一关联关系
例子（用户可以有多个订单，一个订单对应一个用户）
Customer.java

package com.hibernate.entities.n21;

public class Customer {

    private int customerId;
    private String customerName;

    public int getCustomerId() {
        return customerId;
    }
    public void setCustomerId(int customerId) {
        this.customerId = customerId;
    }
    public String getCustomerName() {
        return customerName;
    }
    public void setCustomerName(String customerName) {
        this.customerName = customerName;
    }
}

Order.java

package com.hibernate.entities.n21;

public class Order {

    private Integer orderId;
    private String orderName;

    private Customer customer;

    public Integer getOrderId() {
        return orderId;
    }

    public void setOrderId(Integer orderId) {
        this.orderId = orderId;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public Customer getCustomer() {
        return customer;
    }

    @Override
    public String toString() {
        return "Order [orderId=" + orderId + ", orderName=" + orderName
                + ", customer=" + customer + "]";
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
}

Custormer.hbm.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">
<hibernate-mapping package="com.hibernate.entities.n21">
    <class name="Customer" table="CUSTOMER">
        <id name="customerId" type="int">
            <column name="CUSTOMER_ID" />
            <generator class="native" />
        </id>
        <property name="customerName" type="java.lang.String">
            <column name="CUSTOMER_NAME" />
        </property>
    </class>
</hibernate-mapping>

Order.hbm.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">
<hibernate-mapping package="com.hibernate.entities.n21">
    <class name="Order" table="ORDERS">
        <id name="orderId" type="java.lang.Integer">
            <column name="ORDERID" />
            <generator class="native" />
        </id>
        <property name="orderName" type="java.lang.String">
            <column name="ORDER_NAME" />
        </property>

        <!-- 映射多对一的映射关系，使用many-to-one 来映射多对一的映射关系 
            name：多这一端关联的映射名字
            class：设定待映射的持久化类的属性的类型
            column：设定和持久化类的属性对应的表的外键
        -->
        <many-to-one name="customer" class="Customer" column="CUSTOMER_ID">
        </many-to-one>
    </class>
</hibernate-mapping>

PropertiesTest.java

package com.hibernate.entities.n21;

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;
import org.junit.Test;

import com.sun.org.apache.xpath.internal.operations.Or;

public class PropertiesTest {
    SessionFactory sessionFactory;
    Session session;
    Transaction transaction;

    @Before
    public void init() {
        Configuration configuration = new Configuration().configure();
        @SuppressWarnings("deprecation")
        ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
            .applySettings(configuration.getProperties()).buildServiceRegistry();
        sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        session = sessionFactory.openSession();
        transaction = session.beginTransaction();
    }

    @After
    public void destory() {
        transaction.commit();
        session.close();
        sessionFactory.close();
    }

    /**
     * 在不设定级联关系的情况下，不能直接删除一对多且有多的情况下一这一端的数据
     */
    @Test
    public void testMany2OneDelete() {
        Order order = (Order) session.get(Order.class, 1);
        session.delete(order.getCustomer());
    }

    @Test
    public void testMany2OneUpdate() {
        Order order = (Order) session.get(Order.class, 1);
        order.getCustomer().setCustomerName("barry");
    }

    /**
     * 1. 若查询多的一端的对象，默认情况下只查询了多的一端的对象，而没有查询一的一端的对象（延迟加载）
     * 2. 若需要使用一的一端的对象，才会发送对应的 SQL 语句
     * 3. 在查询Customer一端的时，由多的一端导航到一的一端
     *      如果session关闭，在默认情况下会抛出 LazyInitializationException 异常
     * 4. 获取 Order 对象时，默认情况下其关联的对象是一个代理对象
     */
    @Test
    public void testMany2OneGet() {
        Order order = (Order) session.get(Order.class, 1);
        System.out.println(order.getOrderName());

        System.out.println(order.getCustomer().getClass().getName());
        //session.close();
        Customer customer = order.getCustomer();

        System.out.println(customer.getCustomerName());
    }

    @Test
    public void testMany2OneSave() {
        Customer customer = new Customer();
        customer.setCustomerName("lina");

        Order order1 = new Order();
        order1.setOrderName("外套-1");
        Order order2 = new Order();
        order2.setOrderName("外套-2");

        //设置关联关系
        order1.setCustomer(customer);
        order2.setCustomer(customer);

        //执行save
        //先插入Customer，再插入Order，3条INSERT
        session.save(customer);
        session.save(order1);
        session.save(order2);

        //先插入 Order，在插入 Customer，3条INSERT，两条UPDATE；先插入多的一端会多两条UPDATE语句，推荐先插入1的一端
        /*session.save(order1);
        session.save(order2);

        session.save(customer);*/
    }
}

双向一对多关联关系

这里仍然使用用户和订单例子，只需修改上面Customer文件
Customer.java需要添加orders属性

    /**
     * 1. 声明集合时需要使用接口类型，因为Hibernate在获取接口时返回的是Hibernate内置的集合类型，而不是JavaSe中标准的集合类型
     * 2. 需要把集合初始化，防止出现空指针异常
     */
    private Set<Order> orders = new HashSet<>();
        public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }

Customer.hbm.xml中添加

<!-- 映射 1 对 多的关联关系 -->
<!-- set: 映射 set 类型的属性, table: set 中的元素对应的记录放在哪一个数据表中. 该值需要和多对一的多的那个表的名字一致 -->
<!-- inverse: 指定由哪一方来维护关联关系. 通常设置为 true, 以指定由多的一端来维护关联关系 -->
<!-- cascade 设定级联操作. 开发时不建议设定该属性. 建议使用手工的方式来处理 -->
<!-- order-by 在查询时对集合中的元素进行排序, order-by 中使用的是表的字段名, 而不是持久化类的属性名  -->
<set name="orders" table="ORDERS" inverse="true" cascade="delete-orphan" order-by="ORDER_NAME DESC">
    <!-- 执行多的表中的外键列的名字 -->
    <key column="CUSTOMER_ID"></key>
    <!-- 指定映射类型 -->
    <one-to-many class="Order"/>
</set>

PropertiesTest.java

package com.hibernate.entities.n21.both;

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;
import org.junit.Test;

public class PropertiesTest {
    SessionFactory sessionFactory;
    Session session;
    Transaction transaction;

    @Before
    public void init() {
        Configuration configuration = new Configuration().configure();
        @SuppressWarnings("deprecation")
        ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
            .applySettings(configuration.getProperties()).buildServiceRegistry();
        sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        session = sessionFactory.openSession();
        transaction = session.beginTransaction();
    }

    @After
    public void destory() {
        transaction.commit();
        session.close();
        sessionFactory.close();
    }

    @Test
    public void testCascade() {
        Customer customer = (Customer) session.get(Customer.class, 2);
        customer.getOrders().clear();
    }

    /**
     * 在不设定级联关系的情况下，不能直接删除一对多且有多的情况下一这一端的数据
     */
    @Test
    public void testDelete() {
        Order order = (Order) session.get(Order.class, 1);
        session.delete(order.getCustomer());
    }

    @Test
    public void testOne2ManyUpdate() {
        Customer customer = (Customer) session.get(Customer.class, 1);
        customer.getOrders().iterator().next().setOrderName("连衣裙");
    }

    @Test
    public void testMany2OneUpdate() {
        Order order = (Order) session.get(Order.class, 1);
        order.getCustomer().setCustomerName("barry");
    }

    /**
     * 1. 对 n 的一端使用延迟加载
     */
    @Test
    public void testOne2ManyGet() {
        Customer customer = (Customer) session.get(Customer.class, 3);
        System.out.println(customer.getCustomerName());
        // 返回多的一端的集合是Hibernate内置的集合类型，该类型具有延迟加载和存放代理对象的作用
        System.out.println(customer.getOrders().getClass());
        // 可能会抛出 LazyInitializationException 异常
        //session.close();

        //4. 需要使用集合中元素的时候进行初始化. 
        System.out.println(customer.getOrders());
    }

    /**
     * 1. 若查询多的一端的对象，默认情况下只查询了多的一端的对象，而没有查询一的一端的对象（延迟加载）
     * 2. 若需要使用一的一端的对象，才会发送对应的 SQL 语句
     * 3. 在查询Customer一端的时，由多的一端导航到一的一端
     *      如果session关闭，在默认情况下会抛出 LazyInitializationException 异常
     * 4. 获取 Order 对象时，默认情况下其关联的对象是一个代理对象
     */
    @Test
    public void testMany2OneGet() {
        Order order = (Order) session.get(Order.class, 1);
        System.out.println(order.getOrderName());

        System.out.println(order.getCustomer().getClass().getName());
        //session.close();
        Customer customer = order.getCustomer();

        System.out.println(customer.getCustomerName());
    }

    @Test
    public void testMany2OneSave() {
        Customer customer = new Customer();
        customer.setCustomerName("lina");

        Order order1 = new Order();
        order1.setOrderName("外套-1");
        Order order2 = new Order();
        order2.setOrderName("外套-2");

        //设置关联关系
        order1.setCustomer(customer);
        order2.setCustomer(customer);

        customer.getOrders().add(order1);
        customer.getOrders().add(order2);

        //执行  save 操作: 先插入 Customer, 再插入 Order, 3 条 INSERT, 2 条 UPDATE
        //因为 1 的一端和 n 的一端都维护关联关系. 所以会多出 UPDATE
        //可以在 1 的一端的 set 节点指定 inverse=true, 来使 1 的一端放弃维护关联关系!
        //建议设定 set 的 inverse=true, 建议先插入 1 的一端, 后插入多的一端
        //好处是不会多出 UPDATE 语句
        session.save(customer);
        session.save(order1);
        session.save(order2);

        //先插入 Order，在插入 Customer，3条INSERT，4条UPDATE；
        /*session.save(order1);
        session.save(order2);

        session.save(customer);*/
    }
}

在对象 – 关系映射文件中, 用于映射持久化类之间关联关系的元素, <\set>, <\many-to-one> 和 <\one-to-one> 都有一个 cascade 属性, 它用于指定如何操纵与当前对象关联的其他对象. 不建议使用
这里写图片描述

一对一关联关系

以部门、部门经理为例

基于外键映射的 1-1

对于基于外键的1-1关联，其外键可以存放在任意一边，在需要存放外键一端，增加many-to-one元素。为many-to-one元素增加unique=“true” 属性来表示为1-1关联

<many-to-one name="manager" column="MANAGER_ID" unique="true" class="Manager"></many-to-one>

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

<one-to-one name="department" property-ref="manager" class="Department"></one-to-one>

基于主键映射的 1-1

基于主键的映射策略:指一端的主键生成器使用 foreign 策略,表明根据”对方”的主键来生成自己的主键，自己并不能独立生成主键. 子元素指定使用当前持久化类的哪个属性作为 “对方”
采用foreign主键生成器策略的一端增加 one-to-one 元素映射关联属性，其one-to-one属性还应增加 constrained=“true” 属性；另一端增加one-to-one元素映射关联属性。
constrained(约束):指定为当前持久化类对应的数据库表的主键添加一个外键约束，引用被关联的对象(“对方”)所对应的数据库表主键
Department.hbm.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">
<hibernate-mapping package="com.hibernate.entities.one2one.primary">
    <class name="Department" table="DEPARTMENT">
        <id name="depId" type="int">
            <column name="DEP_ID" />
            <!-- 使用外键的方式来生成当前的主键 -->
            <generator class="foreign">
                <!-- property 属性指定使用当前持久化类的哪一个属性的主键作为外键 -->
                <param name="property">manager</param>
            </generator>
        </id>
        <property name="depName" type="java.lang.String">
            <column name="DEP_NAME" />
        </property>
        <!--  
        采用 foreign 主键生成器策略的一端增加 one-to-one 元素映射关联属性,
        其 one-to-one 节点还应增加 constrained=true 属性, 以使当前的主键上添加外键约束
        -->
        <one-to-one name="manager" class="Manager" constrained="true"></one-to-one>
    </class>
</hibernate-mapping>

Manager.hbm.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">
<hibernate-mapping package="com.hibernate.entities.one2one.primary">
    <class name="Manager" table="MANAGER">
        <id name="managerId" type="int">
            <column name="MANAGER_ID" />
            <generator class="native" />
        </id>
        <property name="managerName" type="java.lang.String">
            <column name="MANAGER_NAME" />
        </property>

        <one-to-one name="department" class="Department"></one-to-one>
    </class>
</hibernate-mapping>

映射多对多关联关系

双向 n-n 关联需要两端都使用集合属性
双向n-n关联必须使用连接表
集合属性应增加 key 子元素用以映射外键列, 集合元素里还应增加many-to-many子元素关联实体类
在双向 n-n 关联的两边都需指定连接表的表名及外键列的列名. 两个集合元素 set 的 table 元素的值必须指定，而且必须相同。set元素的两个子元素：key 和 many-to-many 都必须指定 column 属性，其中，key 和 many-to-many 分别指定本持久化类和关联类在连接表中的外键列名，因此两边的 key 与 many-to-many 的column属性交叉相同。也就是说，一边的set元素的key的 cloumn值为a,many-to-many 的 column 为b；则另一边的 set 元素的 key 的 column 值 b,many-to-many的 column 值为 a.
对于双向 n-n 关联, 必须把其中一端的 inverse 设置为 true, 否则两端都维护关联关系可能会造成主键冲突.

<!-- 指定中间表 -->
<set name="items" table="CATEGORIES_ITEMS" inverse="false" lazy="true">
    <key>
        <column name="C_ID" />
    </key>
    <!-- 使用 many-to-many 指定多对多的关联关系，column 指定 set 集合中持久化类在中间表的外间列的名称 -->
    <many-to-many class="Item" column="I_ID"></many-to-many>
</set>

<set name="categories" table="CATEGORIES_ITEMS" inverse="true" lazy="true">
    <key column="I_ID"></key>
    <many-to-many class="Category" column="C_ID"></many-to-many>
</set>