SSH框架教程

SSH框架的学习
一，Struts 2
1 为什么要学习Struts框架？
1>Struts框架的好处：简化开发工作量，提高开发效率；采用了优秀的MVC
思想
2>如何学习：先掌握框架的使用，在了解内涵
2 MVC模式在javaWeb中的应用
1>MVC思想是根据组件职责不同，将系统分为三部分组成
--M(Model) 负责业务处理
--V(View) 负责与用户交互
--C(Controller) 负责协调试图部分和模型部分协同工作
2> 为什么使用MVC:易于扩展和升级
3 Struts框架的处理流程
浏览器发出struts请求—>请求进入struts控制器—>struts控制器解析XML配置文件—>控制器根据不同请求，调用不同的Action—>Action 调用DAO处理请求返回结果—>控制器根据结果调用试图组件，响应给用户
4 Struts 历史
Struts框架分为Struts1和Struts2 两者没有必然联系，Struts2 是以WebWork 框架核心（Xwork）为基础构建起来的
5 Struts 基本使用
1>引入核心开发包五个：
commons-logging-1.0.4.jar ( 主要用于日志处理)
struts2-spring-plugin-2.0.14.jar ( struts2整合spring需要的包)
2>在web.xml 中配置struts控制器
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExcuteFilter
3>根据要求编写Action 和JSP Action要继承ActionSupport
4>在struts.xml定义Action和请求对应关系
6 struts.xml 基本配置可以放在src下面
1><struts> 根元素里面包含多个<package>元素
2><package> 主要是为了将Action分组定义name用于指定包名；extends一
般指定struts-default(在struts-default.xml中定义)，里面包括struts2运行所需的必要组件
3><action name=”” class=”” method=””>
4><result> 一个<action>可以包括多个<result> 主要用于试图响应
5>下面一个例子：
7 为列表添加分页功能例如每页2个
page =1；
pageSize=2；
int begin=(page-1)*pageSize+1;
int end=page*pageSize;
eg: select * from ( select rownum rn , c.* form COST c ) where rn between 1 and 6;
8 利用Struts2标签+OGNL技术
1>OGNL: (Object-Graph Navigation Language)对象图导航语言，主要用于访问对
象的数据和方法。

2>OGNL主要由三部分组成
--OGNL引擎：负责解析OGNL表达式，定位数据；
--Root根存储区：负责存储要访问的目标对象；
--Context变量存储区(Map 类型) 负责存放多个要访问的目标对象；
3> OGNL 基本语法：
A，访问Root区域对象基本语法:
--访问简单数据：属性—> “name”;
--访问数组和List集合：属性[index] —> “list[2]”;
--访问Map集合：属性.Key —> “map.sex”;
--访问方法：属性.方法( ) —> “list.size( )”;
--创建List对象：”{ element1, element2}”;
--创建Map对象：”#{key1 : value1 , key2 : value2}”;
--创建对象: “ new 包名.构造方法” —> “ new int( totalPages )”
B，访问Context区域对象基本语法:
采用”#key”即可
4> OGNL技术在Struts上面的应用
在Struts中有一个ValueStack( )值栈数据对象，该对象存储了请求相关的所有的数据信息。

例如request session application action等，struts采用OGNL 工具对ValueStack进行操作。

--- xwork对OGNL进行了部分改造：
答：将Root存储区改造成一个栈结构(CompoundRoot)，当利用”属性”表
达式访问时。

优先对栈顶对象查找，没有再去次栈顶查找，以此类推5>Struts标签的使用
利用Struts2标签显示数据，需要为标签指定OGNL表达式，标签利用表达式定位ValueStack中的数据，进行相应的操作
--- <debug> : 显示valueStack状态
Eg：<s:debug></s:debug>
--- <iterator> : 循环集合元素
Eg：<s:iterator value=”new int(totalPages)” status=”i”/> 分页中用到了；
<s:iterator value=”pageRows” var=”cost”/>
注：value :指定循环集合或数组
var：指定循环变量，会被存放到ValueStack的Context中。

status：指定循环状态变量，会被存放到ValueStack的Context中，该
变量有count属性表示循环了多少个元素(1开始)，index表示当前循
环元素的索引(0开始)。

