粗浅看Struts2和Hibernate框架
[ 版权申明：本文系作者原创，转载请注明出处]
文章出处： http://blog.csdn.net/sdksdk0/article/details/52424578
作者：朱培 ID：sdksdk0 邮箱： zhupei@tianfang1314.cn
--------------------------------------------------------------------------------------------
struts2和hibernate分别都是框架是JavaEE中的三大框架之一，同时也是非常“老”的两个框架，现在很多已经转换为springMVC和mybatis来开发javaee应用了，既然sturts2和hibernate可以成为经典，那肯定还是有其存在的必要的，对于一些老的项目来说，如果我们要对其进行维护什么的，我们还是需要了解struts2和hibernate的用法什么的。从使用角度上面来说的话hibernate对于数据库的查询什么的还是有一定的不足之处的，虽然说写HQL语句更为简洁一点，但是其依然有瓶颈的。虽然慢慢的在一些新的项目中struts2和hibernate可能会用的很少或者被替换为其他的，但是其框架的思想还是对我们很有借鉴意义的！使用框架比以前直接用MVC模式的话，解耦合了很多，让程序更为健壮，从这个角度来说还是非常好的。一个设计良好的框架一般分为三层：（1）接口层，这一层要尽量使用interface，在这一层中你要考虑到你现在的、将来的可能支持的功能，但不需要去实现它，只定义到接口层次就可以了。如Struts中的插件接口PlugIn。（2）抽象层，这一层要针对你当前的需求做定制，对你的需求中的通用逻辑做实现。这一层应该出现大量的抽象类。如Struts中的ActionServlet、Action和ActionForm等类。（3）实现层，不用说了，把前面两层没有做掉的事情在这一层都做了吧。如Struts中后台实现的各种功能。
以下内容是struts2和hibernate的精华知识点，如果有哪个地方的知识还很模糊的话建议再去复习一下吧！
struts2篇
简介
Struts 是 Apache 软件基金会（Apache Software Foundation）资助的一个为开发基于MVC模式应用架构的开源框架，是利用Java Servlet和JSP、XML等方面的技术来实现构建Web应用的一项非常有用的技术，它也是基于MVC模式的Web应用最经典框架。
struts和struts2只是名字相似，没有其他关系。
给予spring AOP思想的拦截器机制，更易扩展。
struts2
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
struts2
/*
执行过程
动作类就是一个POJO,
实现Action接口，可以使用接口中定义的常量:
SUCCESS:一切ok，不返回任何的结果视图。
ERROR：出错了，服务器忙等。
INPUT：数据回显。
LOGIN：要求登陆。
动作类一般选择继承com.opensymphony.xwork2.ActionSupport。
可以使用Action接口中的常量，提供用户输入验证功能，消息国际化。
Action:定义一个动作， name：动作名称，对应用户的请求名称 class:框架要实例化的动作名称，全名称。 method:执行的动作类的方法，默认是execute。
动作类的动作方法调用。
DMI动态方法调用。 国际化、用户输入数据的校验。
常用常量 default.properties属性。
在动作类中使用servlrt。
ServletActionContext
通配符：适合有规律的。 多个struts.xml中用包含进来。 在动作类中访问servlet的API： ServletActionContext的静态方法、动作类实现ServletRequestAware接口，注入的方式传递进来的，由一个叫servletConfig的拦截器完成的。
结果视图： /success.jsp
dispatcher:转发到一个页面。默认
redirect:重定向到一个页面
chain:转发到另外一个动作
redirectAction:重定向到另外一个动作
结果视图
局部逻辑视图：服务于当前的动作。
局部逻辑视图
/success.jsp
/error.jsp
全局逻辑视图
/success.jsp
/error.jsp
自定义结果类型
封装参数
静态参数注入
原理：由一个叫做staticParams拦截器完成的。
动态参数注入
动作类作为模型对象，动作类中存储着用户输入的数据。
动作类处理用户请求，模型封装数据。
模型驱动
1、动作类和模型分开
由一个ModelDriven的拦截器完成的。
批量添加数据：
用户注册
封装数据的类型转换
用户输入的数据是字符串类型的，而实体bean有其他类型。 读数据。 DefaultTypeConverter
注册类型转换器： 局部类型转换器注册：针对属性 全局类型转换器：针对转换类型。
在属性所属类的包中，user.properties。
invalid.fieldvalue.birthday=The birthday must be yyyy-MM-dd
用户输入的校验
客户端校验，服务端校验。
动作类继承ActionSupport.
编程式校验：
针对动作类中的方法校验。 StringUtils.isBlank(user.getName()){
} 转换失败都会转向一个name=input的视图。
声明式校验：可插入式的校验。
针对所有方法：
针对某个动作进行校验：
<%@ taglib uri="/struts-tags" prefix="s"%>
OGNL表达式
对象图导航语言，struts2使用OGNL表达式做为默认的表达式语言。 支持普通对象的方法调用。
OGNL上下文
就是一个Map
根中的数据:
其他contextMap中的数据,
用户发出一次动作请求时，Struts2框架每次都会产生ActionContext对象（引用了contextMap），ValueStack对象，同时还会实例化动作类。
ActionContext和ValueStack
互相引用。
private Map context:contextMap
public Map getApplication():获取ServletContext中的所有Attributes
public Map getContextMap()：获取contextMap的引用
public Map getParameters()：获取请求参数的Map
public Map getSession()：获取HttpSession中的所有Attributes
public ValueStack getValueStack()：获得ValueStack对象的引用
public Object get(String key)：从contextMap中根据key获得对象
public void put(String key, Object value)：向contextMap中存放数据
ValueStack
setValue:以#存在contextMap中，不以#开头，相当于设置栈中对象的属性（从栈顶到栈底).
Struts2中的EL表达式
org.apache.struts2.dispatcher.StrutsRequestWrapper
${p}
${username}
标签库
循环遍历，类似于
取属性值：
value:ognl表达式。要遍历的数据 var:引用当前遍历的元素，放到了contextMap中。不是ognl表达式，是一个字符串. 如果不指定var，是把当前遍历的元素放到了根的栈顶。 status:引用一个对象，该对象记录着当前遍历的元素的一些信息.放在了contextMap中 int getIndex(); int getCount(); boolean isLast(); boolean isFirst(); boolean isOdd(); boolean isEven();
点击跳转：
点我啊！
动态包含
1、把OGNL当作普通字符串对待，要加单引号。 2、把字符串当作ONGL表达式，加上%{} 3、在xml配置文件和properties文件中，使用ONGL表达式,要加上${表达式}
UI标签和主题
在struts2中的jsp编写时尽量使用struts2的标签。
标签调查常用属性: 引入css类选择器.
主题默认使用的是xhtml. 支持： struts.ui.theme=xhtml struts.ui.templateDir=template
覆盖主题只需要在职介的项目中建立对应的目录结构，freemarker的语法。
更改默认主题： 添加theme="simple"
在form标签中制定主题
统一主题:
防止表单重复提交
1、尽量使用提交后重定向 2、令牌机制， 在表单中加入
配置token拦截器。
Hibernate篇
简介
hibernate是轻量级的JAVAEE应用的持久层解决方案，是一个关系型数据库ORM框架。 ORM：对象关系映射，对象：java中一切皆对象javaBean，关系：数据库中的表（二维表），映射：配置文件。
编写步骤
- 创建java项目
- 导入jar包
- 核心配置文件(hibernate.cfg.xml)
- javaBean +映射文件（ bena名称.hbm.xml),必须将映射文件加入到核心配置文件。
核心配置文件：
驱动、url、username、password、规范
com.mysql.jdbc.Driver
jdbc:mysql://localhost:3306/day15
zp
a
org.hibernate.dialect.MySQL5Dialect.class
映射文件： User.hbm.xml，和javabean同包。
配置javabena属性和表中字段的对应关系.
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)
事务操作
- 开启事务：beginTransaction()
- 提交事务： commit（）
- 回滚:rollback()
主配置文件
hibernate.cfg.xml 位置:src(classpath) ,在WEN-INF/classes目录下
true
true
update
none
thread
映射文件基本配置
insert="false" 表示生成insert语句没有当前字段 update="false" 表示生成update语句没有当前字段
在class中设置动态的添加和修改，默认是false，如果属性内容为空，则生成的sql中就没有该字段。
dynamic-insert="false" dynamic-update="false" 如果使用动态更新，数据必须是查询获得的。
派生属性
从数据库另一张表查询获得。 聚合函数：count(),max(),min(),avg(),sum()等。
sql语句：如果使用字段，默认从当前表中获得字段的，如果要获得B表字段，必须使用表的别名。
生成的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:OID属性名称
column：表字段列名
length:表字段长度
type:表字段类型
unsaved-value:save或update方法使用依据
String,默认是null,如果使用unsaved-value="abc" ，当执行save方法，设置“abc”相当之前null
generator:主键生成策略
increment:类型必须是整型，自己维护表的数据自动增长，在执行insert语句执行之前，先查询，查询最大值，加1，但是在高并发或集群中会有一定的问题。
identity:使用数据库底层的自动增长，auto_increment
sequence:oracle序列
hilo:采用高低位算法，不支持自动增长，也不支持序列
table ，设置数据库中，另一个表A的表名。
column，表A的列名
max_lo，一次操作多少条记录。100表示可以允许一次操作100条记录。
算法：max_lo * next_value + next_value
例如：
hi_value
next_value
100
非整型：
uuid:随机字符串32长度
assigned:自然主键，手动设置
持久对象状态
状态分类：
- 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图（关系实体图），开发时进行表之间的描述。
一对多
--
一对多： 多方必须维护外键信息，如果一方没有OID值，将触发update语句， 一方默认对外键信息进行维护，一方将放弃对外键的维护 在Customer.hbm.xml中，加入
inverse="true"
级联操作
级联保存或更新
save-update:A关联瞬时态B，当保存A时，自动将瞬时态的B转换成持久态B
cascade="save-update"
级联删除：
删除客户的时候删除订单： 删除后台执行的语句：
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=?
孤儿删除
解除关系之后，那个表外键设置null,从表记录就是孤儿，一并进行删除，解除关系时，一并删除订单，但是客户还是存在的。
多对多
--
操作
两个对象不用同时对中间表进行维护，所以需要在多对多中有一方配置放权。
inverse="true"
级联保存 直接保存即可。
双向级联删除
Student.hbm.xml
*
* Course.hbm.xml
*
集成log4j
hibernate使用的是slf4j日志框架。
组件映射
通过面向对象角度，使用设计模式，将数据都抽取到一个对象中，将多个对象组合在一起，达到重复利用的目的。
必须确定组合javabean类型，每一个对象属性必须在表中都存在独有列名。
继承映射
继承方式1：sub-class 所有内容保存一张表，给表提供标识字段，每一个子类都具有独有的字段。
继承方式1：
继承方式2：
继承方式3： 将生成多张表，彼此之间没有关系，但主键值逐渐增强，需要hiberate自动维护三张表之间的主键唯一，存在并发问题。
抓取策略
检索方式
立即检索：在执行查询之后，立即执行select语句进行查询
延迟检索：在执行查询方法之后，没有进行查询，底层生成代理对象呢，直到需要相应的数据，在进行查询。 除OID之外的值，关联的数据
检索类型
类别级检索：当前对象所有属性值。，查询当前类的所有内容，只查询一次，优化指查询时机优化。
关联级检索：当前对象关联对象数据。
多对一，一对一：共同特点都拥有一方
一对多、多对多
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 allCustomer=sqlQuery.list();
//QBC
Criteria criteria=session.createCriteria(Customer.class);
List allCustomer=criteria.list();
//List 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 allCustomer=(List) session.createQuery("from Customer c order by c.cid ").list();
//sql
//List allCustomer=(List) session.createSQLQuery("select * from t_customer order by cid desc").addEntity(Customer.class).list();
//QBC
List allCustomer=(List) session.createCriteria(Customer.class).addOrder(org.hibernate.criterion.Order.asc("cid")).list();
for (Customer customer : allCustomer) {
System.out.println(customer);
}
查询部分内容（投影）
hql,默认查询部分将查询结果封装到object数组中，需要封装到指定的对象中，投影查询的结果是脱管态的。
List allCustomer=(List) session.createQuery(" select new Customer(cid,name) from Customer ").list();
//sql
//List allCustomer=(List) session.createSQLQuery("select cid,name from t_customer ").addEntity(Customer.class).list();
//QBC
List 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 allCustomer=session.createQuery("from Customer").setFirstResult(0).setMaxResults(2).list();
//sql,必须将查询结果封装到相应的对象中
//List allCustomer=session.createSQLQuery("select * from t_customer").addEntity(Customer.class).setFirstResult(0).setMaxResults(2).list();
//QBC
List 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();
连接查询
- 内连接：[inner] join
- 左外连接： left [outer] join
- 右外连接： right [outer] join
- 迫切左外连接： left [outer] join fetch
- 迫切内连接： [inner]join fetch
左外连接,将每一条查询结果封装到Customer 和Order对象，然后创建 new Object[2]{c,o} 。将所有的数组 存放到另一个数组返回
List allCustomer=session.createQuery("from Customer c left outer join c.orderSet ").list();
迫切左外连接，将所有的查询结果封装Customer和Order对象，然后将Order 添加到 Customer(customer.getOrderSet().add(order)) ,最后返回Customer对象集合
List allCustomer=session.createQuery("select distinct c from Customer c left outer join fetch c.orderSet ").list();
命名查询
将HQL语句存放到配置文件中，之后不需要修改java源码，服务器tomcat重启即可。
全局：可以直接获得，在。hbm.xml文件中配置。与class同级之后
from Customer
使用：
List allCustomer=(List )session.getNamedQuery("findAllCustomer").list();
局部：必须通过包名获得
from Customer
使用：
List allCustomer=(List )session.getNamedQuery("cn.tf.init.Customer.findAllCustomer2").list();
常用配置
整合c3p0
org.hibernate.connection.C3P0ConnectionProvider
事务
一组操作，要么全部成功，要么全部失败。 特性：ACID，原子性，一致性，隔离型，持久性
脏读，不可重复读，虚读
4
丢失更新 lost update
两个人都在同时进行数据更新，后面讲前面的数据进行覆盖。
乐观锁：丢失更新肯定不发生：在表中提供一个字段（版本字段），如果版本一致可以提交，如果不一致不进行提交。
悲观锁：丢失更新肯定发生，采用mysql数据库的锁机制。读锁：共享锁，多个人可以一起读。 写锁：排它锁，
二级缓存
介于应用程序和永久性数据存储源之间，其作用是降低应用程序直接读写永久性存储源的频率，从而提高应用的运行性能，其物理介质是内存。
如果缓存不够用，可以将缓存写到文件中。
二级缓存
一级缓存，hibernate实现了，必须使用的。是用户自己共享数据。
二级缓存：SessionFactory级别的缓存，hibernate提供了规范（接口），如果需要使用必须有实现类，用户之间共享数据，
SessionFactory缓存： 内置缓存：自带的，不可卸载 外置缓存：二级缓存，需要配置
类缓存、集合缓存、时间戳、查询缓存。
并发访问策略：read-write、read-only
很少修改的，不重要的数据适合放入二级缓存中，允许偶尔的并发问题。
配置
1、导入jar包 2、开启二级缓存 3、确定提供商 4、确定需要缓存的内容 5、第三方配置文件
true
org.hibernate.cache.EhCacheProvider
true
true
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 allCustomer = session1.createQuery("from Customer").setCacheable(true).list();
ehcache.xml配置
确定缓存内容的硬盘位置：
性能检测
二级缓存监测 ，先需要在配置文件中配置
true
Statistics statistics = factory.getStatistics();
撞击数：
statistics.getSecondLevelCacheHitCount()
丢失：
statistics.getSecondLevelCacheMissCount()
总结：软件系统发展到今天已经很复杂了，特别是服务器端软件，设计到的知识，内容，问题太多。在某些方面使用别人成熟的框架，就相当于让别人帮你完成一些基础工作，你只需要集中精力完成系统的业务逻辑设计。而且框架一般是成熟，稳健的，他可以处理系统很多细节问题，比如，事物处理，安全性，数据流控制等问题。还有框架一般都经过很多人使用，所以结构很好，所以扩展性也很好，而且它是不断升级的，你可以直接享受别人升级代码带来的好处。框架一般处在低层应用平台（如J2EE）和高层业务逻辑之间的中间层。
struts2案例： 员工信息管理系统：https://github.com/sdksdk0/PMSystem
整合案例：贴吧：https://github.com/sdksdk0/TieBa