struts2 处理请求流程分析（结合源码）3

最新推荐文章于 2018-08-02 16:10:54 发布
最新推荐文章于 2018-08-02 16:10:54 发布
阅读量85 收藏
点赞数
分类专栏： struts2 文章标签： Struts Servlet Spring Access Go

 2.3、dispatcher.serviceAction(request, response, servletContext, mapping);方法分析

  public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context,
                              ActionMapping mapping) throws ServletException {
    	//包装了Http的四个作用域,extraContext 保存了所有的servlet 容器的作用域和struts2 包装的容器作用域
        Map<String, Object> extraContext = createContextMap(request, response, mapping, context);

        // If there was a previous value stack, then create a new copy and pass it in to be used by the new Action
        //如果之前有ValueStack 值栈存在，则用这个，否则创建一个新的，保存在extraContext 中
        ValueStack stack = (ValueStack) request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);
        if (stack != null) {
            extraContext.put(ActionContext.VALUE_STACK, ValueStackFactory.getFactory().createValueStack(stack));
        }
        String timerKey = "Handling request from Dispatcher";
        try {
            UtilTimerStack.push(timerKey);
            //获得action 的配置信息
            String namespace = mapping.getNamespace();
            String name = mapping.getName();
            String method = mapping.getMethod();

            Configuration config = configurationManager.getConfiguration();
            //创建一个ActionProxy
            ActionProxy proxy = config.getContainer().getInstance(ActionProxyFactory.class).createActionProxy(
                    namespace, name, extraContext, true, false);
            //如果method 为空，则设为“excue”
            proxy.setMethod(method);
            //保存值栈供struts2 使用
            request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack());

            // if the ActionMapping says to go straight to a result, do it!
            //如果result 不为空的话，进行调转
            if (mapping.getResult() != null) {
                Result result = mapping.getResult();
                //注入的是ActionInvaction
                result.execute(proxy.getInvocation());
            } else {
                proxy.execute();
            }

            // If there was a previous value stack then set it back onto the request
            if (stack != null) {
                request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, stack);
            }
        } catch (ConfigurationException e) {
            LOG.error("Could not find action or result", e);
            sendError(request, response, context, HttpServletResponse.SC_NOT_FOUND, e);
        } catch (Exception e) {
            throw new ServletException(e);
        } finally {
            UtilTimerStack.pop(timerKey);
        }
    }

 

    （1）createContextMap(request, response, mapping, context);方法

public Map<String,Object> createContextMap(HttpServletRequest request, HttpServletResponse response,
            ActionMapping mapping, ServletContext context) {

        // request map wrapping the http request objects
        Map requestMap = new RequestMap(request);

        // parameters map wrapping the http paraneters.
        Map params = null;
        if (mapping != null) {
            params = mapping.getParams();
        }
        Map requestParams = new HashMap(request.getParameterMap());
        if (params != null) {
            params.putAll(requestParams);
        } else {
            params = requestParams;
        }

        // session map wrapping the http session
        Map session = new SessionMap(request);

        // application map wrapping the ServletContext
        Map application = new ApplicationMap(context);
        //对上面的http 作用域包装的map 进行封装
        Map<String,Object> extraContext = createContextMap(requestMap, params, session, application, request, response, context);
       //把mapping 也放进map 里
        extraContext.put(ServletActionContext.ACTION_MAPPING, mapping);
        return extraContext;
    }

   由此可以看出struts2 对servlet 容器的作用域都进行包装成相应的Map ，然后放在extraContext  统一进行保存。

