Java框架学习笔记

开发基于 Struts/Hibernate/Spring/Ajax 的网上信息发布平台
第一章：框架技术概述 ........................................................................................................................................... 1 第二章：Struts 原理（一） ..................................................................................................................................... 1 第三章：Struts 原理（二） ..................................................................................................................................... 4 第四章：Struts 标签库 ............................................................................................................................................. 5 第五章：使用 Hibernate 完成对象持久化 .............................................................................................................. 6 第六章：Hibernate 的关系映射............................................................................................................................... 9 第七章：Hibernate 查询........................................................................................................................................... 9 第八章：使用 Spring 管理对象 ............................................................................................................................. 13 第九章：Spring 与 Sturts、Hibernate 的集成 ....................................................................................................... 15
第一章： 第一章：框架技术概述
1．SSH：即 Struts+Spring+HiberNate. 2．DWR: 一个 Ajax 框架 3．三层结构的命名规则 层 表示层 业务逻辑层 数据访问层 实体对象 Java 中的命名规则 包括 JSP 页面和对应的后台 Servlet（或 Struts 的 ActionBean 和 FormBean 代码） ，放在 Web 包下 放在 biz 包下，类名（或接口名）后缀为 Biz。 放在 dao 包下，类名后缀为 DAO 放在 entity 包下 命名空间后缀为 BLL 命名空间后缀为 DAL 命名空间后缀为 Models .Net 中的命名规则
第二章： 原理（ 第二章：Struts 原理（一）
1．基于 Struts 开发的应用由 3 类组件构成：控制器组件、模型组件和视图组件 控制器组件：包括一个 ActionServlet，是 Struts 的核心控制器，还包括自定义的 Action 类（代表用户的一 控制器组件 个操作，比如登录或注册） ，自定义的 Action 类继承自 Struts 提供的 org.aptech.struts.action.Action。 模型组件：并不由 Struts 提供，一般由普通的接口和 JavaBean 充当。需要我们自己编码实现。 模型组件 视图组件：一般由 JSP 实现，还包括自定义的 ActionForm 类和 Struts 标签。自定义的 ActionForm 类用于 视图组件 封装 request 中的数据。Struts 可以将 request 中的数据自动填充到 ActionForm 类中。自定义的 ActionFrom 类继承自 org.aptech.struts.action.ActionForm.. ActionServlet 在系统启动的时候加载 struts-config.xml 配置文件。该文件包含与 Action、ActionForm、页面 转向等相关的配置。 2．添加到项目中的步骤 (1)将 Struts 添加到项目中（将 lib 目录下的库文件添加到项目，其中 jar 文件复制到/WEB-INF/lib 下，其他 文件复制到/WEB-INF 下）

