框架的概念是一个提供了可重用的公共结构的半成品
SSH是指：Struts 2 + Spring + Hibernate

框架的强大之处不是源自它能让你做什么,而是它不能让你做什么!
Hibernate 是什么： 是数据持久化工具,是一个开放源代码的对象关系映射框架。
                   作用：负责简化将对象数据保存到数据库中。或从数据库中读取数据并封装到对象的中。
OMR 是什么：即是对象/关系映射，是一种数据持久化的技术。
        作用：把关系型模型映射成对象模型(具体就是不再需要使用SQL语句操作数据库中的表,使用API直接操作JavaBean对象就可以实现数据的存储、查询、更改、删除等操作)。
         Hibernate就是采用ORM对象关系映射技术的持久化开发框架。

Hibernate：优点： 1.程序更加面向对象；        缺点： 1.效率比JDBC略差
                               2.提高了生产率；                           2.不适合批量操作
                               3.方便移植（修改配置文件）;        3.不适用于小型项目,也不使用于关系模型设计不合理、不规范的系统
                               4.具有良好的扩展性(笑)

Hibernate中对Java对象的三种状态分别是：

1.瞬时状态：没有通过Session对象的实例对其进行任何持久化的操作
                             2.持久状态：实体对象是与Session对象的实例相关的
                             3.游离状态：不再与Session对象关联时

第一次使用的时候环境搭配：正确的导入(hibernate-configuration-3.0.dtd,hibernate-mapping-3.0.dtd)
   用法：
    1.下载Hibernate3.3.2相关资源包，把需要驱动包添加到当前工程环境中去,lib文件夹中添加相关jar包
    2.添加和编写Hibernate配置文件：hibernate.cfg.xml
    3.添加学生持久化类和对象关系映射文件：***.hbm.xml(映射文件必须要以..结尾)
    4.使用hibernate相关API完成：HibernateUtils 和 OpenSessionInViewFilter(必须先导入包：)
    5.运行测试
    
Hibernate有四种查询方案：   
    1、Get,Load方法,根据id查找对象
    2、HQL,(from 对象名)使用createQuery
    3、SQL,(完整的SQL语句：select * from 表名)使用SQLcreateQuery
    4、Criteria--标准查询语言（查询对象：Criteria，查询条件：Criterion）

什么是HQL:(Hibernate Query Lanaguage)是面向对象的查询语句,跟SQL语句有些相似。是Hibernate查询中最常用的的一种查询方式             query语句.createQuery()
HQL获取结果采用的集中方式： .list()得到list对象集合 .iterator方法得到迭代.uniqueResult()得到对象返回的是Object类型必须要强转
HQL参数绑定： 查询语句中使用占位符的形式"?",如:(from 对象名 where id = ?).setString("index","value"),index从”0”开始！
            查询语句中使用参数名称的形式":name",如:(form 对象名 where name = :name).setString("name","value"),直接指定参数则可
         .setString()是绑定String类型,相对.setDouble()就是小数类型辣.或者直接使用.setParameter()方式绑定任意类型的参数

分页查询!这塔么是重点！提供的两个方法必须要记住分别是：
    1.query.setFirstResult((pagaIndex-1)*pageSize) 得到当前页码
    2.query.setMaxResults(pageSize) 得到
    3.list result = query.list() 得到分页查询结果
    计算总页数的语句如下：int totalpages = (count % pageSize == 0)?(count / pageSize):(count / pageSize + 1);
    参考项目里面有详解:

投影查询：有时并不需要获取对象的全部属性,只需要对象的某一个或某几个属性.
    有三种方式分别是： 1.将每条查询结果封装成Object对象：HQL语句：(select 属性值 from 对象类)返回属性值那列的数据,单个
               2.将每条查询结果封装成Object数组：HQL语句：(select 属性值1,属性值2 from 对象类)返回属性值那几列的数据,多个
               3.将每条查询结果通过构造函数封装成对象：HQL语句：(select new 对象类(属性值1,属性值2) from 对象类),该方式对象类中必须要有无参构造函数
               4.以上方式只针对HQL语句查询,SQL语句该怎么查就怎么查..
        
方向工程：直接通过数据库表生成映射文件.hbm.xml和持久化类(没有参考)
正向工程：直接用过映射文件.hbm.xml和持久化类生成数据库表(参考：ExportDDL.java)