--- if…else…标签判断分支：<s:if test=””></s:if> test指定ognl判断表达式Eg：<s:if test=”#cost.status==0”>暂停</s:if>
<s:else>开通</s:else>
--- <s:property value=””/> 显示数据标签value指定ognl表达式
Eg：<s:property value=”#cost.id”/>
--- <s:date name=”” format=””/> 将数据date格式化输出
Eg：<s:date name=”#cost.startTime” format=”yyyy/MM/dd HH:mm:ss” /> 9 Action组件的相关使用
1> Action 组件的原理
客户发出action请求给struts控制器—> struts控制器会创建ValueStack对象—>struts控制器根据请求创建Action对象，并将Action压入ValueStack 的root栈顶(线程安全，不用考虑并发问题)—>struts控制器将请求相关的Request,Session对象放入到ValueStack的Context区域—>struts控制器执行Action对象的execute方法处理请求—>struts控制器根据execute结果生成响应信息输出—>请求处理完毕，销毁ValueStack和Action对象。

2>Action属性注入
在<action>配置中，为Action对象的属性指定初始值，使用格式如下<action name=”” class=”” method=””>
<param name=”属性名”>属性值</param>
<result></result>
</action>
注意：type类型如果你想再见跳转的页面需要Action的数据的话要用dispatcher，如果用redirect时候，将所有的数据删除了，jsp页面中
也不能获取到应有的值了。

10 Result组件的相关使用
1> 作用：负责生成响应试图内容。

Struts2框架提供了多种不同的Result组件类型，用于做不同形式响应，例如json数据响应，流数据响应，jsp页面响应等。

2> Result组件相关配置---声明定义
<package>
<result-types>
<result-type name=”result类型” class=”result组件实现类”/> </result-types>
</package>
3> Result组件相关配置---使用定义
<action>
<result name=”action返回的标识符” type = “result类型”></result> </action>
4> 掌握经常使用的Result组件
--Jsp试图
--dispatcher：以转发方式调用Jsp页面
--redirect：以重定向方式调用Jsp页面
<result name=”” type=”dispatcher/redirect”>Jsp页面</result>
--Action试图
--chain：以转发方式调用下一个Action
--redirectAction:以重定向方式调用下一个Action
相同命名空间的调用：<result type=”chain/redirectAction”>请求名</result>跨命名空间的调用：<result type=”chain/redirectAction”>
<param name=”actionName”>请求名</param>
<param name=”namespace”>
/命名空间名
</param>
</result>
5> JSON Result组件
主要负责Action的属性以JSON字符串格式输出，JSON Result的使用步骤：---引入struts2-json-plugin.jar。

---将<package>元素的extends继承”json-default”;
---<result>使用配置
---只返回Action中一个属性：
<result type=”json”>
<param name=”root”>属性名</param>
</result>
---返回Action中多个属性：
<result type=”json”>
<param name=”includeProperties”>属性名1，属性名2，属性名3
</param>
</result>
---返回Action中的所以属性值
<result type=” json” ></result>
11 拦截器组件
Struts2组件提供了大量的拦截器组件，如果不能满足开发者需求，可以自行定义，一般利用拦截器封装一些通用性的功能，例如请求参数给action赋值，文件上传，权限检查等；
1> 拦截器的作用：
拦截器可以在Action 和Result组件调用之前执行，也可以在其之后执行。

2> 拦截器的原理：
---所有的拦截器组件实现类都必须实现接口Interceptor此接口必须实现三个方法init ，destory，intercept。

或者抽象类AbstractInterceptor此
抽象类只需要实现intercept即可，
ai.invoke()拦截器如果只有一个拦截器执行完这个方法后，会返回给试图，如果多个拦截器，它只有执行完所有的拦截器，才会返回给试图
3> 所有拦截器都具有下列注册配置
也可以在使用拦截器的时候给它设置参数，就在<action>的<result>下面用
12 Struts表单标签
界面封装了界面显示逻辑，用于简化JSP ,以后需要时候再进行查找标签库例如：
二，Hibernate
1 Hibernate框架作用，
1> 优点：
----Hibernate框架主要用于对数据库的操作，使用该框架可以简化数据操作代码，这样程序员可以将更多经历放在业务编写上。

----免费开源。

----完全面向对象。

