您的位置:首页 > 编程语言 > Java开发

粗浅看Struts2和Hibernate框架

sdksdk09o0 2016-09-03 19:08 82 查看
----------------------------------------------------------------------------------------------
[版权申明:本文系作者原创,转载请注明出处]
文章出处: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思想的拦截器机制,更易扩展。

<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

执行过程

动作类就是一个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:重定向到另外一个动作

结果视图

局部逻辑视图:服务于当前的动作。

<action name="action1" >
局部逻辑视图
<result name="success">/success.jsp</result>
<result name="error">/error.jsp</result>
</action>

全局逻辑视图

<global-results>
<result name="success">/success.jsp</result>
<result name="error">/error.jsp</result>

</global-results>

自定义结果类型

封装参数

静态参数注入

原理:由一个叫做staticParams拦截器完成的。

动态参数注入

动作类作为模型对象,动作类中存储着用户输入的数据。

动作类处理用户请求,模型封装数据。

模型驱动

1、动作类和模型分开

由一个ModelDriven的拦截器完成的。

批量添加数据:

用户注册

封装数据的类型转换

用户输入的数据是字符串类型的,而实体bean有其他类型。 读数据。 DefaultTypeConverter

注册类型转换器: 局部类型转换器注册:针对属性 全局类型转换器:针对转换类型。

<s:fieldError /> 或者<s:actionError />

在属性所属类的包中,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"%>

<s:form action="regist"><!-- 自动加应用名称,method默认是post。自动加动作的扩展名。自动数据回显。写起来很方便 -->
<s:textfield name="username" label="用户名" requiredLabel="true" requiredPosition="left"></s:textfield>
<s:password name="password" label="密码"></s:password>
<s:radio list="#{'0':'女','1':'男'}" name="gender" label="性别"></s:radio>
<s:textfield name="birthday" label="生日"></s:textfield>
<s:textfield name="email" label="邮箱"></s:textfield>
<s:submit value="注册"></s:submit>
</s:form>

OGNL表达式

对象图导航语言,struts2使用OGNL表达式做为默认的表达式语言。 支持普通对象的方法调用。

<s:property  value="'abcdf'.length()"/> <br />
<s:property  value="'abcdf'.charAt(2)"/> <br />

<s:property  value="@java.lang.Integer@MAX_VALUE"/> <br />
<s:property  value="@java.lang.Math@abs(-100)"/> <br />

<!-- 创建List或者Map对象 -->
<s:radio  list="{'男','女'}"  name="gender"  label="性别"  /><br />

<s:radio list="#{0:'女',1:'男' }"   name="姓名"></s:radio>

OGNL上下文

就是一个Map<String,Object>数据的中心,每次动作的请求,struts2框架都会为每个线程创建一个OGNL上下文对象,存放了所有的有关数据.

根中的数据: <s:property value="username" />username是一个OGNL表达式,搜索根中所有对象的username属性,直到找到为止。

其他contextMap中的数据, <s:property value="#session" />

用户发出一次动作请求时,Struts2框架每次都会产生ActionContext对象(引用了contextMap),ValueStack对象,同时还会实例化动作类。

ActionContext和ValueStack

互相引用。

private Map<String, Object> context:contextMap
public Map<String, Object> getApplication():获取ServletContext中的所有Attributes
public Map<String, Object> getContextMap():获取contextMap的引用
public Map<String, Object> getParameters():获取请求参数的Map
public Map<String, Object> 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

<s:property value="#session.p"/><br/>
${p}<br/>
<hr/>
<s:property value="username"/><br/>
${username}

标签库

循环遍历,类似于<c:forEach >

<s:iterator value=""></s:iterator>

取属性值: <s:property value="#status.index"/>

value:ognl表达式。要遍历的数据 var:引用当前遍历的元素,放到了contextMap中。不是ognl表达式,是一个字符串. 如果不指定var,是把当前遍历的元素放到了根的栈顶。 status:引用一个对象,该对象记录着当前遍历的元素的一些信息.放在了contextMap中 int getIndex(); int getCount(); boolean isLast(); boolean isFirst(); boolean isOdd(); boolean isEven();

点击跳转:

<s:a action="action1" >点我啊!</s:a>

动态包含

<s:action name="action1"  executeResult="false"></s:action>

1、把OGNL当作普通字符串对待,要加单引号。 2、把字符串当作ONGL表达式,加上%{} 3、在xml配置文件和properties文件中,使用ONGL表达式,要加上${表达式}

UI标签和主题

在struts2中的jsp编写时尽量使用struts2的标签。

标签调查常用属性: 引入css类选择器. <s:textfield cssClass="odd" cssStyle="" name="" />

<s:form  action="" >
<s:textfield name="username"  label="用户名"  requiredLabel="true"></s:textfield>
<s:password name="password"  label="密码"  requiredLabel="true"></s:password>
<!-- 多选框 -->
<s:checkboxlist name="hobby"  list="{'吃饭','睡觉','逗你玩'}"></s:checkboxlist>
<s:radio  name="gender" list="#{1:'男',0:'女' }"   value="1"  label="性别"></s:radio>
<s:select  name="city"   label="城市"   list="#{'HY':'衡阳','CS':'长沙' }"     value="'HY'" headerKey="-1"headerValue="--请选择--" ></s:select>
<s:textarea  name="des"   label="描述"></s:textarea>
<s:submit  value="保存" ></s:submit>
<s:reset  value="重置"></s:reset>
</s:form>

主题默认使用的是xhtml. 支持: struts.ui.theme=xhtml struts.ui.templateDir=template

覆盖主题只需要在职介的项目中建立对应的目录结构,freemarker的语法。

更改默认主题: 添加theme="simple"

<s:submit  value="保存"   theme="simple"></s:submit>

在form标签中制定主题

统一主题:

<constant name="struts.ui.theme" value="simple"></constant>


防止表单重复提交

1、尽量使用提交后重定向 2、令牌机制, 在表单中加入 <s:token></s:token>

配置token拦截器。

<interceptor-ref name="defaultStack"></interceptor-ref>
<interceptor-ref name="token"></interceptor-ref>


<interceptor-ref name="defaultStack"></interceptor-ref>
<interceptor-ref name="tokenSession"></intercep


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)

事务操作

开启事务:beginTransaction()

提交事务: commit()

回滚: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="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
例如:
<generator class="hilo">
<param name="table">hi_value</param>
<param name="column">next_value</param>
<param name="max_lo">100</param>
</generator>

非整型:
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图(关系实体图),开发时进行表之间的描述。

一对多

<!--  一个客户拥有多个订单,一对多
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="员工">
<id  name="eid">
<generator class="native"></generator>
</id>

<discriminator column="etemp"></discriminator>

<property name="name"></property>

<subclass  name="cn.tf.inherit.subclass.SalaryEmployee"  discriminator-value="正式员工">
<property name="salary"></property>
</subclass>
<subclass  name="cn.tf.inherit.subclass.HourEmployee"  discriminator-value="小时工">
<property name="rate"></property>
</subclass>

继承方式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();

连接查询

内连接:[inner] join

左外连接: left [outer] join

右外连接: right [outer] join

迫切左外连接: left [outer] join fetch

迫切内连接: [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
标签: