Hibernate篇

简介

hibernate是轻量级的JAVAEE应用的持久层解决方案，是一个关系型数据库ORM框架。 ORM：对象关系映射，对象：java中一切皆对象javaBean，关系：数据库中的表（二维表），映射：配置文件。

编写步骤

• 创建java项目
• 导入jar包
• 核心配置文件(hibernate.cfg.xml)
• javaBean +映射文件（ bena名称.hbm.xml),必须将映射文件加入到核心配置文件。

核心配置文件：

驱动、url、username、password、规范

<?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://localhost:3306/day15</property>
        <property name="hibernate.connection.username">zp</property>
        <property name="hibernate.connection.password">a</property>

        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect.class</property>

    </session-factory>

</hibernate-configuration>

映射文件： User.hbm.xml，和javabean同包。

配置javabena属性和表中字段的对应关系.

<?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="cn.tf.domain.User"  table="t_user">
        <!-- 给表配置主键 -->
        <id name="uid">
            <!-- 主键生成策略 -->
            <generator class="native"></generator>
        </id>
        <!-- 其他属性 -->
        <property name="username"></property>
        <property name="password"></property>   
    </class>
</hibernate-mapping>

API详解

SessionFactory,单例的，线程安全的，不同的线程可以获得不同的session。

configuration。buildSessionFactory（）：获得实例

openSseeion(),创建一个会话，每执行一次，session都是新的。

Configuration:提供用于去加载配置文件的。

核心配置文件的种类：hibernate.properties(只能配置基本信息) 和hibernate.cfg.xml(可以配置基本信息，映射文件等)

构造方法：new Configuration().configure(); 去加载hibernate.cfg.xml配置文件。

通过configure(string ),指定自定义的cfg.xml文件。

config.addResource("cn/tf/domain/User.hbm.xml");

或者：

config.addClass(User.class);

Session:

每个用户必须独享自己的session， save,update,delete,createQuery(list/setFirstResult/setMaxResults)

事务操作

1. 开启事务：beginTransaction()
2. 提交事务： commit（）
3. 回滚:rollback()

主配置文件

hibernate.cfg.xml 位置:src(classpath) ,在WEN-INF/classes目录下

<!-- 显示生产sql语句 -->
    <property name="hibernate.show_sql">true</property>
    <!-- 格式化方式显示sql -->
    <property name="hibernate.format_sql">true</property>


    <!-- 表的创建 ,先有表，再有映射，实际开发中通过表自动生成hbm.xml映射文件
        取值：validate:程序运行时，将校验映射文件和表的对应关系，如果一一对应程序正常运行，如果不正常则抛异常。
             create :每一次都将创建表，如果表已经存在了就删除，程序结束之后表还在
             create-drop:每一次都将创建表，如果表已经存在了就删除,程序结束之后表也删除了, 必须执行factory.close()
             update:如果表不存在就创建，如果存在，将维护映射到表的关系。只负责添加，但不进行删除。

    -->


    <property name="hibernate.hbm2ddl.auto">update</property>

    <!-- 取消bena校验 -->
    <property name="javax.persistence.validation.mode">none</property>


    <!-- 将session绑定到本地线程中     
        当在cfg.xml配置了thread，SessionFactory提供的getCurrentSession()将可以使用
        get():相当于map.get(Thread)
        set(value): 相当于map.put(Thread,value)
        remove()  :map.remove(Thread)
      -->
    <property name="hibernate.current_session_context_class">thread</property>

映射文件基本配置

