天天看点
返回

struts1与spring的集成

Spring和Struts整合的价值在于将Struts使用的BO或DAO 乃至Action交给Spring管理，从而充分利用Spring强大的IoC和AOP 特性。

无论使用哪种方式整合，都需要为 Struts装载 Spring 应用上下文环境。有以下三种方式：

1) 在struts-config.xml中使用Struts Plugin

<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn"> 

<set-property property="contextConfigLocation"    

   value="/WEB-INF/classes/applicationContext.xml,/WEB-INF/action-servlet.xml"/> 

</plug-in>

2) 在web.xml中使用ContextLoaderListener

<context-param> 

      <param-name>contextConfigLocation</param-name> 

      <param-value>/WEB-INF/classes/applicationContext.xml</param-value> 

</context-param> 

<listener> 

      <listener-class> 

           org.springframework.web.context.ContextLoaderListener 

      </listener-class> 

</listener>

3) 在web.xml中使用ContextLoaderServlet

<context-param> 

      <param-name>contextConfigLocation</param-name> 

      <param-value>/WEB-INF/classes/applicationContext.xml</param-value> 

</context-param> 

<servlet> 

     <servlet-name>SpringContextServlet</servlet-name> 

     <servlet-class> 

         org.springframework.web.context.ContextLoaderServlet 

     </servlet-class> 

     <load-on-startup>1</load-on-startup> 

</servlet>

注意：

用Struts PlugIn的方式加载Spring配置文件有可能导致DWR无法取得Spring中定义的bean，因为DWR有可能先于Struts被访问使用，而此时Struts配置文件还未加载！

因此，在Spring、Struts和DWR 集成时，应该在web.xml中通过ContextLoaderLisenter或ContextLoaderServlet加载Spring配置文件。

最佳实践是使用Struts PlugIn的方式加载Struts Action配置文件/WEB-INF/action-servlet.xml，而使用ContextLoaderLisenter或ContextLoaderServlet方式加载Spring配置文件applicationContext.xml，通过两次加载完成Spring所有配置文件的加载。

至少有四种Spring与Struts整合方式：

1.      手工创建Spring 环境整合 Spring和Struts

   为了Web应用环境可以和Spring的IoC容器很好的结合，Spring提供了专门用于Web应用

环境中的Spring容器——WebApplicationContext。使用ContextLoaderPlugIn装载 Spring 应

用程序环境时，ContextLoaderPlugIn会自动创建一个WebApplicationContext对象，并加载

相应的配置文件，然后将其保存在ServletContext中。之后所有的Servlet或Action便都可以过

ServletContext访问该WebApplicationContext实例并从中获取BO或DAO Bean。

ServletContext servletContext=this.getServlet().getServletContext(); 

WebApplicationContext ctx= 

        WebApplicationContextUtils.getWebApplicationContext(servletContext); 

UserInfoDAO userInfoDAO=(UserInfoDAO)ctx.getBean("userInfoDAO");

2.      使用 Spring 的 ActionSupport 类整合 Struts

org.springframework.web.struts.ActionSupport 类提供了一个 getWebApplicationContext() 方法可以获取到WebApplicationContext实例，您所做的只是从 Spring 的 ActionSupport 而不是 Struts Action 类扩展您的动作：

public class AddActionSupport extends ActionSupport { 

    public ActionForward execute(ActionMapping mapping, ActionForm form, 

            HttpServletRequest request, HttpServletResponse response) { 

        AddForm addForm = (AddForm) form; 

        UserInfo user=new UserInfo(); 

        user.setUserName(addForm.getName()); 

        user.setUserPwd(addForm.getPassword()); 

        UserInfoDAO userInfoDAO= 

                           (UserInfoDAO)getWebApplicationContext().getBean("userInfoDAO"); 

        userInfoDAO.save(user); 

        return mapping.findForward("success"); 

    } 

}

        结论：第1、2种整合方式由Spring来管理BO或DAO Bean，实现了表示层和业务逻辑层的解耦，但Struts的Action和Spring耦合在了一起，违反了Spring“非侵入”性原则；另外,Action类负责查找由Spring管理的Bean,也违背了Spring控制反转(IoC)的原则。以下第3、4种整合方式实现了由Spring来管理Struts Action，实现了Struts和Spring的解耦，从而解决了以上问题。

3.      使用 Spring 的 DelegatingRequestProcessor 覆盖 Struts 的 RequestProcessor

用Spring的DelegatingRequestProcessor重载Struts 默认的 RequestProcessor。这样当收到一个针对Action的请求时，DelegatingRequestProcessor会自动从Spring Context中查找对应的Action Bean。

在struts-config.xml中添加：

<controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor"/>

4.      【最佳方案】使用DelegatingActionProxy将Struts Action 管理全权委托给 Spring 框架

即：使用spring的aop动态代理机制

Action 的创建和对象的依赖注入全部由IOC容器来完成，使用Spring的DelegatingAcionProxy来帮助

实现代理的工作。DelegatingActiongProxy继承于org.apache.struts.action.Action 。此时需要将struts-

config.xml中所有Action类别全部配置为 org.springframework.web.struts.DelegatingActionProxy：

<action 

      attribute="loginForm" 

      input="/login.jsp" 

      name="loginForm" 

      path="/login" 

      scope="request" 

      type="org.springframework.web.struts.DelegatingActionProxy"> 

      <forward name="error" path="/error.html" /> 

      <forward name="success" path="/success.html" /> 

</action>

3、4两种方式都需要在WEB-INF下新建一个action-servlet.xml作为Spring context文件，创建Struts Action Bean，并对Action进行BO或DAO Bean注入：

<!--name 的取值一定要和Struts 配置文件action 中的path 的值相对应--> 

<bean name="/login" class="cn.qdqn.ssh.struts.action.LoginAction"> 

      <property name="userBO"> 

       <ref bean="userBO"/> 

      </property> 

</bean>

结论：

以上2种方式实现了由Spring管理Struts的Action，从而可以利用Spring在Struts Action中轻松的注入BO或DAO，还可以将 Spring 的 AOP 拦截器应用于Struts 动作，用最小的代价处理横切关注点。

第3种整合方式只需要配置一个<controller>，不需要改动Struts Action配置信息，但Struts的 RequestProcessor只能被重载一次，如果在应用中还要进行编码等其它功能RequestProcessor重载时，此种方式将异常繁琐。

第4种整合方式可以避免RequestProcessor的占用，但必须将struts-config.xml中所有Action类别全部配置为 org.springframework.web.struts.DelegatingActionProxy。

源自：http://fengqinyun168.blog.163.com/blog/static/114628027200931710350646/

spring和struts1.x的整合有三种方法：本人习惯使用其中的一种，在这里做一下简要的介绍，如果对其他整合方法感兴趣的话，可以查阅相关资料。

低耦合的Struts集成Spring的实例 （以简单的学生管理系统为例）

我们在集成Spring和struts的时候，往往习惯于使用spring提供的ActionSupport,然后使用getWebApplicationContext()方法获得spring的bean,这样固然方便，但有一个弊端，就是我们的struts action依赖了spring的api，增加了耦合，现在什么都流行高内聚，低耦合，spring为我们提供了代理的Struts action,这样，我们在struts-config.xml不再为path设置真正的action,而是设计spring的代理Action,然后由spring的代理action,去寻找在spring bean 容器中的真正的action,这样，我们的action是一个完全没有依赖于spring的action ，具体实现请看以下代码：

public class StudentAction extends DispatchAction {

 private StudentDao studentDao;

 private GradeDao gradeDao;

 public StudentDao getStudentDao() {

  return studentDao;

 }