来看看extraContext  这个map 里放的是全部servlet 容器作用域还有相应的struts2的包装map，和 locale，从下面的源码中可以看出。

 public HashMap<String,Object> createContextMap(Map requestMap,
                                    Map parameterMap,
                                    Map sessionMap,
                                    Map applicationMap,
                                    HttpServletRequest request,
                                    HttpServletResponse response,
                                    ServletContext servletContext) {
        HashMap<String,Object> extraContext = new HashMap<String,Object>();
        extraContext.put(ActionContext.PARAMETERS, new HashMap(parameterMap));
        extraContext.put(ActionContext.SESSION, sessionMap);
        extraContext.put(ActionContext.APPLICATION, applicationMap);

        Locale locale;
        if (defaultLocale != null) {
            locale = LocalizedTextUtil.localeFromString(defaultLocale, request.getLocale());
        } else {
            locale = request.getLocale();
        }

        extraContext.put(ActionContext.LOCALE, locale);
        //extraContext.put(ActionContext.DEV_MODE, Boolean.valueOf(devMode));

        extraContext.put(StrutsStatics.HTTP_REQUEST, request);
        extraContext.put(StrutsStatics.HTTP_RESPONSE, response);
        extraContext.put(StrutsStatics.SERVLET_CONTEXT, servletContext);

        // helpers to get access to request/session/application scope
        extraContext.put("request", requestMap);
        extraContext.put("session", sessionMap);
        extraContext.put("application", applicationMap);
        extraContext.put("parameters", parameterMap);

        AttributeMap attrMap = new AttributeMap(extraContext);
        extraContext.put("attr", attrMap);

        return extraContext;
    }

 

（2）ActionProxy proxy = config.getContainer().getInstance(ActionProxyFactory.class).createActionProxy(
                    namespace, name, extraContext, true, false);默认由DefaultActionProxyFactory类创建ActionProxy 。

 public ActionProxy createActionProxy(String namespace, String actionName, Map extraContext, boolean executeResult, boolean cleanupContext) throws Exception {
        //创建ActionProxy
        ActionProxy proxy = new DefaultActionProxy(namespace, actionName, extraContext, executeResult, cleanupContext);
        container.inject(proxy);
       //为了创建ActionInvocation
        proxy.prepare();
        return proxy;
    }

 

    proxy.prepare(); 在这方法中创建ActionInvocation（默认为DefaultActionInvocation），主要由ActionInvocation来调度Action 的实际操作

 public void prepare() throws Exception {
        String profileKey = "create DefaultActionProxy: ";
        try {
            UtilTimerStack.push(profileKey);
            config = configuration.getRuntimeConfiguration().getActionConfig(namespace, actionName);
    
            if (config == null && unknownHandler != null) {
                config = unknownHandler.handleUnknownAction(namespace, actionName);
            }
            if (config == null) {
                String message;
    
                if ((namespace != null) && (namespace.trim().length() > 0)) {
                    message = LocalizedTextUtil.findDefaultText(XWorkMessages.MISSING_PACKAGE_ACTION_EXCEPTION, Locale.getDefault(), new String[]{
                        namespace, actionName
                    });
                } else {
                    message = LocalizedTextUtil.findDefaultText(XWorkMessages.MISSING_ACTION_EXCEPTION, Locale.getDefault(), new String[]{
                        actionName
                    });
                }
                throw new ConfigurationException(message);
            }
            
            invocation = new DefaultActionInvocation(objectFactory, unknownHandler, this, extraContext, true, actionEventListener);
           //如果method 为空，则this.method = "execute";
            resolveMethod();
        } finally {
            UtilTimerStack.pop(profileKey);
        }
    }

 

   在创建ActionInvocation 的时候有个主要的方法 init();

 protected DefaultActionInvocation(final ObjectFactory objectFactory, final UnknownHandler handler, final ActionProxy proxy, final Map extraContext, final boolean pushAction, final ActionEventListener actionEventListener) throws Exception {
    	UtilTimerStack.profile("create DefaultActionInvocation: ", 
    			new UtilTimerStack.ProfilingBlock<Object>() {
					public Object doProfiling() throws Exception {
						DefaultActionInvocation.this.proxy = proxy;
                        DefaultActionInvocation.this.objectFactory = objectFactory;
				        DefaultActionInvocation.this.extraContext = extraContext;
				        DefaultActionInvocation.this.pushAction = pushAction;
                        DefaultActionInvocation.this.unknownHandler = handler;
                        DefaultActionInvocation.this.actionEventListener = actionEventListener;
                        init();//这里
						return null;
					}
    			});
    }

  

   init();方法，该方法创建了Action 和ActionContext