<class  name="cn.tf.domain.Person"  table="t_person">
    <!-- 给表配置主键 -->
    <id name="pid">
        <!-- 主键生成策略 -->
        <generator class="native"></generator>
    </id>
    <!-- 其他属性
        name:默认用于配置javabean属性名称
        length:配置长度，默认255
        column:当前属性对应表中字段名称，默认和name值相同
                column的属性： <property  column=""  ></property>
                <column  name=""></column>
        type: 数据字段类型
                hibernate类型:例如:string(都是小写)
                java类型:例如java.lang.String
                mysql类型:例如varchar(50)  ,  <column  name="name"  sql-type="varchar(50)" />

        日期时间类型：
                date:日期，java.util.Date
                time:java.util.Date
                timestamp:java.util.Date,时间戳随时间变化而变化
                项目中使用datetime表示日期时间
     -->

     <!-- 其他配置
            access ，用于确定当前属性如何进行数据封装
                property : 默认值，hibernate采用javabean属性 与 表字段进行对应。在javabean必须提供 getter/setter方法
                field ： hibernate采用 javabean 字段 与 表字段进行对应。 可以没有getter/setter方法
                    例如：private String username;
                noop : 提供给hibernate hql使用，数据库没有对应字段。一般不使用。
            precision 和 scale 给 oracle配置，在mysql没有作用。
                precision 配置数字位数
                scale 配置小数位数 
                例如：numeric(precision,scale)  , 12.34  numeric(4,2)


      -->


    <property name="name"  length="50"  column="name"  type="string"   access="property">   </property>
    <property name="gender"  ></property>
    <property name="age"  type="integer"></property>
    <property name="photo"  type="binary"   length="200000"></property>
    <property name="birthday" >
        <column name="birthday"  sql-type="datetime"></column>
    </property>
    <property name="desc"  column="`desc`"></property>



</class>

insert="false" 表示生成insert语句没有当前字段 update="false" 表示生成update语句没有当前字段

在class中设置动态的添加和修改，默认是false，如果属性内容为空，则生成的sql中就没有该字段。

dynamic-insert="false" dynamic-update="false" 如果使用动态更新，数据必须是查询获得的。

派生属性

从数据库另一张表查询获得。 聚合函数：count(),max(),min(),avg(),sum()等。

sql语句：如果使用字段，默认从当前表中获得字段的，如果要获得B表字段，必须使用表的别名。

<property name="orderCount"  formula="(SELECT COUNT(*) FROM t_order  o  WHERE o.book_id=bid)"></property>

生成的sql语句:

select
    book0_.bid as bid1_0_,
    book0_.title as title1_0_,
    book0_.price as price1_0_,
    (SELECT
        COUNT(*) 
    FROM
        t_order  o  
    WHERE
        o.book_id=book0_.bid) as formula0_0_ 
from
    t_book book0_ 
where
    book0_.bid=?

OID映射

hibernate通过OID确定系统，及OID相同，对象就相同，OID取值为数据库主键的值。

<id  name="cid" >
        <generator class="identity"></generator>
    </id>


         id属性配置,
         name:OID属性名称
         column：表字段列名
         length:表字段长度
         type:表字段类型
         unsaved-value:save或update方法使用依据
                    String,默认是null,如果使用unsaved-value=http://www.mamicode.com/"abc" ，当执行save方法，设置“abc”相当之前null>

持久对象状态

状态分类：

• transient:瞬时态，session中没有缓存数据，数据库没有对应的数据。
• persistent:持久态，session中有缓存数据，数据库中最终会有该数据，例如save(user).
• detached:脱管态,session没有缓存，但是数据库中有该数据，

瞬时态->持久态 :执行save()和saveOrUpdate()

瞬时态->脱管态 :手动设置OID，如果OID对应的记录不存在，之后操作将抛出异常

持久态->瞬时态 :当执行delete()，（删除态）

持久态->脱管态 :close()关闭,clear()清除所有缓存，session.evict(PO)将指定的对象从缓存中移除

脱管态->瞬时态 :手动删除OID

脱管态->持久态 :执行update，执行了saveOrUpdate()

所有查询结果，对象都是持久态，查询结果保存在session中。

一级缓存

session级别的缓存，及将数据保存在session中。 一级缓存内置，不能删除，必须使用的。

目的：提高性能，减少数据库的访问。