 public void setStudentDao(StudentDao studentDao) {

  this.studentDao = studentDao;

 }

 public GradeDao getGradeDao() {

  return gradeDao;

 }

 public void setGradeDao(GradeDao gradeDao) {

  this.gradeDao = gradeDao;

 }

 public ActionForward loadadd(ActionMapping mapping, ActionForm form,

   HttpServletRequest request, HttpServletResponse response)

   throws Exception {

     List<Grade> list = gradeDao.list();

     request.setAttribute("list", list);

  return mapping.findForward("loadadd");

 }

 public ActionForward add(ActionMapping mapping, ActionForm form,

   HttpServletRequest request, HttpServletResponse response)

   throws Exception {

  StudentForm sf = (StudentForm)form;

  Student stu = sf.getStu();

  String gradeId = request.getParameter("gradeId");

  Grade grade = new Grade();

  grade.setGradeId(Integer.parseInt(gradeId));

  stu.setGrade(grade);

  studentDao.add(stu);

  return mapping.findForward("add");

 }

 public ActionForward loadedit(ActionMapping mapping, ActionForm form,

   HttpServletRequest request, HttpServletResponse response)

   throws Exception {

  String id = request.getParameter("id");

  Student stu = studentDao.getStu(Integer.parseInt(id));

  request.setAttribute("stu", stu);

  List<Grade> list = gradeDao.list();

     request.setAttribute("list", list);

  return mapping.findForward("loadedit");

 }

 public ActionForward edit(ActionMapping mapping, ActionForm form,

   HttpServletRequest request, HttpServletResponse response)

   throws Exception {

  StudentForm sf = (StudentForm)form;

  Student stu = sf.getStu();

  String gradeId = request.getParameter("gradeId");

  Grade grade = new Grade();

  grade.setGradeId(Integer.parseInt(gradeId));

  stu.setGrade(grade);

  studentDao.edit(stu);

  return mapping.findForward("edit");

 }

 public ActionForward delete(ActionMapping mapping, ActionForm form,

   HttpServletRequest request, HttpServletResponse response)

   throws Exception {

  String id = request.getParameter("id");

  studentDao.delete(Integer.parseInt(id));

  return mapping.findForward("delete");

 }

 public ActionForward list(ActionMapping mapping, ActionForm form,

   HttpServletRequest request, HttpServletResponse response)

   throws Exception {

  List<Student> list = studentDao.list();

  request.setAttribute("list", list);

   return mapping.findForward("list");

 }

 public ActionForward search(ActionMapping mapping, ActionForm form,

   HttpServletRequest request, HttpServletResponse response)

   throws Exception {

  String gradeId= request.getParameter("gradeId");

  Map<String, String> map = new HashMap<String, String>();

  map.put("gradeId", gradeId);

  List<Student> list  = studentDao.search(map);

  request.setAttribute("list", list);

  return mapping.findForward("search");

 } 

}

Dao接口的实现类：

public class StudentDaoImpl extends HibernateDaoSupport implements StudentDao {

 public void add(Student stu) {

  getHibernateTemplate().save(stu);

 }

 public void delete(int id) {

  getHibernateTemplate().delete(

    getHibernateTemplate().get(Student.class, id));

 }

 public void edit(Student stu) {

  getHibernateTemplate().update(stu);

 }

 public Student getStu(int id) {

  return (Student) getHibernateTemplate().get(Student.class, id);

 }

 public List<Student> list() {

  return getHibernateTemplate().loadAll(Student.class);

 }

 public List<Student> search(Map<String, String> map) {

  List<Student> list = null;

  String gradeId = map.get("gradeId");

  String hql = "from Student where 1=1 ";

  if (gradeId != null && !"".equals(gradeId)) {

   hql += " and gradeId=" + gradeId;

  }

  list =  getHibernateTemplate().find(hql);

  return list;

 }

}

现在书写struts－config.xml文件：

