1 懒加载（感觉用处不是很大）

需要的时候加载，不需要的时候就不加载。

1.1 环境的搭建

hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <!--
        一个sessionFactory就代表一个数据库的描述
    -->
<session-factory>
    <!-- 链接数据库的用户名 -->
    <property name="connection.username">root</property>
    <!-- 链接数据库的密码 -->
    <property name="connection.password">root</property>
    <!-- 链接数据库的驱动 -->
    <property name="connection.driver_class">
        com.mysql.jdbc.Driver
    </property>
    <!-- 链接数据库的url -->
    <property name="connection.url">
        jdbc:mysql://localhost:3306/hibernate
    </property>
    <!--
        方言
        告诉hibernate用什么样的数据库，将来会生成什么样的sql语句
    -->
    <property name="dialect">
        org.hibernate.dialect.MySQLDialect
    </property>
    <!--
        hibernate对表的策略
        validate  在hibernate容器启动的时候，根据映射文件和持久化类校验表
        create    每次当hibernate启动的时候，都会根据持久化类和映射文件创建表
        create-drop  每次当hibernate启动的时候，都会根据持久化类和映射文件创建表,销毁的时候删除表
        update  检查，如果和映射文件不一致，则更新表的结构，如果没有表，则会创建表
    -->
    <property name="hbm2ddl.auto">update</property>

    <!--
            显示sql语句
        -->
    <property name="show_sql">true</property>
    <property name="format_sql">true</property>
    <property name="current_session_context_class">thread</property>

    <mapping resource="com/xuweiwei/vo/Classes.hbm.xml"/>
    <mapping resource="com/xuweiwei/vo/Student.hbm.xml"/>

</session-factory>
</hibernate-configuration>

Classes.java

package com.xuweiwei.vo;

import java.io.Serializable;
import java.util.Set;

/**
 * 班级
 */
public class Classes implements Serializable{
    private Long cid;
    private String name;
    private String description;

    private Set<Student> students ;

    public Long getCid() {
        return cid;
    }

    public void setCid(Long cid) {
        this.cid = cid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Set<Student> getStudents() {
        return students;
    }

    public void setStudents(Set<Student> students) {
        this.students = students;
    }

    @Override
    public String toString() {
        return "Classes{" +
                "cid=" + cid +
                ", name='" + name + '\'' +
                ", description='" + description + '\'' +
                ", students=" + students +
                '}';
    }
}

Classes.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!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.xuweiwei.vo.Classes" >

        <id name="cid">
            <generator class="increment"/>
        </id>
        <property name="name"/>
        <property name="description"/>

        <set name="students" cascade="save-update" inverse="false">
            <key>
                <column name="cid"/>
            </key>
            <one-to-many class="com.xuweiwei.vo.Student"></one-to-many>
        </set>
    </class>
</hibernate-mapping>

Student.java

package com.xuweiwei.vo;

import java.io.Serializable;

/**
 * 学生
 */
public class Student implements Serializable{
    private Long sid;
    private String name;
    private String description;

    private Classes classes;

    public Long getSid() {
        return sid;
    }

    public void setSid(Long sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Classes getClasses() {
        return classes;
    }

    public void setClasses(Classes classes) {
        this.classes = classes;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", name='" + name + '\'' +
                ", description='" + description + '\'' +
                '}';
    }
}

Student..hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!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.xuweiwei.vo.Student">
        <id name="sid">
            <generator class="increment"/>
        </id>
        <property name="name"/>
        <property name="description"/>
        <many-to-one name="classes" column="cid" class="com.xuweiwei.vo.Classes"/>

    </class>
</hibernate-mapping>

1.2 类的延迟加载

示例：使用load方法

    @Test
    public void testLoad(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        Classes classes1 =  (Classes) session.load(Classes.class,1L);
        System.out.println(classes1);
        session.close();
    }

示例：在映射文件上的class元素上配置lazy属性

<?xml version="1.0" encoding="UTF-8"?>
<!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.xuweiwei.vo.Classes" lazy="false" >

        <id name="cid">
            <generator class="increment"/>
        </id>
        <property name="name"/>
        <property name="description"/>

        <set name="students" cascade="save-update" inverse="false">
            <key>
                <column name="cid"/>
            </key>
            <one-to-many class="com.xuweiwei.vo.Student"></one-to-many>
        </set>
    </class>
</hibernate-mapping>

1.3 集合的延迟加载

1.3.1 lazy="true"

默认情况下，集合就是延迟加载。
只有当遍历集合中的元素的时候，才发出查询SQL