一级缓存操作

session提供map容器，用于执行一些指定的操作时，进行相应PO对象缓存。

save方法

当OID类型为：代理主键，执行save方法时，将触发insert语句，确定OID的值。直到commit数据才进入数据库。
当OID类型为：自然主键，执行save方法时，此时不触发insert语句，直到commit才触发insert语句，数据进入数据库。
如果OID在数据库中已经存在记录将抛异常。

saveOrUpdate方法

对象时瞬时态，执行saveOrUpdate，底层执行save方法。如果对象时脱管态，执行saveOrUpdate，底层执行update方法。
OID 代理主键，OID如果没有值，执行save方法；如果有值（setUid(,,)），执行update方法。
如果设置oid，但数据库中没有对应记录，将抛异常。
oid自然主键，先执行select查询来获得主键的值，若OID不存在，则save，OID存在，则update。

update方法

当执行update时，都会执行update，即使数据没有变更。

可以通过映射文件配置：select-before-update,在更新前先查询，如果数据系统，将不进行update，适用于更新不频繁的应用。

一级缓存内容的操作

清空缓存

session.clear();

或者

session.evict(user);

一级缓存快照（备份）

提交时要确定一级缓存的数据是否进行了修改，如果没有修改，就不进行任何操作，如果修改了，就执行update，将一级缓存的数据同步到数据库。是否修改的依据就是一级缓存的数据与快照的数据是否一致。

默认提交时，一级缓存的数据将进行刷新，执行update语句，使一级缓存的数据同步到数据库。刷新时机是可以修改的：在hibernate中提供了FlushMode进行设置。

刷新时机：1、查询前，2，提交时，3，执行flush进行手动刷新，4，默认进行commit时，可以理解为依据进行了flush了。

关联关系映射

一对多、多对多、一对一

实体关系

采用ER图（关系实体图），开发时进行表之间的描述。

一对多

<!--  一个客户拥有多个订单，一对多  
            Set:set
            List:list
            Map:map
            Array:array
            key:用来确定从表的

    -->
    <set name="orderSet" >
            <key column="customer_id"></key>
            <one-to-many  class="cn.tf.domain.Order" />

    </set>

--

<!-- 多个订单属于一个客户
        每一个映射文件都可以完整的描述对象之间的关系
        column,确定从表外键
     -->
    <many-to-one name="customer"   class="cn.tf.domain.Customer"   column="customer_id">

    </many-to-one>

一对多： 多方必须维护外键信息，如果一方没有OID值，将触发update语句， 一方默认对外键信息进行维护，一方将放弃对外键的维护 在Customer.hbm.xml中，加入

inverse="true"

级联操作

级联保存或更新

save-update:A关联瞬时态B，当保存A时，自动将瞬时态的B转换成持久态B

cascade="save-update"

级联删除：

<set name="orderSet"  cascade="delete"   >

删除客户的时候删除订单： 删除后台执行的语句：

Hibernate:

select
    customer0_.cid as cid1_0_,
    customer0_.cname as cname1_0_ 
from
    t_customer customer0_ 
where
    customer0_.cid=?

Hibernate:

select
    orderset0_.customer_id as customer3_1_1_,
    orderset0_.oid as oid1_,
    orderset0_.oid as oid2_0_,
    orderset0_.price as price2_0_,
    orderset0_.customer_id as customer3_2_0_ 
from
    t_order orderset0_ 
where
    orderset0_.customer_id=?

Hibernate:

update
    t_order 
set
    customer_id=null 
where
    customer_id=?

Hibernate:

delete 
from
    t_order 
where
    oid=?

Hibernate:

delete 
from
    t_customer 
where
    cid=?

孤儿删除

<set name="orderSet"  cascade="delete-orphan"   >

解除关系之后，那个表外键设置null,从表记录就是孤儿，一并进行删除，解除关系时，一并删除订单，但是客户还是存在的。

多对多

