SSH三大框架整合(详细版)

合集下载

SSH整合

参考资料SSH整合主要内容✓SSH整合概述✓应用IoC进行整合✓应用AOP进行整合✓Open Session In View模式1.框架与架构终于，我们学完了Struts、Spring、Hibernate（所谓“SSH”）三大框架，在实际开发中，合理的应用三大框架，才能发挥出各个框架的长处。

我们知道Struts作用于表现层，使表现层符合MVC结构，而Hibernate作用于数据访问层，使DAO能够通过ORM的方式操作数据库。

各个层之间的交互示意图如下：图1 未整合时框架的交互在未使用Spring整合时，这种架构固然能体现出Struts与Hibernate的优点，但也存在以下不足：1.层与层之间耦合性较大。

层之间的耦合主要体现在表现层依赖于业务层，业务层依赖于数据访问层。

在《软件设计与最佳实践》一书中曾介绍过依赖倒转原则，应针对接口编程，而不是实现类，遵照这一原则，我们应该为业务层的建立业务接口，具体的业务类实现接口，同样数据访问层应有数据访问接口。

但即使存在这些接口，在实例化时依然需要指定具体类，当具体类发生变化时会影响到其它层。

2.不能很好的处理事务。

事务的边界应该在业务层确定，但业务层中不应存在实现事务的具体代码，否则会与数据访问层的实现技术紧密耦合在一起（如业务层使用Session.beginTransaction则数据访问层必须用Hiberante技术实现，如果改用JDBC技术实现，则需要改动业务层的代码，违反了分层架构中一层发生变化不影响另一层的初衷），在未使用Spring技术的架构中，事务处理一直是比较头疼的问题。

2.Spring整合概述使用Spring对各个层进行整合可以避免上述不足，使用IoC特性可以有效解除层与层之间的依赖性，每一层不需要选择具体的实现类，而是通过Spring容器注入（图2）。

这样每一层的类可以真正做到只依赖于接口，而不是实现类。

当需要切换实现类时，修改Spring 的配置文件即可以实现，无需改动代码，重新编译。

ssh整合框架原理及流程

ssh整合框架原理及流程SSH（Spring、Struts和Hibernate）框架整合的原理和流程如下：原理：1. 控制反转（IoC）：IoC是一种设计原则，通过这种原则，对象之间的依赖关系由容器来控制，而非传统的直接操控。

这使得程序代码更加灵活，易于复用。

2. 依赖注入（DI）：DI是IoC的一种实现方式。

通过DI，组件之间的依赖关系由容器在运行时决定，并动态地将这种关系注入到组件中。

流程：1. 建立web工程，并将其编码设置为UTF-8。

2. 将整个JSP页面也设置为UTF-8编码格式。

3. 建立三个source folder文件：src（存放源代码）、config（存放所有的配置文件，如Struts、Hibernate和Spring配置文件）、test（存放测试类）。

4. 在WebRoot\WEB-INF\lib中导入相应的jar包。

5. 配置文件。

在这个文件中，Spring容器以监听器的形式与Tomcat整合。

6. Struts负责控制Service（业务逻辑处理类），从而控制Service的生命周期。

这样层与层之间的依赖很强，属于耦合。

7. 使用Spring框架来控制Action对象（Struts中的）和Service类。

这使得两者之间的关系变得松散。

Spring的IoC机制（控制反转和依赖注入）正是用在此处。

8. Spring的AOP应用：事务的处理。

在以往的JDBCTemplate中，事务提交成功、异常处理都是通过Try/Catch来完成。

整合SSH框架的目的是提高软件开发的效率和灵活性，减少代码的冗余和复杂性，使代码更易于维护和扩展。

SSH框架总结

//利用Hibernate来操作DB
public class UserDao {
private SessionFactory sessionFactory;
private HibernateTemplate htemplate;
public void setSessionFactory(SessionFactory sessionFactory) {
UserDao dao=(UserDao)context.getBean("userDao");
dao.insert(user);
//String usname=request.getParameter("uname");
//Байду номын сангаасtring uspwd=request.getParameter("pwd");
else{
return mapping.findForward("false");
}
}
}
六。配置文件
********spring-struts.xml


String uspwd=user.getPwd();
if(usname.equals("feng")&uspwd.equals("123"))
{
return mapping.findForward("suc");
}
String pwd=uform.getPwd();

三大框架ssh模式的详解

6 16JAVA三大框架ssh-Struts、Spring、Hibernate(面试时用)文章分类:Java编程JAVA三大框架ssh-Struts、Spring、HibernateStruts1. struts是一个按MVC模式设计的Web层框架，其实它就是一个大大的servlet，这个Servlet名为ActionServlet，或是 ActionServlet的子类。

我们可以在web.xml文件中将符合某种特征的所有请求交给这个Servlet处理，这个Servlet 再参照一个配置文件（通常为/WEB-INF/struts-config.xml）将各个请求分别分配给不同的action去处理。

一个扩展知识点：struts的配置文件可以有多个，可以按模块配置各自的配置文件，这样可以防止配置文件的过度膨胀；2. ActionServlet把请求交给action去处理之前，会将请求参数封装成一个formbean对象（就是一个java类，这个类中的每个属性对应一个请求参数），封装成一个什么样的formbean对象呢？看配置文件。

3.要说明的是， ActionServlet把formbean对象传递给action的execute方法之前，可能会调用formbean的validate方法进行校验，只有校验通过后才将这个formbean对象传递给action的execute方法，否则，它将返回一个错误页面，这个错误页面由input属性指定，（看配置文件）作者为什么将这里命名为input属性，而不是error属性，我们后面结合实际的运行效果进行分析。

