Hibernate的关联关系(多对多)映射、抓取策略

最新推荐文章于 2020-07-28 21:32:13 发布

凹凸凹

最新推荐文章于 2020-07-28 21:32:13 发布

阅读量222

点赞数

分类专栏： Hibernate 文章标签： Hibernate Multi to multi mapping

本文链接：https://blog.csdn.net/weixin_41653442/article/details/81368158

版权

Hibernate 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1.1多对多的配置:

步骤一创建实体和映射:

    Student:

public class Student {
    private Integer sid;
    private String sname;
    // 学生选择多门课程.
    private Set<Course> courses = new HashSet<Course>();
...
}

    Course:

public class Course {
    private Integer cid;
    private String cname;
    // 课程可以被多个学生选择:
    private Set<Student> students = new HashSet<Student>();
...
}

Student.hbm.xml

<hibernate-mapping>
    <class name="cn.itcast.demo3.Student" table="student">
        <id name="sid" column="sid">
            <generator class="native"/>
        </id>
        <property name="sname" column="sname"/>
        <!-- 配置多对多关联关系 -->
        <set name="courses" table="stu_cour">
            <key column="sno"/>
            <many-to-many class="cn.itcast. demo3.Course" column="cno"/>
        </set>
    </class>
</hibernate-mapping>

Course.hbm.xml

<hibernate-mapping>
    <class name="cn.itcast. demo3.Course" table="course">
        <id name="cid" column="cid">
            <generator class="native"/>
        </id>

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

        <!-- 配置多对多关联关系映射 -->
        <set name="students" table="stu_cour">
            <key column="cno"/>
            <many-to-many class="cn.itcast. demo3.Student" column="sno"/>
        </set>
    </class>
</hibernate-mapping>

2.抓取策略（优化）

2.1检索方式
立即检索：立即查询，在执行查询语句时，立即查询所有的数据。
延迟检索：延迟查询，在执行查询语句之后，在需要时在查询。（懒加载）

2.2检查策略
类级别检索：当前的类的属性获取是否需要延迟。
关联级别的检索：当前类关联另一个类是否需要延迟。

2.3类级别检索
get：立即检索。get方法一执行，立即查询所有字段的数据。
load：延迟检索。默认情况，load方法执行后，如果只使用OID的值不进行查询，如果要使用其他属性值将查询。

Customer.hbm.xml

<class  lazy="true | false">

lazy 默认值true，表示延迟检索，如果设置false表示立即检索。
这里写图片描述

@Test
    public void demo02() {
        //类级别
        Session session = factory.openSession();
        session.beginTransaction();

        //1立即
        //Customer customer = (Customer) session.get(Customer.class, 1);
        //2延迟
        Customer customer = (Customer) session.load(Customer.class, 1);
        //打印
        System.out.println(customer.getCid());
        System.out.println(customer.getCname());

        session.getTransaction().commit();
        session.close();
    }

2.4关联级别检索

2.4.1一对多或多对多

2.4.1.1介绍
容器<set> 提供两个属性：fetch、lazy
fetch：确定使用sql格式
lazy：关联对象是否延迟。
fetch：join、select、subselect
join：底层使用迫切左外连接
select：使用多个select语句（默认值）
subselect：使用子查询
lazy：false、true、extra
false：立即
true：延迟（默认值）
extra：极其懒惰
这里写图片描述
2.4.1.2fetch=”join”
fetch=”join” ，lazy无效。底层使用迫切左外连接，使用一条select将所有内容全部查询。

@Test
    public void demo03() {
        //关联级别：一对多，
        // * Customer.hbm.xml  <set fetch="join">
        // *** select语句使用左外连接，一次性查询所有
        Session session = factory.openSession();
        session.beginTransaction();

        //1 查询客户
        Customer customer = (Customer) session.get(Customer.class, 1);
        System.out.println(customer.getCname());

        //2 查询客户订单数
        Set<Order> orderSet = customer.getOrderSet();
        System.out.println(orderSet.size());

        //3 查询客户订单详情
        for (Order order : orderSet) {
            System.out.println(order);
        }

        session.getTransaction().commit();
        session.close();
    }

2.4.1.3fetch=”select”
当前对象和关联对象使用多条select语句查询。
lazy=”false” , 立即，先查询客户select，立即查询订单select
lazy=”true”,延迟，先查询客户select，需要订单时，再查询订单select
lazy=”extra”，极其懒惰（延迟），先查询客户select，如果只需要订单数，使用聚合函数（不查询详情）
这里写图片描述