 @Test
    public void testCollectionLazy(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        Classes classes =  (Classes) session.get(Classes.class,1L);
        Set<Student> students =  classes.getStudents();
        for(Student s : students){
            System.out.println(s);
        }

        session.close();
    }

1.3.2 lazy="false"

<?xml version="1.0" encoding="UTF-8"?>
<!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.xuweiwei.vo.Classes" >

        <id name="cid">
            <generator class="increment"/>
        </id>
        <property name="name"/>
        <property name="description"/>

        <set name="students" cascade="save-update" inverse="false" lazy="false" >
            <key>
                <column name="cid"/>
            </key>
            <one-to-many class="com.xuweiwei.vo.Student"></one-to-many>
        </set>
    </class>
</hibernate-mapping>

    @Test
    public void testCollectionLazy(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        Classes classes =  (Classes) session.get(Classes.class,1L);
        Set<Student> students =  classes.getStudents();
        for(Student s : students){
            System.out.println(s);
        }

        session.close();
    }

当查询班级的同时查询班级下的所有学生信息。

1.3.3 lazy="extra" 更进一步

<?xml version="1.0" encoding="UTF-8"?>
<!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.xuweiwei.vo.Classes" >

        <id name="cid">
            <generator class="increment"/>
        </id>
        <property name="name"/>
        <property name="description"/>

        <set name="students" cascade="save-update" inverse="false" lazy="extra" >
            <key>
                <column name="cid"/>
            </key>
            <one-to-many class="com.xuweiwei.vo.Student"></one-to-many>
        </set>
    </class>
</hibernate-mapping>

    @Test
    public void testCollectionLazy(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        Classes classes =  (Classes) session.get(Classes.class,1L);
        System.out.println(classes.getStudents().size());

        session.close();
    }

查询的SQL如下：

1.4 延迟加载的总结

延迟加载（懒加载）就是通过控制发出SQL的时间来提升效率的。

2 抓取策略fetch

fetch="select"，默认

<?xml version="1.0" encoding="UTF-8"?>
<!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.xuweiwei.vo.Classes" >

        <id name="cid">
            <generator class="increment"/>
        </id>
        <property name="name"/>
        <property name="description"/>

        <set name="students" cascade="save-update" inverse="false" fetch="select" >
            <key>
                <column name="cid"/>
            </key>
            <one-to-many class="com.xuweiwei.vo.Student"></one-to-many>
        </set>
    </class>
</hibernate-mapping>

示例：查询所有的班级以及班级下面的所有学生（会引起N+1问题）

  @Test
    public void testCollection(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        Classes classes1 =  (Classes) session.load(Classes.class,1L);
        session.close();
        System.out.println(classes1.getName());

    }

- 所谓的N+1问题：
  - 1：就是Hibernate在查询所有的班级的信息，直接通过select * from classes
  - N：就是Hibernate通过外键，到student表中查询，比如classes表中有4条数据，那么Hibernate会这样发出SQL语句：select * from student where cid = 1;select * from student where cid =2;……

其实：在查询所有班级的信息的同时查询班级下面的所有学生的信息，一般我们写SQL会这样写

SELECT  s.*
FROM student s WHERE s.`cid` 、IN (SELECT cid FROM classes);

这是个子查询。所以fetch应该是"subselect"

<?xml version="1.0" encoding="UTF-8"?>
<!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.xuweiwei.vo.Classes" >

        <id name="cid">
            <generator class="increment"/>
        </id>
        <property name="name"/>
        <property name="description"/>

        <set name="students" cascade="save-update" inverse="false" fetch="subselect" >
            <key>
                <column name="cid"/>
            </key>
            <one-to-many class="com.xuweiwei.vo.Student"></one-to-many>
        </set>
    </class>
</hibernate-mapping>

 /**
     * 查询所有的班级以及班级下面的所有学生
     */
    @Test
    public void testClassesAndStudent(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        //查询所有的班级以及所有的学生
        List<Classes> classesList = session.createQuery("from Classes").list();
        System.out.println(classesList);

        for(Classes classes : classesList){
            Set<Student> students = classes.getStudents();
            for(Student student : students){
                System.out.println(student);
            }
        }

        session.close();

    }

所以，如果是子查询，fetch="subselect"效率高点。

示例：如果我们需要查询班级为1号的信息和1号班级下的所有学生的信息，那么我们一般是这些写SQL的

SELECT c.*,s.*
FROM classes c
LEFT OUTER JOIN student s
ON c.cid = s.cid

所以，这个时候，fetch要设置为join

<?xml version="1.0" encoding="UTF-8"?>
        <!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.xuweiwei.vo.Classes" >

    <id name="cid">
        <generator class="increment"/>
    </id>
    <property name="name"/>
    <property name="description"/>