4.action执行完后要返回显示的结果视图，这个结果视图是用一个ActionForward对象来表示的，actionforward对象通过struts-config.xml配置文件中的配置关联到某个jsp 页面，因为程序中使用的是在struts-config.xml配置文件为jsp页面设置的逻辑名，这样可以实现action 程序代码与返回的jsp页面名称的解耦。

SSH(Struts+Spring+Hibernate)三层架构

目录目录 (1)一、SSH整体介绍 (3)1. 简介 (3)（1）Struts用于表现层，负责页面数据提取，页面动作响应。

(3)（2）Spring是一种轻量级的框架模型，主要负责业务逻辑层的对象创建，表现层的Action的创建，以及持久层的DAO的创建。

(3)（3）Hibernate负责把内存中的数据对象保存到数据库中。

(3)2. 框架集成说明 (3)1) Struts与Spring的集成 (3)2) Spring与Hibernate的集成 (3)3. 程序的包结构 (4)1) 表现层的类包 (4)2) 持久层的类包 (4)3) 业务层的类包 (4)二、核心的配置文件的说明： (5)1. Web.xml文件——工程初始化配置文件 (5)1) Servlet配置 (5)2) init-param设置 (6)3) servlet-mapping配置 (7)4) Spring配置文件配置 (7)5) Spring的Bean工厂配置 (7)6) Filter配置 (8)7) 欢迎页面配置 (9)2. struts-config.xml——Struts的配置文件 (9)（1）Form的配置 (9)（2）Action的配置 (9)（3）全局异常处理类配置 (10)（4）全局转发配置 (10)（5）action配置 (10)（6）资源文件配置 (11)3. applicationContext-common.xml——Spring公共配置文件 (11)（1）Session工厂配置 (11)（2）事务配置 (12)4. applicationContext-beans.xml——Spring中Bean的配置文件 (12)5. hibernate.cfg.xml——Hibernate的配置文件 (13)（1）Hibernate中Session工厂的配置 (13)（2）hbm.xml配置文件 (14)（3）DAO实现类说明 (15)三、Demo实例说明 (15)1、demo.jsp： (15)2、addRate.jsp (16)3、rateList.jsp (16)4、rateinfoAction (17)5、rateinfoAction 的配置(struts-config.xml) (17)6、配置spring文件 (18)7、比例列表（rateList.jsp）： (20)一、SSH整体介绍1. 简介本Demo程序采用的是SSH（Struts+Spring+Hibernate）三层架构。

三大框架集成(ssh2)

