Hibernte

　　什么是CRM?(了解)

CRM(customer relationship management)即客户关系管理，是指企业用CRM技术来管理与客户之间的关系。在不同场合下，CRM可能是一个管理学术语，可能是一个软件系统。通常所指的CRM，指用计算机自动化分析销售、市场营销、客户服务以及应用等流程的软件系统。它的目标是通过提高客户的价值、满意度、赢利性和忠实度来缩减销售周期和销售成本、增加收入、寻找扩展业务所需的新的市场和渠道。CRM是选择和管理有价值客户及其关系的一种商业策略，CRM要求以客户为中心的企业文化来支持有效的市场营销、销售与服务流程。

　　CRM的功能模块

　　什么是框架

框架：指的是软件的半成品，已经完成了部分功能。

　　EE的经典三层结构

　　什么是Hibernate(理解)

Hibernate - 开放源代码的对象关系映射框架

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JaveEE架构中取代CMP，完成数据持久化的重任。

　　Hibernate：Hibernate是一个持久层的ORM框架。

　　什么是ORM

　　ORM：Object Relational Mapping（对象关系映射）。指的是将一个Java中的对象与关系型数据库中的表建立一种映射关系，从而操作对象就可以操作数据库中的表。

　　为什么学习hibernate

　　下载Hibernate的开发环境

Hibernate3.x  Hibernate4.x  Hibernate5.x

https://sourceforge.net/projects/hibernate/files/hibernate-orm/5.0.7.Final/

　　解压Hibernate

documentation :Hibernate开发的文档

lib :Hibernate开发包

required :Hibernate开发的必须的依赖包

optional :Hibernate开发的可选的jar包

project :Hibernate提供的项目

　　 创建一个项目，引入jar包

1.数据库驱动包

2. Hibernate开发的必须的jar包

3. Hibernate引入日志记录包