    <set name="students" cascade="save-update" inverse="false" fetch="join" >
        <key>
            <column name="cid"/>
        </key>
        <one-to-many class="com.xuweiwei.vo.Student"></one-to-many>
    </set>
</class>
</hibernate-mapping>

   @Test
    public void testOneClassesAndStudents(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        Classes Classes = (Classes) session.get(Classes.class,1L);
        Set<Student> students = Classes.getStudents();
        for(Student student : students){
            System.out.println(student);
        }

        session.close();

    }

3 lazy和fetch

当fetch为join，我们知道Hibernate是直接发出SQL查询的，所以lazy不会起作用的。
当fetch为select，先加载classes后加载student，而lazy决定什么时候加载student。

4 HQL（Hibernate Query Language）

4.1 单表的HQL

示例：查询所有班级的信息

    /**
     * 查询所有的班级
     */
    @Test
    public void testQueryClasses(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        List<Classes> classesList = session.createQuery("from Classes").list() ;

        session.close();

    }

示例：查询班级的名称和描述信息

 /**
     * 查询所有班级的名称和描述信息
     */
    @Test
    public void testQueryClassesNameAndDescription(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        List<Object[]> list = session.createQuery("select name,description from Classes").list() ;

        session.close();

    }

示例：根据cid查询班级信息

  /**
     * 根据cid查询班级信息
     */
    @Test
    public void testQueryClassesByCid(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        List<Classes> classesList = session.createQuery("from Classes where cid = ?").setParameter(0,1L).list();
        for(Classes c:classesList){
            System.out.println(c);
        }

        session.close();
    }

示例：根据cid查询班级的信息

 /**
     * 根据cid查询班级信息
     */
    @Test
    public void testQueryClassesByCid(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        List<Classes> classesList = session.createQuery("from Classes where cid =:cid ").setParameter("cid",1L).list();

        for(Classes c:classesList){
            System.out.println(c);
        }

        session.close();
    }

示例：查询班级的个数

  /**
     * 查询班级的个数
     */
    @Test
    public void testCount(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        Object object = session.createQuery("select count(*) from Classes").uniqueResult();
        System.out.println(object);

        session.close();
    }

示例：查询主键的最大值

/**
     * 查询cid的最大值
     */
    @Test
    public void testSelectMaxCid(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        Long max = (Long) session.createQuery("select max(cid) from Classes").uniqueResult();
        System.out.println(max);

        session.close();

    }

4.2 多表的HQL

内连接

 /**
     * 内连接
     */
    @Test
    public void testEq(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        List<Object[]> list = session.createQuery("from Classes c ,Student s where c.cid = s.classes.cid").list();

        session.close();

    }

示例：内连接

    @Test
    public void testInnerJoin(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        List<Object[]> list = session.createQuery("from Classes c inner join c.students s").list();

        session.close();
    }

示例：左外连接

@Test
    public void testLeftOuterJoin(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        List<Object[]> list = session.createQuery("from Classes c left outer join c.students s").list();

        session.close();

    }

示例：迫切左外连接

    @Test
    public void testLleftOuterJoinFetch(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        List<Classes> list = session.createQuery("from Classes c left outer join fetch c.students s").list();

        session.close();
    }

示例：迫切内连接