关联关系:类于类之间醉普遍的关系就是关联关系，而且关联是有方向的。
    Hibernate关联关系是指：对象之间的关系，并不是指数据库中的关系。
    关系有: 多对一,一对多 ; 一对一; 多对多;又分单向和多向..
   七种对象关联关系:单向N-1,1-1,1-N,N-N双向:1-N,N-N,1-1
   
    配置单向多对一的关联：在一个对象类中定义另一个对象的属性  private 对象类 对象属性; 
                 <mant-to-one name = "对象属性" cloumn="在数据库中的列名" class="对象类" />
    配置单向多对一的关联：在实体类中创建使用HashSet<>(哈希表)
                 private Set<实体> set* = new HashSet<实体>();加入get,set方法
                  在hbm.xml中加入
                 <set name="set*" inverse="true" lazy="false" cascade="all">
                     <key>
                            <column name="对应的id" precision="22" scale="0" not-null="true" />
                     </key>
                     <one-to-many class="实体类路径" />
                 </set>
    配置单向多对多的关联：参考以上：在标签<Set>里面的<one-to-many>改成<many-to-many>
    配置双向多对多的关联：两个实体中都有HashSet<>(哈希表)属性,然后两个映射文件都需要更改以上单向多对多的关联
    
加载策略：<class>标签中加入属性Lazy,属性等于true就是延迟加载,false是立即加载,默认值是true
延迟加载：能避免架子啊应用程序不需要访问的关联对象
立即加载：立即查询并加载与之相关的对象，有两个不足：1.频繁的访问数据库,影响查询性能 2.会访问不需要访问的对象,浪费了许多多余的空间

Open Session In View 模式：在用户的每一次请求过程中始终保持一个Session对象打开
                         实现步骤：1.创建OpenSessionInViewFilter
                         2.更改web.xml

Hibernate缓存：Hibernate是一个持久层框架，经常访问物理数据库。
           作用：降低应用程序直接读写永久性数据存储源的频率，从而提高应用的运行性能
            原理实例：http://www.cnblogs.com/wean/archive/2012/05/16/2502724.html
         分为3大类：一级缓存： 又称为“Session的缓存”。Session的缓存是事务范围的缓存，是必须存在的，一级缓存中，持久化类的每个实例都具有唯一的OID。
                          当应用程序调用Session的save()..等方式以及Query查询接口的.list()..等方法时,如果在Session的缓存中还不存在相应的对象,Hibernete就会把该对象加入到一级缓存中
                          在刷新缓存时,Hibernate会根据缓存中的对象的状态变化来同步更新数据库
                    
                         从缓存中清楚指定的持久化对象： session.evict(对象)
                         清空缓存中的所有持久化对象：session.clear
                         强制进行从缓存到数据库的同步 ：session.flush()
                              
               二级缓存：又称为“SessionFactory的缓存”。Hibernate二级缓存是进程范围或者集群范围的缓存，有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。
                            第二级缓存是可选的，是一个可配置的插件，默认下SessionFactory不会启用这个插件。
                   Hibernate提供了org.hibernate.cache.CacheProvider接口,它充当缓存插件与Hibernate之间的适配器。
                   配置二级缓存的方法：1.创建ehcache.xml(Src文件夹下)
                              2.开启二级缓存
                              3.指定缓存产品提供商
                              4.指定使用二级缓存的持久化类,修改持久化类的映射文件。
                               实现步骤：1.添加ehcache-1.2.3.jar以及commons-logging-1.1.1.jar到lib包中
                              2.创建ehcache.xml(Src文件夹下)
                              3.配置Hibernate.cfg.xml及持久化类映射文件
                              4.测试..
               查询缓存： 1.在Hibernate.cfg.xml文件中加入:
                       <property name = "hibernate.cache.use_query_cache" >true</property>
                      2.在程序中启动查询缓存
                          query.setCacheable(true);在Query查询对象中加入
                     适用于：经常使用的查询语句
                             对查询到的数据很少有插入,删除或更新操作

Hibernate提供了两种映射一对一的关联关系的方法：外键映射和主键映射
                          
HQL的连接查询:
    内连接：form Entity 别名 inner  join 别名.属性
    外连接：左：form Entity left join Entity.属性       属于左边的表信息会被全部查询出来
           右：form Entity right join Entity.属性    属于右边的表信息会被全部查询出来
    交叉连接： 适用于两个类之间没有定义任何关联时,通过属性作为筛选条件。如：from Entity1,Entity2
    
批量处理数据：Hibernate提供了以下方式进行批量处理操作  Query.executeUpdate();
        参考：http://youngflying.com/2012/09/14/hibernate-batch-processing/
        1.使用HQL进行批量操作
        2.使用JDBC API 进行批量操作
        3.使用Session进行批量操作

聚合函数：1.count(*)统计记录数：Long count = (Long)session.createQuery("select count(*) from Entity").uniqueResult();
      2.sum()求和：Double sum = (Double)session.createQuery("select sum(e.属性) from Entity e").uniqueResult();
      3.min()求最少值或max()求最大值：Double money = (Double)session.createQuery("select min(e.属性) from Entity e").uniqueResult();
      4.avg()求平均值：Double money = (Double)session.createQuery("select avg(e.属性) from Entity e").uniqueResult();
