整合SSH三大框架介绍

合集下载

ssh框架原理及流程

ssh框架原理及流程SSH框架原理及流程。

SSH框架是指Struts、Spring、Hibernate三个开源框架的整合，它们分别解决了Web层、业务逻辑层和数据访问层的问题。

在实际开发中，SSH框架已经成为了JavaEE开发的主流框架之一。

本文将从SSH框架的原理和流程两个方面进行介绍。

首先，我们来了解一下SSH框架的原理。

Struts框架主要用于处理Web层的请求，它采用MVC（Model-View-Controller）的设计模式，将应用程序分为模型、视图和控制器三个部分。

Spring框架是一个轻量级的IoC（控制反转）和AOP（面向切面编程）容器，它提供了一个全面的基础设施，用于构建企业级应用。

Hibernate框架则是用来解决数据访问层的问题，它是一个强大的、高性能的对象关系映射（ORM）框架，能够将对象和数据库表之间进行映射，从而简化了数据访问层的开发。

接下来，我们将介绍SSH框架的流程。

首先，用户发送请求到Struts的Action，Action根据请求调用相应的业务逻辑，然后将处理结果返回给用户。

在这个过程中，Spring负责管理业务逻辑组件，提供了IoC容器和AOP框架的支持。

同时，Hibernate负责处理数据的持久化，它可以通过配置文件来映射Java对象和数据库表，从而实现数据的增删改查操作。

整个流程中，三个框架各司其职，相互配合，使得开发变得更加高效和简洁。

总结一下，SSH框架的原理是由Struts、Spring、Hibernate三个框架整合而成，分别解决了Web层、业务逻辑层和数据访问层的问题。

在实际开发中，SSH框架的流程是用户发送请求到Struts的Action，Action调用业务逻辑，Spring负责管理业务逻辑组件，Hibernate负责数据持久化。

三个框架相互配合，使得开发变得更加高效和简洁。

通过本文的介绍，相信读者对SSH框架的原理和流程有了更深入的了解，希望能够对大家在实际开发中有所帮助。

Java的strutsspringhibernate精通SSH三大框架的底层机制及原理

Java的struts、spring、hibernate精通SSH三大框架的底层机制及原理1. 什么是SSH框架SSH是由Struts、Spring、Hibernate三个框架整合而成的，它是一种企业级、全栈式框架，非常适合开发大型Web应用程序。

Struts是MVC架构模式中的控制器层，负责接收请求并转化成对应的业务逻辑进行处理，同时也控制着视图层进行渲染。

Spring是一个轻量级的开源框架，它可以被用来构建Java企业级应用，能够提供全周期的、全栈式的框架服务。

Hibernate是一个ORM（对象关系映射）框架，之前在持久化层需要进行数据库的操作，但是Hibernate可以让开发者不用直接操作数据库，而是通过Java对象与数据库进行交互。

2. SSH框架的优势SSH框架的三个组件各自拥有一系列的优势。

Struts提供了用于Web开发的MVC架构，使得应用程序的开发和维护更加清晰、明了。

Spring专注于解决企业开发中的复杂问题，比如事务管理、安全管理、远程调用、Web框架等。

Hibernate则是优秀的ORM框架，可以将Java对象与关系型数据库进行映射，让开发者不用关心具体的SQL语句。

3. SSH框架的实现机制SSH框架的三个组件相互整合，形成了一个高效、稳定、易于使用的开发框架。

在SSH框架中，Web请求首先被Struts2框架接收，Struts2框架通过ActionContext来向Action中注入Spring容器管理的Bean完成业务逻辑处理，而Bean之间的关系都是由Spring的IOC容器维护的。

声明式事务管理交给Spring框架完成，Hibernate框架在ORM层将Java对象映射到数据库记录。

下面分别来详细介绍一下SSH框架各自的底层机制及原理。

3.1 Struts2框架Struts2框架是一个基于MVC模式的Web应用程序框架。

在Struts2中，负责接收请求转发的控制器为Action。

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三大框架整合(详细版)

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.jaraspectjweaver.jar 使用ASPECTJ表达式需要用到的包如果是使用DBCP连接池的话，需要两个jar包commons-dbcp.jar commons-pool.jar如果需要用到commons增加包的话，可以加入以下包commons-beanutils.jar commons-lang.jar commons-logging.jarStruts2的包：commons-fileupload-1.2.1.jar commons-io-1.3.2.jarfreemarker-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.xml7：修改空白的Hibernate.cfg..xml并创建表结构8：创建DAO,SERVICE,ACTION9：修改配置文件并且按照模块的分布进行applicationContext文件的配置Struts.xml。

SSH框架简介

SSH框架简介SSH 即是Struts + Spring + Hibernate 3个开源框架。