<!-- 多对多
        确定中间表的表名
        当前表在中间表对应的名称
        确定容器中另一个对象,class来确定另一个对象的类型,column确定的是另一个表对应的外键名称
     -->
    <set name="studentSet"  table="t_student_course" >
        <key column="course_id"></key>
        <many-to-many class="cn.tf.domain2.Student"   column="student_id"></many-to-many>
    </set>

--

<set name="courseSet"  table="t_student_course">
        <key column="student_id"></key>
        <many-to-many  class="cn.tf.domain2.Course"  column="course_id"></many-to-many>
    </set>

操作

两个对象不用同时对中间表进行维护，所以需要在多对多中有一方配置放权。

inverse="true"

级联保存 直接保存即可。

双向级联删除

Student.hbm.xml
 *      <set name="courseSet" table="m_student_course" cascade="delete">
 *  Course.hbm.xml
 *      <set name="studentSet" table="m_student_course" cascade="delete" inverse="true">

集成log4j

hibernate使用的是slf4j日志框架。

组件映射

通过面向对象角度，使用设计模式，将数据都抽取到一个对象中，将多个对象组合在一起，达到重复利用的目的。

必须确定组合javabean类型，每一个对象属性必须在表中都存在独有列名。

<class  name="cn.tf.component.Person"   table="t_person">
    <id  name="pid">
        <generator class="native"></generator>
    </id>
    <property name="name"></property>

    <component name="homeAddress"  class="cn.tf.component.Address">
            <property name="addr"  column="homeAddr"></property>
            <property name="tel"  column="homeTel"></property>
    </component>

    <component name="companyAddress"  class="cn.tf.component.Address">
            <property name="addr"  column="companyAddr"></property>
            <property name="tel"  column="companyTel"></property>
    </component>

继承映射

继承方式1：sub-class 所有内容保存一张表，给表提供标识字段，每一个子类都具有独有的字段。

继承方式1：

<class  name="cn.tf.inherit.subclass.Employee"   table="t_employee"   discriminator-value=http://www.mamicode.com/"员工">>

继承方式2：

<joined-subclass  name="cn.tf.inherit.joinedclass.HourEmployee"  table="j_hour">
    <key column="hid"></key>
    <property name="rate"></property>
</joined-subclass>
<joined-subclass  name="cn.tf.inherit.joinedclass.SalaryEmployee"  table="j_salary">
    <key column="sid"></key>
    <property name="salary"></property>
</joined-subclass>  

继承方式3： 将生成多张表，彼此之间没有关系，但主键值逐渐增强，需要hiberate自动维护三张表之间的主键唯一，存在并发问题。

<union-subclass name="cn.tf.inherit.unionclass.HourEmployee"  table="u_hour">
    <property name="rate"></property>
</union-subclass>
<union-subclass name="cn.tf.inherit.unionclass.SalaryEmployee"  table="u_salary">
    <property name="salary"></property>
</union-subclass>   

抓取策略

检索方式

立即检索：在执行查询之后，立即执行select语句进行查询

延迟检索：在执行查询方法之后，没有进行查询，底层生成代理对象呢，直到需要相应的数据，在进行查询。 除OID之外的值，关联的数据

检索类型

类别级检索：当前对象所有属性值。，查询当前类的所有内容，只查询一次，优化指查询时机优化。

关联级检索：当前对象关联对象数据。

多对一，一对一：共同特点都拥有一方

一对多、多对多

<set name="orderSet"   fetch="join"  lazy="true">

fetch用来确定hibernate生成的sql的样式，lazy表示制定sql的时间。

fetch="join" ，lazy无效，hibernate 将使用“迫切左外连接”，底层执行sql语句就是“左外连接”，只执行一条select，将当前对象及关联对象数据一次性查询出来。

fetch="select" ，默认值，执行多条select语句

lazy="false" 立即执行，在执行get方法时，立即执行多条select语句。

