hibernate 一对多关联关系总结

最新推荐文章于 2020-07-30 11:12:45 发布

从小白小菜开始

最新推荐文章于 2020-07-30 11:12:45 发布

阅读量98

点赞数

分类专栏： hibernate 文章标签： hibernate 1to n总结

hibernate 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

单向n-1的关联关系
　　单向 n-1 关联：只能从 n 的一端可以访问 1 的一端。
　　域模型：从 Order 到 Customer 的多对一单向关联需要在Order 类中定义一个 Customer 属性，而在 Customer 类中无有关Order的设置。
　　关系数据模型： ORDERS 表中的 CUSTOMER_ID 参照 CUSTOMER 表的主键。（外键）
　　Hibernate 使用元素来映射多对一关联关系。
　　例如，在Customer和Order的例子中，首先创建两个类文件：

public class Customer {
    private Integer customerId;
    private String customerName;
    //getters and setters
}

public class Order {
    private Integer orderId;
    private String orderName;
    private Customer customer;
    //getters and setters
}

生成hibernate映射文件：
Customer.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>
    <class name="com.atguigu.hibernate.entities.n21.Customer" table="CUSTOMERS">
        <id name="customerId" type="java.lang.Integer">
            <column name="CUSTOMER_ID" />
            <generator class="native" />
        </id>
        <property name="customerName" type="java.lang.String">
            <column name="CUSTOMER_NAME" />
        </property>
    </class>
</hibernate-mapping>

这里要注意的是；用hibernate 生成的 hbm.xml文件，主键的生成策略会默认为assigned，这个是由程序员自己指定的，如果在程序是不指定，则会报错。
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.atguigu.hibernate.entities.n21">
    <class name="Order" table="ORDERS">
        <id name="orderId" type="java.lang.Integer">
            <column name="ORDER_ID" />
            <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>

多这一端需要注意的有：
1、使用 many-to-one 来映射多对一的关联关系
2、 name: 多这一端关联的一那一端的属性的名字（多端的属性名）在这里插入图片描述
3、class: 一那一端的属性对应的类名（全限定类名，不带".JAVA"哈哈）
4、column: 一那一端在多的一端对应的数据表中的外键的名字（多端的外键名）。

单向n-1的save操作：

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

        Order order1 = new Order();
        order1.setOrderName("ORDER-1");

        Order order2 = new Order();
        order2.setOrderName("ORDER-2");

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

        //执行  save 操作: 先插入 Customer, 再插入 Order, 3 条 INSERT
        //先插入 1 端, 再插入 n 端, 只有 INSERT 语句.
        session.save(customer);

        session.save(order1);
        session.save(order2);

        //先插入 Order, 再插入 Customer. 3 条 INSERT, 2 条 UPDATE
        //先插入 n 的一端, 再插入 1 的一端, 会多出 UPDATE 语句!
        //因为在插入多的一端时, 无法确定 1 的一端的外键值. 所以只能等 1 的一端插入后, 再额外发送 UPDATE 语句.
        //推荐先插入 1 的一端, 后插入 n 的一端
        //session.save(order1);
        //session.save(order2);

        //session.save(customer);
    }
}

先插入“1端”能提高效率。

单向n-1的get操作：