(2)在/WEB-INF 下创建 structs-config.xml（内容见后面） (3)在 Web.xml 中正确配置 ActionServlet。配置如下： （Struts 支持多个配置文件）
action org.apache.struts.action.ActionServlet config /WEB-INF/struts-config.xml 0 action *.do
注：配置访问路径时可以使用通配符，常用的有*.do, /action/*,
*.action
3．ActionForm（自定义的表单对象）继承自框架的 ActionForm 类，为提交的表单中所有字段的实体类， 其中各个属性的名字要与表单中相应控件 name 相同，以便于 Struts 自动封装到 ActionForm 中。 4．Action（自定义的动作处理对象）继承自框架的 Action 类，每个 Action 都应该重写一个 execute 方法， 方法签名如下：
public class AddAction extends Action { private Calculator biz=new Calculator(); //处理对象 public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { ActionForward af=null; AddForm addForm=(AddForm)form; //调用业务对象方法 double resultData=biz.add(addForm.getNum1(), addForm.getNum2()); request.setAttribute("resultData", resultData); //将数据模型存储到request中 af=mapping.findForward("result"); return af; } } //将请求转发逻辑名为"result"的页面 //获取表单参数
5．在 structs-config.xml 中配置 FormBean 和 Action，示例如下：

注：ActionForm（即 FormBean）的配置较简单，只需指定 name 和 type 属性。Action 配置较多，具体如下： name 属性指定关联的 ActionForm 的 name。 path 属性指定访问这个 Action 的路径，以“/”开头，注意不需要加“.do”。 type 属性指定这个 ActionBean 的类名 scope 属性定义这个 Action 对应的 ActionForm 的作用域 节点定义了该 Action 可能转发到的页面，对应每一个页面都有一个逻辑名，在 Action 代码 中，我们只允许通过逻辑名引用到将要转发到的页面，不可以直接使用物理名。 提醒：form 提交的地址依然是 add.do。从表单对象中可以取出操作数${requestScope.addForm.num1} 使用 Struts 开发步骤总结： 首先将 Struts 加入到项目中。 开发时， 首先创建对应的 ActionBean 和 FormBean， 6． 在 struts-config.xml 中进行配置，得到这个功能的框架代码；然后在 Action 的 execute 方法中编码，通过 FormBean 得到页面提交的参数， 调用业务逻辑方法 （Model 部分） 接着将业务逻辑执行结果保存在 request ， 对象的 attribute 属性中，再选择返回的页面。最后调试运行是否正确。 7．Struts 运行过程，如下图： （注意，ActionServlet 采用的是转发方式，如果需要使用重定向的方式，可以 在 Action 中使用 response.sendRedirect(url)语句，并返回 null。
8．在仅仅进行页面转向时，可写一个转向的 Action，不必配置它的属性，而是在 Action 中直接 根据 ForwardForm 传递过来的 page 直接 new 出一个新的 ActionForward 对象。

第三章：Struts 原理（二） 原理（
1．DispatchAction（可完成多种业务操作） 继承自 DispatchAction 的 Action 类中不必定义 execute 方法，而是创建一些实现实际业务的方法，如 doAdd()、doSubtract()等，但这些方法的参数和返回值要和普通 Action 的 execute 方法相同。 在配置中多加一项 parameter=”operate”。operate 为客户请求中提交上来的参数。该参数应该在客户端 的隐藏域中，其 value 应该对应于相应的 DispatchAction 中的处理方法的名称。 （参数值是什么，就执行什 么方法） 在项目中一般用 Dispatch 把相关的操作组织到一起，放到一个 ActionBean 中。 2．命名规范 在 DispatchActionBean 中，方法名称的前缀也应遵循一定的规则。toXxx 表示转到 Xxx 页面，doXxx 表示执行 Xxx 操作。如转到编辑页面用 toEdit，执行编辑操作用 doEdit。 3．Struts 的错误处理机制 步骤：编辑“属性文件”;修改对应 Action 代码;在页面上显示报错信息。 （1） 在 项 目 中 增 加 一 个 ApplicationResources.properties 资 源 文 件 （ 国 际 化 可 以 再 增 加 一 个 ApplicationResources_zh_CN.properties） 。其内容如下：
#ApplicationResources.properties errors.header= errors.footer= error.validate.number=Divisor cannot be 0.
（2） 在 struts-config.xml 中配置。配置方法如下： （3） 修改 Action 代码
public ActionForward doDivide(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { CalcForm calcForm=(CalcForm)form; ActionMessages errors=new ActionMessages(); if (calcForm.getNum2()==0) errors.add("error2",new ActionMessage("error.validate.number")); if (!errors.isEmpty()) { super.saveErrors(request, errors); } double result=biz.divide(calcForm.getNum1(), calcForm.getNum2()); request.setAttribute("resultData", result); return mapping.findForward("result"); } //将错误信息保存到请求中 return mapping.findForward("input");

（4） 在页上显示报错信息
<%@ taglib uri="/WEB-INF/tld/struts-html.tld" prefix="html" %>
小技巧：可以通过设置 errors.header 和 errors.footer 来设置弹出 JS 对话框提示错误，配置如下：
#ApplicationResources.properties errors.header= error.validate.number=\u9664\u6570\u4E0D\u80FD\u4E3A0\u3002
4．DynaActionForm（动态 Form） 在 struts-config.xml 中直接定义 FormBean

使用方法：Action 中
DynaActionForm calcForm=(DynaActionForm)form; int num1=(Integer)calcForm.get("num1"); int num2=(Integer)calcForm.get("num2");
注意：此时在页面中取出 num1 的值的语法应该是${ calcDynaForm.map[“num1”]} 5．使用实体对象作为 Form 属性 在 ActionForm 中引用一个实体类对象，并提供其 getter/setter 方法，如下：
public class CalcForm extends ActionForm { private Nums nums=new Nums(); //getter/setter省略 }
在提交表单的页面中，将相应表单元素的 name 属性改为 nums.字段名，如下：
在显示结果的页面中：${calcForm.nums.num1}
第四章：Struts 标签库
常用的 Struts 标签有三类：html 标签、logic 标签、bean 标签（同 EL 一样，要先进行声明） 1． html 标签主要用来“绑定”数据。示例：

查询 不限--
注：表单中 action 与配置文件中的 path 须相同。在中，name 表示查找属性 qxList,找
到后，将 qx 设为 option 的内容，qxid 设为 option 的 value.(以上内容均可自动绑定)
2． logic 标签（用来处理业务逻辑） 当 session 中找不到 user 属性或者其值为 null 时，此内容不可见 小结：关于 name, property, scope 属性的意义？ 这三个属性定义该标签如何获取自身的值，而且是组合生效的。 name 指定所用的 Bean 名称， property 指定使用的是 Bean 中的哪个属性 （省略则取 Bean 本身的值） ，scope 指定所查找 Bean 的作用域
//会先取出zfxx.uid属性的值，与value中的值作比较。相等时执行当中的代码。value可以是常量，jsp 表达式或EL表达式 [编辑][删除] 迭代标签（与类似：其中 name 类似于 items，id 类似于 var）
3． bean 标签 可对数字和日期进行格式化。

(相当于定于一个变量 dataList，取出 request 中的 list，赋值给 dataList) 后面可以在页面中使用<%=dataList.size() %> (获取一个集合中记录的数目)
共找到${count }条记录
第五章：使用 Hibernate 完成对象持久化
ORM（O/R Mapping）：对象/关系映射机机制 1．使用 Hibernate 的准备：

(1)添加 jar 包(暂不配置数据库连接) (2)配置 Hibernate 配置文件(项目 src 目录下添加 hibernate.cfg.xml)


jdbc:sqlserver://localhost:1433;databaseName=HouseDB com.microsoft.sqlserver.jdbc.SQLServerDriver sa sodi org.hibernate.dialect.SQLServerDialect

true


(3)实体类和映射文件（其中实体类需要实现 Serializable 接口，且有默认构造方法），映射文件示例如下：

在映射文件中， 每个节点配置一个实体类的映射信息， 其中的 name 对应实体类的名字， table 对应数据库中相应的表名。 每个下面，有一个必须的节点，用于定义实体的标识属性，对应数据库表的主键。的 name 属性对应实体的属性名，type 对应该属性的类型。 下有两个子节点，其中为该属性对应的数据库表中名称为 name 属性值的字段。 节点用于指定主键的生成策略，常用的值有”native”和”assigned”，其中前者表示由数据库生成 主键的值，后者表示在添加新记录到数据库前由程序设定主键的值。 节点对应数据库表中的其他字段，属性与类似，只是不能包含节点。 2．使用 hibernate 持久化的代码操作步骤 步 骤 1 操作 代码 Configuration conf=new Configuration().configure(); SessionFactory sf= conf.buildSessionFactory(); Session session=sf.openSession(); Transaction tx=session.beginTransaction(); session.save(user); https://www.360docs.net/doc/603192497.html,mit(); session.close(); 与 JDBC 类比 相当于使用 DataSource 获 取 连 接 前 读 取 DataSource 的配置文件 相当于创建 DataSource 对象 相当于 JDBＣ获得连接 开始事务 持久化操作 提交事务 关闭连接
读取并解析配置文件 读取并解析映射信息， 创建 SessionFactory 打开 session 开始一个事务(增删改操 作必须，查询操作可选) 持久化操作 提交事务 关闭 session
2 3 4 5 6 7
3．用 Hibernate 实现数据的删改：（增删改一定要在事务环境中完成） 数据的加载：(User) user=(User)session.get(User.class, id); //即根据主键将一条数据查出来 数据的修改：先加载，再修改。如下 (User) user=(User)session.get(User.class, id); user.setUname(“新名字”); session.update(user); 数据的删除： (User) user=(User)session.get(User.class, id); session.delete(user); 4．本章重点：三个准备，七个步骤。使用 Eclipse 工具可以简化“三个准备”，提取重复代码到基类可以简 化“七个步骤”（注：实体类中字符串初始值需为 null，否则在查找时会出现找不到的情况）

第六章： 第六章：Hibernate 的关系映射
1．单向多对一关系映射（在实体类中，外键字段应该直接声明成一个主表类型的属性，如 private Qx qx;） 配置映射时该属性应写为: 其中 name 为 Jd 类的属性名，column 为映射到表 TBL_JD 中的字段名，class 为关联到的主表的类别。 2．单向一对多关系（在实体类中，Qx 类中应声明成 private Set jds=new HashSet();）（不是很常用） 映射配置： //对应 Qx 类中的 jds 属性 //对应”多”的一方的外键字段名（即 TBL_JD 中的 qxid 字段） 在配置节点时，有一个 inverse(反转)属性（可选）,表示是否由对方（多的一方）管理双方的关联 关系，为 true 时由多方管理，为 false 时自己管理双方的。一般为 true。 cascade(级联)属性：主表操作时是否级联操作其子表。可选值包括：all，对所有的操作都进行级联； none，对所有的操作都不级联；save-update，执行更新操作时级联；delete，执行删除操作时级联。 3．双向一对多关系：与一对多类似，不过只有双向关联时才需要配置 inverse 和 cascade。 4．双向多对多关系：与双向一对多类似，需在一方中设置 inverse 和 cascade。 如：查看项目的开发人员和查看每个人员参予的项目。配置如下：

5．补充：关于外键关系的引用。只有在使用的时候才会查询，所以在加载所有需要的属性之前，不可以 关闭 Session(尚未有完善的思路)
第七章 第七章：Hibernate 查询
Hibernate 支持两种主要的查询方式：HQL 查询和 Criteria 查询。其中前者是重点。

Hibernate 的查询结果是直接存放在 List 中的对象，不需要再进行封装。 HQL 中没有表和字段的概念，只有类、对象和属性 1．使用 HQL 查询的步骤：得到 session——编写 HQL 语句——创建 Query 对象——执行查询，得到结果。 如下例：
Session session=super.getSession(); String hql="FROM TblZfxx"; List list=query.list(); //得到 session //编写 HQL 语句 //招待查询,得到结果
Query query=session.createQuery(hql); //创建 Query 对象
注： 上面的 HQL 语句中， TblZfxx 不是表名， 而是类名 （区分大小写） 也可以定成”com.jb.entity.TblZfxx”； ， FROM 关键字不区分大小写；HQL 语句可以省略 Select 子句，TblZfxx 也可以用 as 指定别名(as 可省略)， 如以上语句可以写成"Select zf FROM TblZfxx as zf"，此语句表示查询所有的住房信息，以 TblZfxx 列表的 方式返回。 2．HQL 的丰富功能 HQL 的 where 子句支持的运算符有：>, <, >=, <=, <>, =, is null, and, or, not, in, between, 括号。 (1)属性查询 （只查询对象中的某几个属性， 查询数据还是保存在 List 中， 不过每行数据为一个 Object 数组） 。 示例如下：
Session session=super.getSession(); String hql="Select zf.date,zf.title FROM TblZfxx zf"; Query query=session.createQuery(hql); List list=query.list(); super.closeSession(); for (Object[] obj : list) { System.out.println(obj[0]+"\t"+obj[1]); }
(2)参数查询（条件查询，支持 where 子句、like 和”%”）(如果使用拼接时好像会出现乱码)，参数查询也支 持类似于 PreparedStatement 的方式（参数下标从 0 开始）。如下：
Session session=super.getSession(); Query query=session.createQuery(hql); query.setString(0, "%房子%"); List list=query.list(); super.closeSession(); //得到session String hql="FROM TblZfxx zf where zf.title like ?";
也可以使用命名参数查询（可以增强可读性，HQL 语句中的变量名为占位符）：
//根据租金范围查询房屋信息 public void testQueryByZj(int zj1,int zj2) { Session session=super.getSession(); Query query=session.createQuery(hql); query.setInteger("zj1", zj1); query.setInteger("zj2", zj2); List list=query.list(); super.closeSession(); //得到session String hql="FROM TblZfxx zf where zf.zj between :zj1 and :zj2";

printZfxxList(list); }
(3)关联查询(类似于表联接查询)
//查询某个联系人所拥有的房屋所在的街道信息 查询某个联系人所拥有的房屋所在的街道信息 public void testAssociatedQuery(String lxr) { Session session=super.getSession(); Query query=session.createQuery(hql); query.setString(0, lxr); List list=query.list(); printJdList(list); super.closeSession(); } //得到session String hql="select jd From TblJd jd,TblZfxx zf where zf.tblJd=jd and zf.lxr like ?";
(4)分页查询
//分页查询 public List search(int pageNo, int pageSize) { Session session=super.getSession(); Query query=session.createQuery(hql); query.setFirstResult((pageNo-1)*pageSize); query.setMaxResults(pageSize); List list=query.list(); super.closeSession(); return list; } //得到session String hql="FROM TblZfxx zf order by zf.zj asc";
注：query.setFirstResult(从第几条记录开始)；query,setMaxResults(共返回多少条数据) (5)统计函数。包括 min(),max(),count(),avg(),sum()。 当查询结果只有一条时，我们可以用 query.uniqueResult()方法直接获得结果。如下：
String hql="select sum(zf.zj) from TblZfxx zf"; Query query=session.createQuery(hql); double count=(Double)query.uniqueResult();
综合示例：下图中，fw.lx.lxid 只有在面向对象的查询中才可以这样使用.

3．Criteria 查询 步骤：创建 Criteria 对象——用 Restrictions 对象的静态方法（like,ge,le,in 等）构造查询条件，并添加 进 Criteria 对象——通过 Criteria 的 addOrder()方法指定查询的排序方式（也支持分页查询）。 注：c.add(Restrictions.like("title", condition.getTitle(), MatchMode.ANYWHERE)); 其中第一个参数是属性名，第二个参数是属性的值，第三个参数是关键字匹配模式，可选的有 MatchMode.ANYWHERE, MatchMode.END, MatchMode.START, MatchMode.EXACT(精确查询)。如下例所 示：
//根据条件查询 public List search(TblZfxx condition) { Criteria c=super.getSession().createCriteria(TblZfxx.class); if (condition != null) { if (condition.getTitle()!=null && !condition.getTitle().trim().equals("")) { c.add(Restrictions.like("title", condition.getTitle(), MatchMode.ANYWHERE)); } if (condition.getZj1() != 0) { c.add(Restrictions.ge("zj", condition.getZj1())); } if (condition.getZj2()!=0) { c.add(Restrictions.le("zj", condition.getZj2())); } //下面的问题没有解决掉（异常：不能解析tblFwlx.fwlx）

if (condition.getFwlxs().size()>0) { c.add(Restrictions.in("tblFwlx.fwlx", condition.getFwlxs())); } } c.addOrder(Order.asc("zj")); List list=c.list(); super.closeSession(); return list; } //指定排序属性
第八章：使用 Spring 管理对象
Spring 组成部分：Spring Core，Spring AOP，Spring DAO，Spring Context，Spring Web MVC，Spring ORM， Spring Web 1．Spring 依赖注入的步骤：添加 Spring 支持——编写 Bean 配置文件——在代码中使用。 其中，配置文件如下：（另外，在定义引用时一般引用的是接口）

注：Bean 中注入 property 的地方在类中需要有相应的 setter 方法。在节点中，value 属性用于注 入基本类型的值。ref 属性用于注入已经定义好的 Bean。 在代码中引用 Bean 的方法

ApplicationContext context=new ClassPathXmlApplicationContext("di.xml"); Printer printer=(Printer)context.getBean("printer");
2．Spring AOP(面向方面编程)：独立编写业务逻辑代码和方面代码，在系统运行时，再将方面代码“织入” 到系统中。 实现特定功能的方面代码在 AOP 概念中称为“通知(Advice)”，分为前置通知、后置通知、环绕通知和 异常通知。 前置通知是在方法执行之前自动执行的通知；后置通知是在方法执行之后自动执行的通知；环绕通知 能力最强，可以在方法调用前执行通知代码，可以决定是否还调用目标方法；异常通知是方法抛出异常时 自动执行的方法。 3．实现 AOP 的步骤：编写业务代码——编写方面代码（实现相应的接口）——配置 aop.xml 文件（示例 见 后 面 ） —— 将 方 面 代 码 织 入 到 业 务 对 象 中 ， Spring 会 将 原 Bean 和 方 面 都 封 装 到 org.springframework.aop.framework.ProxyFactoryBean 类别中。用户使用时通过代理类访问原 Bean. 前置通知要实现 MethodBeforeAdvice 接口，该接口实现一个方法：
public void before(Method m, Object[] args, Object target) throws Throwable; “织入”代理Bean的配置文件： com.bookshop.aop.BookBiz logAdvice
注：首先定义原Bean“bookBizTarget”和“logAdvice”；定义代理类，名为“bookBiz”，我们将通过这个 Bean访问业务方法。 代理类有三个必须设置的属性：proxyInterfaces，表示被代理的接口；interceptorNames，表示织入的通 知列表；target，表示被代理的原Bean。 4．调用方法：如下：
ApplicationContext context=new ClassPathXmlApplicationContext("aop.xml");

BookBiz bookBiz=(BookBiz)context.getBean("bookBiz"); bookBiz.buy("高志水", "CMMI使用手册", 50); https://www.360docs.net/doc/603192497.html,ment("王筝", "《盗墓笔记》一点都不恐怖，很好看！");
第九章： 第九章：Spring 与 Sturts、Hibernate 的集成 、
1．Spring+Hibernate 的配置。 注入 Session 的默认配置（开发阶段使用）

“生产机配置”（部署到机器上时使用，可以使用 DataSource）
com/aptech/jb/model/entity/User.hbm.xml

com/aptech/jb/model/entity/Zfxx.hbm.xml com/aptech/jb/model/entity/Fwlx.hbm.xml com/aptech/jb/model/entity/Qx.hbm.xml com/aptech/jb/model/entity/Jd.hbm.xml org.hibernate.dialect.SQLServerDialect true
2．使用 Spring 管理依赖关系 我们的程序依赖关系是：Action==>Biz==>DAO==>SessionFactory==>DataSource，而在 Spring 中，注入的 方式向与依赖的方向相反，注入方式为：Action<==Biz<==DAO<==SessionFactory<==DataSource 3．业务逻辑层与数据访问层的衔接。 (1)把 Biz 层中直接实例化数据访问接口的代码去掉，并增加接口属生的 setter 方法，方便注入。如：
public class ZfxxBizImpl implements ZfxxBiz { private ZfxxDAO zfxxDAO; public void setZfxxDAO(ZfxxDAO zfxxDAO) { this.zfxxDAO = zfxxDAO; } public List getZfxxList(Zfxx condition) { return this.zfxxDAO.getZfxxList(condition); } }
(2)在 Spring 配置文件中定义 zfxxBiz Bean，在上面的配置文件中新加代码如下：

(3)测试代码（普通测试）
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml"); ZfxxBiz biz=(ZfxxBiz)context.getBean("zfxxBiz"); Zfxx cond=new Zfxx(); cond.setTitle("");

List zfxxes = biz.getZfxxList(cond); for (Zfxx zfxx : zfxxes) { System.out.println(zfxx.getTitle()+"\t\t"+zfxx.getLxr()); } System.out.println(zfxxes.size());
4．与 Struts 集成（通过 Spring 提供的 ContextLoaderPlugIn 插件实现） ，具体步骤如下： (1)在 stuts-config.xml 配置文件中增加如下代码：

注：classpath 表示到 classpath 下去找 xml 文件，如果 Spring 配置文件在/WEB-INF/下，可以这样配置 value="/WEB-INF/applicationContext.xml"。如果 Spring 配置文件有多个，则可以同时配置多个路径，各路 径之间用逗号隔开。 (2)将 struts-config.xml 中的 Action 类别都配置为“org.springframework.web.struts.DelegatingActionProxy”类 型，如下：

(3)在 Spring 配置文件中配置 ZfxxAction。 （此时的没有 id 属性了，而是 name 属性，且 name 属性的 值要与对应的 ActionBean 的 path 属性一致。。如下： ）

5．一个完整的 Spring 配置文件。

com/aptech/jb/model/entity/User.hbm.xml org.hibernate.dialect.SQLServerDialect true
6．Spring1.x 的事务处理方式： （与上一章配置 logAdvice 类似） ，步骤如下： (1)声明一个事务管理器，需要注入 sessionFactory 属性。 (2)配置 AOP 代理

PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED,readOnly
注释：PROPAGATION_REQUIRED,readonly(每条属性的定义方式)
其中 key 表示匹配方法的模式，可以使用通配符， “add*”表示这条属性应用于 add 开头的方法。 属性的值为 PROPAGATION_REQUIRED，表示当前方法必须运行在一个事务环境中，如果一个现有事务 正在运行中，该方法将运行在这个事务中，否则，就要开始一个新的事务。可选的值如下： PROPAGATION_MANDATORY：表示当前方法必须运行在一个事务上下文中，否则就抛出异常。 PROPAGATION_NEVER：表示当前方法不应该运行在一个事务上下文中，否则就抛出异常。 PROPAGATION_REQUIRED_NEW：表示当前方法必须运行在自己的事务里。 PROPAGATION_SUPPORTS：表示当前方法不需要事务处理环境，但如果有一个事务正在运行的话，这个 方法也可以运行在这个事务里。 出于效率的考虑，不需要更改数据的方法应配置 readOnly 启用只读事务。 7．同时配置多个类，可以采取类似于基类的方法

8．Spring2.0 中声明事物的方法（尚不理解）