lazy="true" 延迟执行，在执行get方法时先查询客户Customer，直到使用Order数据时才查询Order

lazy="extra" 极其懒惰，在执行get方法时先查询客户Customer（select tcustomer），如果需要order 订单数，将执行聚合函数只查询数量（select count() torder），如果需要详情再查询详情(select t_order))。 fetch="subselect" ，采用子查询

lazy 取值与 fetch="select" 相同。 注意：必须使用Query进行查询。

检索方式总结

1、通过OID检索：get()立即查询，如果没有就返回null;load()默认延迟检查，如果没有抛出异常。使用以上两个方法进行查询，结果都是持久态对象，持久态对象就在以及缓存中。

2、对象导航图：通过持久对象自动获得关联对象。例如customer.getOrderSet().size()

3、SQL，session.createSQLQuery("sql语句")

4,QBC,hibernate提供的纯面向对象查询语句。

5，HQL， 提供面向对象的查询语句。 HQL使用对象和对象属性，sql语句使用表名和字段名称，对象和属性区分大小写，表名和字段不区分大小写。

查询所有

//1、HQL //Query query=session.createQuery("from Customer");

    //使用全限定名
    //Query query=session.createQuery("from cn.tf.init.Customer");

    //别名,不能使用*号
    //Query query=session.createQuery("select c  from Customer as c");


    //sql,必须将查询结果封装到相应的对象中
    SQLQuery sqlQuery=session.createSQLQuery("select * from t_customer");
    sqlQuery.addEntity(Customer.class);
    List<Customer>  allCustomer=sqlQuery.list();

    //QBC
    Criteria criteria=session.createCriteria(Customer.class);
    List<Customer> allCustomer=criteria.list();

    //List<Customer>  allCustomer=query.list();

    //输出
    for (Customer customer : allCustomer) {
        System.out.println(customer);
    }

根据ID查询

//hql
    //Customer customer=(Customer) session.createQuery("from Customer c where c.cid=1").uniqueResult();

    //sql
    //Customer customer=(Customer) session.createSQLQuery("select * from t_customer c where  c.cid=1").addEntity(Customer.class).uniqueResult();

    //QBC
    Customer customer=(Customer) session.createCriteria(Customer.class)
            .add(Restrictions.eq("cid", 1))
            .uniqueResult();

排序

//hql
    //List<Customer> allCustomer=(List<Customer>) session.createQuery("from Customer c order by  c.cid ").list();

    //sql
    //List<Customer> allCustomer=(List<Customer>) session.createSQLQuery("select * from t_customer order by cid desc").addEntity(Customer.class).list();

    //QBC
    List<Customer> allCustomer=(List<Customer>)  session.createCriteria(Customer.class).addOrder(org.hibernate.criterion.Order.asc("cid")).list();

    for (Customer customer : allCustomer) {
        System.out.println(customer);
    }

查询部分内容（投影）

hql,默认查询部分将查询结果封装到object数组中，需要封装到指定的对象中，投影查询的结果是脱管态的。

List<Customer> allCustomer=(List<Customer>) session.createQuery(" select new Customer(cid,name)  from Customer  ").list();

    //sql
    //List<Customer> allCustomer=(List<Customer>) session.createSQLQuery("select cid,name from t_customer  ").addEntity(Customer.class).list();

    //QBC
    List<Customer> allCustomer = session.createCriteria(Customer.class)
            .setProjection(Projections.projectionList()
                    .add(Projections.alias(Projections.property("cid"), "cid"))
                    .add(Projections.alias(Projections.property("name"), "name"))
                    )
                    .setResultTransformer( new AliasToBeanResultTransformer(Customer.class))
                    .list();

分页查询

