使用 Spring 框架的 ActionSupport组件整合 Struts 框架和 Spring框架的应用实例

struts整合springStruts Recipes的合著者George Franciscus将介绍另一个重大的Struts整合窍门——这次是将Struts应用程序导入Spring框架。

请跟随George，他将向您展示如何改变Struts 动作，使得管理Struts动作就像管理Spring beans那样。

结果是一个增强的web框架，这个框架可以方便地利用Spring AOP的优势。

您肯定已经听说过控制反转(IOC)设计模式，因为很长一段时间以来一直在流传关于它的信息。

如果您在任何功能中使用过Spring框架，那么您就知道其原理的作用。

在本文中，我利用这一原理把一个Struts应用程序注入Spring框架，您将亲身体会到IOC模式的强大。

将一个Struts应用程序整合进Spring框架具有多方面的优点。

首先，Spring是为解决一些关于JEE的真实世界问题而设计的，比如复杂性、低性能和可测试性，等等。

第二，Spring框架包含一个AOP实现，允许您将面向方面技术应用于面向对象的代码。

第三，一些人可能会说Spring框架只有处理Struts比Struts处理自己好。

但是这是观点问题，我演示三种将Struts应用程序整合到Spring框架的方法后，具体由您自己决定使用哪一种。

我所演示的方法都是执行起来相对简单的，但是它们却具有明显不同的优点。

我为每一种方法创建了一个独立而可用的例子，这样您就可以完全理解每种方法。

请参阅下载部分获得完整例子源代码。

请参阅参考资料，下载Struts MVC和Spring框架。

为什么Spring这么了不起?Spring的创立者Rod Johnson以一种批判的眼光看待Java™企业软件开发，并且提议很多企业难题都能够通过战略地使用IOC模式(也称作依赖注入)来解决。

当Rod 和一个具有奉献精神的开放源码开发者团队将这个理论应用于实践时，结果就产生了Spring框架。

Spring 和struts 整合的三种方式。

1，使用Spring 的ActionSupport2, 使用Spring 的DelegatingRequestProcessor 类。

3，全权委托。

无论用那种方法来整合第一步就是要为struts来装载spring的应用环境。

就是在struts 中加入一个插件。

struts-config.xml中<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn"><set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml"/> </plug-in>spring 的配置文件被作为参数配置进来。

这样可以省略对web.xml 文件中的配置。

确保你的applicationContext.xml 在WEB-INF目录下面1，使用Spring的ActionSupport .Spring 的ActionSupport 继承至org.apache.struts.action.ActionActionSupport的子类可以或得WebApplicationContext类型的全局变量。

通过getWebApplicationContext()可以获得这个变量。