    @Test
    public void testInnerJoinFetch(){
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        Session session = sessionFactory.openSession();

        List<Classes> list = session.createQuery("from Classes c inner join fetch c.students s").list();

        session.close();
    }

Hibernate （四）的更多相关文章

hibernate(四) 双向多对多映射关系
序言莫名长了几颗痘,真TM疼,可能是现在运动太少了,天天对着电脑,决定了,今天下午花两小时去跑步了, 现在继上一章节的一对多的映射关系讲解后,今天来讲讲多对多的映射关系把,明白了一对多,多对多个人感 ...
Hibernate(四)之对象状态及一级缓存
一.Hibernate中的对象状态 1.1.瞬时态(临时态) 没有与Hibernate产生关联与数据库中的记录没有产生关联(有关联就是与数据库中表的id相对应) 获得:一般都只直接创建(new) 瞬 ...
Hibernate(四)结构-基础语义和事务
一.基础语义核心: Configuration SessionFactory Session 二.Configuration Configuration类负责管理Hibernate的配置信息,Hib ...
hibernate(四)__由表逆向创建Domain对象和对象关系映射文件
之前我们是手写Domain对象和对象关系映射文件->然后生成数据库中的Table. 现在我们反过来先在数据库中建好Table->然后用工具生成Domain对象和对象关系映射文件. 步骤: ...
Hibernate四批量处理
Hibernate批量处理一批量插入将很多条记录插入数据库时,Hibernate通常会采用以下做法:public void test() { for(int i=0;i<1000;i++){ ...
Hibernate(四)——缓存策略+lazy
Hibernate作为和数据库数据打交道的框架,自然会设计到操作数据的效率问题,而对于一些频繁操作的数据,缓存策略就是提高其性能一种重要手段,而Hibernate框架是支持缓存的,而且支持一级和二级两 ...
ORM框架Hibernate (四) 一对一单向、双向关联映射
简介在上一篇博客说了一下多对一映射,这里再说一下一对一关联映射,这种例子在生活中很常见,比如一个人的信息和他的身份证是一对一.又如一夫一妻制等等. 记得在Java编程思想上第一句话是“一切皆对象”, ...
ssh架构之hibernate(四)二级缓存
二级缓存使用步骤: 1.拷贝jar包 2.配置Hibernate.cfg.xml文件 a.#开启二级缓存 hibernate.cache.use_second_level_cache=true b.# ...
Hibernate(四)
==================================投影(查询)=============================投影查询:查询一个持久化类的一个或多个属性值 1.将每条 ...
Hibernate(四)--延迟加载(lazyload)
hibernate中的延迟加载(lazyload)分属性的延迟加载和关系的延迟加载属性的延迟加载: 当使用load的方式来获取对象的时候,只有访问了这个对象的属性,hibernate才会到数据库中进 ...

随机推荐

[转载]binlog归档
1.1. 前言对数据库数据进行备份都是日常的工作(虽然都是自动做的),备份中有一项必备的那就是binglog了.在工作中一般这些备份都会保留一段时间后归档.时间长了归档的数据将会非常大.这时候我们就 ...
如何使用webapi集成swagger
现在B/S开发中,前后端分离无疑已经成为一种新的时尚,但是如何把后端开发的接口更好的提供给前段开发呢?还用接口文档?low了吧.不仅要花时间开发接口,还得花时间写文档,白花花的时间不久浪费了吗.如果接 ...
从 0 到 1，Java Web 网站架构搭建的技术演进
初始搭建最开始,就是各种框架一搭,然后扔到 Tomcat 容器中跑,这时候我们的文件.数据库.应用都在一个服务器上. 服务分离随着系统的上线,用户量也会逐步上升,很快一台服务器已经满足不了系统的负 ...
【eclipse】Target runtime Apache Tomcat v7.0 is not defined解决
在eclipse中导入项目时提示Target runtime Apache Tomcat v7.0 is not defined, 解决方法:右键项目--properties--targeted ru ...
viewport预备知识
dpr === dppx dpr:device pixel ratio 设备像素比 dppx:Number of dots per px unit 每像素有多少点 . 1dppx = 96dpi dp ...
使用神经网络来拟合函数y = x^3 +b
我们使用一个三层的小网络来,模拟函数y = x^3+b函数 import tensorflow as tf import numpy as np import matplotlib.pyplot as ...
bzoj usaco 金组水题题解（2.5）
bzoj 2197: [Usaco2011 Mar]Tree Decoration 树形dp..f[i]表示处理完以i为根的子树的最小时间. 因为一个点上可以挂无数个,所以在点i上挂东西的单位花费就是 ...
BZOJ2726: [SDOI2012]任务安排
题目:http://www.lydsy.com/JudgeOnline/problem.php?id=2726 倒着做,前面的点对后面的点都是有贡献的. f[i]=min(f[j]+cost[i]*( ...
[国嵌攻略][142][LCD驱动程序架构]
LCD裸机驱动回顾 1.LCD初始化 1.1.控制器初始化 1.2.端口初始化 1.3.指明了帧缓冲 2.LCD图形显示 2.1.将图形数据写入帧缓冲 Linux帧缓冲体验把图片转换成开发板屏对应的 ...
JQuery的deferred对象学习总结
什么是deferred? 可以帮助我们按规定的顺序执行函数,比如说我们ajax请求数据之后,对dom进行数据填充,那我们就要先执行完ajax,拿到数据之后才能进行dom数据填充,所以这就是一个顺序执行 ...

Hibernate （四）

1 懒加载 （感觉用处不是很大）

1.1 环境的搭建

1.2 类的延迟加载

1.3 集合的延迟加载

1.3.1 lazy="true"

1.3.2 lazy="false"

1.3.3 lazy="extra" 更进一步

1.4 延迟加载的总结

2 抓取策略fetch

3 lazy和fetch

4 HQL（Hibernate Query Language）

4.1 单表的HQL

4.2 多表的HQL

Hibernate （四）的更多相关文章

随机推荐

热门专题

1 懒加载（感觉用处不是很大）