2> 缺点：
----性能比较差，尤其是批处理方面，大数据量开发的时候，最好使用JDBC ----HQL的功能相对薄弱
3> 本质：对JDBC技术的封装。

4> 原有JDBC技术的缺点：
----需要编写大量复杂的SQL语句。

----需要做大量的对象和记录的转换。

----数据库移植时，需要修改SQL语句。

例如：分页语句，不同数据库写法不同
5> Hibernate 设计原理
---- Hibernate框架是一款ORM工具，基于ORM设计思想开发出来的
---- ORM: 对象关系映射。

Mapping映射
Object ：对象－－－－－－Relation关系
对象：Java中Entity实体类。

关系：关系型数据库。

思想：将程序中的对象与关系型数据库中的数据自动映射转化。

-----这样在查询时候，可以自动将记录封装成对象返回。

在更新和插入时候，可以将对象自动写入数据表中，像中间得SQL+JDBC的操作一样，完全
封装在工具的底层。

基于这种思想的框架还有Hibernate Ibatis 等
2 Hibernate主要结构
1> Hibernate 主要包括以下几个部分构成。

---- java实体类( n 个)：用于封装数据表记录的Java对象类型。

例如：Person.java。

----实体类名.hbm.xml( n 个):映射描述文件，里面定义了实体类与数据库之间的对应关系。

例如：Person.hbm.xml。

---- hibernate.cfg.xml ( 1 个)：主配置文件，里面主要定义链接数据库的参数。

---- Hibernate 主要API :在使用时候，需要使用Hibernate提供的API ,他们将SQL+JDBC封装起来了
2> hibernate开发需要导入的jar包
----Hibernate3.jar 和hibernate-core-3.3.1.GA.jar (hibernate核心jar包)
----antlr.jar (Another Tool for Lanuage Recognition可构造语言识别器，将HQL解析为SQL的需要)
----commons-collections.jar (包含了一些Apache开发的集合类，功能比
java.util.*强大)
----dom4j.jar (越来越多的java软件都在使用dom4j来操作xml，Hibernate也不例外)
----javassist.jar (代码生成工具，Hibernate用它在运行时扩展java类实现，同cglib包)
----jta.jar (标准的java事务处理接口)
----cglib (cglib字节码解释器)
----slf4-api.jar和slf4j-log4j12.jar (hibernate使用的日志系统)
----asm.jar (ASM字节码库，如果使用”cglib”则必要)
----asm-attrs.jar (ASM字节码库，如果使用”cglib”则必要)
----ehcache.jar (EHCache缓存，如果想使用时候加入)
----log4j.jar (必须加入的)
3>hibernate常用的API
----Configuration:加载hibernate核心的配置文件hibernate.cfg.xml
----SessionFactory:hibernate中重量级对象(重量级:消耗资源最多，功能最强
大的对象)，主要是用于创建创建Hibernate中Session对象
控制对数据库的链接，建议一个项目中，最好只有一个
SessionFactory，利用单例模式即可；
-----Session:hibernate中所有的增删改查操作都是依赖session对象实现其功能的，代表java程序与数据库的一次链接，是最常用的工具对象。

-----Transaction 事务提交：对表的改变必须依赖程序员开启事务，并且提交
事务
4>Hibernate使用步骤
----创建工程，引入hibernate的jar包。

----在src下追加hibernate.cfg.xml主配置。

----根据数据表创建实体类Entity。

----编辑实体类和数据库表的映射文件hbm.xml。

----利用Hibernate API实现增删改查操作。

如果想自动生成表则需要以下代码：
//代表控制台输出的sql语句，我们能看到。

3 Hibernate 映射类型
在***.hbm.xml中，描述属性和字段之间映射的时候，可以使用type属性指定映射类型
1>Hibernate映射类型主要有：
---整数类型：byte，short，integer，long。

---浮点数类型：float，double。

---字符串类型：string。

---事件日期类型：date，time，timestamp。

---boolean类型：yes_no (将true/false转换成Y/N)，
true_false (将true/false转换成T/F)。

---其他：big_decimal，big_integer，clob，blob。

4主键的生成策略
1>在***.hbm.xml中，可以主键指定生成方式。

