Hibernate多表的关联关系、懒加载

已于 2022-11-23 11:11:32 修改
阅读量434 收藏
点赞数 1
分类专栏： Hibernate 文章标签： hibernate java jvm
于 2022-11-21 22:38:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53881899/article/details/127972209
版权

参考文章：Hibernate实体关联关系映射，作者：骑猪下不来的猴

目录：

一、什么是Hibernate中的关联映射？

  • 简单来说Hibernate是ORM映射的持久层框架，全称是（Object Relational Mapping），即对象关系映射。
  • 它将数据库中的表映射成对应的对象，以对象的形式展现，这样我们就可以通过映射的对象来对数据库中的数据进行间接的操作。
  • 关联映射是将数据库中的表映射成与之相对应的对象，当你对这个对象进行操作的时候，Hibernate会对数据库中对应的表执行相应的操作，你对该实体的操作实际上就是在间接的操作数据库中与之相对应的表。
  • Hibernate正是实现了这种思想，达到了方便开发人员以面向对象的思想来实现对数据库的操作。

二、Hibernate的关联关系：

1.单向关联：

单向关联是指只有A方有B方的关联信息而B方没有A方的关联信息 。

例如：
 	  A——>B
 	  A对象中有B对象的关联信息
 	  B对象中没有A对象的关联信息  
 	  我们可以通过A对象中B的关联信息查询或修改B对象的信息但无法通过B对象来查询修改A对象的信息

单向关联又分为：

  • 一对一单向关联
  • 一对多单项关联
  • 多对一单项关联
  • 多对多单项关联

2.双向关联：

例如：
 	  A<——>B
 	  A对象中有B对象的关联信息
 	  B对象中也有A对象的关联信息
 	  我们可以通过A对象中B的关联信息查询或修改B对象的信息也可以通过B对象中A的关联信息来查询修改A对象的信息

双向关联又分为：

  • 一对一双向关联
  • 一对多双向关联（多对一双向关联）
  • 多对多双向关联

三、一对多与多对一关联：

只在一方配置关联关系而另一方不进行配置。

1.一对多单向关联：

（1）思路：
例如：
 	  Customer——>Order
      一个顾客（Customer）对应多个订单（Order）。
      当业务要求通过Customer可以获取该顾客下所有Order，但不能通过Order找到Customer时，这就需要一对多单向关联关系。

一对多单向关联关系的实现是通过在Customer类中创建Order类的集合属性，这样我们能够通过Customer获取和修改该客户对应的Order集合。（但是不能通过Order获取和修改Customer）

（2）代码实现：
  • 数据库表：

order表中有外键指向customer表。
在这里插入图片描述

  • 创建顾客实体类Customer，存储顾客信息：

注意我们在顾客类中用S集合封装了顾客名下的订单信息。

Customer类中要有订单Order的集合。

import lombok.Getter;
import lombok.Setter;
import java.util.Set;
@Getter
@Setter
public class Customer {
    private int id;
    private String name;
    private Integer age;
    //在顾客表中加入订单集合
    private Set<Order> orders;

    @Override
    public String toString() {
        return "Customer{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", orders=" + orders +
                '}';
    }
}
  • Order类：
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class Order {
    private int id;
    private String orderNumber;
    private Double orderPrice;
	//注意这里没有定义数据库中的外键属性
    @Override
    public String toString() {
        return "Order{" +
                "id=" + id +
                ", orderNumber='" + orderNumber + '\'' +
                ", orderPrice=" + orderPrice +
                '}';
    }
}
  • Customer.hbm.xml：
<hibernate-mapping package="org.example.Entity">
    <class name="Customer" table="customer">
        <id name="id" column="id" type="java.lang.Integer"/>
        <property name="name" column="name" type="java.lang.String"/>
        <property name="age" column="age" type="java.lang.Integer"/>
        <!--table:orders属性对应的数据库表-->
        <set name="orders" table="`order`">
            <!--key:该表中的外键-->
            <key column="customer_id"/>
            <!--一对多关系中多方所属的实体类-->
            <one-to-many class="org.example.Entity.Order"/>
        </set>
    </class>
