`

struts与spring如何整合(2)

StrutsSpringBeanServletWeb 
阅读更多

问题：这里的plug-in标签的作用是什么？可以不写plugin-in这个标签吗？
1、其实plug-in只是为了装载Struts的ActionServlet用的，如果在web.xml的context-param中已经指定了这个Struts的ActionServlet配置文件，那么此时可以不写plug-in。
2、如果在web.xml的context-param中并没有指定这个Struts的ActionServlet配置文件，那么必须加上plug-in
3、plug-in中contextConfigLocation属性的作用是什么？可以不要这个属性吗？
如果用了plug-in，那么contextConfigLocation属性的作用是指定Struts的ActionServlet配置文件所在的位置；
如果去掉了contextConfigLocation属性，那么Struts的ActionServlet配置文件将被指定为/WEB-INF/{app}-servlet.xml文件，
({app}指的是web.xml中servlet-name的值，此处为"action"

Java代码 复制代码
  1. <!-- struts 的配置 -->   
  2.         <servlet>   
  3.             <servlet-name>action</servlet-name>   
  4.             <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>   
  5.             <init-param>   
  6.                 <param-name>config</param-name>   
  7.                 <param-value>   
  8.                     /WEB-INF/struts/struts-config.xml,   
  9.                     /WEB-INF/struts/action/fileupload-action-config.xml,   
  10.                     /WEB-INF/struts/action/demo-action-config.xml   
  11.                 </param-value>   
  12.             </init-param>   
  13.             <load-on-startup>1</load-on-startup>   
  14.         </servlet>   
  15.         <servlet-mapping>   
  16.             <servlet-name>action</servlet-name>   
  17.             <url-pattern>*.do</url-pattern>   
  18.         </servlet-mapping>  
<!-- struts 的配置 -->
	    <servlet>
	        <servlet-name>action</servlet-name>
	        <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
	        <init-param>
	            <param-name>config</param-name>
	            <param-value>
	                /WEB-INF/struts/struts-config.xml,
	                /WEB-INF/struts/action/fileupload-action-config.xml,
	                /WEB-INF/struts/action/demo-action-config.xml
	            </param-value>
	        </init-param>
	        <load-on-startup>1</load-on-startup>
	    </servlet>
	    <servlet-mapping>
	        <servlet-name>action</servlet-name>
	        <url-pattern>*.do</url-pattern>
	    </servlet-mapping>


)
所以，这是就必须在/WEB-INF/下存在action-servlet.xml文件。

现在默认的/WEB-INF/action-servlet.xml文件或由plug-in的contextConfigLocation属性指定的/WEB-INF/struts/spring/demo-action.spring.xml文件内容应该结合
web.xml的struts配置中指定的config文件内容可以这样写：

Java代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>   
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
  3. <beans>   
  4.     <bean name="/demo/list" parent="baseTxService">   
  5.         <property name="target">   
  6.             <bean class="com.ramix.demo.webapp.action.DemoListAction" autowire="byName">   
  7.                 <property name="mgr" ref="parentManager"/>   
  8.             </bean>   
  9.         </property>   
  10.     </bean>   
  11.     <bean name="/demo/save" parent="baseTxService">   
  12.         <property name="target">   
  13.             <bean class="com.ramix.demo.webapp.action.DemoSaveAction" autowire="byName">   
  14.                 <property name="mgr" ref="parentManager"/>   
  15.             </bean>   
  16.         </property>   
  17.     </bean>   
  18.     <bean name="/demo/client" class="com.ramix.demo.webapp.action.DemoClientAction">   
  19.         <property name="dws" ref="demoClient"/>   
  20.     </bean>   
  21.     <bean name="/demo/send" class="com.ramix.demo.webapp.action.DemoSendAction">   
  22.         <property name="mgr" ref="mailSendManager"/>   
  23.     </bean>   
  24.   
  25.     <bean name="/demo/child/create" parent="baseTxService">   
  26.         <property name="target">   
  27.             <bean class="com.ramix.demo.webapp.action.DemoChildCreateAction" autowire="byName">   
  28.                 <property name="mgr" ref="parentManager"/>   
  29.             </bean>   
  30.         </property>   
  31.     </bean>   
  32.     <bean name="/demo/child/save" parent="baseTxService">   
  33.         <property name="target">   
  34.             <bean class="com.ramix.demo.webapp.action.DemoChildSaveAction" autowire="byName">   
  35.                 <property name="PMgr" ref="parentManager"/>   
  36.                 <property name="CMgr" ref="childManager"/>   
  37.             </bean>   
  38.         </property>   
  39.     </bean>   
  40.     <bean name="/demo/child/list" parent="baseTxService">   
  41.         <property name="target">   
  42.             <bean class="com.ramix.demo.webapp.action.DemoChildListAction" autowire="byName">   
  43.                 <property name="mgr" ref="childManager"/>   
  44.             </bean>   
  45.         </property>   
  46.     </bean>   
  47.        
  48.     <bean name="/demo/ajax/child/list" parent="baseTxService">   
  49.         <property name="target">   
  50.             <bean class="com.ramix.demo.webapp.action.DemoAjaxChildListAction" autowire="byName">   
  51.                 <property name="mgr" ref="jdbcManager"/>   
  52.             </bean>   
  53.         </property>   
  54.     </bean>   
  55.     <bean name="/demo/test" parent="baseTxService">   
  56.         <property name="target">   
  57.             <bean class="com.ramix.demo.webapp.action.Test" autowire="byName">   
  58.             </bean>   
  59.         </property>   
  60.     </bean>   
  61. </beans>  
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean name="/demo/list" parent="baseTxService">
        <property name="target">
            <bean class="com.ramix.demo.webapp.action.DemoListAction" autowire="byName">
                <property name="mgr" ref="parentManager"/>
            </bean>
        </property>
    </bean>
    <bean name="/demo/save" parent="baseTxService">
        <property name="target">
            <bean class="com.ramix.demo.webapp.action.DemoSaveAction" autowire="byName">
                <property name="mgr" ref="parentManager"/>
            </bean>
        </property>
    </bean>
    <bean name="/demo/client" class="com.ramix.demo.webapp.action.DemoClientAction">
        <property name="dws" ref="demoClient"/>
    </bean>
    <bean name="/demo/send" class="com.ramix.demo.webapp.action.DemoSendAction">
        <property name="mgr" ref="mailSendManager"/>
    </bean>

    <bean name="/demo/child/create" parent="baseTxService">
        <property name="target">
            <bean class="com.ramix.demo.webapp.action.DemoChildCreateAction" autowire="byName">
                <property name="mgr" ref="parentManager"/>
            </bean>
        </property>
    </bean>
    <bean name="/demo/child/save" parent="baseTxService">
        <property name="target">
            <bean class="com.ramix.demo.webapp.action.DemoChildSaveAction" autowire="byName">
                <property name="PMgr" ref="parentManager"/>
                <property name="CMgr" ref="childManager"/>
            </bean>
        </property>
    </bean>
    <bean name="/demo/child/list" parent="baseTxService">
        <property name="target">
            <bean class="com.ramix.demo.webapp.action.DemoChildListAction" autowire="byName">
                <property name="mgr" ref="childManager"/>
            </bean>
        </property>
    </bean>
	
	<bean name="/demo/ajax/child/list" parent="baseTxService">
        <property name="target">
            <bean class="com.ramix.demo.webapp.action.DemoAjaxChildListAction" autowire="byName">
                <property name="mgr" ref="jdbcManager"/>
            </bean>
        </property>
    </bean>
    <bean name="/demo/test" parent="baseTxService">
    	<property name="target">
    		<bean class="com.ramix.demo.webapp.action.Test" autowire="byName">
    		</bean>
    	</property>
    </bean>
</beans>


其实这样配置的目的也就是为了利用spring的依赖注入，能够使得Struts的servletAction自如的使用service层的bean。

这里需要关注的一点是：
请看/WEB-INF/struts/action/demo-action-config.xml中的

Java代码 复制代码
  1. <action path="/demo/test"  
  2.         type="com.ramix.demo.webapp.action.DemoListAction"  
  3.         parameter="method"  
  4.         scope="request"  
  5.         name="globalForm">   
  6.     <forward name="test" path="/WEB-INF/page/demo/test.jsp"/>   
  7. </action>  
<action path="/demo/test"
		type="com.ramix.demo.webapp.action.DemoListAction"
		parameter="method"
		scope="request"
		name="globalForm">
	<forward name="test" path="/WEB-INF/page/demo/test.jsp"/>
</action>


和/WEB-INF/struts/spring/demo-action.spring.xml中的

Java代码 复制代码
  1. <bean name="/demo/test" parent="baseTxService">   
  2.     <property name="target">   
  3.         <bean class="com.ramix.demo.webapp.action.Test" autowire="byName">   
  4.         </bean>   
  5.     </property>   
  6. </bean>  
<bean name="/demo/test" parent="baseTxService">
	<property name="target">
		<bean class="com.ramix.demo.webapp.action.Test" autowire="byName">
		</bean>
	</property>
</bean>



当url中执行..../demo/test.do时，将会是个什么样的过程？
首先会到/WEB-INF/struts/spring/demo-action.spring.xml中去找name为"/demo/test"的bean，
1、找到了，则执行target属性中指定的bean（此bean就是ServletAction类）：com.ramix.demo.webapp.action.Test的execute方法，并通过autowire="byName"对该类的set方法进行依赖注入。
2、没找到，才会去/WEB-INF/struts/action/demo-action-config.xml中去找/demo/test.do,
并执行type属性中指定的ServletAction：com.ramix.demo.webapp.action.DemoListAction的execute方法

提问：servletAction中必须要写execute方法吗？
如果真的写了execute方法，那么就失去了parameter="method"的意义，如果这样做的话，那势必每个功能（通过页面操作增删改查）都需要写一个action类，这样会导致action类数量的急剧膨胀。
其实，struts的DispatchAction的execute方法被执行时，他的机制是去获得method参数，如果该参数有值，那么会去执行这个元素对应的方法。比如url是这样的.../demo/test.do?method=test
就会去执行对应的servletAction类中的test方法；如果method参数没有值，则会去执行unspecified方法。
这样我们可以通过在servletAction中多写几个方法就能很好的解决这个action类急剧膨胀的问题，从管理上看还能更加的简介。
所以如果重写了execute方法，那么就失去了这些功能。

现在可以看看com.ramix.demo.webapp.action.Test类可以怎么写了：

Java代码 复制代码
  1. package com.ramix.demo.webapp.action;   
  2.   
  3. import javax.servlet.http.HttpServletRequest;   
  4. import javax.servlet.http.HttpServletResponse;   
  5.   
  6. import org.apache.struts.action.ActionForm;   
  7. import org.apache.struts.action.ActionForward;   
  8. import org.apache.struts.action.ActionMapping;   
  9.   
  10. import com.ramix.common.webapp.action.BaseAction;   
  11.   
  12. public class Test extends BaseAction {   
  13.     @Override  
  14.     public ActionForward unspecified(ActionMapping mapping, ActionForm form,   
  15.             HttpServletRequest request, HttpServletResponse response) {   
  16.         request.setAttribute("test", "test");   
  17.         return mapping.findForward("test");   
  18.     }   
  19.   
  20.     public ActionForward test(ActionMapping mapping, ActionForm form,   
  21.             HttpServletRequest request, HttpServletResponse response) {   
  22.         request.setAttribute("test", request.getParameter("test"));   
  23.         return mapping.findForward("test");   
  24.     }   
  25. }  
package com.ramix.demo.webapp.action;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

import com.ramix.common.webapp.action.BaseAction;

public class Test extends BaseAction {
	@Override
	public ActionForward unspecified(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) {
		request.setAttribute("test", "test");
		return mapping.findForward("test");
	}

	public ActionForward test(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) {
		request.setAttribute("test", request.getParameter("test"));
		return mapping.findForward("test");
	}
}



unspecified是不带method参数是执行的方法
test是method参数值为test是执行的方法

当然如果应用很简单的，你并不需要parameter="method"的话，你非要写上execute方法也没有关系，就像下面代码这样：

Java代码 复制代码
  1. package com.ramix.demo.webapp.action;   
  2.   
  3. import javax.servlet.http.HttpServletRequest;   
  4. import javax.servlet.http.HttpServletResponse;   
  5.   
  6. import org.apache.struts.action.ActionForm;   
  7. import org.apache.struts.action.ActionForward;   
  8. import org.apache.struts.action.ActionMapping;   
  9.   
  10. import com.ramix.common.webapp.action.BaseAction;   
  11.   
  12. public class Test extends BaseAction {   
  13.   
  14.     public ActionForward execute(ActionMapping mapping, ActionForm form,   
  15.             HttpServletRequest request, HttpServletResponse response)   
  16.             throws Exception {   
  17.         System.out.println("ok");   
  18.         System.out.println("ok1");   
  19.         return null;   
  20.     }   
  21. }   
  22.   
  23.   
  24.   
  25. 说明：这里的BaseAction只是对org.springframework.web.struts.DispatchActionSupport做了封装，代码如下：   
  26.   
  27. package com.ramix.common.webapp.action;   
  28.   
  29. import com.ramix.common.util.RequestParamUtil;   
  30. import org.apache.log4j.Logger;   
  31. import org.apache.struts.action.ActionForward;   
  32. import org.apache.struts.action.ActionMapping;   
  33. import org.springframework.context.ApplicationContext;   
  34. import org.springframework.web.context.support.WebApplicationContextUtils;   
  35. import org.springframework.web.struts.DispatchActionSupport;   
  36.   
  37. import javax.servlet.http.HttpServletRequest;   
  38. import javax.servlet.http.HttpSession;   
  39. import java.util.Map;   
  40.   
  41. /**  
  42.  * 基础的Action，提供一些action中最基本的方法  
  43.  *  
  44.  * @author: Feng  
  45.  * @since: 2007-11-30  
  46.  */  
  47. public class BaseAction extends DispatchActionSupport {   
  48.     // 用来输出log。   
  49.     protected final Logger log = Logger.getLogger(this.getClass());   
  50.   
  51.     // 默认分页个数   
  52.     protected static final int DEF_PAGE_SIZE = 10;   
  53.   
  54.     // 默认错误页   
  55.     protected static final String DEF_VIEW_PAGE = "view";   
  56.   
  57.     // 默认错误页   
  58.     protected static final String DEF_ERROR_PAGE = "globalError";   
  59.   
  60.     // 默认成功页   
  61.     protected static final String DEF_SUCCESS_PAGE = "globalSuccess";   
  62.   
  63.     // 令牌名称   
  64.     protected static final String TOKEN_KEY = "RIMAX_TOKEN";   
  65.   
  66.     /**  
  67.      * 用来得到spring注入的bean。  
  68.      *  
  69.      * @param beanName 在spring配置文件中定义的bean的名字。  
  70.      * @return 从ApplicationContext中得到的bean对象。  
  71.      */  
  72.     protected Object getBean(String beanName) {   
  73.         ApplicationContext ctx = WebApplicationContextUtils.getRequiredWebApplicationContext(servlet.getServletContext());   
  74.         return ctx.getBean(beanName);   
  75.     }   
  76.   
  77.     /**  
  78.      * 从request取得目标页码，没有设置，默认显示第一页  
  79.      *  
  80.      * @param request HttpServletRequest  
  81.      * @return 目标页码  
  82.      */  
  83.     protected int getPageNum(HttpServletRequest request) {   
  84.         return RequestParamUtil.getIntParam(request, "pageNum", 1);   
  85.     }   
  86.   
  87.     /**  
  88.      * 从request取得目标页码，没有设置，默认显示第一页  
  89.      *  
  90.      * @param request HttpServletRequest  
  91.      * @return 目标页码  
  92.      */  
  93.     protected int getPageSize(HttpServletRequest request) {   
  94.         return RequestParamUtil.getIntParam(request, "pageSize", DEF_PAGE_SIZE);   
  95.     }   
  96.   
  97.     /**  
  98.      * 转向错误页面  
  99.      *  
  100.      * @param mapping ActionMapping  
  101.      * @param request HttpServletRequest  
  102.      * @param message 显示信息  
  103.      * @param url     目标地址  
  104.      * @return ActionForward  
  105.      */  
  106.     protected ActionForward toGobalError(ActionMapping mapping, HttpServletRequest request, String message, String url) {   
  107.         request.setAttribute("url", url);   
  108.         request.setAttribute("message", message);   
  109.         return mapping.findForward(DEF_ERROR_PAGE);   
  110.     }   
  111.   
  112.     /**  
  113.      * 转向全局成功页面  
  114.      *  
  115.      * @param mapping ActionMapping  
  116.      * @param request HttpServletRequest  
  117.      * @param message 显示信息  
  118.      * @param url     目标地址  
  119.      * @return ActionForward  
  120.      */  
  121.     protected ActionForward toGobalSuccess(ActionMapping mapping, HttpServletRequest request, String message, String url) {   
  122.         request.setAttribute("url", url);   
  123.         request.setAttribute("message", message);   
  124.         return mapping.findForward(DEF_SUCCESS_PAGE);   
  125.     }   
  126.   
  127.     /**  
  128.      * 验证当前提交的令牌，并不重置令牌  
  129.      *  
  130.      * @param request HttpServletRequest  
  131.      * @return 令牌是否有效  
  132.      */  
  133.     protected boolean validCurToken(HttpServletRequest request) {   
  134.         HttpSession session = request.getSession();   
  135.         if (session == null) {   
  136.             return false;   
  137.         }   
  138.         Map map = (Map) session.getAttribute(TOKEN_KEY);   
  139.         if (map == null) {   
  140.             return true;   
  141.         }   
  142.         String strToken = request.getParameter(TOKEN_KEY);   
  143.         if (strToken == null) {   
  144.             return false;   
  145.         }   
  146.         return map.containsKey(strToken);   
  147.     }   
  148.   
  149.     /**  
  150.      * 删除当前令牌  
  151.      *  
  152.      * @param request HttpServletRequest  
  153.      */  
  154.     protected void removeCurToken(HttpServletRequest request) {   
  155.         HttpSession session = request.getSession();   
  156.         if (session == null) {   
  157.             return;   
  158.         }   
  159.         Map map = (Map) session.getAttribute(TOKEN_KEY);   
  160.         if (map == null) {   
  161.             return;   
  162.         }   
  163.         String strToken = request.getParameter(TOKEN_KEY);   
  164.         if (strToken == null) {   
  165.             return;   
  166.         }   
  167.         map.remove(strToken);   
  168.     }   
  169. } 
分享到：
| struts与spring如何整合(1)
评论
1 楼 wangchao_0625 2009-05-19  
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    ssh整和技术struts与hibernate整合，struts与spring整合，hibernate与spring整合，struts，hibernate，sp

    Struts技术资料 hibernate技术资料 spring技术资料 ssh整合技术（struts与hibernate整合，struts与spring整合，hibernate与spring整合，struts，hibernate，spring整合）

    struts和spring整合的2种方式

    在实际应用中，随着Struts2的出现和Spring Boot的流行，这种Struts1与Spring的整合方式逐渐被新的框架组合取代，如Spring MVC或Spring Boot的WebFlux。然而，对于学习和理解框架整合以及依赖注入的概念，这些基础...

    struts和spring整合（两种实现方法）

    用DelegatingRequestProcessor和DelegatingActionProxy两种方法实现struts和spring的整合，不同的地方就在struts-config.xml文件中，当前文件中DelegatingRequestProcessor是注释的。

    Struts2整合Spring、JPA

    Struts2整合Spring和JPA是企业级Java应用开发中常见的技术组合，它们分别负责不同的职责：Struts2作为一款成熟的MVC框架，主要用于处理Web层的请求与响应；Spring作为一个全面的轻量级框架，提供了依赖注入（DI）和...

    struts2与spring2的整合

    本文将深入探讨Struts2与Spring2的整合过程及其背后的原理。 首先，Struts2是一个基于MVC设计模式的Web应用框架，它主要负责处理HTTP请求，提供强大的动作（Action）和结果（Result）管理，以及丰富的插件系统。...

    struts+spring+hibernate整合

    通过以上步骤，一个基本的Struts、Spring和Hibernate整合的应用就搭建完成了。这个整合的关键在于Struts处理HTTP请求，Spring管理业务对象和依赖，而Hibernate则处理数据库操作。这样的架构可以实现松耦合，便于代码...

    struts2和spring整合包

    **Struts2和Spring整合** 整合Struts2和Spring的主要目标是利用两者的优点，创建一个更强大的MVC应用。整合步骤通常包括： 1. **配置Spring**：创建Spring的ApplicationContext配置文件，定义Bean及其依赖。 2. **...

    struts1 spring ibatis整合项目源码

    struts1 spring ibatis整合项目源码struts1 spring ibatis整合项目源码struts1 spring ibatis整合项目源码struts1 spring ibatis整合项目源码struts1 spring ibatis整合项目源码struts1 spring ibatis整合项目源码

    最新版本的Struts2+Spring4+Hibernate4框架整合

    整合使用最新版本的三大框架（即Struts2、Spring4和Hibernate4），搭建项目架构原型。 项目架构原型：Struts2.3.16 + Spring4.1.1 + Hibernate4.3.6。 此外，还有：log4j、slf4j、junit4、ehcache等知识点。 项目...

    Struts2与Spring整合的demo

    下面我们将深入探讨Struts2与Spring整合的相关知识点。 1. **Struts2框架**： - Struts2是一个基于MVC设计模式的Web应用框架，用于简化Java Web应用的开发。 - 它提供了强大的Action类，负责处理请求并调用业务...

    spring与struts2整合

    Spring 和 Struts2 是两个...总之，Spring 和 Struts2 的整合利用了两者的优势，提供了一种强大的方式来构建可扩展、易于维护的 Java Web 应用。通过深入学习和实践，开发者可以掌握这种整合技巧，并在实际项目中应用。

    SSH整合源码（Struts+Spring+Hibernate整合用户注册例子）

    Struts和Spring之间通过ActionServlet和Spring的DispatcherServlet协同工作，而Spring与Hibernate之间的整合通常通过SessionFactoryBean和HibernateTemplate完成。 8. **用户注册流程**：用户提交注册信息后，...

    整合struts2和spring

    将Struts2和Spring整合可以充分利用各自的优势，实现更加灵活、高效的应用开发。 整合Struts2和Spring主要涉及以下几个关键步骤： 1. **添加依赖**：首先，需要在项目的构建配置文件（如Maven的pom.xml或Gradle的...

    SSH(struts2,Hibernate,Spring)整合及测试亲测可用

    在整合过程中，开发者需要注意配置文件的正确设置，包括Struts2的struts.xml、Hibernate的hibernate.cfg.xml以及Spring的applicationContext.xml等。还需要确保各框架之间的依赖注入正确无误，例如，Spring需要知道...

    struts2整合spring、hibernate的jar包

    2. **Spring整合**：Spring框架的核心在于IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入），它能管理对象的生命周期和依赖关系。在整合Struts2时，我们需要配置Spring的`spring-beans...

    struts 与spring整合关键点

    以上就是Struts与Spring整合的关键点，整合这两个框架可以使应用程序更易于测试和维护，同时充分利用Spring的强大功能，如依赖注入和事务管理，提高开发效率和应用质量。在实际项目中，需要根据具体需求选择合适的...

    Struts Spring Hibernate整合实践

    2. **Spring 与 Hibernate 整合**： - Spring 提供了对 Hibernate 的支持，可以方便地管理 SessionFactory 和 Transaction，通过AOP实现声明式事务管理，降低了代码的复杂性，提高了可维护性。 3. **整合流程**： ...

    EJB3与Struts与Spring整合开发（SSE）

    在"EJB3与Struts与Spring整合开发（SSE）"的场景中，开发者可能将EJB3作为业务逻辑层，处理复杂的业务操作；Struts作为前端控制器，负责用户交互和请求转发；而Spring则作为整个应用的“胶水”，实现各层间的协调和...

    Struts+Spring+Hibernate整合教程.pdf

    整合Struts、Spring和Hibernate可以构建出高度模块化的应用，提高开发效率和代码质量。然而，随着Java EE技术的发展，现代Web应用更多地转向Spring Boot、Spring MVC和MyBatis等更现代的解决方案，它们在易用性、...

Magicbox
Global site tag (gtag.js) - Google Analytics