----uuid：每次插入新的数据时候，hibernate自动生成不重复的32位字符串，hibernate独有的。

----sequence：采用指定序列生成，适用于Oracle这样需要使用序列自增的DB。

用oracle创建序列：
----identity:采用数据库自增长机制，适用于mysql和sqlserver数据库。

----native：根据方言自动选择identity或者sequence生成方式。

----increment：首先获取最大主键值将其+1，在执行插入操作，适用各种DB。

----assigned：忽略主键生成，需要程序员自己指定主键值。

2> <property>中配置方法：
5 Hibernate框架的基本特性
1>一级缓存(Session级别的，默认开启)：每次创建一个Session时会为这个session
对象提供一个缓冲区，用于缓存Session查询出来的单个对象，当使用Session 再次查询同一个对象时候，就从缓存里面直接查出，避免对数据库进行二次查询，从而提高效率。

2>一级缓存区管理办法：evict()---驱逐，clear()—清理等方法，
flush()将session缓存中的数据跟数据库同步。

6 Hibernate对象的持久性
Hibernate是一个持久层框架，实体对象可以具有下面三种状态：
----临时态：采用new方式构建的对象，执行完毕后被垃圾回收掉。

session.save()可将临时态变为持久态；
----持久态：
1> 采用Session对象查询出来的，受到了Session对象所管理的对象，
例如:调用load，get，save，update方法之后的对象,
2> 处于持久态的对象特点：
---对象变为持久态对象之后，在调用对象的set方法后，当事务提交
mit()/执行session.flush()方法时，对象的数据状态可以
更新到数据库。

---对象不能被垃圾回收器回收。

---对象存储在一级缓存里面，由Session负责管理。

----托管态/游离态：脱离Session管理的对象，
例如:用到了session.evict()/session.clear();
session.update()可将游离态变为持久态。

注意：我们用saveOrUpdate()方法代替save()和update()。

7 Hibernate的延迟加载
Hibernate提供一些方法，利用这些方法所返回的对象，并没有立刻发生sql 语句加载数据库中的数据，而是在调用对象的getter方法时候才触发数据库的查询，加载数据记录。

例如session.load()就是延迟加载的一个方法。

-----使用延迟加载方法时需要注意：
要避免出现LazyInitializationException:could not initialize proxy – not Session 原因是关闭过早了。

-----解析get()和load()的区别：
1>相同点：都是根据主键Id当条件查询某个对象。

2>不同点：---load()是采用延迟加载机制，
get采用立即加载机制。

---load()没有符合的记录会抛出异常ObjectNotFoundException，
get()会返回null，而不会抛出异常。

---load()返回的是动态生成一个类型(动态代理)，
get()则返回是实体类型。

8 Hibernate 延迟加载实现原理--------cglib动态代理。

---Hibernate采用了cglib.jar和asm.jar两个开发包，实现了动态新类和动态编译成class，这是hibernate内部临时生成一个暂时替代的查找对象。

9 update()方法
1> 先查询出要修改的对象，再调用update()方法
好处：稳定，不出现空值。

2> 直接创建对象，添加id，修改属性
坏处：容易出现空值。

10 Hibernate 关系映射的作用
1> 一对多关系映射(单向)：
(例如：一个部门有多个员工)由一的一端来维护关联关系，外键字段由一
的一端创建，多的一端不维护关联关系。

----需求：由一方对象查询n方记录，可以采取一对多的关系映射。

----首先在一方实体实体类中添加集合属性Set。

----然后在一方的***.hbm.xml中定义一对多关系映射的描述。

----使用时，通过一方对象的关系属性，获取n方数据
----语法：
<set name=”对象中的关联属性”>
<key column = “关联条件的外键字段” />
<one-to-many class=”多的一端的类名路径”/>
</set>
2>多对一关系映射(双向)：
(例如：多个员工可以查询他们同属一个公司的信息)
-----需求：由多方对象查询一方对象的信息。

-----在多方实体类中添加属性，该属性为一方类型
(例如：private Dept dept 其中Dept是一方的class类)。

-----在多方的***.hbm.xml中，添加属性描述信息。

<many-to-one name=”对象中的关联属性”
column=” 关联条件的外键字段”
class=” 一的一端的类名路径”/>
-----使用时，通过多方对象的关联属性获取相关一方的记录信息。

11关联操作
1>关联查询：
----默认情况下，关联属性的加载采用了延迟加载机制，当调用getter方法时候才发出查询，在使用时候，如果需要将关联属性和主对象一起
加载，
----可以通过以下方法改变加载机制：【Hibernate中的抓取策略】在***.hbm.xml中为该属性添加lazy = “false”；关联属性数据在主对
象加载时候加载为该属性追加fetch=”加载方式”，指定关联属性加
载方式(select[默认] join subselect为fetch的加载方式)。

注：当在<many-to-one> 中加入fetch=”select”会发出两条sql语句，一条是Emp的基本属性，第二条是查询与之关联的Dept的属性
当加入fetch=”join”只发出一条sql语句，使用链接查询。

2>级联添加：
----对主对象做添加操作时，关联属性的数据也做相应的添加操作
●需要在***.hbm.xml的关联属性定义中添加cascade属性，属性值可
以是none[默认]，all[级联删除和级联添加]，delete[级联删除]，
save-update[级联添加更新]。

●在执行session.save()之前，将关联数据对象添加到主对象的关联属
性中去。

3>级联删除：
----对主对象做删除操作时候，关联属性的数据也做相应的删除操作。

●需要在***.hbm.xml中的关联属性开启级联删除操作。

●在执行session.delete(obj)操作时候，删除的obj是利用session查询
出来的，不要用new方式，因为其不具有关联数据。

●级联删除采用的是n+1个delete清除数据，因此关联数据对象n过
多时候，不推荐使用，而是采取HQL语句进行删除。

4>inverse属性：
----可以控制关系字段值维护的操作由哪一方负责，默认情况下由双方负责。

----使用一对多时，一般都会加上inverse=”true”。

----一般在一方关联的集合中inverse使用true，意识要一方放弃关系维护操作，当程序对一方的对象做级联操作时，不再会出现update维护关系字
段的语句。

12 如何利用Myeclipse根据数据库生成实体类和映射描述文件。

1>新建一个web Project工程。

2> DB Browser(Myeclipse database explorer)中建立一个与数据库的链接。

3>为工程添加Hibernate开发框架(导入包，添加主配置及其参数设置)
选中工程右键—>Myeclipse—>Add Hibernate Capabilities。

4>在Add Hibernate Capabilities里面添加Hibernate框架开发包，添加主配置
文件，设置链接参数，在里面创建一个HibernateSessionFactory工具类，(---此步骤就是生成了hibernate.cfg.xml 和HibernateSessionFactory)。

5>进入DB Browser，
选中要操作的数据表右键—>Hibernate Reverse Engineering—>根据向导页面生成实体类和***.hbm.xml 。

注：向导页面1: 选择存放实体类和***.hbm.xml的工程和package，选择你
要生成的文件，可自动生成hbm.xml，pojo，dao。

向导页面2: 将Type Mapping 选中为Hibernate Types ，id的自动生成
选择为native。

向导页面3: Finish—>No。

13多对多关系映射：例如：
(一个公司中刘,李等多个人可以具有多个头衔，返回来多个头衔可以对多个人) 1>多对多关系的数据库中是由三张表构成的，其中一张表，专门用来维护
关联关系的。

2>例如：职位—>职位ID 员工ID <—员工如果需要职位查找员工，可以建立
多对多的关系映射。

3> 可以在职位中追加一个集合属性，里面存储多个员工。

(单向)
在职位和员工中各家一个Set集合属性。

(双向)
注：多对多双向关联映射的文件中的表名和列名必须一致。

14 一对一主键单向关联映射
两张表中的主键相同，例如：姓名和身份证号都代表同一个人。

也就是一张表的主键是参照另一张表的主键而建的；
Eg：Card中的主键依靠Person中的主键而建立的
Test：
15 一对一双向关联，
----只需要在Person.java中加入private Card card；
----Person.hbm.xml中加入<one-to-one name=”card” class=””>即可，这样在查询时候就
可以从任意一方能查询出另外一方。

16 Hibernate查询
1>Hibernate Query Language：HQL与SQL 结构相似，SQL语句是面向数据表
和字段进行查询的，而HQL是一种面向对象的查询语言。