一、Struts是一个MVC框架，通过配置文件很好的实现了模型与视图的分离，Struts应用包括3个组件:控制器组件(ActionServ let和自定义Action);模型组件(普通接口和Jav aBean);视图组件(ActionForm和Struts标签);Struts 的MVC设计模式可以使我们的逻辑变得很清晰。

Struts的工作流程:在web应用启动时就会加载初始化ActionServ let,ActionServ let从struts-conf ig.xml文件中读取配置信息,把它们存放到各种配置对象当ActionServ let接收到一个客户请求时,将执行如下流程.-(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息;-(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;-(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的v alidate()方法;-(4)如果ActionForm的v alidate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功;-(5)ActionServ let根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;-(6)Action的execute()方法返回一个ActionForward对象,ActionServ let在把客户请求转发给ActionForward对象指向的JSP组件;-(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;二、Spring是一个轻量级框架，提供依赖注入容器，AOP实现,DAO/ORM支持，Web集成等功能。

SSH各框架工作原理

SSH各框架工作原理SSH 是指以 Spring + SpringMVC + MyBatis 为基础的 Java Web 开发框架。

它是将三个框架集成在一起，以实现各自的功能，并提供了更加便捷的开发方式和高效的开发效率。

在了解 SSH 的工作原理之前，我们先来了解一下每个框架的作用和特点。

1. Spring：Spring 是一个开源的 JavaEE 框架，它提供了一个容器，负责管理对象的创建、销毁和依赖注入等工作。

Spring 的特点是灵活，它通过配置文件或注解的方式将对象进行装配，降低了耦合度，并支持面向切面编程（AOP）和事务管理等功能。

2. SpringMVC：SpringMVC 是 Spring 框架的一个模块，用于开发Web 应用程序。

它采用 MVC（Model-View-Controller）的设计模式，将业务逻辑、视图展示和用户交互分开。

SpringMVC 提供了一套基于注解的方式来映射 URL 到具体的处理方法，并支持数据校验、文件上传等常用功能。

3. MyBatis：MyBatis 是一个持久层框架，用于操作数据库。

它通过XML 配置文件或注解的方式，将 SQL 语句与 Java 对象进行映射。

MyBatis 提供了丰富的查询功能，并支持事务管理和缓存机制，可以有效地减少开发人员编写 SQL 语句的工作量。

了解了每个框架的作用和特点，下面我们来了解SSH框架是如何工作的。

1. 客户端发送请求：用户通过浏览器发送 HTTP 请求到服务器，请求的 URL 被映射到 SpringMVC 控制器的处理方法上。

2. SpringMVC 控制器处理请求：SpringMVC 根据请求的 URL，查找到对应的控制器，并调用相应的处理方法对请求进行处理。

控制器方法可以通过注解方式获取请求参数、校验数据等。

3. 控制器调用业务逻辑：在控制器中，可以调用业务逻辑层（Service）处理业务逻辑。

业务逻辑层通过依赖注入的方式获取数据库访问层（DAO）的实例。

ssh框架

SSH框架首先，SSH不是一个框架，而是多个框架（struts+spring+hibernate）的集成，是目前较流行的一种Web应用程序开源集成框架，用于构建灵活、易于扩展的多层Web应用程序。

集成SSH框架的系统从职责上分为四层：表示层、业务逻辑层、数据持久层和域模块层（实体层）。

Struts作为系统的整体基础架构，负责MVC的分离，在Struts框架的模型部分，控制业务跳转，利用Hibernate 框架对持久层提供支持。

Spring一方面作为一个轻量级的IoC容器，负责查找、定位、创建和管理对象及对象之间的依赖关系，另一方面能使Struts和Hibernate更好地工作。

由SSH构建系统的基本业务流程是：1、在表示层中，首先通过JSP页面实现交互界面，负责传送请求(Request)和接收响应(Response)，然后Struts根据配置文件(struts-config.xml)将ActionServlet接收到的Request委派给相应的Action处理。

2、在业务层中，管理服务组件的Spring IoC容器负责向Action提供业务模型(Model)组件和该组件的协作对象数据处理(DAO)组件完成业务逻辑，并提供事务处理、缓冲池等容器组件以提升系统性能和保证数据的完整性。

3、在持久层中，则依赖于Hibernate的对象化映射和数据库交互，处理DAO组件请求的数据，并返回处理结果。

采用上述开发模型，不仅实现了视图、控制器与模型的彻底分离，而且还实现了业务逻辑层与持久层的分离。

这样无论前端如何变化，模型层只需很少的改动，并且数据库的变化也不会对前端有所影响，大大提高了系统的可复用性。

而且由于不同层之间耦合度小，有利于团队成员并行工作，大大提高了开发效率。

下面我们再详细看一下组成SSH的这三个框架一、Spring1、什么是Spring？简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

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框架用法1. 什么是SSH框架SSH框架是一种用于构建分布式系统的开发框架，它由三个关键组件组成：Spring、Struts和Hibernate。

这三个组件分别负责处理应用程序的业务逻辑、Web层和数据访问层。

通过将它们集成在一起，SSH框架提供了一个完整的解决方案，使开发人员能够更快速、更高效地开发和维护复杂的分布式系统。

2. SSH框架的优势SSH框架具有以下几个优势：•模块化：SSH框架将整个应用程序划分为不同的模块，每个模块负责不同的功能。

这种模块化设计使得应用程序易于维护和扩展。

•松耦合：SSH框架使用依赖注入（Dependency Injection）来管理各个组件之间的依赖关系。

这种松耦合的设计使得各个组件可以独立开发、测试和部署。

•高效性能：SSH框架采用了多种优化技术，如缓存、懒加载等，来提高应用程序的性能。

同时，Hibernate作为数据访问层的组件，可以利用其自身的缓存机制来减少数据库访问次数，进一步提高性能。

•安全性：SSH框架提供了多种安全措施，如用户认证、权限控制等，以保护应用程序的安全。

同时，SSH框架还支持HTTPS协议，可以加密数据传输，提高数据的安全性。

3. SSH框架的核心组件SSH框架由三个核心组件组成：•Spring：Spring是一个轻量级的Java开发框架，它提供了依赖注入、面向切面编程等功能。

在SSH框架中，Spring负责处理应用程序的业务逻辑。

通过使用Spring的IoC容器和AOP技术，开发人员可以更方便地管理各个业务组件之间的依赖关系，并实现横切关注点的模块化。

•Struts：Struts是一个基于MVC设计模式的Web开发框架，它负责处理应用程序的Web层。

在SSH框架中，Struts作为前端控制器接收用户请求，并将请求转发给相应的业务处理组件。

通过使用Struts的标签库和拦截器机制，开发人员可以更方便地实现表单验证、页面跳转等功能。

三大框架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_三大框架介绍

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三大框架整合

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框架整合原理

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)。

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

二.添加struts2框架支持
1.引入struts2必须得几个jar包，放在WebRoot->WEB-INF->lib
目录下。

2.将WEB应用部署到tomcat服务器上：找到tomacat的安装目录Tomcat6.x\apache-tomcat-6.0.33\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>
4.在web项目的src目录下，建一个struts.xml文件，这里是处理struts整个流程的文件。

在其中加入
<struts>
<package name="struts2
extends="struts-default">
</package>
</struts>上面的name随便取，extends绝对不能变。

5.这样以后，启动tomcat服务器看看能不能正常启动，如果正常启动后，在浏览器上访问，http://localhost/上下文/index.jsp看能不能进入，若能进入则表示struts2的框架已经成功加到web项目中了，可以开始下一步了。

三．添加hibernate3的支持
1.左键选中web项目，在左键单击选中，MyEclipse软件的MyEclipse选项，选择Project Capabilities->Add Hibernate Capabilities进入如下页面
安如图所示选择，对于最后一个，若是web项目必须选第二个copy 。

，如果是一般的java项目则可以选择第一个add。

，，单击next进入如下页面：
继续next：
将上面默认的勾去掉。

再next：
再将上面的勾去掉再finish，添加完成。

四.添加Spring2.5的支持
1.将struts2的支持spring的插件的jar包加入到lib目录下。

该包在struts2的解压资源目录下可以找到名为struts2-spring-plugin-
2.2.
3.1.jar。

2.在web项目的web.xml中加入spring的监听用于启动spring容器代码为
<listener>
<listener-class>
org.springframework.web.context.ContextLoad erListener
</listener-class>
</listener>
3.左键选中web项目，在左键单击选中，MyEclipse软件的MyEclipse选项，选择Project Capabilities->Add Spring Capabilities进入如下页面：
勾选前三个和下面一个叫
共四个Libraries，注意下面那个选中copy。

，然后直接next，配置如下：
再点next：
再点击finish，这样就添加了spring2.5的支持了。

五，添加数据库驱动和连接池
1.加入数据库驱动，本例以mySql数据库为例：加入名为mysql-connector-java-5.0.8-bin.jar的驱动包。

2.加入连接数据库的链接池和其依赖的包一共两个：
commons-dbcp-1.4.jar和commons-pool.jar两个包。

3.至此数据库已经添加完成了。

4.进入工程文件夹WebRoot的WEB-INF的lib下把asm.jar
的后面版本都删除，为了防止相同名字版本不同的包相互
冲突。

包只保留一个asm.jar包，至此包一共有76个。

六，启动tomcat服务器开始测试。