struts1与spring的集成

最新推荐文章于 2021-02-21 18:40:22 发布

chendc201

最新推荐文章于 2021-02-21 18:40:22 发布

阅读量4.8k

点赞数

分类专栏： j2ee框架文章标签： action Action path PATH Path spring Spring struts Struts

j2ee框架专栏收录该内容

6 篇文章 0 订阅

订阅专栏

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：

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

<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">


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

<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

chendc201

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
struts1与spring的集成

Spring和Struts整合的价值在于将Struts使用的BO或DAO 乃至Action交给Spring管理，从而充分利用Spring强大的IoC和AOP 特性。无论使用哪种方式整合，都需要为 Struts装载 Spring 应用上下文环境。有以下三种方式：1) 在struts-config.xml中使用Struts Plugin value="/WEB-INF/cla
复制链接

扫一扫

专栏目录