2>HQL和SQL的共同点：
----都支持：select，from，where，order by，having，group by等。

----都支持运算符表达式：+ ，-，*，/，<，>等。

----都支持：in，not in，between and，like等过滤条件关键字。

----都支持分组函数：max，min，sum，avg，count。

3>HQL和SQL的不同点：
----HQL是大小写敏感的，类名属性名严格区分大小写。

----HQL不支持select * 写法。

----HQL不支持join…on…中的on子句，只可以用join(….inner join….等)。

----HQL不支持表名字段名。

4>HQL 的案例：
----查询对象中所有的内容：
----查询对象，用别名查询(同上面具有相同结果)：
----查询部分字段用new时候一定要：
给Emp中加上带参构造器。

返回List<Emp>
返回List<Object[]> ----带查询条件的HQL
----带？的查询条件用setParameter(第n个问号[0开始],内容)
----in(?,?,?.....)关键字
----in(:字段)如果字段很多的话可以用setParameterList(“:字段”,new Object[]{})
----between ? and ? 同理。

----SQL语句要用到createSQLQuery(sql)。

----inner join：只返回两表中联结字段相等的行。

----left join：返回包括左表中的所有记录和右表中联结字段相等的行。

----right join：返回包括右表中的所有记录和左表中联结字段相等的行。

----分页查询的用法：setFirstResult(num) 从num+1开始的数
setMaxResult(num) 到num+1结束的数
例如查询从id在4-7的内容：
----count(*) 用uniqueResult()返回Long型的数
String hql = select count(*) from Dept;
long count = (Long)session.createQuery(hql).uniqueResult();
-----delete from Dept d where d.id=7; update同理。

17 缓存详细解答：
1> 什么是缓存：缓存是数据库的数据在内存中的临时容器，它包含了库表数
据在内存中的临时拷贝，位于数据库和访问层之间。

2> Hibernate读取数据的顺序：先缓存，如果缓存中不存在，在发送SQL语句。

3> 数据缓存策略
----事务级缓存：当前事务范围内的数据缓存。

----应用级缓存：某个应用中的数据缓存。

4> 一级缓存：是事务级缓存，也叫session级缓存，一级缓存的数据结构是
Map，用于存储查询实体，Map.key存储的是实体的id，Map.value
存储的是实体本身，所以一级缓存无法存储查询的属性，一级
缓存属于内置的，每次建立session时候自动开启缓存。

它的生
命周期与session有关，是从session的创建到销毁为一个生命
周。

5> 二级缓存：
-----是sessionFactory级缓存，二级缓存可以被所有的session共享二级缓存的生命周期与sessionFactory的生命周期一致，可以利sessionFactory的
evict()等方法管理该缓存。

-----什么情况下可以考虑一下二级缓存：
----该对象被多个不同用户频繁使用。

----该对象更新操作不频繁。

-----提案二级缓存的方法：
A,添加ehcache.jar开发包和加入ehcache.xml配置到src下。

B,在hibernate.cfg.xml中开启二级缓存，指定供应商，
C,需要缓存那个对象，就在hibernate.cfg.xml中添加<class-cache>配置。

-----二级缓存只能缓存实体对象，不缓存属性。

get()，load()，iterate()方法读写，而list()方法只写不读二级缓存，
-----我们可以通过SessionFactory的evict()方法清除二级缓存中一个或一类对象，来达到禁止写二级缓存的效果。

例如：sessionFactory.evict(Dept.class,1)删除一个对象。

sessionFactory.evict(Dept.class)删除一类对象。

18二级缓存的案例
1> 测试list()方法的只写不读。

结果：两次发送的结果相同；
2> 测试iterate() 可以读写。

结果：只发出一条查询id的sql语句，第一次使用list()，把对象放到二级缓存中，第二次使用iterate()先发出查询id的sql语句，然后根据
Id在二级缓存中查找
3> iterate() 和list()如果对属性查询，控制台出现的查询结果一样;
list();
iterate();
结果：一样，因为二级缓存只能存储对象，不能存储属性，所以还需要发送SQL语句，到数据库中查找
4> load() 和get() 都可以读取二级缓存。

结果：
只查询一次，数据存储在SessionFactroy级了
5> 二级缓存的管理
结果：直查询两次
当用sessionFactory.evict(Dept.class)时候，结果：两次相同。