private void init() throws Exception {
      
        Map contextMap = createContextMap();
      //创建Action
        createAction(contextMap);
      
        if (pushAction) {
           //把Action 放进值栈
            stack.push(action);
        }
        //创建ActionContext
        invocationContext = new ActionContext(contextMap);
        invocationContext.setName(proxy.getActionName());

        // get a new List so we don't get problems with the iterator if someone changes the list
        List interceptorList = new ArrayList(proxy.getConfig().getInterceptors());
        interceptors = interceptorList.iterator();
    }

   

    创建Action，通过objectFactory 进行创建，而这个类在struts.properties中可以重写这个属性 。默认为SpringObjectFactory:struts.objectFactory=spring，在前面BeanSelectionProvider中通过配置文件为ObjectFactory设置实现类  

protected void createAction(Map contextMap) {
        // load action
        String timerKey = "actionCreate: "+proxy.getActionName();
        try {
            UtilTimerStack.push(timerKey);
            action = objectFactory.buildAction(proxy.getActionName(), proxy.getNamespace(), proxy.getConfig(), contextMap);
        } catch (InstantiationException e) {
            throw new XWorkException("Unable to intantiate Action!", e, proxy.getConfig());
        } catch (IllegalAccessException e) {
            throw new XWorkException("Illegal access to constructor, is it public?", e, proxy.getConfig());
        } catch (Exception e) {
            String gripe = "";

            if (proxy == null) {
                gripe = "Whoa!  No ActionProxy instance found in current ActionInvocation.  This is bad ... very bad";
            } else if (proxy.getConfig() == null) {
                gripe = "Sheesh.  Where'd that ActionProxy get to?  I can't find it in the current ActionInvocation!?";
            } else if (proxy.getConfig().getClassName() == null) {
                gripe = "No Action defined for '" + proxy.getActionName() + "' in namespace '" + proxy.getNamespace() + "'";
            } else {
                gripe = "Unable to instantiate Action, " + proxy.getConfig().getClassName() + ",  defined for '" + proxy.getActionName() + "' in namespace '" + proxy.getNamespace() + "'";
            }

            gripe += (((" -- " + e.getMessage()) != null) ? e.getMessage() : " [no message in exception]");
            throw new XWorkException(gripe, e, proxy.getConfig());
        } finally {
            UtilTimerStack.pop(timerKey);
        }

        if (actionEventListener != null) {
            action = actionEventListener.prepare(action, stack);
        }
    }


 public Object buildAction(String actionName, String namespace, ActionConfig config, Map extraContext) throws Exception {
        return buildBean(config.getClassName(), extraContext);
    }

 public Object buildBean(String className, Map extraContext) throws Exception {
        return buildBean(className, extraContext, true);
    }

 public Object buildBean(String className, Map extraContext, boolean injectInternal) throws Exception {
        Class clazz = getClassInstance(className);
        Object obj = buildBean(clazz, extraContext);
        if (injectInternal) {
            injectInternalBeans(obj);
        }
        return obj;
    }
 protected Object injectInternalBeans(Object obj) {
        if (obj != null && container != null) {
            container.inject(obj);
        }
        return obj;
    }

  

    proxy.execute();方法是struts2 中流程的重要方法。

 

    public String execute() throws Exception {
        ActionContext nestedContext = ActionContext.getContext();
        ActionContext.setContext(invocation.getInvocationContext());

        String retCode = null;

        String profileKey = "execute: ";
        try {
        	UtilTimerStack.push(profileKey);
        //这个是重点，主要的拦截器功能在这实现，执行返回跳转的字符串
            retCode = invocation.invoke();
        } finally {
            if (cleanupContext) {
                ActionContext.setContext(nestedContext);
            }
            UtilTimerStack.pop(profileKey);
        }

        return retCode;
    }

  

   invoke 方法调用了DefaultActionInvocation的invoke()去实现Action的调用

    public String invoke() throws Exception {
	......
    	try {
	        ......

    		if (interceptors.hasNext()) {// (1)
    			final InterceptorMapping interceptor = (InterceptorMapping) interceptors.next();
    			UtilTimerStack.profile("interceptor: "+interceptor.getName(), 
    					new UtilTimerStack.ProfilingBlock<String>() {
							public String doProfiling() throws Exception {
				    			resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);
				    			return null;
							}
    			});
    		} else {
    			resultCode = invokeActionOnly();
    		}

    		if (!executed) {// (2)
    			if (preResultListeners != null) {// (2)-1
    				for (Iterator iterator = preResultListeners.iterator();
    					iterator.hasNext();) {
    					PreResultListener listener = (PreResultListener) iterator.next();
    					
    					String _profileKey="preResultListener: ";
    					try {
    						UtilTimerStack.push(_profileKey);
    						listener.beforeResult(this, resultCode);
    					}
    					finally {
    						UtilTimerStack.pop(_profileKey);
    					}
    				}
    			}

    			if (proxy.getExecuteResult()) {// (2)-2
    				executeResult();
    			}

    			executed = true;
    		}

    		return resultCode;
    	}
    	finally {
    		UtilTimerStack.pop(profileKey);
    	}
    }

 

    整个方法主要由2个if从句分割，在(1)处的if从句中，主要实现了拦截器的"递归"调用，说它是递归调用，其实是一种非传统的递归。传统的递归应该是函数调用自身，最后达成一定条件后退出，但是这里是将自身的引用作为参数传递给intercept()，然后在intercept()内部再调用DefaultActionInvocation的invoke()，实现了递归调用。