//1、HQL
    //List<Customer>  allCustomer=session.createQuery("from Customer").setFirstResult(0).setMaxResults(2).list();

    //sql,必须将查询结果封装到相应的对象中
    //List<Customer>  allCustomer=session.createSQLQuery("select * from t_customer").addEntity(Customer.class).setFirstResult(0).setMaxResults(2).list();

    //QBC
    List<Customer>  allCustomer=session.createCriteria(Customer.class).setFirstResult(0).setMaxResults(2).list();;

绑定

占位符： #属性=? 从0开始,setXXX(index,oid);第一个参数表述索引号，从0开始，第二个表示oid的值,也可以使用.setParameter(0, 1) 别名：

 *  属性=:别名
 *      第一个参数是别名，一般建议使用属性名称


Customer  customer=(Customer) session.createQuery("from Customer  c where c.cid= ? ")
            //.setInteger(0, 1)  
            .setParameter(0, 1)
            .uniqueResult();

    Customer  customer=(Customer) session.createQuery("from Customer  c where c.cid=:cid")
            .setInteger("cid", 1)  
            .uniqueResult();

聚合函数

//Object obj=session.createQuery("select count(*) from Customer").uniqueResult();

    //Object obj=session.createQuery("select count(*) from Customer").uniqueResult();

    Long  numLong=(Long) session.createQuery("select count(*) from Customer").uniqueResult();
    int num=numLong.intValue();
    //输出

    //2 sql
    //BigInteger numObj = (BigInteger) session.createSQLQuery("select count(cid) from t_customer").uniqueResult();

    //3 qbc
    Long numObj = (Long)session.createCriteria(Customer.class)
                .setProjection(
                        Projections.projectionList()
                        .add(Projections.rowCount())
                    )
                .uniqueResult();

连接查询

1. 内连接：[inner] join
2. 左外连接： left [outer] join
3. 右外连接： right [outer] join
4. 迫切左外连接： left [outer] join fetch
5. 迫切内连接： [inner]join fetch

左外连接,将每一条查询结果封装到Customer 和Order对象，然后创建 new Object[2]{c,o} 。将所有的数组 存放到另一个数组返回

        List<Customer> allCustomer=session.createQuery("from  Customer  c left outer join  c.orderSet ").list();

迫切左外连接，将所有的查询结果封装Customer和Order对象，然后将Order 添加到 Customer(customer.getOrderSet().add(order)) ,最后返回Customer对象集合

        List<Customer> allCustomer=session.createQuery("select distinct c from Customer  c left outer join fetch  c.orderSet ").list();

命名查询

将HQL语句存放到配置文件中，之后不需要修改java源码，服务器tomcat重启即可。

全局：可以直接获得，在。hbm.xml文件中配置。与class同级之后

<!-- 配置全局hql -->
<class></class>
    <query name="findAllCustomer">from Customer</query>

使用：

List<Customer>  allCustomer=(List<Customer> )session.getNamedQuery("findAllCustomer").list();

局部：必须通过包名获得

<class><!-- 局部 -->
        <query name="findAllCustomer2">from Customer</query></class>

使用：

List<Customer>  allCustomer=(List<Customer> )session.getNamedQuery("cn.tf.init.Customer.findAllCustomer2").list();

常用配置

整合c3p0

<!-- 整合c3p0 -->
<property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>

事务

一组操作，要么全部成功，要么全部失败。 特性：ACID，原子性，一致性，隔离型，持久性

脏读，不可重复读，虚读

<property name="hibernate.connection.isolation">4</property>

丢失更新 lost update

两个人都在同时进行数据更新，后面讲前面的数据进行覆盖。

乐观锁：丢失更新肯定不发生：在表中提供一个字段（版本字段），如果版本一致可以提交，如果不一致不进行提交。

悲观锁：丢失更新肯定发生，采用mysql数据库的锁机制。读锁：共享锁，多个人可以一起读。 写锁：排它锁，

二级缓存

介于应用程序和永久性数据存储源之间，其作用是降低应用程序直接读写永久性存储源的频率，从而提高应用的运行性能，其物理介质是内存。

如果缓存不够用，可以将缓存写到文件中。