2.4.1.4fetch=”subselect”
将使用子查询。注意：必须使用Query否则看不到效果。
lazy= 同上

public void demo04() {
        //关联级别：一对多，
        // 演示3：* Customer.hbm.xml  <set fetch="subselect">
        Session session = factory.openSession();
        session.beginTransaction();

        //1 查询客户
        List<Customer> allCustomer = session.createQuery("from Customer").list();
        Customer customer = allCustomer.get(0);
        System.out.println(customer.getCname());

        //2 查询客户订单数
        Set<Order> orderSet = customer.getOrderSet();
        System.out.println(orderSet.size());

        //3 查询客户订单详情
        for (Order order : orderSet) {
            System.out.println(order);
        }


        session.getTransaction().commit();
        session.close();
    }

这里写图片描述

2.4.2多对一

2.4.2.1介绍
<many-to-one fetch="" lazy=""> ()
fetch取值：join、select
join：底层使用迫切左外连接
select：多条select语句
lazy取值：false、proxy、no-proxy
false：立即
proxy：采用关联对象类级别检索的策略。
订单关联客户（多对一）
订单立即获得客户，需要在客户Customer.hbm.xml <class lazy="false">
订单延迟获得客户，需要在客户Customer.hbm.xml <class lazy="true">

no-proxy 不研究
这里写图片描述
2.4.2.2fetch=”join”
fecth=”join” select语句使用左外连接，此时lazy无效。

@Test
    public void demo05() {
        //关联级别：多对一，
        // 演示1：* Order.hbm.xml  <set fetch="join">  lazy无效
        // * 注意：检查Customer.hbm.xml 和 Order.hbm.xml 没有额外的配置
        Session session = factory.openSession();
        session.beginTransaction();

        //1 查询订单
        Order order = (Order) session.get(Order.class, 1);
        System.out.println(order.getPrice());

        //2 查询订单客户信息
        Customer customer = order.getCustomer();
        System.out.println(customer.getCname());


        session.getTransaction().commit();
        session.close();
    }

2.4.2.3fetch=”select”
将采用多条select语句，lazy=”proxy”是否延迟，取决关联对象类级别检索策略。

lazy=”false”
这里写图片描述

2.5批量查询
当客户关联查询订单，给每一个客户生产一个select语句查询订单。批量查询使用in语句减少查询订单语句个数。
默认：select * from t_order where customer_id = ?
批量：select * from t_order where customer_id in (?,?,?,?)<set batch-size="5">
5表示括号中?个数。
这里写图片描述

@Test
    public void demo06() {
        //批量查询
        Session session = factory.openSession();
        session.beginTransaction();

        //1 查询所有客户
        List<Customer> allCustomer = session.createQuery("from Customer").list();

        //2遍历
        for (Customer customer : allCustomer) {
            System.out.println(customer.getCname());
            System.out.println(customer.getOrderSet().size());
        }
        session.getTransaction().commit();
        session.close();
    }

2.6检索总结
这里写图片描述
Customer Get(int id)
Return Session.load(Customer.class,id);
1.layz=false
2.在Service层获得在页面要上要用到的属性=> 在Service层中确保数据已经

3.查询方式总结

1.通过OID检索（查询）
get（）立即、如果没有数据返回null
load（）延迟，如果没有数据抛异常。
2.导航对象图检索方式：关联查询
customer.getOrderSet()
user.getPost().getDepartment().getDepName();
3.原始sql语句
SQLQuery sqlQuery = session.createSQLQuery(“sql 语句”) —>表，表字段（列）
sqlQuery.list() 查询所有
sqlQuery.uniqueResult() 查询一个
4.HQL，hibernate query language hibernate 查询语言【1】
Query query = session.createQuery(“hql语句”) –> 对象，对象属性
5.QBC，query by criteria 纯面对对象查询语言【2】

over~~~

凹凸凹

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Hibernate的关联关系(多对多)映射、抓取策略

1.1多对多的配置:步骤一创建实体和映射: Student:public class Student { private Integer sid; private String sname; // 学生选择多门课程. private Set&amp;lt;Course&amp;gt; courses = new HashSet&amp;lt;Course&amp;gt;();...
复制链接

扫一扫