<struts-config>

  <data-sources />

  <form-beans>

      <form-bean name="studentForm" type="com.ssh.form.StudentForm" />

      <form-bean name="gradeForm" type="com.ssh.form.GradeForm" />

  </form-beans>

  <global-exceptions />

  <global-forwards />

  <action-mappings>

       <action path="/student"

               type="org.springframework.web.struts.DelegatingActionProxy"

               parameter="cmd"

               name="studentForm"

               scope="request">

            <forward name="loadadd" path="/student_add.jsp" />

            <forward name="add" path="/student.do?cmd=list" redirect="true" />

            <forward name="loadedit" path="/student_edit.jsp" />

            <forward name="edit" path="/student.do?cmd=list" redirect="true" />

            <forward name="delete" path="/student.do?cmd=list" redirect="true" />

            <forward name="list" path="/student_list.jsp" />

            <forward name="search" path="/student_list.jsp" />

       </action>

       <action path="/grade"

               type="org.springframework.web.struts.DelegatingActionProxy"

               parameter="cmd"

               name="gradeForm"

               scope="request">

            <forward name="loadadd" path="/grade_add.jsp" />

            <forward name="add" path="/grade.do?cmd=list" redirect="true" />

            <forward name="loadedit" path="/grade_edit.jsp" />

            <forward name="edit" path="/grade.do?cmd=list" redirect="true" />

            <forward name="delete" path="/grade.do?cmd=list" redirect="true" />

            <forward name="list" path="/grade_list.jsp" />

            <forward name="search" path="/grade_list.jsp" />

       </action>

  </action-mappings>

  <message-resources parameter="ApplicationResources" />

  <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">

     <set-property property="contextConfigLocation" value="classpath:applicationContext-*.xml"/>

  </plug-in>

</struts-config>

applicationContext.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>

<beans

 xmlns="http://www.springframework.org/schema/beans"

 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

<!-- 声明dao的实现类 -->

 <bean id="studentDao" class="com.ssh.dao.impl.StudentDaoImpl">

    <property name="sessionFactory" ref="sessionFactory" />

 </bean>

 <bean id="gradeDao" class="com.ssh.dao.impl.GradeDaoImpl">

      <property name="sessionFactory" ref="sessionFactory" />

 </bean>

 <!-- 与struts的整合 --> 

 <bean name="/student" class="com.ssh.action.StudentAction">

   <property name="studentDao" ref="studentDao" />

   <property name="gradeDao" ref="gradeDaoProxy" />

 </bean>

 <bean name="/grade" class="com.ssh.action.GradeAction">

   <property name="gradeDao" ref="gradeDao" />

 </bean>

</beans>

需要说明的是，由于spring dtd规定id不能有"/",所以我们用name定义path,并且，spring bean的name要和struts-config.xml中的path一致

使用DelegatingActionProxy的好处就在于你可以用不用任何spring特定的类编写Struts Action,这个方法也有不足之处，就是不太直观，因为所有路径都映射到同一个类了

对于这种情况，spring也有解决方法，就是使用请求委托

首先，为struts-config.xml增加controller

  <!-- 使用请求委托 -->

 <controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor">

 </controller>

然后，修改我们的path定义位 <action path="/listStudentAction" type="action.ListStudentActionAction"/>

这样，又和我们单独使用struts的时候一样了，但内部还是让spring取代理我们的真正的action

需要说明的是，这里的type其实是个摆设，完全可以使用 <action path="/listStudentAction"/>，写上是为了解决我们上面提到的“不够直观的”的问题

源自：http://blog.sina.com.cn/s/blog_6145ed810100dvmf.html

j2ee框架 action path spring struts
上一篇: linux 动态扫描 数码管,数码管动态扫描实用模块范例之更新（带程序和仿真图）...
下一篇: 利用全加器实现7段数码管_可以用段码液晶屏的驱动方式驱动数码管屏吗？

继续阅读