利用这种方式，实现了拦截器和Action的如下的调用逻辑：

Interceptor1
Interceptor2
Interceptor3
Action
Interceptor3
Interceptor2
Interceptor1

    最后，当interceptors.hasNext()返回false时，也就是全部拦截器调用完毕之后，函数调用了invokeActionOnly();去实现Action的调用：

    public String invokeActionOnly() throws Exception {
    	return invokeAction(getAction(), proxy.getConfig());
    }

 

   invokeActionOnly()内部是使用invokeAction()去实现Action的调用的，源代码如下：

    protected String invokeAction(Object action, ActionConfig actionConfig) throws Exception {
        String methodName = proxy.getMethod();

        if (LOG.isDebugEnabled()) {
            LOG.debug("Executing action method = " + actionConfig.getMethodName());
        }

        String timerKey = "invokeAction: "+proxy.getActionName();
        try {
            UtilTimerStack.push(timerKey);
            
            Method method;
            try {
                method = getAction().getClass().getMethod(methodName, new Class[0]);
            } catch (NoSuchMethodException e) {
                try {
                    String altMethodName = "do" + methodName.substring(0, 1).toUpperCase() + methodName.substring(1);
                    method = getAction().getClass().getMethod(altMethodName, new Class[0]);
                } catch (NoSuchMethodException e1) {
                    throw e;
                }
            }

            Object methodResult = method.invoke(action, new Object[0]);
            if (methodResult instanceof Result) {
            	this.result = (Result) methodResult;
            	return null;
            } else {
            	return (String) methodResult;
            }
        } catch (NoSuchMethodException e) {
            throw new IllegalArgumentException("The " + methodName + "() is not defined in action " + getAction().getClass() + "");
        } catch (InvocationTargetException e) {
            Throwable t = e.getTargetException();

            if (actionEventListener != null) {
                String result = actionEventListener.handleException(t, getStack());
                if (result != null) {
                    return result;
                }
            }
            if (t instanceof Exception) {
                throw(Exception) t;
            } else {
                throw e;
            }
        } finally {
            UtilTimerStack.pop(timerKey);
        }
    }

 

    由这句Object methodResult = method.invoke(action, new Object[0]);可以看出，最后通过反射实现了Action的执行方法的调用。


    调用完方法之后，invoke()方法的流程来到了(2)处，由于刚刚调用完Action的那次invoke()调用此时executed为false，所以可以进入此处的if语句。
(2)-1处调用了在PreResultListener中的定义的一些执行Result前的操作。
(2)-2处则根据配置文件中的设置执行Result。

    private void executeResult() throws Exception {
        result = createResult();// 根据配置文件构建Result

        String timerKey = "executeResult: "+getResultCode();
        try {
            UtilTimerStack.push(timerKey);
            if (result != null) {
                result.execute(this);
            } else if (resultCode != null && !Action.NONE.equals(resultCode)) {
                throw new ConfigurationException("No result defined for action " + getAction().getClass().getName() 
                        + " and result " + getResultCode(), proxy.getConfig());
            } else {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("No result returned for action "+getAction().getClass().getName()+" at "+proxy.getConfig().getLocation());
                }
            }
        } finally {
            UtilTimerStack.pop(timerKey);
        }
    }

 