</hibernate-mapping>
  • Order.hbm.xml:
<hibernate-mapping>
    <class name="org.example.Entity.Order" table="`order`">
        <id name="id" column="id" type="java.lang.Integer"/>
        <property name="orderNumber" column="orderNumber" type="java.lang.String"/>
        <property name="orderPrice" column="orderPrice" type="java.lang.Double"/>
    </class>
</hibernate-mapping>
  • 测试类及运行结果：
@Test
public void test3(){
    //创建SessionFactory,从根路径下获取核心配置文件
    SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
    //创建session
    Session session = factory.openSession();
    //创建并开启事务
    Transaction transaction = session.beginTransaction();
    //获取Customer主键为1的顾客信息及其所有订单信息
    Customer customer = session.get(Customer.class,1);
    //打印数据
    System.out.println(customer.toString());
    //提交事务
    transaction.commit();
    //关闭SessionFactory
    factory.close();
}

在这里插入图片描述

2.多对一单向关联：

（1）思路：
例如：
 	  Customer<——Order
      多个订单（Order）属于一个顾客（Customer）。
      当业务要求通过Order可以获取该订单所属Customer，但不能通过Customer找到Order时，这就需要多对一单向关联关系。

多对一单向关联关系的实现是通过在Order类中创建Customer类作为属性，这样我们能够通过Order获取和修改该客户Customer的信息。（但是不能通过Customer获取和修改Order）

（2）代码实现：
  • 数据库表：

order表中有外键指向customer表。
在这里插入图片描述

  • Customer类：