@Test
    public void testMany2OneGet(){
        //1. 若查询n端的一个对象, 则默认情况下, 只查询了n端的对象. 而没有查询关联的 1 的那一端的对象!
        Order order = (Order) session.get(Order.class, 1);
        System.out.println(order.getOrderName()); 

        System.out.println(order.getCustomer().getClass().getName());

        //session.close();

        //2. 只有在需要使用到关联的对象时, 才发送对应的 SQL 语句. 
        Customer customer = order.getCustomer();
        System.out.println(customer.getCustomerName()); 
        //3. 在查询 Customer 对象时, 由多的一端导航到 1 的一端时, 
        //若此时 session 已被关闭, 则默认情况下
        //会发生 LazyInitializationException 异常

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

单向n-1的update操作：

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

单向n-1的delete操作：

@Test
    public void testDelete(){
        //在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象
        Customer customer = (Customer) session.get(Customer.class, 1);
        session.delete(customer); 
    }

<set name="orders" table="ORDERS" cascade="delete">

在这里插入图片描述
但是在开发时并不建议设定级联属性，而建议使用手工的方式来处理。

双向1-n的关联关系
Hibernate 使用元素来映射set类型的属性。

public class Customer {

    private Integer customerId;
    private String customerName;

    /*
     * 1. 声明集合类型时, 需使用接口类型, 因为 hibernate 在获取
     * 集合类型时, 返回的是 Hibernate 内置的集合类型, 而不是 JavaSE 一个标准的集合实现. 
     * 2. 需要把集合进行初始化, 可以防止发生空指针异常
     */
    private Set<Order> orders = new HashSet<>();

    //getters and setters
}

public class Order {

    private Integer orderId;
    private String orderName;

    private Customer customer;

    //getters and setters
}

Order类与单向时一样，Customer 多了个set
hbm文件（Order映射文件与与单向时相同）

<?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.atguigu.hibernate.entities.n21.both">

    <class name="Customer" table="CUSTOMERS">

        <id name="customerId" type="java.lang.Integer">
            <column name="CUSTOMER_ID" />
            <generator class="native" />
        </id>

        <property name="customerName" type="java.lang.String">
            <column name="CUSTOMER_NAME" />
        </property>

        <!-- 映射 1 对多的那个集合属性 -->
        <!-- set: 映射 set 类型的属性, name:一的这一端关联的多的那一端的属性名,table: set 中的元素对应的记录放在哪一个数据表中. 该值需要和多对一的多的那个表的名字一致 -->
        <set name="orders" table="ORDERS">
            <!-- 指定关联的表中的外键列的名字 -->
            <key column="CUSTOMER_ID"></key>
            <!-- 指定映射类型 -->
            <one-to-many class="Order"/>
        </set>

    </class>

</hibernate-mapping>

Customer的hbm文件多了

<set></set>

双向1-n的save操作：

@Test
    public void testOne2ManySave(){
        Customer customer = new Customer();
        customer.setCustomerName("AA");

        Order order1 = new Order();
        order1.setOrderName("ORDER-1");

        Order order2 = new Order();
        order2.setOrderName("ORDER-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, 再插入 Cusomer, 3 条 INSERT, 4 条 UPDATE
        //session.save(order1);
        //session.save(order2);

        //session.save(customer);
    }
}

那么，如果我们不希望两端都维护关联关系，该怎么办呢？
　　解决办法是，在hibernate的配置文件中可以通过设置inverse属性来决定是由双向关联的哪一方来维护表和表之间的关系。inverse = false的为主动方，inverse = true 的为被动方。由主动方负责维护关联关系。在没有设置inverse属性的情况下，默认父子两边都维护父子关系。
在Customer.hbm.xml映射文件中设置set节点为：

<set name="orders" table="ORDERS" inverse="true">

双向1-n的get操作：

@Test
    public void testOne2ManyGet(){
        //1. 对 n 的一端的集合使用延迟加载
        Customer customer = (Customer) session.get(Customer.class, 7);
        System.out.println(customer.getCustomerName()); 
        //2. 返回的多的一端的集合时 Hibernate 内置的集合类型. 
        //该类型具有延迟加载和存放代理对象的功能. 
        System.out.println(customer.getOrders().getClass()); 

        //session.close();
        //3. 可能会抛出 LazyInitializationException 异常 

        System.out.println(customer.getOrders().size()); 

        //4. 再需要使用集合中元素的时候进行初始化. 
    }

与单向n-1的get操作类似，在双向1-n的get操作中，如果先加载了customer对象，在使用它的orders集合之前，是不会加载orders集合的，这使用了懒加载机制，那么同样，也有可能抛出懒加载异常。

双向1-n的update操作：

@Test
    public void testUpdat2(){
        Customer customer = (Customer) session.get(Customer.class, 1);
        customer.getOrders().iterator().next().setOrderName("GGG"); 
    }

双向1-n的delete操作：

@Test
    public void testDelete(){
        //在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象
        Customer customer = (Customer) session.get(Customer.class, 1);
        session.delete(customer); 
    }

关于双向1-n的两个类的映射文件中，属性的对应关系，如下图所示：
在这里插入图片描述
声明本文引用自：https://blog.csdn.net/xiangwanpeng/article/details/53457124

从小白小菜开始

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
hibernate 一对多关联关系总结

单向n-1的关联关系　　单向 n-1 关联：只能从 n 的一端可以访问 1 的一端。　　域模型：从 Order 到 Customer 的多对一单向关联需要在Order 类中定义一个 Customer 属性，而在 Customer 类中无有关Order的设置。　　关系数据模型： ORDERS 表中的 CUSTOMER_ID 参照 CUSTOMER 表的主键。（外键）　　Hibernate 使...
复制链接

扫一扫