于是，最终的调用顺序应该是：
Interceptor1
Interceptor2
Interceptor3
Action
PreResultListener
Result
Interceptor3
Interceptor2
Interceptor1

 

iteye_20670
关注
专栏目录
深入struts2.0(六)--ActionProxy类
夜深人静后的码农
06-17 7703
1.1     ActionProxy接口以及实现 ActionProxy在struts框架中发挥着非常重要的作用。通过webwork和xwork交互关系图可以看出，它是action和xwork中间的一层。 正因为ActionProxy的存在导致Action调用更加简洁。接下来我们一起研究下这个核心类。 1.1.1       ActionProxy接口方法 图 3.3.1 Ac
Struts2请求流程和原理（源码解析，运行流程）
青元子的博客
05-09 5799
前言：此文章为本人复习Struts2的一个学习记录，如果有什么错误的地方可以留言讨论，当前Struts2更新到了2.5.16更新了不少东西，支持JSR303，debug标签只能在dev mode环境下面显示等等，看官们如果有需要可以移步下面链接因为本次测试不会涉及到这些：https://cwiki.apache.org/confluence/display/WW/Version+Notes+2.5...
Struts2简单开发流程
ManagementAndJava的博客
10-13 403
Struts1的执行流程是什么； Struts2的执行流程是什么； 我们的Action如何编写； 4.Action的配置问题； 1. Struts1的执行流程大致思路如下： 当web客户端的浏览器发出http请求，然后到达tomcat的web应用服务器，将http请求头封装成HttpServletRequest和HttpServletResponse对象，然后doPost(req,resp)或者
ActionInvocation类的使用和探究
suoyihen
12-09 194
“将Web页面中的输入元素封装为一个（请求）数据对象”,这个对象就是ActionInvocation类型. 对于Xwork 而言，前端的Webwork 组件为其提供的是一个Map 类型的数据结构。而Action面向的却是Model对象所提供的数据结构。在何时、何处对这两种不同的数据结构进行转换？ 写一个辅助类完成这样的工作，并在每次Action 调用之前由框架代码调用他完成转换工作...
struts2 处理请求流程分析（结合源码）2
yansong_8686的专栏
05-16 681
2、过滤器中的doFilter(ServletRequest req, ServletResponse res, FilterChain chain) 方法 2.1、request = prepareDispatcherAndWrapRequest(request, response);分析      我们知道JSTL默认是从page，request，session，application这四
struts2 处理请求流程分析（结合源码）1
zhxing
12-04 101
struts2 源码版本2.0.11.1 本文是综合网上部分人的分析成果，然后再自己结合源码进行的，分析中如有错误，请指正。    从struts2 中的web.xml的启动配置可以看出，首先分析的是FilterDispatcher 这个过滤器类。   1、过滤器的初始化方法 void init(FilterConfig filterConfig) //初始化方法 public vo...
struts2 处理请求流程分析（结合源码）
走马观花
05-26 789
http://zhxing.iteye.com/blog/541059 struts2 源码版本2.0.11.1 本文是综合网上部分人的分析成果，然后再自己结合源码进行的，分析中如有错误，请指正。    从struts2 中的web.xml的启动配置可以看出，首先分析的是FilterDispatcher 这个过滤器类。   1、过滤器的初始化方法 void init(FilterConf
结合源码分析Struts2运行流程
aerf5sd的博客
03-02 429
1.准备阶段注:准备阶段还有其他一些细节，比如包装Request，构建ActionContext并与当前线程绑定等，在此只挑出帮助理解流程的关键部分介绍。 准备ActionMapping下图是StrutsPrepareAndExecuteFilter.doFilter()方法体内的部分代码 ActionMapping封装了关于目标Action的简单信息如2图的代码所示，在prepare.findAc
Struts2的启动流程(结合struts2的源码详解)
weixin_40234548的博客
08-02 2098
一：项目启动后解析web.xml文件，会解析到配置的StrutsPrepareAndExecuteFilter的过滤器。 二：项目启动时解析完web.xml文件后,就创建过滤器并执行struts2过滤器的init()方法， dispathch的init中初始化的内容是默认配置文件(default.xml,struts.xml,以及一些参数的解析) 三：服务器启动后，当有后缀名为s...
Struts2源码分析
09-13
总的来说，Struts2的源码分析可以帮助开发者深入理解其内部机制，包括请求处理流程、拦截器的运作方式以及视图组件的实现。这有助于提高应用的可维护性，优化性能，并使开发者能够更好地定制和扩展框架。对于熟悉...
Struts2源码
06-22
结合源码阅读和PPT讲解，你可以逐步掌握Struts2的核心概念，提升在实际项目中的应用能力。同时，也要关注Struts2与其他框架（如Spring、Hibernate）的整合，以及如何利用Struts2实现RESTful服务。通过深入学习，你将...
毕业设计论文-IT计算机-内容管理系统(hibernate3+struts2+spring2)-源码.zip
04-02
这篇毕业设计论文主要探讨了如何构建一个基于Java技术的内容管理系统，使用了三个核心框架：Hibernate3、Struts2和Spring2。这些框架是Java企业级应用开发中的重要工具，它们各自承担着不同的职责，共同构成了一个...
struts2数据封装源码
11-16
这个"struts2数据封装源码"很可能是为了演示如何在Struts2框架下处理用户输入数据并进行封装的过程。在Struts2中，数据封装是通过Action类和模型对象（通常称为POJOs，Plain Old Java Objects）来实现的，这使得业务...
一款纯VF控制的变频器方案方案说明:可做0.2KW7.5KW 220V，0.2KW75KW 380V，富士通MB90F462A
10-02
一款纯VF控制的变频器方案方案说明:可做0.2KW7.5KW 220V，0.2KW75KW 380V，富士通MB90F462A LQFP64单片机控制，可提供源码及电路原理图，PCB图 这是一种基于纯VF控制的变频器方案。它可以在220V电压下提供0.2KW到7.5KW的功率输出，或者在380V电压下提供0.2KW到75KW的功率输出。该方案采用了富士通MB90F462A LQFP64单片机进行控制，并且提供了源码、电路原理图和PCB图。 知识点和领域范围： - 变频器：变频器是一种电力电子设备，用于控制交流电机的转速和输出功率。它通过改变输入电压的频率和幅值，实现对电机的调速控制。 - VF控制：VF控制是一种变频器控制方式，通过同时改变电压和频率的比例，实现对电机转速的精确控制。 - 单片机控制：单片机是一种集成电路芯片，具有处理器、存储器和输入输出接口等功能。它可以用于控制和管理各种电子设备，包括变频器。 - 源码：源码是计算机程序的原始代码，通常以文本形式表示。它包含了程序的逻辑和算法，可以被编译器或解释器转为可执行的机器代码。 - 电路原理图：电路原理图是一种图
基于Java语言实现的软件工程Lab1-2021111888设计源码
10-02
本项目为软件工程课程Lab1作业，采用Java语言实现，源码包含63个文件，包括16个Java源代码文件、11个PNG图片文件、8个XML配置文件、8个JAR包文件、8个class字节码文件、5个TXT文本文件、4个Git忽略配置文件、2个IDE配置文件和1个项目名称文件。
基于Python的入门级人脸、视频、文字检测与识别项目设计源码
10-02
该项目是一款入门级的人工智能项目，利用Python语言实现了人脸、视频和文字的检测与识别功能。项目包含130个文件，其中包括50个PNG图片文件、42个Markdown文档、25个Python源代码文件、3个HDF5数据文件、3个GIF动画文件、2个JPG图片文件、1个Git忽略规则文件、1个开源许可证文件、1个JSON数据文件和1个H5数据文件。该系统适合作为人工智能学习的入门项目。
SANJIAO_JICHU gerber.zip
10-02
SANJIAO_JICHU gerber.zip
大创资源推荐学习《word文档》
最新发布
10-02
大创资源推荐学习《word文档》 大创资源推荐学习知识点概述 大创资源推荐学习《word文档》 大创资源推荐学习知识点概述
深入理解Struts2：工作原理与源码分析
Struts2是一个流行的Java Web应用程序框架，它是Struts1.x和WebWork的结合体，提供了一种更强大、更灵活的架构来处理MVC（Model-View-Controller）模式。本章深入探讨了Struts2的工作原理，强调了其与WebWork的紧密...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值