当用sessionFactory.evict(Dept.class,n)时候，结果：发出三条查询语句。

19查询缓存
1>由于一，二级缓存只能缓存单个对象，查询缓存可以缓存一个select结果，
它的生命周期是当关联表发生改变的时候，则生命周期结束。

2>查询缓存的使用：
---要对查询目标对象开启二级缓存。

---在Hibernate.cfg.xml中开启查询缓存设置。

---在执行query.list()之前，必须手动调用query.setCacheable(true);
3>在使用关联映射的时候，关系属性数据默认不参与缓存，即使访问对象在
缓存中存在，当访问该对象的关联属性时候还得去数据库中查询，如果需要缓存关联属性数据，需要在hibernte.cfg.xml中的<class-cache>设置一下。

4>适用情况：
----当不同用户执行相同的sql语句时候可以使用。

----查询结果集不发生改变的时候。

5> list()读写查询缓存，iterate()不读查询缓存。

list()
-----------------------------------------------------------------------------------------------
iterate()
6> 二级缓存和查询缓存一起使用效果更佳。

结果：
----二级缓存和查询缓存都开启时：
第一次使用list()，开启了二级缓存，将对象Dept放入二级缓存中，之后
开启了查询缓存，把Dept的id和其他属性都放入查询缓存中，第二次用到list()查询相同的Dept对象时候他先去查询缓存，拿着Dept对象的Id，根据id，去二级缓存中查出对象，没有发出SQL语句。

20 悲观锁和乐观锁
当出现多个用户同时执行更新操作时候，会出现事务交叉更新操作的冲突，会破坏业务中的数据的完整性，这时候可以使用乐观和悲观锁机制。

----悲观锁：使用极少，使用数据库底层机制实现的，在操作的整个过程中，只要事务不释放(commit()/rollback()),则任何用户都不能查看和修
改，并发性太差。

----乐观锁：采用数据版本控制(version)的方式,一般在数据库中加入一个
version字段。

当查询数据时候，该字段也同时查询出来，修改该
数据时候，version会自动加1,在修改数据时候，只有用户的版本
号高于该数据的版本号，才可以正常修改
----使用步骤：
1>首先在po实体类中添加version字段并且get()，set()方法。

2>在***.hbm.xml中class里面加入元素属性。

并且<id>
之后紧跟着<version>元素，
----配置文件：
21 Hibernate中的Criteria[标准] 英[kraɪˈtɪərɪə]----QBC (Query By Criteria)
---Hibernate设计了CriteriaSpecification作为Criteria的父接口，下面提供了
Criteria和DetachedCriteria的用法。

1> Criteria和DetachedCriteria主要区别在于创建形式不同，
---Criteria是在线的，所有它运用session进行创建。

sessionFactory.openSession().createCriteria(Class);
---DetachedCriteria是离线的，创建时候不需要session，而他提供了静态方法forClass(Class)进行实例的创建。

2>Criterion是Criteria的查询条件，其中可以编写代码：
(1)Criteria.add(Criterion criterion)的方法来添加查询条件。

Criteria.addOrder(Criterion criterion)的方法用来添加查询排序。

Criteria.setProjection(Projections.***)做单个统计。

Criteria.setProjection(Projections.projectionList.add(Projections.***)))
做多个统计。

(2)其中Criterion接口的主要实现包括Junction，SimpleExpression，而
Junction实际使用的是它的两个子类Conjunction和Disjunction，他们分别是使用and和or操作符来连接查询条件
(3)Restrictions工具类来创建Criterion。

Restrictions提供了大量的静态方法，
以下进行说明。

---SimpleExpression实例的创建：Restrictions的静态方法
eq()(等于)，gt()(大于)，ge()(大于等于)，lt()(小于)，le()(小于等于)，
and()，or()
between()，in()，like()，not()
isNotNull()，isNull()
Order.asc(“实体类的属性名”)升序，Order.desc(“实体类的属性名”)降序
以下是和like一起应用的：
MatchMode.EXACT—>字符串精确匹配
MatchMode.ANYWHERE—>字符串在中间匹配
MatchMode.START —>字符串在最前面的位置
MatchMode.END —> 字符串在最后面的位置。