package org.example.Entity;
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class Customer {
    private int id;
    private String name;
    private Integer age;

    @Override
    public String toString() {
        return "Customer{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
  • 创建订单类Order，存储订单信息：

订单类中应该有顾客类，用来指明该订单属于哪个顾客。
订单类中要有顾客属性，类型是顾客类的类型。

package org.example.Entity;
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class Order {
    private int id;
    private String orderNumber;
    private Double orderPrice;
    //订单类中要有顾客Customer属性
    private Customer customer;

    @Override
    public String toString() {
        return "Order{" +
                "id=" + id +
                ", orderNumber='" + orderNumber + '\'' +
                ", orderPrice=" + orderPrice +
                ", customer=" + customer +
                '}';
    }
}
  • Customer.hbm.xml：
<hibernate-mapping package="org.example.Entity">
    <class name="Customer" table="customer">
        <id name="id" column="id" type="java.lang.Integer"/>
        <property name="name" column="name" type="java.lang.String"/>
        <property name="age" column="age" type="java.lang.Integer"/>
    </class>
</hibernate-mapping>
  • Order.hbm.xml:
<hibernate-mapping>
    <class name="org.example.Entity.Order" table="`order`">
        <id name="id" column="id" type="java.lang.Integer"/>
        <property name="orderNumber" column="orderNumber" type="java.lang.String"/>
        <property name="orderPrice" column="orderPrice" type="java.lang.Double"/>
        <!--设置customer属性为多对一关系的一方-->
        <many-to-one name="customer" column="customer_id"  class="org.example.Entity.Customer"/>
    </class>
</hibernate-mapping>
  • 测试类及运行结果：
@Test
public void test3(){
    //创建SessionFactory,从根路径下获取核心配置文件
    SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
    //创建session
    Session session = factory.openSession();
    //创建并开启事务
    Transaction transaction = session.beginTransaction();
    //获取订单主键为111的订单信息及该订单所属的顾客信息
    Order order = session.get(Order.class,111);
    //打印数据
    System.out.println(order.toString());
    //提交事务
    transaction.commit();
    //关闭SessionFactory
    factory.close();
}

在这里插入图片描述

3.一对多（多对一）双向关联：

（1）思路：
例如：
 	  Customer<——>Order
      一个顾客（Customer）对应多个订单（Order）。
      当业务要求通过Customer可以获取该顾客下所有Order，且通过Order能获取对应Customer时，这就需要一对多双向关联关系。

双向关联关系就是同时使用一对多单向关联和多对一单向关联。 所以需要在Customer类中创建Order类的集合属性，并在Order类中创建Customer属性。

双向关联时易错点inverse属性：

我们进行双向关联后，顾客类中有订单类，订单类中有顾客类，当我们想要执行插入操作时，如果双方都维护关联关系，那么会出现重复执行SQL语句的情况，使得效率低下。
所以我们需要配置一个属性，让双向关联的某一方交出维护权。
inverse=“true” 表示将关联关系交由对方控制。inverse=“false” 表示自己控制关联关系。

补充cascade属性：

该属性表示级联操作，cascade=“delete” 设置级联删除，设置后当删除某一行时，会级联删除绑定该行外键的其他行。

（2）代码实现：
  • 数据库表：

order表中有外键指向customer表。
在这里插入图片描述

  • 创建顾客实体类Customer，存储顾客信息：

注意我们在顾客类中用S集合封装了顾客名下的订单信息。

Customer类中要有订单Order的集合。

import lombok.Getter;
import lombok.Setter;
import java.util.Set;
@Getter
@Setter
public class Customer {
    private int id;
    private String name;
    private Integer age;
    //在顾客表中加入订单集合
    private Set<Order> orders;
}
  • 创建订单类Order，存储订单信息：

订单类中应该有顾客类，用来指明该订单属于哪个顾客。
订单类中要有顾客属性，类型是顾客类的类型。

package org.example.Entity;
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class Order {
    private int id;
    private String orderNumber;
    private Double orderPrice;
    //订单类中要有顾客Customer属性
    private Customer customer;
}
  • Customer.hbm.xml：
<hibernate-mapping package="org.example.Entity">
    <class name="Customer" table="customer">
        <id name="id" column="id" type="java.lang.Integer"/>
        <property name="name" column="name" type="java.lang.String"/>
        <property name="age" column="age" type="java.lang.Integer"/>
        <!--table:orders属性对应的数据库表-->
        <!--这里一定要设置inverse属性，或在订单映射文件设置inverse-->
        <set name="orders" table="`order`" inverse="true" cascade="delete">
            <!--key:该表中的外键-->
            <key column="customer_id"/>
            <!--一对多关系中多方所属的实体类-->
            <one-to-many class="org.example.Entity.Order"/>
        </set>
    </class>
</hibernate-mapping>
  • Order.hbm.xml:
<hibernate-mapping>
    <class name="org.example.Entity.Order" table="`order`">
        <id name="id" column="id" type="java.lang.Integer"/>
        <property name="orderNumber" column="orderNumber" type="java.lang.String"/>
        <property name="orderPrice" column="orderPrice" type="java.lang.Double"/>
        <!--设置customer属性为多对一关系的一方-->
        <many-to-one name="customer" column="customer_id"  class="org.example.Entity.Customer"/>
    </class>
</hibernate-mapping>
  • 测试类及运行结果：
@Test
public void test3(){
    //创建SessionFactory,从根路径下获取核心配置文件
    SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
    //创建session
    Session session = factory.openSession();
    //创建并开启事务
    Transaction transaction = session.beginTransaction();
    //获取订单主键为111的订单信息及该订单所属的顾客信息
    Order order = session.get(Order.class,111);
    //打印数据
    System.out.println(order.getCustomer().getName());
    //提交事务
    transaction.commit();
    //关闭SessionFactory
    factory.close();
}

在这里插入图片描述

（3）关联插入操作的实现：

  • 测试类：
    注意要建立关联关系。
public class AppTest{
    @Test
    public void test(){
        //创建SessionFactory,从根路径下获取核心配置文件
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
        //创建session
        Session session = factory.openSession();
        //创建事务
        Transaction transaction = session.beginTransaction();
        //创建顾客类对象并给相应属性赋值
        CustomerEntity customer = new CustomerEntity();
        customer.setId(4);
        customer.setName("44");
        customer.setAge(18);
        //创建订单类对象并给相应属性赋值
        OrdersEntity order = new OrdersEntity();
        order.setId(4);
        order.setOrderNumber("4");
        order.setOrderPrice(4.0);
        //建立关联关系，若不建立关联关系order表的数据为空
        order.setCustomer(customer);
        //保存，所有对象都要保存
        session.save(customer);
        session.save(order);
        //提交事务
        transaction.commit();
        //关闭SessionFactory
        factory.close();
    }
}
  • 运行结果：
    在这里插入图片描述

四、多对多关联：

1.多对多单向关联：

（1）思路：

例如：
 	  Pupil===>Course
      一个学生（Pupil）有多门课程（Course）。
      当业务要求通过Pupil学生可以获取该学生的所有课程Course，但通过Course课程不能获取对应Pupil学生时，这就需要多对多单向关联关系。

多对多关系通过一个中间表来维护。
在这里插入图片描述

（2）代码实现：

  • 数据库表：

pupil_course表中有两个外键分别指向pupil表和course表的主键。
在这里插入图片描述

  • 创建Pupil实体类：

Pupil类中有课程Course的集合。

import lombok.Getter;
import lombok.Setter;
import java.util.Set;

@Getter
@Setter
public class Pupil {
    private int aid;
    private String aname;
    private Set<Course> courses;

    @Override
    public String toString() {
        return "Pupil{" +
                "aid=" + aid +
                ", aname='" + aname + '\'' +
                ", courses=" + courses +
                '}';
    }
}
  • 创建Course实体类：
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class Course {
    private int cid;
    private String cname;

    @Override
    public String toString() {
        return "Course{" +
                "cid=" + cid +
                ", cname='" + cname + '\'' +
                '}';
    }
}
  • 创建中间表实体类：
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class PupilCourse {
    private int id;
    private Integer aid;
    private Integer cid;
}
  • 创建Pupil实体类映射文件:
<hibernate-mapping>
    <class name="org.example.Entity.Pupil" table="pupil">
        <id name="aid" column="aid" type="java.lang.Integer"/>
        <property name="aname" column="aname" type="java.lang.String"/>
        <set name="courses" table="pupil_course" >
            <key column="aid"/>
            <!--column 属性与中间表的外键字段名对应,这里配的是CoursesEntity在中间表中对应的外键-->
            <many-to-many class="org.example.Entity.Course" column="cid"/>
        </set>
    </class>
</hibernate-mapping>
  • 创建Course实体类映射文件:
<hibernate-mapping>
    <class name="org.example.Entity.Course" table="course">
        <id name="cid" column="cid" type="java.lang.Integer"/>
        <property name="cname" column="cname" type="java.lang.String"/>
    </class>
</hibernate-mapping>
  • 创建中间表实体类映射文件：
<hibernate-mapping>
    <class name="org.example.Entity.PupilCourse" table="pupil_course">
        <id name="id" column="id" type="java.lang.Integer"/>
        <property name="aid" column="aid" type="java.lang.Integer"/>
        <property name="cid" column="cid" type="java.lang.Integer"/>
    </class>
</hibernate-mapping>
  • 测试类及运行结果：
@Test
public void test8(){
    //创建SessionFactory,从根路径下获取核心配置文件
    SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
    //创建session
    Session session = factory.openSession();
    //创建事务
    Transaction transaction = session.beginTransaction();
    //获取主键ID为0的学生信息及其选课信息
    Pupil pupil = session.get(Pupil.class,0);
    //输出结果
    System.out.println(pupil.toString());
    //提交事务
    transaction.commit();
    //关闭SessionFactory
    factory.close();
}

在这里插入图片描述

2.多对多双向关联：

（1）思路：

例如：
 	  Pupil<===>Course
      一个学生（Pupil）有多门课程（Course），一门课程有多个学生选择。
      当业务要求通过Pupil学生可以获取该学生的所有课程Course，且通过Course课程能获取对应Pupil学生时，这就需要多对多双向关联关系。

多对多关系通过一个中间表来维护。
在这里插入图片描述

易错：双向关联关系注意设置inverse和cascade属性。

（2）代码实现：

  • 数据库表：

pupil_course表中有两个外键分别指向pupil表和course表的主键。
在这里插入图片描述

  • 创建Pupil实体类：

Pupil类中有课程Course的集合。

import lombok.Getter;
import lombok.Setter;
import java.util.Set;

@Getter
@Setter
public class Pupil {
    private int aid;
    private String aname;
    private Set<Course> courses;

    @Override
    public String toString() {
        return "Pupil{" +
                "aid=" + aid +
                ", aname='" + aname + '\'' +
                ", courses=" + courses +
                '}';
    }
}
  • 创建Course实体类：

Course类中有课程Pupil的集合。

import lombok.Getter;
import lombok.Setter;

import java.util.Set;

@Getter
@Setter
public class Course {
    private int cid;
    private String cname;
    private Set<Pupil> pupils;
}
  • 创建中间表实体类：
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class PupilCourse {
    private int id;
    private Integer aid;
    private Integer cid;
}
  • 创建Pupil实体类映射文件:
<hibernate-mapping>
    <class name="org.example.Entity.Pupil" table="pupil">
        <id name="aid" column="aid" type="java.lang.Integer"/>
        <property name="aname" column="aname" type="java.lang.String"/>
        <set name="courses" table="pupil_course">
            <key column="aid"/>
            <!--column 属性与中间表的外键字段名对应,这里配的是CoursesEntity在中间表中对应的外键-->
            <many-to-many class="org.example.Entity.Course" column="cid"/>
        </set>
    </class>
</hibernate-mapping>
  • 创建Course实体类映射文件:
<hibernate-mapping>
    <class name="org.example.Entity.Course" table="course">
        <id name="cid" column="cid" type="java.lang.Integer"/>
        <property name="cname" column="cname" type="java.lang.String"/>
        <set name="pupils" table="pupil_course">
            <key column="cid"></key>
            <many-to-many class="org.example.Entity.Pupil" column="aid"></many-to-many>
        </set>
    </class>
</hibernate-mapping>
  • 创建中间表实体类映射文件：
<hibernate-mapping>
    <class name="org.example.Entity.PupilCourse" table="pupil_course">
        <id name="id" column="id" type="java.lang.Integer"/>
        <property name="aid" column="aid" type="java.lang.Integer"/>
        <property name="cid" column="cid" type="java.lang.Integer"/>
    </class>
</hibernate-mapping>
  • 测试类及运行结果：
@Test
public void test8(){
    //创建SessionFactory,从根路径下获取核心配置文件
    SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
    //创建session
    Session session = factory.openSession();
    //创建事务
    Transaction transaction = session.beginTransaction();
    //获取主键ID为0的课程信息及课程内的学生
    Course course = session.get(Course.class,0);
    //输出结果
    for (Pupil pupil : course.getPupils()) {
        System.out.println(pupil.getAname());
    }
    //提交事务
    transaction.commit();
    //关闭SessionFactory
    factory.close();
}

在这里插入图片描述

（3）关联插入操作的实现：

  • 测试类：
    @Test
    public void test2(){
        //创建SessionFactory,从根路径下获取核心配置文件
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
        //创建session
        Session session = factory.openSession();
        //创建事务
        Transaction transaction = session.beginTransaction();
        //创建Courses类对象并给相应属性赋值
        CoursesEntity course = new CoursesEntity();
        course.setCname("JAVA");
        //创建Accounts类对象并给相应属性赋值
        AccountsEntity account = new AccountsEntity();
        account.setAname("张三");
        //建立关联关系
        Set<CoursesEntity> courses = new HashSet<>();
        courses.add(course);
        account.setCourses(courses);
        //保存，所有对象都要保存
        session.save(course);
        session.save(account);
        //提交事务
        transaction.commit();
        //关闭SessionFactory
        factory.close();
    }
}
  • 运行结果：
    在这里插入图片描述

五、一对一关联：

一对一单向关联没有测出来，所以没写，有会实现的的欢迎与我交流。

1.一对一双向关联：

（1）思路：
例如：
 	  Person<——>Address
      一个人（Person）对应一个家（Address）。
      当业务要求通过Person可以获取他的家庭住址Address，且能通过Address找到Person时，这就需要一对一双向关联关系。

一对一双向关联关系的实现是通过在Person类中创建Address类作为属性，并在Address类中创建Person类作为属性

（2）代码实现：
  • 数据库表：

在这里插入图片描述

  • Person类：

Person类中要有地址Address类作为属性。

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class Person {
    private int personId;
    private String personName;
    private String personPhone;
    //Person类中要有地址Address类
    private Address address;

    @Override
    public String toString() {
        return "Person{" +
                "personId=" + personId +
                ", personName='" + personName + '\'' +
                ", personPhone='" + personPhone + '\'' +
                ", address=" + address +
                '}';
    }
}
  • Address类：

Address类中要有Person类作为属性。

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class Address {
    private int addressId;
    private String addressDetail;
    //Address类中要有地址Person类
    private Person person;

    @Override
    public String toString() {
        return "Address{" +
                "addressId=" + addressId +
                ", addressDetail='" + addressDetail + '\'' +
                '}';
    }
}
  • Person.hbm.xml：
<hibernate-mapping>
    <class name="org.example.Entity1.Person" table="person">
        <id name="personId" column="person_id"/>
        <property name="personName" column="person_name"/>
        <property name="personPhone" column="person_phone"/>
        <!--另一端使用ome-to-one元素，该元素使用property-ref属性指定使用被关联实体主键以外的字段作为关联字段-->
        <one-to-one name="address"  class="org.example.Entity1.Address" property-ref="person" />
    </class>
</hibernate-mapping>
  • Address.hbm.xml:
<hibernate-mapping>
    <class name="org.example.Entity1.Address" table="address">
        <id name="addressId" column="address_id"/>
        <property name="addressDetail" column="address_detail"/>
        <!--在需要存放外键的一端，增加many-to-one元素 在many-to-one元素增加unique="true"属性来表示1-1关联-->
        <many-to-one name="person" column="personid" unique="true" class="org.example.Entity1.Person"/>
    </class>
</hibernate-mapping>
  • 测试类及运行结果：
    @Test
    public void test1(){
        //创建SessionFactory,从根路径下获取核心配置文件
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
        //创建session
        Session session = factory.openSession();
        //创建事务
        Transaction transaction = session.beginTransaction();
        //创建实体类对象并给相应属性赋值
        Person person = session.get(Person.class,1);
        System.out.println(person);
        //提交事务
        transaction.commit();
        //关闭SessionFactory
        factory.close();
    }

在这里插入图片描述

六、懒加载：

懒加载条件下查询顾客信息和订单信息。

什么是懒加载？点击查看

具体配置同上。
需要在customer类的映射文件中为order的set集合配置 lazy="true"，设置order的懒加载，这样在查询customer信息时会根据需求判断是否查询order。
需要在order类的映射文件中为customer的many-to-one设置lazy=proxy"，设置customer的懒加载，这样在查询order信息时会根据需求判断是否查询customer。
默认条件下所有Hibernate映射文件都会开启懒加载。

  • 测试类1：
@Test
public void test3(){
    //创建SessionFactory,从根路径下获取核心配置文件
    SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
    //创建session
    Session session = factory.openSession();
    //创建事务
    Transaction transaction = session.beginTransaction();
    //查询主键为4的顾客信息
    CustomerEntity customer = session.get(CustomerEntity.class,4);
    System.out.println(customer);
    //提交事务
    transaction.commit();
    //关闭SessionFactory
    factory.close();
}
  • 运行结果1：

因为会调用toString方法，toString会打印学生信息和订单信息，所以有两条SQL语句。
在这里插入图片描述
如果只打印customer.name()，则只会有第一条SQL，这就是懒加载。

  • 测试类2：
@Test
public void test4(){
    //创建SessionFactory,从根路径下获取核心配置文件
    SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
    //创建session
    Session session = factory.openSession();
    //创建事务
    Transaction transaction = session.beginTransaction();
    //查询主键为4的订单信息
    OrdersEntity orders = session.get(OrdersEntity.class,4);
    System.out.println(orders);
    //提交事务
    transaction.commit();
    //关闭SessionFactory
    factory.close();
}
  • 运行结果2：
    在这里插入图片描述
    如果只打印order.name()，则只会有第一条SQL，这就是懒加载。
姓蔡小朋友
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Hibernate懒加载问题的5种解决方案
zhaohong_bo的专栏
05-05 7738
** 1、Hibernate基础 ** Hibernate基础，传送门 ** 2、什么是Hibernate懒加载 ** 当我们查询一个对象的时候，在默认情况下，返回的只是该对象的代理对象，当用户去使用该对象的属性时，才会向数据库再一次发出查询语句。 例如，有一个对象是Employee，还有一个对象是Department。显然，对于Employee相对Department来说，是多对一的关系；而对于...
Hibernate表间关联ppt课件.ppt
11-18
默认情况下，Hibernate使用懒加载来提高性能，只在真正需要时才加载关联的对象。 8. 复合主键（Composite Key）： 当表使用多列作为主键时，需要创建一个专门的类来封装这些主键列，并在映射文件中使用`...
Hibernate处理表之间的关联（多对多）
欧世乐
08-23 172
1.表多对多之间的关联 题目：课程和老师之间是多对多的关系，要求实现：对课程的信息进行查询额时候，无需另外查询就可以得到老师的信息，对老师的信息进行查询的时候也可以知道他所任教的课程。 步骤 建立三个表：course、teacher、jiaoke 建立POJO，course.java，teacher.java,建立Hibernate配置文件，将其与两个hbm文件绑定 在course.java里面...
Hibernate 基本操作、懒加载以及缓存
Gefangenes的博客
05-11 269
上一篇咱们介绍了 Hibernate 以及写了一个 Hibernate 的工具类，快速入门体验了一波 Hibernate 的使用，我们只需通过 Session 对象就能实现数据库的操作了。现在，这篇介绍使用 Hibernate 进行基本的 CRUD、懒加载以及缓存的知识。本篇文章主要讲了基本的 CRUD 操作，都是通过 Session 去操作的，根据一个持久化类的类型以及一个唯一标识进行相关操作，然后讲了 Hibernate 中的对象的状态，有 4 种，分别是瞬时、持久、游离、删除。
hibernate学习笔记之二（映射关系与懒加载）
qq_43663493的博客
08-29 201
hibernate 映射关系 关系型数据库中，多表之间存在三种关联关系，分别为一对一，一对多和多对多。 主外键的添加： 一对一：在任意一方引入对方主键作为外键。 一对多：在“多”的一方，添加“一”的一方的主键作为外键。 多对多：产生中间关系表，引入两张表的主键作为外键，两个主键成为联合主键。 一对一的关系就是在本类中定义对方类型的对象，如 A 类中定义 B 类类型的属性 b，B 类中定义 A 类类型的属性 a；一对多的关系，在一个 A 类类型对应多个 B 类类型的情况下，需要在 A 类以 Set 集
hibernate的懒加载的四种解决方式
zcl1199的博客
05-11 784
懒加载的产生原因： 当使用hibernate查询一个对象的时候，如果Session关闭，在调用该对象关联的集合或者对象的时候，会出现懒加载异常 解决方案（以用户和角色为例）： 方案一： 在session关闭之前，查询对象关联的集合或者对象，所有在业务层的方法上添加 public ElecUserfindUserByLogonName(String name) {         S
解决Hibernate懒加载的4种方式
nwpu_geeker的博客
01-18 5150
前言在项目开发中，如果设置集合映射中一方的懒加载（lazy=true）,那么在加载jsp页面中，集合元素获取有时候会报错，session关闭的问题。而本文总结了我在学习hibernate过程中，解决hibernate懒加载问题的四种方式。懒加载当我们查询一个对象的时候，比如（user=(User)session.load(User.class,1); ）,在默认情况下，返回的只是该对象的代理对象，当
关于hibernate的关联对象懒加载处理
qq_40085888的博客
10-23 606
为了提高查询性能,我们会把一些不常用的关联对象进行懒加载.但有时候开发中会需要显示其中一两个字段.那我们可以通过自定义一个get方法去让其获取. 这样就可以在需要用到该字段时自然通过其getter进行加载关联字段了.不需要人为getStaffInfo(). 因为对于list的话,则需要循环中一个个 getStaffInfo(). 代码也不优雅 @Transient //该字段不作...
Hibernate多对多关联关系demo
04-10
在Java的持久化框架Hibernate中，多对多（Many-to-Many）关联关系是一种常见的实体间关系类型，它表示一个实体可以与多个其他实体相关联，反之亦然。本示例"Hibernate多对多关联关系demo"将深入探讨如何在实际开发中...
hibernate一对多关联映射学习小结
08-29
Hibernate的关联映射是其核心功能之一，可以将Java对象之间的关系映射到数据库表之间的关系中。 一对多关联映射是Hibernate中的一种常见的关联映射类型，它表示一个对象可以拥有多个其他对象的引用。在Hibernate中...
hibernate多对一单向关联关系实现源码
10-08
在Java的持久化框架Hibernate中，多对一（ManyToOne）关联关系是一种常见的对象关系映射（ORM）场景。这种关系通常出现在一个实体类拥有多条与另一个实体类相关的记录，而另一个实体类可能只有一条对应的记录。例如...
hibernate 中 fetch=FetchType.LAZY 懒加载失败处理方法
08-29
hibernate 中 fetch=FetchType.LAZY 懒加载失败处理方法 Hibernate 中 fetch=FetchType.LAZY 懒加载失败处理方法是 Hibernate 框架中的一种常见问题。当我们在 Hibernate 中使用懒加载特性时，可能会遇到 ...
深入探索Stage #2：属性中的XSS注入技术
weixin_43822401的博客
06-04 626
在Web安全的学习旅程中，XSS（跨站脚本）注入是一个不可忽视的话题。"XSS Challenges"闯关游戏的Stage #2专为进阶学习者设计，专注于属性中的XSS注入技术。本文将详细介绍这一阶段的实操过程和关键概念。
配置Java开发环境
最新发布
Broken_x的博客
07-10 1065
Java开发环境配置
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 269
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1743
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1172
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java占位符替换五种方式
weixin_61478518的博客
07-08 343
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 2922
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
Hibernate怎么多表联查
07-27
在Hibernate中进行多表联查可以通过配置ORM映射文件或使用注解来实现。 如果使用配置ORM映射文件，可以在映射文件中定义多对多关系。例如，可以使用元素定义一个集合属性，然后使用元素指定另一方的类型和在第三...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

姓蔡小朋友

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值