* 检索策略
* 区分类级别和关联级别检索
1）类级别检索：直接加载目标对象本身----Customer c = session.get(Customer.class,1);
2）关联级别检索：通过检索到的对象导航到关联的对象---Customer c = session.get(Customer.class,1);c.getOrders();

* 关联级别检索中，由一方（客户）关联查询多方（订单）
    在Customer.hbm.xml中<set>,两个属性 fetch lazy
    a. fetch="join" lazy将被忽略 ---查询客户时，会立即查询订单，sql形式为左外连接查询
    b. fetch="select"
        lazy="false"---查询客户时，会立即查询订单，sql形式为多条sql查询-----select * from customer where id = 1;select * from orders where cid = 1;
        lazy="true"----查询客户时，不会立即查询订单，当访问订单集合size时，发出sql查询订单详情----select * from orders where cid = 1;
        lazy="extra"---查询客户时，不会立即查询订单，
            当访问订单集合size时，发出sql统计订单数量---select count(id) from orders where cid = 1;
            当访问订单属性时，发出sql查询订单真实信息---select * from orders where cid = 1;
    c. fetch="subselct"
        lazy="false"---查询客户时，会立即查询订单，sql形式为子查询---select * from orders where cid in(select id from customer)
        lazy="true"----查询客户时，不会立即查询订单，当访问订单集合size时，发出sql查询订单详情---select * from orders where cid in(select id from customer)
        lazy="extra"---查询客户时，不会立即查询订单，
            当访问订单集合size时，发出sql统计订单数量---select count(id) from orders where cid = 1;
            当访问订单属性时，发出sql查询订单真实信息，sql形式为子查询---select * from orders where cid in(select id from customer)
* 当使用Query.list(hql)方法查询时，会忽略fetch="join",是延迟还是立即检索订单，由lazy决定

* 关联级别检索中，由多方（订单）关联查询一方（客户）
    在Order.hbm.xml中<many-to-one>,两个属性 fetch lazy
    a. fetch="join" lazy被忽略---查询订单时，会立即查询订单关联的客户，sql形式为左外连接查询---select o.*,c.* from orders o left outer join customer c on c.id = o.cid and o.id = ?
    b. fetch="select"
        lazy="false":查询订单时，会立即查询订单关联的客户，sql行为为多条sql--select * from orders where id = ?;select * from customer where id = ?
        lazy="proxy":
            如果Customer.hbm.xml中配置<class name="cn.itcast.domain.Customer" lazy="false">---立即查询客户
            如果Customer.hbm.xml中配置<class name="cn.itcast.domain.Customer" lazy="true">---不会立即查询客户
* 当使用Query.list(hql)方法查询时，会忽略fetch="join",是延迟还是立即检索客户，由Customer.hbm.xml类级别检索策略决定
            如果Customer.hbm.xml中配置<class name="cn.itcast.domain.Customer" lazy="false">---立即查询客户
            如果Customer.hbm.xml中配置<class name="cn.itcast.domain.Customer" lazy="true">---不会立即查询客户
* 批量检索----减少sql数量，提供查询效率
    查询所有客户时，在Customer.hbm.xml中<set batch-size="5">---表示一次最多可以查询5个客户的订单
    查询所有订单时，在Customer.hbm.xml中<class name="cn.itcast.domain.Customer" batch-size="5">---一次最多查询5个客户

---------------------------------------------------
ACID，指数据库事务正确执行的四个基本要素的缩写。
包含：原子性(Atomicity）、一致性（Consistency）、隔离性 （Isolation）、持久性（Durability）

* 事务并发引发的问题：
1）脏读:一个事务读取到了另一个事务没有提交的数据
2）幻读:一个事务读取到了另一个事务提交的数据（insert）
3）不可重复读:一个事务读取到了另一个事务提交的数据(update)
4）丢失更新:后一个事务覆盖了前一个事务提交的数据

* 解决丢失更新问题
1）悲观锁:使用数据库底层锁机制，锁定操作的数据，防止并发发生
2）乐观锁：在持久化类中添加版本字段，当事务提交时，比较提交的版本是否和数据库中的版本字段一致，如果不一致，抛出异常阻止修改
    public class User {
    private Integer id;
    private String name;
    private Integer age;
    //版本字段
    private Integer ver;

User.hbm.xml中
    <class name="cn.itcast.domain.User" table="user">
        <id name="id">
            <generator class="native"></generator>
        </id>
        <!-- 加入版本字段 -->
        <version name="ver" type="integer"></version>
        <property name="name" length="20"></property>
        <property name="age"></property>
    </class>

* hibernate缓存分为一级缓存和二级缓存
一级缓存为hibernate内置缓存，不用配置
二级缓存为外置缓存，hibernate框架没有提供二级缓存的实现，要使用二级缓存，需要借助第三方产品

* 配置二级缓存
1）将EHCache相关jar导入项目
2）将EHCache核心配置文件放在src下ehcache.xml
3）在hibernate.cfg.xml中开启二级缓存
    !-- 开启二级缓存 -->
    <property name="hibernate.cache.use_second_level_cache">true</property>
4）指定二级缓存提供商：
    <!-- 指定二级缓存提供商 -->
    <property name="hibernate.cache.provider_class">net.sf.ehcache.hibernate.EhCacheProvider</property>
5）在hibernate.cfg.xml中配置哪些类和集合使用二级缓存
    <!-- 配置哪些类和集合放入二级缓存  -->
    <class-cache usage="read-write" class="cn.itcast.domain.Customer"/>
    <class-cache usage="read-write" class="cn.itcast.domain.Order"/>
   
    <collection-cache usage="read-write" collection="cn.itcast.domain.Customer.orders"/>

* 配置查询缓存
    hibernate.cfg.xml中配置
    <!-- 配置使用查询缓存 -->
    <property name="hibernate.cache.use_query_cache">true</property>

Session session1 = HibernateUtils.getSession();
        Transaction tx1 = session1.beginTransaction();
       
        Query query = session1.createQuery("from Customer");
        query.setCacheable(true);//使用查询缓存，将查询出的数据放入查询缓存中
        query.list();//将查询出的数据放入一级缓存和二级缓存
       
        Query query2 = session1.createQuery("from Customer");
        query2.setCacheable(true);//使用查询缓存
        query2.list();//不会发出sql，直接从查询缓存中获取
       
        tx1.commit();
        session1.close();