三大框架集成（Struts2.1+Spring2.0+Hibernate3.1）1.新建Web项目a)选择Java EE 5.02.添加Springa)选择spring 2,除去Myeclipse Librariesb)不创建applicationContext.xml3.添加Hibernatea)选择Hibernate3.1,除去Myeclipse Librariesb)创建Spring configuration file(applicationContext.xml)c)SessionFactory ID:sessionFactory（在applicationContext.xml中创建一个ID为sessionFactory的Bean）d)选择数据源:Bean Id为dateSource（在applicationContext.xml中创建一个ID为datasource的Bean）注：可以不选择数据源e)不创建SessionFactory class4.添加ssh2的库文件5.在src文件目录下添加一个struts.xml6.配置web.xml注：struts2的配置<filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping>注：读取application配置<context-param><param-name>contextCofigLocation</param-name><param-value>classpath:applicationContext.xml</param-value> </context-param>注：设置spring的监听<listener><listener-class>org.springframework.web.context.ContextLoaderListener </listener-class></listener>注：解决乱码问题<filter><filter-name>encoding</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter </filter-class><init-param><param-name>encoding</param-name><param-value>utf-8</param-value></init-param></filter><filter-mapping><filter-name>encoding</filter-name><url-pattern>/*</url-pattern></filter-mapping>7.新建包a)com.dao（数据操作类和接口：数据的添删查改）b)com.domain（实体类：get，set方法）连接数据库，自动生成c)com.junitd)com.action（控制器）。

ssh三大框架整合

ssh三⼤框架整合Hibernate框架 1 hibernate核⼼配置⽂件（0）orm思想 - 对象关系映射（1）数据库信息（2）hibernate信息（3）映射配置（4）hibernate核⼼配置⽂件 - 如果单纯使⽤hibernate框架，核⼼配置⽂件名称 hibernate.cfg.xml和位置 src下⾯固定的 - hibernate和spring整合时候，hibernate核⼼配置⽂件名称和位置没有固定要求的 2 hibernate映射配置⽂件（1）实体类和数据库表映射关系—使⽤orm思想 3 hibernate操作的步骤（1）在spring框架对hibernate框架进⾏封装，使⽤hibernateTemplateStruts2框架 1 Action操作（1）action创建三种⽅式 - 继承类 ActionSupport （2）配置action访问路径 - 创建struts.xml配置⽂件，这个⽂件名称和位置固定 src下⾯的（3）配置访问action的多个⽅法 - 使⽤通配符⽅式配置（4）在action获取表单提交数据 - 获取request对象 ** 使⽤ServletActionContext类获取 - 属性封装 - 模型驱动（重点） - 表达式封装（5）在action操作域对象 - 使⽤ServletActionContext获取域对象（6）配置struts2的过滤器 2 值栈（1）向值栈放数据 - set⽅法 - push⽅法 - 定义变量，⽣成get⽅法（2）从值栈获取数据 - 在jsp中使⽤struts2标签+ognl获取 - <s:property> - <s:iterator> 3 拦截器（1）aop和责任链模式（2）⾃定义拦截器 - 继承MethodFilterInterceptor - 重写类⾥⾯的⽅法 - 配置拦截器和action关联Spring框架 1 spring核⼼配置⽂件（1）名称和位置没有固定要求（2）在spring核⼼配置⽂件中引⼊schema约束 2 创建对象（1）xml配置⽅式：<bean id=”” class=”” scope=””/> （2）注解⽅式：四个注解 3 注⼊属性(对象类型属性) （1）xml配置⽅式：（2）注解⽅式：两个注解 - autowired - resource 3 使⽤ServletContext对象和监听器实现（1）在服务器启动时候，加载spring配置⽂件，创建对象（2）配置spring的监听器（3）指定spring配置⽂件位置 4 jdbcTemplate 5 spring事务配置（1）xml⽅式（2）注解⽅式SSH框架整合思想 1 三⼤框架应⽤在javaee三层结构 2 struts2框架和spring整合（1）struts2的action在spring配置 3 spring框架和hibernate框架整合（1）hibernate的sessionFactory交给spring配置（2）把hibernate数据库配置交给spring配置整合struts2和spring框架 1 把struts2的action交给spring管理 2 实现过程第⼀步导⼊struts2的jar包（1）导⼊⽤于整合的jar包（log4j.properties为log4j的⽇志输出格式，放⼊src下⾯）（2）Spring为了整合Struts还需要额外再导⼊⼀个jar包：（该包在struts的lib⽬录下）（3）导⼊Struts2的jar包（struts2版本为2.3.24）：（4）创建Actionpublic class UserAction extends ActionSupport {public String execute() throws Exception {System.out.println("Success....");return NONE;}} （5）创建Strut2的核⼼配置⽂件<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN""/dtds/struts-2.3.dtd"><struts><package name="demo" extends="struts-default" namespace="/"><action name="userAction" class="erAction"></action></package></struts> （6）在web.xml中配置struts2的过滤器<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> （7）导⼊Spring整合Web项⽬的jar包，也就是监控项⽬启动的监听器所在的jar包（8）创建Spring的核⼼配置⽂件并在其中引⼊约束<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/tx/schema/tx/spring-tx.xsd"></beans> （9）把action交给Spring进⾏配置1 2 3 <bean id="userAction" class="erAction" scope="prototype"></bean> ①在spring配置action对象，在struts.xml中也配置action对象 ②解决：只需要在spring⾥⾯配置action对象，不要在struts.xml中配置<struts><package name="demo1" extends="struts-default" namespace="/"><action name="userAction" class="userAction"></action></package></struts> 可以这样写的原因是我们导⼊了⼀个Spring整合Struts2的jar包：struts2-spring-plugin-2.3.24.jar （10）web.xml中Spring监听器的配置<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:bean.xml</param-value></context-param> （11）测试准备 ①所需的为Struts2的核⼼配置⽂件：struts.xml ②Spring的配置⽂件：bean.xml ③项⽬的配置⽂件：web.xml ④Struts2的UserAction类 ⑤在UserAction中对UserService的调⽤ ⑥UserService中对UserDao的调⽤ ⑦UserDao类的编写struts.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN""/dtds/struts-2.3.dtd"><struts><package name="demo1" extends="struts-default" namespace="/"><action name="userAction" class="userAction"></action></package></struts>bean.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/tx/schema/tx/spring-tx.xsd"><bean id="userAction" class="erAction"><property name="userService" ref="userService"></property></bean><bean id="userService" class="erService"><property name="userDao" ref="userDaoImp"></property></bean><bean id="userDaoImp" class="erDaoImp"></bean></beans>web.xml<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance" xmlns="/xml/ns/javaee" xsi:schemaLocation="/xml/ns/javaee /xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" <display-name>spring-day4-ssh</display-name><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:bean.xml</param-value></context-param><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><welcome-file-list><welcome-file>index.html</welcome-file><welcome-file>index.htm</welcome-file><welcome-file>index.jsp</welcome-file><welcome-file>default.html</welcome-file><welcome-file>default.htm</welcome-file><welcome-file>default.jsp</welcome-file></welcome-file-list></web-app>UserAction.javaimport com.opensymphony.xwork2.ActionSupport;import erService;public class UserAction extends ActionSupport {private UserService userService;public void setUserService(UserService userService) {erService = userService;}public String execute() throws Exception {userService.add();return NONE;}}UserService.javapublic class UserService {private UserDao userDao;public void setUserDao(UserDao userDao) {erDao = userDao;}public void add() {userDao.add();}}UserDao.java 其实现类public class UserDaoImp implements UserDao {public void add() {System.out.println("UserDaoImp....");}} （12）测试结果：可以在后台观察到如下测试结果：image ⾄此，Spring和Struts2的整合已经完毕，然后是Spring对Hibernate的整合了。

三大框架ssh模式的详解

三大框架ssh模式的详解SSH是Secure Shell的缩写，是一种用于安全远程登录的协议。

它可以通过加密隧道来传输数据，并提供了身份验证和数据完整性保护。

SSH模式可以分为以下三大框架：SSH-1、SSH-2和OpenSSH。

1.SSH-1：SSH-1是最早的SSH协议版本，由Tatu Ylönen在1995年开发。

SSH-1使用了基于RSA算法的身份验证机制，并使用了Diffie-Hellman 算法进行密钥交换。

然而，SSH-1存在许多安全漏洞，包括易受到中间人攻击的问题。

因此，SSH-1在1996年被SSH-2所取代，成为历史遗留的协议版本。

2.SSH-2：SSH-2是目前最广泛使用的SSH协议版本。

与SSH-1相比，SSH-2具有更好的安全性和可靠性。

SSH-2支持多种身份验证机制，包括密码、公钥和基于证书的身份验证。

它还增加了Diffie-Hellman组合机制和更强大的加密算法，如AES和3DES。

SSH-2还提供了压缩数据和端口转发等功能。

由于SSH-2的安全性和功能，它成为了企业网络中常用的远程登录协议。

3. OpenSSH：OpenSSH是SSH协议的开源实现，也是最常用的实现之一、OpenSSH 包括了SSH客户端和服务器端。

它被广泛使用于Linux和Unix系统中，提供了安全的远程登录和文件传输功能。

OpenSSH拥有良好的安全性和稳定性，并提供了许多高级功能，如X11转发、SFTP文件传输和动态端口转发。

OpenSSH还支持在非标准端口上运行，从而增加了安全性。

总结来说，SSH模式的三大框架包括SSH-1、SSH-2和OpenSSH。

SSH-1是最早的SSH协议版本，但存在安全漏洞，已被SSH-2所取代。

SSH-2具有更好的安全性和可靠性，支持多种身份验证机制和强大的加密算法。

而OpenSSH则是SSH协议的开源实现，被广泛应用于Linux和Unix系统中，提供了安全的远程登录和文件传输功能，并支持多种高级功能。

ssh框架融合

SSH：Struts（表示层）+Spring（业务层）+Hibernate（持久层）Struts：Struts是一个表示层框架，主要作用是界面展示，接收请求，分发请求。

在MVC框架中，Struts属于VC层次，负责界面表现，负责MVC关系的分发。

（View：沿用JSP，HTTP，Form，Tag，Resourse ；Controller：ActionServlet，struts-config.xml，Action）Hibernate：Hibernate是一个持久层框架，它只负责与关系数据库的操作。

Spring：Spring是一个业务层框架，是一个整合的框架，能够很好地黏合表示层与持久层。

我们知道，传统的Java Web应用程序是采用JSP+Servlet+Javabean来实现的，这种模式实现了最基本的MVC分层，使的程序结构分为几层，有负责前台展示的JSP、负责流程逻辑控制的Servlet以及负责数据封装的Javabean。

但是这种结构仍然存在问题：如JSP页面中需要使用符号嵌入很多的Java代码，造成页面结构混乱，Servlet 和Javabean负责了大量的跳转和运算工作，耦合紧密，程序复用度低等等。

Struts为了解决这些问题，出现了Struts框架，它是一个完美的MVC实现，它有一个中央控制类(一个Servlet)，针对不同的业务，我们需要一个Action类负责页面跳转和后台逻辑运算，一个或几个JSP页面负责数据的输入和输出显示，还有一个Form类负责传递Action和JSP中间的数据。

JSP中可以使用Struts框架提供的一组标签，就像使用HTML标签一样简单，但是可以完成非常复杂的逻辑。

从此JSP页面中不需要出现一行包围的Java代码了。

可是所有的运算逻辑都放在Struts的Action里将使得Action 类复用度低和逻辑混乱，所以通常人们会把整个Web应用程序分为三层，Struts负责显示层，它调用业务层完成运算逻辑，业务层再调用持久层完成数据库的读写。

SSH框架整合详解(精典)

已经经过本人测试第一步：准备工作MyEclipse 6.0------T omcat6.0所需jar文件:（所有jar文件已整理ssh_jars文件夹）注意：ssh_test项目中采用的是MySql 数据库。

而本文档中配置的是Oracle数据库，注意其中配置的不同之处哦(在相应的地方有注明)第二步：(建立项目，包结构，导入所需jar文件)新建一个web project:建立包结构如下：各包功能说明：com.ssh.config : 配置文件（*.properties）,如数据库配置信息com.ssh.resource : 资源文件m : 公共工具(util)包com.ssh.util.orm.hibernate : hibernate DAO 模板com.ssh.model : 各实体类文件com.ssh.service : 业务逻辑包相当于bizcom.ssh..test : 测试包com.ssh.action : struts Action包结构可以根据自己需要自行划分导入jar文件：新建一个User Library: sshJars添加jar文件:将新建的User Library: sshJars加入到项目中：第三步：撰写资源文件jdbc.properties在jdbc.properties 里写上连接数据库的配置信息,此文件的配置信息用于在spring的配置文件中使用，数据库的配置信息也可以写到Spring 的配置文件中，这在一个jdbc.properties文件中是为了方便更改.在com.ssh.resource包中新建下列文件：各文件详细内容及说明如下：----------------------------------------------------------------------------------------------------------------------------------------- applicationContext.xml:<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:jee="/schema/jee"xmlns:tx="/schema/tx"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd/schema/jee/schema/jee/spring-jee-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd"default-lazy-init="true"><description>Spring公共配置文件</description><bean id="propertyConfigurer"class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"><list><value>classpath*:com/ssh/config/jdbc.properties</value></list></property><bean id="dataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="${jdbc.driverClassName}" /><property name="url" value="${jdbc.url}" /><property name="username" value="${ername}" /><property name="password" value="${jdbc.password}" /></bean><bean id="sessionFactory"class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBea n"><!—此处hibernate 的映射采用的是.xml 配置则应设置为：class=”org.springframework.orm.hibernate3.LocalSessionFactoryBean”--> <property name="dataSource" ref="dataSource" /><property name="hibernateProperties"><props><propkey="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop><prop key="hibernate.show_sql">true</prop><prop key="e_query_cache">true</prop><propkey="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop> <propkey="hibernate.cache.provider_configuration_file_resource_path">/ehcache-hiberna te.xml</prop></props></property><property name="annotatedClasses"> <!—此处hibernate 的映射采用的是.xml 配置同则应设置name=”mappingResource”--><list><value>er</value><!—此处hibernate 的映射采用的是.xml 配置同则应设置<value>具体配置文件名(*.hbm.xml)</value>--></list></property></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory" /><tx:annotation-driven transaction-manager="transactionManager" /><beanclass="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostPr ocessor" /></beans>----------------------------------------------------------------------------------------------------------------------------------------- applicationContext-security.xml:<?xml version="1.0" encoding="UTF-8"?><beans:beans xmlns="/schema/security"xmlns:beans="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/security/schema/security/spring-security-2.0.xsd"default-autowire="byType" default-lazy-init="true"></beans:beans>此文件用于AOP的安全验证,也可不添加----------------------------------------------------------------------------------------------------------------------------------------- applicationContext-service.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd"default-autowire="byType" default-lazy-init="true"><bean name="userService" class="erService"></bean><bean name="/hello" class="com.ssh.action.HelloAction"></bean></beans>Service（业务逻辑类）的注入----------------------------------------------------------------------------------------------------------------------------------------- ehcache-hibernate.xml:<ehcache><diskStore path="d:\cache" /><cache name="er" maxElementsInMemory="4" eternal="false" overflowToDisk="true"timeToIdleSeconds="600" /><defaultCache maxElementsInMemory="100000" eternal="true"overflowToDisk="true" /></ehcache>Hibernate 缓存的配置（可以不做配置，如果需要才使用缓存才做配置，建议配置上）----------------------------------------------------------------------------------------------------------------------------------------- 第四步：在m 包下添加下列文件此包为hibernate DAO模板中用到的各种工具类，各文件可以在打包的ssh_test项目中找到.第五步：添加hibernate DAO 模板此包为hibernate DAO模板，SimpleHibernateTemplate.java 中包含了对各实体（增，删，改，查，分页查等）的泛形方法。

SSH_三大框架介绍

SSH_三大框架介绍SSH是指Struts、Spring和Hibernate三个开源框架的整合，其中每个框架都有自己的设计思想和特点，通过整合，可以充分发挥它们的优势，提高开发效率和系统性能。

下面将分别介绍这三个框架。

1. Struts：Struts是一个基于MVC设计模式的Web应用程序框架，它将应用程序分为三个层：模型（Model）、视图（View）和控制器（Controller）。

模型负责处理业务逻辑，视图负责展示数据，控制器负责接收用户输入和导航请求。

Struts通过配置文件定义请求的映射和处理逻辑，通过统一的控制器Servlet接收请求，根据配置文件将请求转发给相应的Action。

在Action中进行请求处理和业务逻辑的实现。

2. Spring：Spring是一个轻量级的IoC（Inverse of Control）容器和应用程序框架，它主要解决企业应用中的复杂性问题。

Spring的核心思想是面向接口编程和依赖注入。

通过Spring的IoC容器管理对象的生命周期和依赖关系，将对象的创建和销毁过程交给容器处理。

通过依赖注入，可以将对象之间的依赖关系解耦，提高代码的可维护性和可测试性。

Spring还提供了丰富的功能模块，如AOP（Aspect-Oriented Programming）框架、事务管理、远程调用等，可以在应用程序中灵活地配置和使用。

Spring的优点是具有良好的灵活性和扩展性，可以与其他框架进行无缝集成，支持多种数据库和应用服务器。

同时，Spring还提供了很强的层次化管理和面向切面编程的能力，使得开发人员可以更加精细地控制应用程序的流程和行为。

3. Hibernate：Hibernate是一个开源的对象关系映射框架，用于将Java对象映射到关系数据库中的表结构上。

Hibernate通过配置文件和注解，提供了一种方便的方式来实现数据的持久化和检索。

Hibernate根据对象的映射关系，自动生成相应的SQL语句，实现了对象与数据库之间的映射和转换。

整合SSH三大框架介绍

一.在MyEclipse里先建立一个Web project 的工程，选最新版本的java ee。

1.引入struts2必须得几个jar包，放在WebRoot->WEB-INF->lib目录下。

2.将WEB应用部署到tomcat效劳器上：找到tomacat的安装目录Tomcat6.x\apache-tomcat-\conf，翻开其中的server.xml文件，在文件末尾</Host>上面参加例如<Context path="/ssh2" docBase="F:\javaWeb\ssh2\WebRoot" reloadable="true" />这样的句子，其中path的值为你需要访问网站的上下文，docBase的值为该web工程的WebRoot所在的目录，最后一个readloadable最好选true。

3.在WebRoot->WEB-INF->web.xml中参加struts2的过滤器将部署好的应用纳入到struts2的管辖范围类，具体代码如下<filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPre pareAndExecuteFilter</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping>rc目录下，建一个struts.xml文件，这里是处理struts整个流程的文件。

01、SSH框架整合

1. ssh框架整合通常说的ssh框架，是指Struts，Spring，Hibernate三个Java EE框架，我们在企业级应用开发的时候，通常是将这3个框架结合在一起，来完成企业应用的开发。

那我们就学习一下，怎么将这3个框架整合在一起工作：1.1. 整合步骤1.1.1. 第一步：新建maven工程，要是war类型1.1.2. 第二步：引入3个框架的jar包1.<dependencies>2.3.<dependency>4.<groupId>org.apache.struts</groupId>5.<artifactId>struts2-core</artifactId>6.<version>2.3.15.3</version>7.</dependency>8.<dependency>9.<groupId>org.apache.struts</groupId>10.<artifactId>struts2-convention-plugin</artifactId>11.<version>2.3.15.1</version>12.</dependency>13.14.<dependency>15.<groupId>org.apache.struts</groupId>16.<artifactId>struts2-spring-plugin</artifactId>17.<version>2.3.15.3</version>18.</dependency>19.20.21.22.<dependency>23.<groupId>javax.servlet</groupId>24.<artifactId>javax.servlet-api</artifactId>25.<version>3.1.0</version>26.</dependency>27.28.<dependency>29.<groupId>junit</groupId>30.<artifactId>junit</artifactId>31.<version>4.8.1</version>32.<scope>test</scope>33.</dependency>34.<dependency>35.<groupId>javax.servlet.jsp</groupId>36.<artifactId>jsp-api</artifactId>37.<version>2.2</version>38.</dependency>39.40.41.<dependency>42.<groupId>org.springframework</groupId>43.<artifactId>spring-core</artifactId>44.<version>4.1.6.RELEASE</version>45.</dependency>46.<dependency>47.<groupId>org.springframework</groupId>48.<artifactId>spring-beans</artifactId>49.<version>4.1.6.RELEASE</version>50.</dependency>51.<dependency>52.<groupId>org.springframework</groupId>53.<artifactId>spring-context</artifactId>54.<version>4.1.6.RELEASE</version>55.</dependency>56.<dependency>57.<groupId>org.springframework</groupId>58.<artifactId>spring-tx</artifactId>59.<version>4.1.6.RELEASE</version>60.</dependency>61.<dependency>62.<groupId>org.springframework</groupId>63.<artifactId>spring-jdbc</artifactId>64.<version>4.1.6.RELEASE</version>65.</dependency>66.<dependency>67.<groupId>org.springframework</groupId>68.<artifactId>spring-web</artifactId>69.<version>4.1.6.RELEASE</version>70.</dependency>71.72.<dependency>73.<groupId>org.aspectj</groupId>74.<artifactId>aspectjrt</artifactId>75.<version>1.8.6</version>76.</dependency>77.<dependency>78.<groupId>org.aspectj</groupId>79.<artifactId>aspectjweaver</artifactId>80.<version>1.8.6</version>81.</dependency>82.83.84.<dependency>85.<groupId>org.hibernate</groupId>86.<artifactId>hibernate-core</artifactId>87.<version>4.3.11.Final</version>88.</dependency>89.<dependency>90.<groupId>org.hibernate</groupId>91.<artifactId>hibernate-ehcache</artifactId>92.<version>4.3.11.Final</version>93.</dependency>94.<dependency>95.<groupId>org.springframework</groupId>96.<artifactId>spring-orm</artifactId>97.<version>4.1.6.RELEASE</version>98.</dependency>99.100.<dependency>101.<groupId>commons-dbcp</groupId>102.<artifactId>commons-dbcp</artifactId>103.<version>1.4</version>104.</dependency>105.106.<dependency>107.<groupId>mysql</groupId>108.<artifactId>mysql-connector-java</artifactId> 109.<version>5.1.30</version>110.</dependency>111.112.<dependency>113.<groupId>org.slf4j</groupId>114.<artifactId>slf4j-log4j12</artifactId>115.<version>1.6.1</version>116.</dependency>117.</dependencies>1.1.3. 第三步：配置web.xml1.<?xml version="1.0" encoding="UTF-8"?>2.<web-app version="2.5"3. xmlns="/xml/ns/javaee"4. xmlns:xsi="/2001/XMLSchema-instance"5. xsi:schemaLocation="/xml/ns/javaee6. /xml/ns/javaee/web-app_2_5.xsd">7.8.9.<context-param>10.<param-name>contextConfigLocation</param-name>11.<param-value>classpath:applicationContext.xml</param-value>12.</context-param>13.14.15.<listener>16.<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>17.</listener>18.19.20.<filter>21.<filter-name>struts2</filter-name>22.<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>23.</filter>24.<filter-mapping>25.<filter-name>struts2</filter-name>26.<url-pattern>/*</url-pattern>27. </filter-mapping>28. <welcome-file-list>29. <welcome-file>index.jsp</welcome-file>30. </welcome-file-list>31.</web-app>1.1.4. 第四步：增加struts配置文件：struts.xml1.<?xml version="1.0" encoding="UTF-8"?>2.<!DOCTYPE struts PUBLIC3. "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"4. "/dtds/struts-2.3.dtd">5.6.<struts>7.8.<constant name="struts.objectFactory" value="spring"/>9.<constant name="struts.devMode" value="true" />10.<constant name="struts.ui.theme" value="simple" />11.12.</struts>1.1.5. 第五步：增加hibernate配置文件：hibernate.cfg.xml（也可以不要，详见配置）1.<?xml version='1.0' encoding='utf-8'?>2.<!DOCTYPE hibernate-configuration PUBLIC3. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"4. "/hibernate-configuration-3.0.dtd">5.<hibernate-configuration>6.7.<session-factory>8.9.15.<property name="hbm2ddl.auto">update</property>16.<property name="show_sql">true</property>17.<property name="format_sql">false</property>18.19.</session-factory>20.</hibernate-configuration>1.1.6. 第六步：增加log4j配置文件log4j.properties1.log4j.rootLogger=INFO, Console, R2.3.#Console4.log4j.appender.Console=org.apache.log4j.ConsoleAppenderyout=org.apache.log4j.PatternLayoutyout.ConversionPattern =%d %p [%c]-%m%n7.8.log4j.appender.R=org.apache.log4j.DailyRollingFileAppender9.log4j.appender.R.File=d:/server.logyout=org.apache.log4j.PatternLayoutyout.ConversionPattern =%d %p [%c]-%m%n1.1.7. 第七步：增加数据库配置文件dbcpconfig.properties1.driverClassName=com.mysql.jdbc.Driver2.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8ername=root4.password=root1.1.8. 第八步：增加spring配置文件applicationContext.xml1.<?xml version="1.0" encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3. xmlns:aop="/schema/aop"4. xmlns:tx="/schema/tx"5. xmlns:xsi="/2001/XMLSchema-instance"6. xsi:schemaLocation="/schema/beans7. /schema/beans/spring-beans-2.5.xsd8. /schema/aop9. /schema/aop/spring-aop-2.5.xsd10. /schema/tx11. /schema/tx/spring-tx-2.5.xsd">12.13.16.<bean17.class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">18.<property name="locations">19.<value>classpath:dbcpconfig.properties</value>20.</property>21.</bean>22.23.<bean id="dataSource" destroy-method="close"24.class="mons.dbcp.BasicDataSource">25.<property name="driverClassName" value="${driverClassName}" />26.<property name="url" value="${url}" />27.<property name="username" value="${username}" />28.<property name="password" value="${password}" />29.</bean>30.31.32.<bean id="sessionFactory"33.class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">34.<property name="dataSource">35.<ref bean="dataSource" />36.</property>37.38.<property name="configLocation" value="classpath:hibernate.cfg.xml"/>39.40.41.55.</bean>56.57.<bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager">58.<property name="sessionFactory" ref="sessionFactory" />59.</bean>60.61.62.<tx:advice id="txAdvice" transaction-manager="transactionManager">63.64.<tx:attributes>65.73.<tx:method name="*" propagation="REQUIRED" />74.</tx:attributes>75.</tx:advice>76.77.78.<aop:config>79.80.<aop:pointcut expression="execution(* cn.reachedu.ssh.service..*.*(..))"id="mypointcut"/>81.82.<aop:advisor advice-ref="txAdvice" pointcut-ref="mypointcut"/>83.</aop:config>84.85.</beans>我们已经将3个框架集成在一起，但是目前什么也干不了，因为我们这个框架下没有任何功能，那么现在我们在框架里面增加一个查询用户的功能，进行简单的测试。

SSH三大框架

id="WebApp_ID" version="2.5">
<display-name>SSHTest</display-name>

<filter>
<filter-name>struts2</filter-name>
</beans>
4)整合Spring与Struts。在Struts的lib目录中找到struts2-spring-plugin-*.jar，引入到工程中。
5.配置Hibernate
1)解压缩hibernate-distribution-*.zip。导入hibernate-distribution-*GA/lib/required目录中的jar包。
注意：javassist-3.7.ga.jar包是在struts2-blank-2.2.1.war示例工程中的web-inf/lib下的。
3.Spring：/download/community
还可以在eclipse下安装下载。具体步骤是这样的：
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"/dtds/struts-2.0.dtd">
<filter-class>
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter

SSH三大框架整合

3）Spring3框架:
Spring3.2 开发最基本的6个jar包
spring-beans-3.2.0.RELEASE.jar
spring-context-3.2.0.RELEASE.jar
spring-core-3.2.0.RELEASE.jar
spring-expression-3.2.0.RELEASE.jar
<property name="configLocation" value="classpath:hibernate.cfg.xml"/>
</bean>
Dao中的代码如下：
public class ProductorDaoImpl implements ProductorDao{
实现一个简单的商品添加功能
疑问：为什么在使用Struts2的时候，将表单数据直接封装到Bean对象中的时候，不需要在Action（该Action类实现了ModelDriven）中提供该Bean对象成员变量的getter/setter方法呢？
注意：
在编写程序的过程中要不断地进行测试，以便可以及时地发现问题。
方式一：使用最原始的Hibernate技术
方式二：Hibernate与Spring进行整合：
A、
<bean name="productorDao" class="cn.itcast.dao.ProductorDaoImpl">
<property name="hibernateTemplate" ref="hibernateTemplate"></property>

详解JAVAEE——SSH三大框架整合（spring+struts2+hibernate）

详解JAVAEE——SSH三⼤框架整合（spring+struts2+hibernate）⼀、整合原理⼆、导包(41个)1.hibernate（1）hibernate/lib/required（2）hibernate/lib/jpa | java persist api java的持久化规范(接⼝)（3）数据库驱动2.struts2（1）struts-blank.war/WEB-INF/lib/*注意:javassist-3.18.1-GA.jar包与hibernate中的重复（只保留⾼版本即可）（2）struts整合spring插件包注意:这个包⼀旦导⼊,那么struts2在启动时就会寻找spring容器.找不到将会抛出异常3.spring（1）基本:4+2core | beans | context | expression | logging | log4j（2）整合web:web包spring-web（3）整合aop:4个spring-aop | spring-aspect | aop联盟 | aopweaving（4）整合Hibernate和事务:4个spring-jdbc | spring-tx | c3p0 | spring-orm（5）整合junit4测试:test包spring-test4.标签库standard.jar | jstl-1.2.jar三、单独配置spring容器1.创建applicationContext.xml,并导⼊约束(4个) beans | context | aop | tx<?xml version="1.0" encoding="UTF-8"?><beans xmlns:xsi="/2001/XMLSchema-instance"xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-4.2.xsd /schema/context /schema/context/spring-context-4.2.xsd/schema/aop /schema/aop/spring-aop-4.2.xsd/schema/tx /schema/tx/spring-tx-4.2.xsd "><bean name="userAction" class="erAction"></bean></beans>2.配置spring随项⽬启动（web.xml）<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value></context-param>四、单独配置struts21.配置struts2主配置⽂件（struts.xml）<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN""/dtds/struts-2.3.dtd"><struts><package name="crm" namespace="/" extends="struts-default"><action name="UserAction_*" class="erAction" method="{1}"><result name="success">/success.jsp</result></action></package></struts>2.配置struts2核⼼过滤器到web.xml<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>五、struts2与spring整合1.导包(已经导⼊)struts2-spring-plugin-2.3.24.jar2.配置常量查看默认配置⽂件从31⾏开始找到要配置的变量。

SSH三大框架（StrutsSpringHibernate）

SSH三大框架（StrutsSpringHibernate）struts0、Struts1工作流程：（1）检索和用户请求匹配的ActionMapping实例。

如果不存在此示例，就返回用户请求路径无效。

（2）如果ActionForm实例不存在，就创建一个ActionForm对象，把客户提交的表单数据保存到ActionForm对象中。

（3）根据配置信息决定是否需要表单验证，如果需要验证，就调用ActionForm的validate()方法。

（4）如果ActionForm的validate()方法返回null或返回的ActionErrors对象里不包含ActionMessage对象，就表示表单验证成功。

（5）ActionServlet根据ActionMapping实例包含的映射信息决定将请求转发给哪个Action。

如果相应的Action实例不存在，就先创建这个实例，然后调用Action的execute()方法。

（6）Action的execute()方法返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象所指向的JSP 组件。

（7）通过ActionForward对象指向的JSP组件生成动态网页，返回给客户端。

1、Struts2工作流程：(包含拦截器处理部分，详细描述)1、客户端向Servlet容器（如Tomcat）提交一个请求2、请求经过一系列过滤器（如ActionContextCleanUp (已被JVM和WEB容器废弃的空对象) 过滤器等）3、核心控制器被调用，询问ActionMapper来决定请求是否需要调用某个Action ?4、如果ActionMapper决定需要调用某个Action，核心控制器把控制权委派给ActionProxy （备注：JSP请求无需调用Action）5、ActionProxy通过Configuration Manager询问框架的配置文件（struts.xml），找到需调用的Action类6、ActionProxy创建一个ActionInvocation的实例，(ActionInvocation的作用是如何执行Action，拦截器的功能就是在ActionInvocation中实现的)7、ActionInvocation负责调用Action，在此之前会依次调用所有配置的拦截器8、Action执行完毕，ActionInvocation负责根据结果码字符串在struts.xml的配置中找到对应的返回结果9、拦截器被再次执行10、过滤器被再次执行2、Struts1和Struts2区别：1、Action的实现方面：Struts1要求必须统一扩展自Action类，而Struts2中可以是一个普通的POJO2、线程模型方面：Struts1的Action工作在单例模式，一个Action的实例处理所有的请求。

ssh框架整合原理

ssh框架整合原理SSH框架整合原理引言：SSH（Struts+Spring+Hibernate）是一种常用的Java开发框架组合，它将Struts、Spring和Hibernate三个框架整合在一起，提供了全面的Web应用开发解决方案。

本文将介绍SSH框架的整合原理，以帮助读者深入理解该框架的工作机制。

一、Struts框架Struts是一个基于MVC（Model-View-Controller）模式的Web 应用程序开发框架。

它将应用程序划分为模型（Model）、视图（View）和控制器（Controller）三个部分，以实现业务逻辑和界面展示的分离。

在Struts框架中，用户请求首先由控制器接收，并根据配置文件中的映射规则将其转发给相应的Action处理。

Action负责处理用户请求，并将处理结果封装成一个ActionForm对象，然后将结果返回给控制器。

控制器再将结果转发给指定的视图进行展示。

二、Spring框架Spring是一个轻量级的Java开发框架，它提供了全面的企业级应用程序开发解决方案。

Spring框架主要由IoC（Inversion of Control）和AOP（Aspect-Oriented Programming）两个核心模块组成。

在Spring框架中，IoC容器负责管理应用程序中的对象，并通过依赖注入的方式将对象之间的依赖关系设置好。

通过IoC容器，我们可以通过配置文件或注解的方式将各个模块中的对象整合在一起，实现解耦和灵活性。

AOP模块则通过横切关注点的方式，将应用程序的功能进行模块化，提高了代码的可重用性和可维护性。

在Spring框架中，我们可以通过配置文件或注解的方式定义切面和通知，然后将其与应用程序中的对象进行织入，实现特定功能的增强。

三、Hibernate框架Hibernate是一个优秀的Java持久化框架，它提供了一种对象关系映射（ORM）的方式，将Java对象和数据库表之间进行映射。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

1：构建WEB项目
2：构建数据库
3：加入依赖包
尽量不要依赖IDE，通过自己手动加包完成
访问数据库需要的包：mysql的驱动包
Hibernate的包：hibernate3.jar 核心包
依赖的必须包：antlr-2.7.6.jar 用于解析成HQL语句的包
commons-collections-3.1.jar apache提供的包，提供对集合框架的增强
dom4j-1.6.1.jar 解析XML文件的包
javassist-3.9.0.GA.jar 动态修改字节码需要用到的包
jta-1.1.jar 用于JTA事务的包
slf4j-api-1.5.8.jar 日志接口包---》依赖一定的实现包
slf4j-log4j12-1.5.0.jar log4j.jar
另外一种实现包：slf4j-simple-1.5.10.jar
可选的包：c3p0-0.9.1.jar 用于创建C3P0连接池的包
ehcache-1.2.3.jar ：用于缓存实现的包
cglib-2.2.jar 动态修改字节码的包
Spring的包：spring.jar 核心包
aopalliance.jar 使用Aop功能可以用到的包
aspectjrt.jar
aspectjweaver.jar 使用ASPECTJ表达式需要用到的包
如果是使用DBCP连接池的话，需要两个jar包
commons-dbcp.jar commons-pool.jar
如果需要用到commons增加包的话，可以加入以下包
commons-beanutils.jar commons-lang.jar commons-logging.jar
Struts2的包：commons-fileupload-1.2.1.jar commons-io-1.3.2.jar
freemarker-2.3.13.jar ：在Struts2 中默认使用的是FreeMarker模板引擎
ognl-2.6.11.jar ：Struts2中使用OGNL表达式
struts2-core-2.1.6.jar 核心包
xwork-2.1.2.jar 核心包
struts2-spring-plugin-2.1.6.jar Struts2跟Spring整合需要的插件包
4：构建项目分包结构
5：放置配置文件
6：创建POJO和相对应的hbm.xml
7：修改空白的Hibernate.cfg..xml并创建表结构
8：创建DAO,SERVICE,ACTION
9：修改配置文件
并且按照模块的分布进行applicationContext文件的配置
Struts.xml。