　　创建表 cst_cusstomer.sql

 CREATE TABLE `cst_customer` (
   `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
   `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
   `cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
   `cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
   `cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
   `cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
   `cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
   PRIMARY KEY (`cust_id`)
 ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

创建实体类 Customer.java

 public class Customer {
     private Long cust_id;
     private String cust_name;
     private String cust_source;
     private String cust_industry;
     private String cust_level;
     private String cust_phone;
     private String cust_mobile;
     public Long getCust_id() {
         return cust_id;
     }
     public void setCust_id(Long cust_id) {
         this.cust_id = cust_id;
     }
     public String getCust_name() {
         return cust_name;
     }
     public void setCust_name(String cust_name) {
         this.cust_name = cust_name;
     }
     public String getCust_source() {
         return cust_source;
     }
     public void setCust_source(String cust_source) {
         this.cust_source = cust_source;
     }
     public String getCust_industry() {
         return cust_industry;
     }
     public void setCust_industry(String cust_industry) {
         this.cust_industry = cust_industry;
     }
     public String getCust_level() {
         return cust_level;
     }
     public void setCust_level(String cust_level) {
         this.cust_level = cust_level;
     }
     public String getCust_phone() {
         return cust_phone;
     }
     public void setCust_phone(String cust_phone) {
         this.cust_phone = cust_phone;
     }
     public String getCust_mobile() {
         return cust_mobile;
     }
     public void setCust_mobile(String cust_mobile) {
         this.cust_mobile = cust_mobile;
     }
     @Override
     public String toString() {
         return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + ", cust_source=" + cust_source
                 + ", cust_industry=" + cust_industry + ", cust_level=" + cust_level + ", cust_phone=" + cust_phone
                 + ", cust_mobile=" + cust_mobile + "]";
     }

 }

　　创建映射(理解)

映射需要通过XML的配置文件来完成，这个配置文件可以任意命名。尽量统一命名规范（类名.hbm.xml）

　　Hibernate的映射配置

1.映射的配置

[class 标签的配置]

　　标签用来建立类与表的映射关系

　　属性:   　

　　name     : 类的全路径

　　table      :  表名(类名与表名一致,table可以省略)　　

　　catalog  : 数据库名　　　

[id标签的配置]

　　标签用来建立类中的属性与表中的主键的对应关系

属性:

name:l类中的属性名

column:表中的字段名(类中的属性名和表中的字段名如果一致,column可以省略)

length:长度

type:类型

[property 标签的配置]

标签用来建立类中的普通属性与表中的字段的对应关系

属性:

name:类中的属性名

column:表中的字段名

length:长度

type:类型

not-null:设置非空

unique:设置唯一

Hibernate的核心配置方式（了解）

一种方式:属性文件的方式

hibernate.properties

hibernate.connection.driver_class=com.mysql.jdbc.Driver

…

hibernate.show_sql=true

属性文件的方式不能引入映射文件（手动编写代码加载映射文件）

二种方式:XML文件的方式n hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
<!--建立类与表的映射 -->
<class name="com.zmy.hibernate.demo1.Customer" table="cst_customer">
<!--建立类中的属性与表中的主键对应 -->
<id name="cust_id" column="cust_id">
<!-- 主键生成策略 -->
<generator class="native"/>
</id>
<!--建立类中的普通属性和表的字段相对应 -->
<property name="cust_name" column="cust_name"/>
<property name="cust_source" column="cust_source"/>
<property name="cust_industry" column="cust_industry"/>
<property name="cust_level" column="cust_level"/>
<property name="cust_phone" column="cust_phone"/>
<property name="cust_mobile" column="cust_mobile"/>
</class>
</hibernate-mappin

　编写测试代码

 package com.zmy.hibernate.demo1;

 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
 import org.junit.Test;

 /**
  * Hibernate的入门案例
  * @author Administrator
  *
  */
 public class HibernateDemo01 {

     @Test
     //保存客户的案例
     public void demo01() {
         //1.加载Hibernate的核心配置文件
         Configuration configuration = new Configuration().configure();
         //2.创建一个SessionFactory对象:类似于JDBC的连接池
         SessionFactory sessionFactory = configuration.buildSessionFactory();
         //3.通过SessionFactory对象获取Session对象:类似于JDBC中的Connection
         Session session = sessionFactory.openSession();
         //4.手动开启事务
         Transaction transaction = session.beginTransaction();
         //5.编写代码
         Customer customer = new Customer();
         customer.setCust_name("花木兰");
         session.save(customer);

         //6.提交事务
         transaction.commit();
         //7.资源释放
         session.close();
     }

 }　　

　　XML提示的配置

1. 配置XML提示问题

核心的配置

必须的配置

连接数据库的基本的参数

1.驱动类

2.URL路径

3.用户名

4.密码

方言

可选的配置

显示SQL :hibernate.show_sql

格式化SQ:hibernate.format_sql

自动建表:hibernate.hbm2ddl.auto

　　none : 不使用hibernate的自动建表

　　create:如果数据库已经有表,删除原有表,重新创建,如果没有表,重新创建.(测试)

　　create-drop:如果数据库中已经有表,删除表,执行操作,删除这个表.如果没有表,新建一个,使用完了删除该表.(测试)

　　update:如果数据库中有表,使用原有表,如果没有表,创建新表.(更新表结构)

　　validate:如果没有表,不会创建表.只会使用数据库中原有表.(校验映射和表结构)

映射文件引入

引入映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- 连接数据库的基本参数 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql:///hibernate_day01</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">168520</property>
        <!-- 配置Hibernate的方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- 可选配置======================= -->
        <!-- 打印SQL -->
        <property name="hibernate.show_sql">true</property>
        <!-- 格式化SQL -->
        <property name="hibernate.format_sql">true</property>

        <!-- 配置C3P0连接池 -->
        <property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
        <!--在连接池中可用的数据库连接的最少数目 -->
        <property name="c3p0.min_size">5</property>
        <!--在连接池中所有数据库连接的最大数目  -->
        <property name="c3p0.max_size">20</property>
        <!--设定数据库连接的过期时间,以秒为单位,
        如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->
        <property name="c3p0.timeout">120</property>
         <!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->
        <property name="c3p0.idle_test_period">3000</property>

        <!-- 引入映射 -->
        <mapping resource="com/zmy/hibernate/demo1/Customer.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

Hibernate的常用API

1.Configuration : Hibernate 的配置对象

作用:

加载核心配置文件

　　1.hibernate.properties

Configuration cfg = new Configuration();

　　2.hibernate.cfg.xml

Configuration cfg = new Configuration().configure();

加载映射文件

　　手动加载映射

configuration.addResource("com/itheima/hibernate/demo1/Customer.hbm.xml");

2.SessionFactory :session工厂

SessionFactory内部维护了Hibernate的连接池和Hibernate的二级缓存（不讲）。是线程安全的对象。一个项目创建一个对象即可。

配置连接池：（了解）

<!-- 配置C3P0连接池 -->

<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>

<!--在连接池中可用的数据库连接的最少数目 -->

<property name="c3p0.min_size">5</property>

<!--在连接池中所有数据库连接的最大数目  -->

<property name="c3p0.max_size">20</property>

<!--设定数据库连接的过期时间,以秒为单位,

如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->

<property name="c3p0.timeout">120</property>

 <!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->

<property name="c3p0.idle_test_period">3000</property>

　　 抽取工具类

 Session：类似Connection对象是连接对象

Session代表的是Hibernate与数据库的连接对象.不是线程安全的,是与数据库交互.

Session中的API

　　保存方法:

　　　　Serializable save(Object   obj);

　　查询方法:

　　　　T get(Class  c , Serializable  id);

　　　　T  load(Class c , Serializable   id);

　　

　　get方法和load方法的区别?

修改方法

void update(Object obj);

删除方法

void delete(Object obj);

保存或更新

void saveOrUpdate(Object obj)

查询所有

Transaction：事务对象

Hibernate中管理事务的对象。

commit();  提交

rollback();  回滚

　　Hibernate 的持久化类的编写规则

1.无参构造

2.属性私有

3.属性尽量使用包装类

4.提供一个唯一OID与主键对应

5.不要使用final修饰

Hibernate的主键生成策略

主键分类

　　自然主键

　　代理主键

　　主键生成策略

　　　　increment

　　　　identity

　　　　sequence

　　　　uuid

　　　　native

　　　　assigned

　　　　foreign

Hibernate的持久化类的三种状态

　　瞬时态  :  没有唯一标识的OID,没有被Session管理.

　　持久态 :  有唯一标识OID,已经被session管理.

　　脱管态 :  有唯一标识OID,没有被session管理.

　　状态转换了解()

Hibernate的一级缓存

一级缓存:hibernate的优化手段,称为session缓存.

一级缓存:快照区

Hibernate的事务管理

事务的回顾

事务的概念

事务的特性

引发安全性问题

安全性问题解决

Hibernate解决读问题

配置设置隔离级别

隔离级别是指若干个并发的事务之间的隔离程度，与我们开发时候主要相关的场景包括：脏读取、重复读、幻读。

我们可以看 org.springframework.transaction.annotation.Isolation 枚举类中定义了五个表示隔离级别的值：

public enum Isolation {
    DEFAULT(-1),
    READ_UNCOMMITTED(1),
    READ_COMMITTED(2),
    REPEATABLE_READ(4),
    SERIALIZABLE(8);
}

DEFAULT ：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是： READ_COMMITTED 。 
READ_UNCOMMITTED ：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读和不可重复读，因此很少使用该隔离级别。 
READ_COMMITTED ：该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。 
REPEATABLE_READ ：该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。即使在多次查询之间有新增的数据满足该查询，这些新增的记录也会被忽略。该级别可以防止脏读和不可重复读。 
SERIALIZABLE ：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。 
指定方法：通过使用 isolation 属性设置，例如：@Transactional(isolation = Isolation.DEFAULT)/

2、Propagation：传播行为

所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。

我们可以看 org.springframework.transaction.annotation.Propagation 枚举类中定义了6个表示传播行为的枚举值：

public enum Propagation {
    REQUIRED(0),
    SUPPORTS(1),
    MANDATORY(2),
    REQUIRES_NEW(3),
    NOT_SUPPORTED(4),
    NEVER(5),
    NESTED(6);
}

REQUIRED ：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。 
SUPPORTS ：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。 
MANDATORY ：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。 
REQUIRES_NEW ：创建一个新的事务，如果当前存在事务，则把当前事务挂起。 
NOT_SUPPORTED ：以非事务方式运行，如果当前存在事务，则把当前事务挂起。 
NEVER ：以非事务方式运行，如果当前存在事务，则抛出异常。 
NESTED ：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于 REQUIRED 。 
指定方法：通过使用 propagation 属性设置，例如：@Transactional(propagation = Propagation.REQUIRED)

hibernate解决Service事务

　　采用的是线程绑定方式

hibernate的其他API

Query　　:　　HQL面向对象方式的查询.

Criteria　　:　　QBC完成面向对象华.

SQLQuery　　 　:　　SQL查询.

1.1.1.1 一对多关系

什么样关系属于一对多？

一个部门对应多个员工，一个员工只能属于某一个部门。

一个客户对应多个联系人，一个联系人只能属于某一个客户。

一对多的建表原则：

　　多对多关系

什么样关系属于多对多？

一个学生可以选择多门课程，一门课程也可以被多个学生选择。

一个用户可以选择多个角色，一个角色也可以被多个用户选择。

多对多的建表原则：

什么样关系属于一对一？

一个公司只能有一个注册地址，一个注册地址只能被一个公司注册。

一对一的建表原则：

Hibernate一对多的关系配置

创建一个项目,引入相应的jar包

创建数据库和表

 CREATE TABLE `cst_customer` (
   `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
   `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
   `cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
   `cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
   `cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
   `cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
   `cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
   PRIMARY KEY (`cust_id`)
 ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

 CREATE TABLE `cst_linkman` (
   `lkm_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '联系人编号(主键)',
   `lkm_name` varchar(16) DEFAULT NULL COMMENT '联系人姓名',
   `lkm_cust_id` bigint(32) DEFAULT NULL COMMENT '客户id',
   `lkm_gender` char(1) DEFAULT NULL COMMENT '联系人性别',
   `lkm_phone` varchar(16) DEFAULT NULL COMMENT '联系人办公电话',
   `lkm_mobile` varchar(16) DEFAULT NULL COMMENT '联系人手机',
   `lkm_email` varchar(64) DEFAULT NULL COMMENT '联系人邮箱',
   `lkm_qq` varchar(16) DEFAULT NULL COMMENT '联系人qq',
   `lkm_position` varchar(16) DEFAULT NULL COMMENT '联系人职位',
   `lkm_memo` varchar(512) DEFAULT NULL COMMENT '联系人备注',
   PRIMARY KEY (`lkm_id`),
   KEY `FK_cst_linkman_lkm_cust_id` (`lkm_cust_id`),
   CONSTRAINT `FK_cst_linkman_lkm_cust_id` FOREIGN KEY (`lkm_cust_id`) REFERENCES `cst_customer` (`cust_id`) ON DELETE NO ACTION ON UPDATE NO ACTION
 ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

创建实体类

一的一方的实体

多的一方的实体

创建映射文件

　　多的一方的映射的创建

　　一的一方映射创建

创建核心配置文件

 引入工具类

编写测试类

Hibernate的一对多相关操作

一对多关系只保存一边是否可以

1.1.1.1 一对多的级联操作

什么叫做级联

级联指的是，操作一个对象的时候，是否会同时操作其关联的对象。

级联是有方向性

操作一的一方的时候，是否操作到多的一方

操作多的一方的时候，是否操作到一的一方

　　保存客户级联联系人

保存联系人级联客户

　　测试对象的导航

　　 级联删除

级联删除：

删除一边的时候，同时将另一方的数据也一并删除。

删除客户级联删除联系人

删除联系人级联删除客户（基本不用）

一对多设置了双向关联产生多余的SQL语句

解决多余的SQL语句

单向维护：

使一方放弃外键维护权：

一的一方放弃。在set上配置inverse=”true”

一对多的关联查询的修改的时候。（CRM练习--）

区分cascade和inverse

 Hibernate多对多关系的配置

　　创建表

用户表

 CREATE TABLE `sys_user` (
   `user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用户id',
   `user_code` varchar(32) NOT NULL COMMENT '用户账号',
   `user_name` varchar(64) NOT NULL COMMENT '用户名称',
   `user_password` varchar(32) NOT NULL COMMENT '用户密码',
   `user_state` char(1) NOT NULL COMMENT '1:正常,0:暂停',
   PRIMARY KEY (`user_id`)
 ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

角色表

 CREATE TABLE `sys_role` (
   `role_id` bigint(32) NOT NULL AUTO_INCREMENT,
   `role_name` varchar(32) NOT NULL COMMENT '角色名称',
   `role_memo` varchar(128) DEFAULT NULL COMMENT '备注',
   PRIMARY KEY (`role_id`)
 ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

中间表

 CREATE TABLE `sys_user_role` (
   `role_id` bigint(32) NOT NULL COMMENT '角色id',
   `user_id` bigint(32) NOT NULL COMMENT '用户id',
   PRIMARY KEY (`role_id`,`user_id`),
   KEY `FK_user_role_user_id` (`user_id`),
   CONSTRAINT `FK_user_role_role_id` FOREIGN KEY (`role_id`) REFERENCES `sys_role` (`role_id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
   CONSTRAINT `FK_user_role_user_id` FOREIGN KEY (`user_id`) REFERENCES `sys_user` (`user_id`) ON DELETE NO ACTION ON UPDATE NO ACTION
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

创建实体类

　　用户的实体

角色的实体

创建映射

　　用户的映射

角色的映射

编写测试类

Hibernate的多对多操作

　　只保存一边是否可以

 多对多的级联保存或更新

　　

保存用户级联保存角色

保存角色级联保存用户

多对多的级联删除（基本用不上）

删除用户级联删除角色

删除角色级联删除用户

多对多的其他的操作

　　 给用户选择角色

　　给用户改选角色

　　给用户删除角色

在Hibernate中提供了很多种的查询的方式。Hibernate共提供了五种查询方式。

Hibernate的查询方式：OID查询

OID检索：Hibernate根据对象的OID（主键）进行检索

　　使用get方法

Customer customer = session.get(Customer.class,1l);

　　使用load方法

Customer customer = session.load(Customer.class,1l);

　　Hibernate的查询方式：对象导航检索

对象导航检索：Hibernate根据一个已经查询到的对象，获得其关联的对象的一种查询方式。

LinkMan linkMan = session.get(LinkMan.class,1l);

Customer customer  = linkMan.getCustomer();

Customer customer = session.get(Customer.class,2l);

Set<LinkMan> linkMans = customer.getLinkMans();

　　Hibernate的查询方式：HQL检索

HQL查询：Hibernate Query Language，Hibernate的查询语言，是一种面向对象的方式的查询语言，语法类似SQL。通过session.createQuery()，用于接收一个HQL进行查询方式。

　　初始化一些数据

　　HQL的简单查询

HQL的别名查询

HQL的排序查询

HQL条件查询

　　HQL的投影查询

投影查询：查询对象的某个或某些属性。

　　HQL的分页查询

　　HQL的分组统计查询

 HQL的多表查询

SQL的多表查询

连接查询

　　 交叉连接：笛卡尔积

　　　　select * from A,B;

　　内连接 :inner join (inner 可以省略)

　　隐式内连接：

　　　　select * from A,B where A.id = B.aid;

　　 显示内连接：

　　　　select * from A inner join B on A.id = B.aid;

　　外连接 :

　　　　左外连接:left outer join(outer 可以省略)

　　　　select * from A left outer join B on A.id= B.aid;

　　右外连接:right outer join(outer 可以省略)

　　　　select * from A right outer join B on A.id = B.aid;

子查询

HQL的多表查询

连接查询

交叉连接

内连接

显示内连接

隐式内连接

迫切内连接

外连接

左外连接

右外连接

迫切左外连接

　　 Hibernate的查询方式：QBC检索

QBC查询：Query By Criteria，条件查询。是一种更加面向对象化的查询的方式。

　　简单查询

　　 排序查询

　　分页查询

　　条件查询

　　统计查询

　　离线条件查询（SSH）---DetachedCriteria

　　 Hibernate的查询方式：SQL检索

　　 SQL查询

SQL查询：通过使用sql语句进行查询

1.1.1.1 什么是延迟加载

延迟加载：lazy（懒加载）。执行到该行代码的时候，不会发送语句去进行查询，在真正使用这个对象的属性的时候才会发送SQL语句进行查询。

1.1.1.2 延迟加载的分类

类级别的延迟加载

　　指的是通过load方法查询某个对象的时候，是否采用延迟。session.load(Customer.class,1l);

　　类级别延迟加载通过<class>上的lazy进行配置，如果让lazy失效

　　　　将lazy设置为false

　　　　 将持久化类使用final修饰

　　　　Hibernate. Initialize()

关联级别的延迟加载

　　　　指的是在查询到某个对象的时候，查询其关联的对象的时候，是否采用延迟加载。

　　　Customer customer = session.get(Customer.class,1l);

　　　customer.getLinkMans();----通过客户获得联系人的时候，联系人对象是否采用了延迟加载，称为是关联级别的延迟。

　　　　抓取策略往往会和关联级别的延迟加载一起使用，优化语句。

　　抓取策略的概述

通过一个对象抓取到关联对象需要发送SQL语句，SQL语句如何发送，发送成什么样格式通过策略进行配置。

　　通过<set>或者<many-to-one>上通过fetch属性进行设置

　　fetch和这些标签上的lazy如何设置优化发送的SQL语句

　　 <set>上的fetch和lazy

　　　　fetch：抓取策略，控制SQL语句格式

　　　　select ：默认值，发送普通的select语句，查询关联对象

　　　　 join ：发送一条迫切左外连接查询关联对象

　　　　subselect ：发送一条子查询查询其关联对象

　　　　 lazy：延迟加载，控制查询关联对象的时候是否采用延迟

　　　　 true ：默认值，查询关联对象的时候，采用延迟加载

　　　　 false ：查询关联对象的时候，不采用延迟加载

　　　　extra ：及其懒惰。

　　 <many-to-one>上的fetch和lazy

　　　　fetch ：抓取策略，控制SQL语句格式。

　　　　select ：默认值，发送普通的select语句，查询关联对象。

　　　　 join ：发送一条迫切左外连接。

　　　　 lazy ：延迟加载，控制查询关联对象的时候是否采用延迟。

　　　　 proxy ：默认值，proxy具体的取值，取决于另一端的<class>上的lazy的值。

　　　　false ：查询关联对象，不采用延迟。

　　　　 no-proxy ：（不会使用）

在实际开发中，一般都采用默认值。如果有特殊的需求，可能需要配置join。

　　 批量抓取

　　 什么是批量抓取

　　　　一批关联对象一起抓取，batch-size

　　测试批量抓取