分组查询：select e.属性,count(e.属性) from Entity e group by 属性
      注意：如果分组结果数据来自几个表的值使用迭代器进行获取结果. Iterator it = query语句.list().iterator(); 
        输出迭代器的信息：Object[] obj = null;
                   while(it.hasNext()){
                       obj=it.next();
                       syso(obj[0]...);
                   }
子查询：form Entity e where e.属性=(select 属性 from Entity)

原生的SQL查询：query语句.createSQLQuery()
          query语句.createSQLQuery().addRntity(Entity.class):自己理解的意思就是,处理完查询语句之后强制把结果转换成指定的对象类型
          query语句.createSQLQuery("select {e.*} from Entity").addJoin("e","e.属性")：理解的意思就是类似于占位符..

命名查询：在映射文件中定义，跟<class>标签同级！
 HQL查询语句的命名查询：
      <class name = "HQL方法名">
      </class>          
      <query name = "..">
          <![CDATA[
              from Entity e where e.属性 = :属性
          ]]>
      </query>
      使用：query.getNamedQuery(HQL方法名).setObject("属性",value)
 SQL查询语句的命名查询：
       <sql-query name="SQL方法名">
           <return alias="e" class="对象路径"/>
           select {e.*} from Entity e where e.属性 = :属性 
       </sql-query>
     使用：query.getNamedQuery(SQL方法名).setObject("属性",value)

BLOB 和 CLOB 类型：Oracle数据库中的两种大对象数据类型;    参考：HibernateDome项目中的bigdata
在Hibernate.cfg.xml文件中加入：<mapping resource="cn/HibernateDome/bigdata/Student.hbm.xml"/>
BLOB:二进制大文件：保存二进制文件,视频,音频,文档等信息.
    读取Blob 使用 byte [] temp = new byte[1024];
    使用输入流保存blob类型的文件
    使用StringBuilder类型的.append()方式保存大字符串
CLOB:字符串大对象：保存大字符串,超长文本内容(小说,新闻等)
    读取Clob 使用 char[] clob = new char[1024];
    
Criteria 查询：是HIbernate提供的另一种查询方式，与HQL基于字符串的查询形式完全不同！     不支持.iterator()迭代器
    参考：HibernateDome项目中的criteria
    用法： 1.使用Session接口的createCriteria()方法创建Criteria对象      
                例子：默认查询全部：Criteria c = session.createCriteria(Entity.class);
                            List<Entity> list = c.list();
        2.使用Restrictions类提供的静态方法设置查询条件,返回Criterion对象   
                例子：按条件查询：Criteria c = session.createCriteria(Entity.class);
                           Criterion c2 = Restrictions.eq("属性",value); //eq是等于的意思,还有很多条件..参考书上253页,254,255,256,257页
                           c = c.add(c2);  // 添加查询条件,如果条件多可以再多几个add..
                           List<Entity> list = c.list();
         3.使用Criteria接口的list()方法执行查询语句.
     排序：使用.addOrder(Order.asc("属性")).list();  // asc正序 desc倒序
     分页：使用.setFirstResult(0).setMaxResults(2).list();  // 参数一：当前页,参数二：每页显示数据  书上262页有用法
     
注解：是一种Java代码级别的说明，JDK5以后出现的新特性
    好处：完全可以替代复杂的nbm.xml文件,使得Hibernate程序开发大大简化..
    参考：HibernateDome项目中的annotation
    属性参数参考：书中271页
    使用步骤：1.添加Jar包：
            hibernate-annotations.jar
            hibernate-commons-annotations.jar (Hibernate中支持注解开发的jar包)
            ejb3-persistence.jar(API规范的jar包)
            slf4j/slf4j-api-1.5.0.jar
            slf4j-log4j12-1.5.0.jar
            log4j-1.2.15.jar  （支持日志输出的jar包，注意版本的匹配）
          2.使用注解配置持久化类及对象关联关系 
          3.使用AnnotationConfiguraion建立回话工厂
              sessionFactory = new AnnotationConfiguraion().configure().buildSessionFactory();
          4.在Hibernate.cfg.xml配置文件中声明持久化类
              <mapping class = "持久化类名称"/>

其他不太重要的东西:
脏检查：脏数据根据我的理解是这样的
       比如：某人在对某条数据执行更改操作，而同时，又有某个人在对该记录执行读操作。
        理论上，读操作应该读出的是更改后的数据，但是由于某些原因吧，读出的是更改之前的数据，像这样的数据就叫做脏数据。
        原因很简单，这条数据已过期，非最新的数据。