二级缓存

一级缓存，hibernate实现了，必须使用的。是用户自己共享数据。

二级缓存：SessionFactory级别的缓存，hibernate提供了规范（接口），如果需要使用必须有实现类，用户之间共享数据，

SessionFactory缓存： 内置缓存：自带的，不可卸载 外置缓存：二级缓存，需要配置

类缓存、集合缓存、时间戳、查询缓存。

并发访问策略：read-write、read-only

很少修改的，不重要的数据适合放入二级缓存中，允许偶尔的并发问题。

配置

1、导入jar包 2、开启二级缓存 3、确定提供商 4、确定需要缓存的内容 5、第三方配置文件

<!-- 开启二级缓存 -->
    <property name="hibernate.cache.use_second_level_cache">true</property>
    <!-- 提供商 -->
    <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
    <!-- 开启查询缓存 -->
    <property name="hibernate.cache.use_query_cache">true</property>
    <!-- 二级缓存监测 -->
    <property name="hibernate.generate_statistics">true</property>

    <!-- 类缓存 -->
    <class-cache usage="read-write" class="cn.tf.init.Customer"/>
    <class-cache usage="read-write" class="cn.tf.init.Order"/>
    <!--  
    -->
    <!-- 集合缓存 -->
    <collection-cache usage="read-write" collection="cn.tf.init.Customer.orderSet"/>

1、类缓存：数据为散装数据，一级缓存是对象，二级缓存是数据。

2、集合缓存，只缓存oid，如果需要数据就从类缓存获得。

3、时间戳：任何操作都会在时间戳中留下记录，但不要使用一级缓存特性，一级缓存同步数据库，同时一级缓存同步到二级缓存。保持二级缓存和数据库一致。

执行update语句，跳过一级缓存更新数据库，此时时间戳将记录修改的时间。

    session1.createQuery("update Customer c set c.name = ? where c.cid = ?")
    .setString(0, "王晓绿")
    .setInteger(1, 1)
    .executeUpdate();

4、查询缓存：默认情况查询缓存不能使用。 Query进行查询结果存放到二级缓存，但不从二级缓存获取。通过HQL语句和查询结果形成一一对应关系，之后通过HQL语句可以直接获得查询结果。

存放或获得数据， 查询所有 -- 将结果存放一级缓存，同时保存二级缓存

    List<Customer> allCustomer = session1.createQuery("from Customer").setCacheable(true).list();

ehcache.xml配置

确定缓存内容的硬盘位置：

 <diskStore path="D:\cache"/>

<defaultCache
        maxElementsInMemory="5"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        maxElementsOnDisk="10000000"
        diskPersistent="false"
        diskExpiryThreadIntervalSeconds="120"
        memoryStoreEvictionPolicy="LRU"
        />

性能检测

二级缓存监测 ，先需要在配置文件中配置

    <property name="hibernate.generate_statistics">true</property>

Statistics statistics = factory.getStatistics();

撞击数：

statistics.getSecondLevelCacheHitCount()

丢失：

statistics.getSecondLevelCacheMissCount()

总结：软件系统发展到今天已经很复杂了，特别是服务器端软件，设计到的知识，内容，问题太多。在某些方面使用别人成熟的框架，就相当于让别人帮你完成一些基础工作，你只需要集中精力完成系统的业务逻辑设计。而且框架一般是成熟，稳健的，他可以处理系统很多细节问题，比如，事物处理，安全性，数据流控制等问题。还有框架一般都经过很多人使用，所以结构很好，所以扩展性也很好，而且它是不断升级的，你可以直接享受别人升级代码带来的好处。框架一般处在低层应用平台（如J2EE）和高层业务逻辑之间的中间层。

struts2案例：  员工信息管理系统：https://github.com/sdksdk0/PMSystem

整合案例：贴吧：https://github.com/sdksdk0/TieBa

粗浅看Struts2和Hibernate框架