这是一个servlet 的代码：public class LoginAction extends org.springframework.web.struts.ActionSupport {public ActionForward execute(ActionMapping mapping, ActionForm form,HttpServletRequest request, HttpServletResponse response) {LoginForm loginForm = (LoginForm) form;// TODO Auto-generated method stub//获得WebApplicationContext 对象WebApplicationContext ctx = this.getWebApplicationContext();LoginDao dao = (LoginDao) ctx.getBean("loginDao");User u = new User();u.setName(loginForm.getName());u.setPwd(loginForm.getPwd());if(dao.checkLogin(u)){return mapping.findForward("success");}else{return mapping.findForward("error");}}}applicationContext.xml 中的配置<beans><bean id="loginDao" class="com.cao.dao.LoginDao"/></beans>这种配置方式同直接在web.xml文件配置差别不大。

Spring学习之Spring与Sturts2的整合●单个Struts2操作：通常web客户端访问web服务器要经过拦截器到达action，然后在action中进行一系列的操作，比如访问数据库，转发到目标页面:例如：定义一个TestAction extends ActionSourpport{}⏹需要在struts.xml文件中配置:<action name=”test” class=”TestAction的全限定名称”><result name=”success”>/test.jsp</result></action>⏹在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>●单个Spring操作Spring和Struts2整合操作：由Spring定义TestAction：<bean id=”test”class=”TestAction类的全限定没名称”></bean>当然，在测试的时候，在Spring容器中获取一个对象需要先获取Spirng的IOC容器，然后在容器中获取目标对象首先获取Spring的IOC容器ApplicationContext ac = new ClassPathXmlApplicationContext(“applicationContext.xml”);//然后获取TestAction对象TestAction ta = (TestAction) ac.getBean(“test”);然后就可以使用这个对象了，但是，在一个web应用中，只能使用一个Spring的IOC 容器，如何才能使web的多个业务层使用同一个IOC容器呢，这就需要在web.xml文件中配置Spring的初始化IOC容器的监听器：是在整个web应用中都可以使用<listener><listener-class>org.springframework.web.context.ContextLoaderListener></listener-class> </listener><context-param><param-name>contextConfigLoaction></param-name><param-value>/WEB-INF/classes/applicationContext.xml</param-value>这里是applicationContext.xml位置</context-param>在web.xml文件中配置Spring的初始化IOC容器的监听器，就可以使整个web应用中都共享一个Spring的IOC容器，这样使用注解就可以定义一个bean，如果一个对象需要属性，就使用@Resource给对象注入属性这样，如果需要属性的时候，就可以拿来直接使用：当然也可以这样使用：配置web.xml文件：<?xml version="1.0"encoding="UTF-8"?><web-app version="2.5"xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_2_5.xsd"><!-- 配置Spring的IOC初始化容器配置IOC初始化容器就是为了是整个web应用共用一个Sprig的IOC容器，因为整个容器只能有一个，并且可以在整个web应用中使用--><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener><context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/classes/applicationContext.xml</param-value> </context-param>采用注解，在applicationContext.xml文件中只要配置组件扫描在TestAction中属于控制层:使用@Controller(“prototype”)多例形式package com.workit.acton;import javax.annotation.Resource;import javax.servlet.ServletContext;import org.apache.struts2.ServletActionContext;import org.springframework.context.ApplicationContext;import org.springframework.context.annotation.Scope;import org.springframework.stereotype.Controller;import org.springframework.web.context.support.WebApplicationContextUtils;import com.opensymphony.xwork2.ActionSupport;import erService;@SuppressWarnings("serial")@Controller("testAction")@Scope("prototype")public class TestAction extends ActionSupport{@Resource //给TestAction注入userService属性private UserService userService; //前提是这个UserService类要交给Spring容器管理@Overridepublic String execute() throws Exception {System.out.println("TestAction.execute()");System.out.println("\n============================\n");System.out.println(userService);userService.printInfo();//获取ServletContextServletContext application = ServletActionContext.getServletContext();//获取Spring的ioc容器ApplicationContext ac = WebApplicationContextUtils.getWebApplicationContext(application);System.out.println("在整个应用中使用Spring的IOC的容器");UserService us = (UserService) ac.getBean("userService");System.out.println(us);return "success";}}因为TestAction这个类已经交给Spring的ioc容器管理，所以在<action >中的class中不需要写类的全限定名。

spring和struts1整合Spring和Struts 1的整合是我们经常会使用的，因为我把整合的步骤大致的总结一下，主要是包含各种整合的方法以及每一种方法的利弊。

首先是要看的是如何将Spring整合一般的的Web应用，也就是说即使不使用Struts也是可以使用Spring的，当然这种整合的方法也适合于Struts的应用中。

首要是要注册一个Spring提供的一个监听器，注册好了之后就可以使用Web应用服务器来进行启动Spring 的容器，也是ApplicationContext的实力，然后就可以使用这个对象来获取Spring容器来管理的Bean。

注册监听器的代码是：<listener><listener-class>org.springframework.web.context.ContextLoaderListener </listener-class></listener>为了可以让这个监听器来加载Spring的配置文件，还需要指定Spring配置文件的位置。

<context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/applicationContext.xml</param-value></context-param>当然这个就是默认的值，如果你的配置文件正好放在这个位置，也正好叫这个名字就可以不用配置这个初始化参数，我建议最好配置一下，这样有利于维护。

通过这样配置就可以使用Web容器来启动Spring容器了，那么我们怎么来获取这个ApplicationContext对象呢。

这个监听器就是来产生这个ApplictionContext对象的，产生了以后将这个对象放在ServleContext作用域中，只要的这个这个对象的存储时的键值就可以在Servlet来获取这个ApplicationContext对象了。

Spring 整合 Struts2 详解1. 整合目标：使 Spring 的 IOC 容器管理 Struts2 的 Action2. 步骤概览：1）. 在 WEB 应用中加入 Struts2①. 加入 jar 包②. 在 web.xml 文件中进行一些配置③. 加入 Struts2 自身的配置文件2）. 在 WEB 应用中加入 Spring①. 加入 jar 包②. 加入 Spring 的配置文件③. 在 web.xml 文件中配置启动 IOC 容器的 Listener3）. 整合①. 加入 Spring 插件②. 在 Spring 的配置文件中配置 Struts2 的 Action 实例③. 在 Struts 配置文件中配置 action4）. 原理分析3. 在 WEB 应用中加入 Struts21）. 参照struts-2.3.15.3-all\struts-2.3.15.3\apps 下的 struts2-blank.war2）. 解压struts-2.3.15.3-all\struts-2.3.15.3\apps 下的 struts2-blank.war 到当前文件夹3）. 加入 jar 包：把 struts2-blank\WEB-INF\lib\*.jar 复制到当前 WEB 应用的 WEB-INF 的 lib 目录下4）. 打开struts-2.3.15.3\apps\struts2-blank\WEB-INF\web.xml 文件，复制 filter 部分到当前 WEB 应用的 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>5）.复制struts-2.3.15.3\apps\struts2-blank\WEB-INF\classes下的 struts.xml 文件到当前 WEB 应用的 src 目录下，并删除部分配置，只保留如下内容：<struts><constant name="struts.enable.DynamicMethodInvocation" value="false" /> <constant name="struts.devMode" value="true" /><package name="default" namespace="/" extends="struts-default"></package></struts>4. 在 WEB 应用中加入 Spring：1）. 加入Spring 的jar 包：注意：需要加入WEB 应用的 spring-web-4.0.0.RELEASE.jar,因为Struts2 中已经包含了 commons-logging 的 jar 包，所以这里可以不添加 commons-loggingspring-beans-4.0.0.RELEASE.jarspring-context-4.0.0.RELEASE.jarspring-core-4.0.0.RELEASE.jarspring-expression-4.0.0.RELEASE.jarspring-web-4.0.0.RELEASE.jar2）.在类路径下加入 Spring 的配置文件（也可以放在其它路径下）3）. 在 web.xml 文件中配置启动 IOC 容器的 Listeneri. 配置 Spring 配置文件的位置<context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value> </context-param>ii. 配置启动 IOC 容器的 Listener<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>5. Spring整合 Struts2：1）. 加入Spring 插件：复制 struts-2.3.15.3-all\struts-2.3.15.3\lib\struts2-spring-plugin-2.3.15.3.jar 到当前 WEB 应用的 lib 下2）.在 Spring 的配置文件中配置 Struts2 的 Action 实例，注意：需要配置 scope 属性为 prototype，因为 Struts2 的 Action 不是单例的！例如：<bean id="userAction"class="erAction" scope="prototype"><property name="userService" ref="userService"></property></bean>3）.在 Struts 配置文件中配置 action, 但其 class 属性不再指向该 Action 的实现类, 而是指向 Spring 容器中 Action 实例的 ID例如：<action name="helloworld" class="userAction"><result>/success.jsp</result></action>6. Spring 整合 Struts2 原理解析：Struts2与Spring的集成要用到Spring插件包struts2-spring-plugin-x-x-x.jar。

Struts+Hibernate+Spring整合<1>在eclipes中，新建一个Web项目：<2>添加Spring支持,也就是导入Spring1.2的所有jar包步骤：工程右键--->选择MyEclipes--->Add Spring Capabilities--->进行添加Spring支持选择Spring1,导入Spring1.2所有jar包,把导入的jar包放在/WebRoot/WEB-INF/lib目录下,之后点击下一步,在此我们不改变Spring核心配置文件名称,依然叫applicationContext.xml 之后我们点击Finish完成,此时添加Spring支持完成<3>此时添加Spring支持完成,接下来在工程中创建两个包,名称分别为：(1)org.totti.hibernate：用于存放HibernateSessionFactory类的,利用HibernateSessionFactory可以获取到Sessin对象以及对Sesson进行管理,从而可以通过Session对数据持久化进行操作(2)org.totti.bean：1.此包中用于存放Hibernate通过表产生的映射文件*.hbm.xml2.存放与表产生映射关系的POJO类3.存放Hibernate中DAO框架的实现类,此类中封装着许多写好的对数据操作的方法在此我们配置数据库连接：<4>添加Hibernate支持,,进行对Hibernate和Spring的整合步骤：工程右键--->选择MyEclipes--->Add Hibernate Capabilities--->进行添加Hibernate 支持<5>★在添加Hibernate支持时,我们要导入Hibernate3.1的所有jar包,以及Hibernate3.1的DAO框架,还有与Spring整合的Spring1.2jar,把jar包放在/WebRoot/WEB-INF/lib目录下之后我们点击下一步(Next)<6>★在这一步中我们要注意了,在此我们要选择生成Hibernate中主配置文件的方式,在这里我们选择利用Spring配置文件生成Hibernate的主配置文件(hibernate.cfg.xml)之后我们点击下一步(Next)<7>★在这里我们选择已有的Spring配置文件(也就是一开始我们添加的Spring支持),我们根据他生成Hibernate支持,这样就对Spring和Hibernate进行了整合,在次我们要为我们创建的SessionFactory起一个名字,在这里我们叫做：sessionfactory,此sessionfactory的生成,会在Spring主配置文件中配置,利用IoC依赖注入进行创建之后我们点击下一步(Next)<8>★在这里我们主要是配置数据源,也就是数据库连接,首先要为Bean Id起一个名字,我们叫做datasource,之后我们选择我们之前配置好的数据库连接之后我们点击下一步(Next)<9>在这里我们选择创建SessionFactory类,且把它放在org.totti.hibernate包下,此类主要是用于管理session的创建销毁以及事务处理的<10>★之后我们点击Finish完成,此时会弹出一个提示框,问你是否加载新的jar包,在此我们点击Keep Existing(保持原有),这是因为在Hibernate中包括的一些jar包,Spring 中也存在,在这里我们就不需要再次导入新了jar包了,因此选择Keep Existing<11>此时我们打开Spring的配置文件--applicationContext.xml文件,在其中已经加入了Hibernate的配置,例如：SessionFactory的创建,数据库连接的创建此时Spring和Hibernate整合完毕<12>对数据库中的表进行映射--->产生映射文件*.hbm.xml、产生映射的POJO类以及对应表映射之后的DAO框架在此我们要切换视图,切换到：MyEclipse Database Explorer在这里我们要选择：1.我们映射的工程以及映射类放在那个目录下2.创建*.hbm.xml文件,以及对Hibernate配置文件进行修改(把映射后信息进行添加)3.之后我们产生表的映射类(他是一个POJO类),在此我们不生成他的抽象类4.我们选择添加DAO框架,利用Spring DAO实现,在此Spring配置文件中回为我们配置Hibernate中DAO框架的信息(DAO框架只在Hibernate3之后才存在)之后我们点击下一步(Next)在这里我们要选择数据库表的主键的生成形式,在这里为子增长类型在添加完主键生成形式之后,我们点击下一步(Next)在此我们不需要做任何选择,因为此时我们只有一张表,并没有主外键关系以及一对多或一多一等映射关系(单向关联,双向关联),所以我们直接点击完成(Finish)此时数据库中表的映射就完成了,生成了对应表的的映射文件,映射类以及DAO框架此时我们Hibernate对数据库表的映射完成了<13>之后我们添加Struts支持步骤：工程右键--->选择MyEclipes--->Add Struts Capabilities--->进行添加Struts支持在这里我们选择Struts1.2,且把配置文件以及对应资源文件放入org.totti.struts包下此时添加Struts支持完成(所需要的Struts Jar包全部导入程序中)<14>之后在Struts配置文件(struts-config.xml)建立"三合一"所谓"三合一"就是创建jsp页面以及对应的action和actionform<15>在建立"三合一"之后,我们此时做一个添加用户的操作,因此我们要建立一个Jsp页面,,页面上含有两个struts控件分别是：userName和userPassword,我们生成此JSP 页面之后点击下一步(Next)在此页面中我们不许要修改任何东西,直接点击完成即可(Finish)此时"三合一"配置完成<16>之后我们再创建两个JSP页面,分别为success.jsp(成功页面)和error.jsp(失败页面)我们在addUser对应action中进行业务处理,添加用户成功,则根据success跳转到success.jsp页面,如果用户添加失败,则根据原error跳转到error.jsp页面<17>我们打开添加用户的addUsers(action),进行业务逻辑的处理//执行添加用户操作,根据DAO框架实例化对象调用其save方法实现usersDAO.save(users);returnStr="success";}catch(Exception e){e.printStackTrace();}//根据操作结果进行跳转页面return mapping.findForward(returnStr);}}如图所示,这就是我们在action中进行的业务处理<18>接下来我们修改struts-config.xml文件(Struts配置文件)此时进行Struts和Spring的整合★我们把type中对应的action所在的包.类名复制到Spring配置文件中,1.此时我们要在Spring配置文件中创建一个<bean>标签,把Struts中<action标记的>type中的值复制到Spring中<bean标记中>class中,2.之后把Spring中<bean标记>所对应的name属性中的值为Struts配置文件中<action标记>中path属性中的值3.在Spring中创建的<bean>标记中添加属性,其中属性名称为之前action类中我们设置的属性UsersDAO,而我们注入这个属性的值是通过引用DAO框架在配置文件中创建的值<!--创建Hibernate中DAO框架的实例化对向--><bean id="UsersDAO"class="ersDAO"> <property name="sessionFactory"><ref bean="sessionfactory"/></property></bean><!--创建对应actin对象,其中name中的值为用户请求Strust配置文件中path所对应的值其中属性为usersDAO,此属性在action类中有,他是通过引用之前创建的DAO框架对象之后通过setter注入到action属性中取得--><bean name="/addUser"class="org.totti.struts.action.AddUserAction"> <property name="usersDAO"><ref bean="UsersDAO"/></property></bean><19>★之后把Struts配置文件type中的值改为：org.springframework.web.struts.DelegatingActionProxy(固定值)<forward name="success"path="/success.jsp"/><forward name="error"path="/error.jsp"/></action></action-mappings><message-resourcesparameter="org.totti.struts.ApplicationResources"/><!--配置plug-in插件,使得在服务器加载时就进行了对Spring配置文件的解析,把所有类创建好了以及注入--><!--其中className为固定值表示在初始化时加载这个插件property也为固定值,标识在上下文初始化时对此文件进行加载value表示Spring配置文件所在路径,对其进行加载解析--><plug-inclassName="org.springframework.web.struts.ContextLoaderPlugIn"><set-property property="contextConfigLocation"value="/WEB-INF/applicationContext.xml"/> </plug-in></struts-config><21>★最后我们把Spring的配置文件放入/WebRoot/WEB-INF目录下即可之前忘记操作数据库连接的操作了,在此不上<22>此时Struts与Spring整合完成也就意味着我们Struts+Hibernate+Spring整合完成在这里我们说一下SSH整合后程序执行的过程：<1>在服务器启动之后,Spring配置文件(applicationContext.xml)已经被加载解析到容器之后了,也就是我此时所有IoC注入已经完成,Spring配置文件能在服务器启动时就进行初始化是因为我们在Sturts配置文件中设置了Plug-in插件,此插件可以使Spring配置文件在服务器启动初始化<2>当用户发送请求,例如添加用户操作,此时由于表单提交过来的请求名称为*.do此时回被ActionServlet(Struts核心控制器接管),他会到struts-config.xml (Struts主配置文件）配置文件中去查找对应用户请求的path,找到之后也就找到了对应的action标记,之后根据action标记中的attribute属性去执行formbean(struts标记)的填充之后调用type中指定的action,但是此时由于我们已经交给Spring进行代理执行了,此时调用type中指定包.类名的话,回查找到Spring配置文件<3>在后在Spring配置文件中执行,此时我们并不知道要执行那一个<bean>标记中,以及执行那个action,这是就要通过bean标记中name属性进行指定,name属性中的值和Struts中action标记中path属性中的值是相同的,这也就意味着用户发送请求会根据请求路径在Spring中找到对应<bean>标记,之后找到对应要执行的action,且在此<bean>标记中要进行属性的setter注入<4>在根据Spring找到action类之后,对action类进行操作(控制层),在此进行数据封装之后,会去调用相应模型层进行业务逻辑操作,在业务逻辑操作的过程中我们会进行Hibernate 持久化操作,进行持久层操作,持久层操作完之后返回给模型层,之后返回给控制层,控制层根据返回的结果进行相应的页面跳转,返回给用户。

spring结合strutsStruts调用流程如下图所示。

看到这幅图一下子就能了解了struts的原理。

Spring的核心就是IOC容器和AOP，所以我们用spring主要是管理业务对象和事务的管理，所以主要是Model层来让spring管理，这是我们的一种方案。

第一种集成方案在Action中取得beanFactory还记的在上篇文章中，测试的时候是在单元测试中拿到的BeanFactory，与struts结合就是在Action中取得beanFactory。

步骤如下。

1、建立一个web项目。

2、建立相关页面，代码如下所示。

Login.jsp代码入下所示。

<%@ pagelanguage="Java" contentType="text/html; charset=GB18030"pageEncoding="GB18030"%><!DOCTYPE html PUBLIC"-//W3C//DTD HTML 4.01 Transitional//EN""/TR/html4/loose.dtd"> <html><head><metahttp-equiv="Content-Type" content="text/html;charset=GB18030"><title>Insert titlehere</title></head><body><formaction="login.do" method="post">用户:<input type="text"name="username"><br>密码:<input type="password"name="password"><br><inputtype="submit" value="登录"></form></body></html>Login_success.jsp<%@ pagelanguage="java" contentType="text/html; charset=GB18030"pageEncoding="GB18030"%><!DOCTYPE html PUBLIC"-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"> <html><head><metahttp-equiv="Content-Type" content="text/html;charset=GB18030"><title>Insert titlehere</title></head><body>xx,用户登录成功!</body></html>3、配置struts环境，关于struts的配置，拷贝struts和jstl的依赖包；在web.xml中配置ActionServlet，提供struts-config.xml文件。

1.1采用将Struts的Action类的管理委托给 Spring实现整合Struts框架和Spring框架的应用实例1、spring中的org.springframework.web.struts.DelegatingActionProxy类（1）DelegatingActionProxy同样是org.apache.struts.action.Action的一个子类DelegatingActionProxy同样是org.apache.struts.action.Action的一个子类，它将把调用请求转交给真正的Action实现。

下面是DelegatingActionProxy的execute方法代码：public ActionForward execute(ActionMapping mapping,ActionForm form,HttpServletRequest request,HttpServletResponse response) throws Exception { //获得实际的Action实例，并将请求转交Action delegateAction = getDelegateAction(mapping);return delegateAction.execute(mapping, form, request, response);}（2）作用：代理功能如此一来，Struts 在运行期加载的实际上是DelegatingActionProxy ，而DelegatingActionProxy则实现了针对实际Action的调用代理，Struts最终调用的将是由Spring管理的Action实例。

（3）目的通过这样的方式，Spring 获得了对Action 实例的管理权，它将对Action进行调度，并为Struts提供所需的Action实例。

既然Action已经由Spring全权接管，那么我们就可以将此Action看作是Spring中的一个Bean，它可享受Spring提供的所有服务（依赖注入、实例管理、事务管理等）。

基于M V C模式能J St r ut s和Spr i ng框架的分析及整合任仁(同济大学软件学院上海200092)【攘要】简单介鲠[J2E E，详述州C模式中N odel，V i ew以及C ont r o l l er之间的关系。

对目前-eb应用开发中的两个流行框架st r u t s和spr i ng进行了分析。

针对这两个框架的优点和不足，提出一个将两种框架分层应用、整合形成的新框架。

新的框架充分利用St r u t s、Spr i ng框柴技术的各层的优点，弥补之前两个框架中的不足。

【关键词】J2E E i f fC模式St r u t s框架Spri ng框架整合中图分类号：TP3文献标识码：A文章编号；1671--7597(2008)I”0051--01一、J2E E胃介J2EE(J ava2E nt er pr i s e E di t i on)是建立在J ava2qz台上的企业级应用的解决方案。

J2E E技术的基础便是Jav a2平台，不但有J2SE平台的所有功能，同时还提供r对EJB，Ser v l et，JSp，xM L等技术的全面支持，其最终目标是成为一个支持企业级应用开发的体系结构，简化企业解决方案的开发，部署和管理等复杂问题。

事实上，J2EE已经成为企业级开发的工业标准和首选平台。

J2E E并非一个产品，而是～系列的标准。

=、M vC设计文式M V C英文即(M ode l一V i ew-C ont r ol l e r)，即把一个应用的输入、处理、输出流程按照M o del、V i ew、C ont r ol l e r的方式进行分离，这样一个应用被分成三个层模型层、视图层、控制层。

视图(vi m代表用户交互界面，对于W eb应用来说，可以概括为H TM L界面。

但有可能为X H T M L、X M L和A ppl e t。

模型(M ode l)就是业务流程／状态的处理以及业务规则的制定。

spring struts2 整合原理
Spring和Struts2的整合原理是通过Struts2框架提供的拦截器
来实现的。

在整合中，Spring框架负责管理Struts2的Action
对象，并提供依赖注入的功能。

具体的整合步骤如下：
1. 在Spring的配置文件中，配置Struts2的拦截器，指定
Struts2的配置文件路径，并注册Spring的拦截器。

2. 在Struts2的配置文件中，使用Spring创建Action对象，通
过Spring的依赖注入注入依赖的业务逻辑对象。

3. 配置Struts2的拦截器栈，指定拦截器的顺序和执行条件。

4. 在Struts2的Action类中，使用注解或XML配置将Action
类注册为Spring的Bean。

5. 在Spring的配置文件中，配置Action类所需要的依赖对象，并使用依赖注入将其注入到Action类中。

通过以上的步骤，实现了Spring和Struts2的整合。

整合后，Spring负责管理Struts2的Action对象以及其依赖的业务逻辑
对象，实现了两个框架的功能互补。

同时，整合后还可以利用Spring的强大功能，如AOP、事务管理等，来增强Struts2的
功能。

Struts框架应用步骤第1步：向web应用程序添加struts框架的功能注意：必须要选中项目的根节点第2步：创建一个普通的类，一般都归放在web层的包中。

第3步：在类中定义前台页用户输入的数据项，并为这些数据项提供get/set方法第4步：再定义一个处理业务请求的方法，该方法返回String类型第5步：将这个定义了数据项和业务处理方法的类，在struts.xml中注册第6步：编写前台JSP页面，并导入Struts标签库，并且把form的action属性填写上面配置的action的name值Spring框架应用步骤第1步：选中根节点，选spring框架，如下图第2步：在web.xml文件中加上以下代码<listener><listener-class>org.springframework.web.context.ContextLoaderL istener</listener-class></listener>第3步：在spring的配置文件applicationContext.xml中注册各层的对象注意：每层的对象注册时，如果该对象还有属性依赖别的对象，应该为这个属性生成get/set 方法第4步：在struts配置文件加上以下代码，用以交出对象的控制权<constant name="struts.objectFactory"v alue="spring"></constant><include file="struts-default.xml"></include>第5步：修改struts的action的class属性，使之与spring中的对象id属性值对应第6步：将applicationContext.xml复制到WEB-INF目录下，就可以部署启动了。

方式一:使用spring的ActionSupport或DispachActionSupport 类整合Structs Actionpackage com.yz.actions.action;import ng.reflect.InvocationTargetException;import javax.servlet.http.*;import mons.beanutils.BeanUtils;import org.apache.struts.action.*;import org.springframework.web.struts.DispatchActionSupport;import com.yz.services.*;import com.yz.actions.form.*;import erVo;//spring的action管理请求public class UserAction extends DispatchActionSupport {//针对接口编程IUserServices ius;public IUserServices getIus() {return ius;}public void setIus(IUserServices ius) {this.ius = ius;}public ActionForward test(ActionMapping mapping, ActionForm form,HttpServletRequest request, HttpServletResponse response) {UserForm userForm = (UserForm) form;UserVo uv = new UserVo();try {BeanUtils.copyProperties(uv, userForm);} catch (Exception e) {e.printStackTrace();}/**//*IUserServices ius = new IUserServicesImpl();*///通过父类的方法获取spring容器并得到其中的bean对象ius =(IUserServices)super.getWebApplicationContext().getBean("ius");boolean add = ius.addUsers(uv);System.out.println(uv.getUserName());String url = "/error.jsp";if(add){url = "/ok.jsp";}System.out.println(url);return new ActionForward(url) ;}}自己写的请求处理器，处理中文乱码package com.yz.myReq;import java.io.UnsupportedEncodingException;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.apache.struts.action.RequestProcessor;public class myReq extends RequestProcessor {@Overrideprotected boolean processPreprocess(HttpServletRequest request, HttpServletRespon se response) {try {request.setCharacterEncoding("utf-8");response.setCharacterEncoding("utf-8");} catch (UnsupportedEncodingException e) {e.printStackTrace();}return super.processPreprocess(request, response);}}struts-config.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configur ation 1.2//EN" "/dtds/struts-config_1_2.dtd"><struts-config><data-sources /><form-beans ><form-bean name="userForm" type="erForm" /></form-beans><global-exceptions /><global-forwards /><action-mappings ><actionattribute="userForm"name="userForm"path="/user"scope="request"type="erAction"parameter="actions"/></action-mappings><controller processorClass="com.yz.myReq.myReq"></controller><message-resources parameter="com.yz.actions.ApplicationResources" /><!-- 添加一个插件，用来在启动struts框架的时候，同时读取spring配置文件，启动spring容器 --><plug-in className="org.springframework.web.struts.ContextLoaderPlugIn"><set-property property="contextConfigLocation"value="/WEB-INF/applicationContext.xml"/></plug-in></struts-config>applicationContext.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:util="/schema/util"xmlns:p="/schema/p"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans /sche ma/beans/spring-beans-2.0.xsd/schema/util /schema /util/spring-util-2.0.xsd/schema/tx /schema/t x/spring-tx-2.0.xsd/schema/aop /schem a/aop/spring-aop-2.0.xsd"><bean id="userDaoImpl" class="com.yz.dao.impl.IuserDaoImpl"></bean><!-- action里面有一个ius(service的接口引用),他来自 com.yz.services.impl.IUserServicesImpl(指向接口的实现类)IUserServicesImpl里面有一个iud(IuserDao接口引用)他 ref id为 userDaoImpl(指向接口的实现类)--><bean id="ius" class="com.yz.services.impl.IUserServicesImpl"><property name="iud"><ref bean="userDaoImpl"/></property></bean></beans><!--整合思路：1、通过从 Spring 的 ActionSupport或者DispachActionSuport 类而不是 Struts 的 Action 类进行扩展，创建了一个新的 Action，2、使用 getWebApplicationContext() 方法获得一个 ApplicationContext。

Struts2,Spring,Hibernate整合步骤（自己笔记）配步骤的例子一个：请参看：Struts2,Spring,Hibernate整合例子一个1.建立web项目2.在web.xml 配置 struts2，和 spring ，<!-- 配置Struts2 --><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.FilterDispatcher(struts的过滤器)</filter-class></filter><filter-mapping>（加载struts2）<filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping><!-- 配置Spring --><listener><listener-class>org.springframework.web.context.ContextLoaderListener（spring监听器）</listener-class></listener><!-- 查找spring配置文件 --><context-param>（程序从此处开始加载.xml 文件，并执行）<param-name>contextConfigLocation</param-name><param-value>classpath*:*.xml</param-value></context-param>3.在src根目录下创建struts.xml文件<include file="struts-default.xml"/>固定格式，用到此包4.在src根目录创建hibernate.cfg.xml文件<?xml version='1.0' encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN" "/hibernate-configura tion-3.0.dtd"><hibernate-configuration><session-factory><!-- 基本配置 --><property name="dialect">org.hibernate.dialect.Oracle9Dialect</property><property name="show_sql">false</property><property name="format_sql">true</property><propertyname="e_reflection_optimizer">true</property><property name="max_fetch_depth">2</property><property name="default_batch_fetch_size">8</property><property name="jdbc.batch_size">20</property></session-factory></hibernate-configuration>系统给的文件只需要拷贝，都是一些数据库库的基本配置5.在src根目录拷贝struts.properties文件struts.objectFactory = spring 该项是告诉系统用spring来控制hibernate和Actionstruts.action.extension=action 告诉系统访问时以什么结尾。

Spring和Struts2整合⽬的：spring容器管理Action类，代替Servlet步骤：主要在配置⽂件Struts2：添加⽀持spring的jar包，配置<action class="Action类在容器中的id"Action类：定义需要容器注⼊的属性，也就是定义service，service层也要添加调⽤DAO的属性。

并⽣成get和set⽅法。

Action:service:DAO://模拟数据库连接private String conn;spring：1.web.xml配置⽂件：alt+/ C 选择ContextLoadListener创建配置配置⽂件的位置和名称classpath:spring⽂件名.xml加载容器的监听器<context-param><param-name>contextConfigLocation</param-name><param-value>classpath:app.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><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>2.添加Action类的bean：注⼊Action类的属性scope=“prototype” 多例模式<!-- DAO --><bean id="testDAO" class="com.hanqi.test.TestDAO"><property name="conn" value="Oracle"></property></bean><!-- service --><bean id="testService" class="com.hanqi.test.TestService"><property name="testDAO" ref="testDAO"></property></bean><!-- Action --><!-- scope="prototype"多利模式，Action类的实例不能是单利的 --><bean id="testID" class="com.hanqi.test.TestAction" scope="prototype"> <property name="testService" ref="testService"></property></bean>。

struts+spring+hibernate三个框架的整合准备三个框架结合的lib包Spring3结合Struts2的步骤如下：1：开启Struts2结合Spring3，在struts.xml中添加如下语句：java代码：<constant name="struts.objectFactory" value="spring"/>2：在web.xml中添加listener，如下：java代码：<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>3：在web.xml中指定需要初始读取的spring配置⽂件，如下：java代码：<context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/applicationContext-*.xml,classpath*:applicationContext-*.xml</param-value></context-param>5.当然别忘了加上Struts2⾃⼰的filter4：在struts.xml中Action配置的时候，如下：java代码：<action name="testAction" class="springBeanName"><result name="success">/index.jsp</result></action>5：在Spring中正常定义Bean就可以了，把Action定义成为Bean，如下：java代码：<bean id="testAction" class="com.bjpowernode.test.web.TestActioin"><property name="ebi" ref="testEbi"/></bean>6：在Struts的Action中，就可以通过依赖注⼊的⽅式来注⼊需要使⽤的接⼝了。

Spring 3.0整合Struts 1.3Spring是一个开源框架，它由Rod Johnson创建。

它是为了解决企业应用开发的复杂性而创建的。

Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。

Struts作为优秀的MVC实现框架，曾风靡一时，就现在而言，依然有很多系统采用，它也是我们学习Java web 编程，掌握常用开发框架必须要学习的框架。

如何将两个框架进行整合，相信是不少刚学习完Struts和Spring的程序员们想要掌握和了解的，下面，我们采用一种常用的方式将两个框架整合，更好的进行Java web开发。

1.首先，我们使用Myeclipse（作者使用的是9.0正式版）建立一个Web project，名字就起为spring_struts吧。

2.然后为项目加入Spring3.0和Struts1.3框架。

注意：在加入Spring框架时，我们需要勾选的Libraries有：A.Spring 3.0 Core LibrariesB.Spring 3.0 Web Libraries前者是Spring框架的核心jar，后者是整合Struts需要用的。

3.上面的步骤只要是学习过框架的同学都能实现，接下来就是配置了。

首先，到web.xml文件中，配置监听。

<listener><listener-class>org.springframework.web.context.ContextLoaderList ener</listener-class></listener>监听器里面的类来自Spring框架配置上下文参数，用以加载Spring的配置文件<context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value> </context-param>在struts-config.xml中配置控制器。