struts请求源码的跟踪

　　最近工作任务不是很紧，时间也不能白白浪费，以前常用的struts2框架源码没去了解过，所以就跟踪一下struts2的整个执行过程.由于本人也是抱着学习的态度来阅读掩码，若文章在表述和代码方面如有不妥之处，欢迎批评指正。留下你的脚印，欢迎评论！希望能互相学习。

我这里的struts2源码是maven导jar包来查看源码的，这样方便多了，可以在IDE下查看源码。pom.xml文件如下

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>Struts_test_lishun</groupId>
  <artifactId>Struts_test_lishun</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
   <dependencies>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-core</artifactId>
        <version>2.3.24</version>
    </dependency>
  </dependencies>
</project>

1.实现从web.xml说起：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
     <!-- 添加一个过滤器-->
    <filter>
        <filter-name>action2</filter-name>
        <!-- struts2处理过程的入口 -->
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
        <init-param>
            <param-name >struts.serve.static.browserCache</param-name>
            <param-value>true</param-value>
        </init-param>
        <!-- 初始化参数(访问后缀为.do)，这里的param-name都可以从后面提到的源码中查看到，具体的其他功能本人也不是全部了解，
                            有兴趣的可以自己再去深入，-->
         <init-param>
            <param-name>struts.action.extension</param-name>
            <param-value>do</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>action2</filter-name>
        <!-- 过滤所有的请求 -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

2：开始查看StrutsPrepareAndExecuteFilter 过滤器

2-1:初始化：(tomcat一启动就会执行到这里)

public void init(FilterConfig filterConfig) throws ServletException {
        InitOperations init = new InitOperations();
        Dispatcher dispatcher = null;
        try {
　　　　　　　//封装filterConfig，便于对xml文件的操作
            FilterHostConfig config = new FilterHostConfig(filterConfig);
　　　　　　　//初始化日志
            init.initLogging(config);
　　　　　　　//初始化dispatcher，struts2的核心类，大部分的操作都是在这里完成的
            dispatcher = init.initDispatcher(config);
            init.initStaticContentLoader(config, dispatcher);
       　　 //初始化当前类属性：prepare 、execute(这两个属性会在doFilter里设置ActionContext和encoding的值)
            prepare = new PrepareOperations(dispatcher);
            execute = new ExecuteOperations(dispatcher);
            this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);
　　　　　　　//这是是空函数。说是回调方法，这里不太懂，有了解可以给小弟指引下
            postInit(dispatcher, filterConfig);
        } finally {
            if (dispatcher != null) {
                dispatcher.cleanUpAfterInit();
            }
            init.cleanup();
        }
    }

2-2:对上面init.initDispatcher(config)的跟踪：

public Dispatcher initDispatcher( HostConfig filterConfig ) {
        //这里主要是对新建一个dispatcher，并加载配置文件中的初始化参数
        Dispatcher dispatcher = createDispatcher(filterConfig);
        //初始化dispatcher
        dispatcher.init();
        return dispatcher;
}

2-2-1：dispatcher.init()跟踪：

public void init() {

        if (configurationManager == null) {
            //把struts.xml文件进行封装(默认是名字是struts)
            configurationManager = createConfigurationManager(DefaultBeanSelectionProvider.DEFAULT_BEAN_NAME);
        }

        try {            init_FileManager();
            //加载org/apache/struts2/default.properties
            init_DefaultProperties(); // [1]
            //加载struts-default.xml,struts-plugin.xml,struts.xml
            init_TraditionalXmlConfigurations(); // [2]
            //下面的初始化代码。没去研究，到此已经把web.xml,和struts.xml文件给加载进来了
            init_LegacyStrutsProperties(); // [3]
            init_CustomConfigurationProviders(); // [5]
            init_FilterInitParameters() ; // [6]
            init_AliasStandardObjects() ; // [7]

            Container container = init_PreloadConfiguration();
            //注入dispatcher
            container.inject(this);
            init_CheckWebLogicWorkaround(container);

            if (!dispatcherListeners.isEmpty()) {
                for (DispatcherListener l : dispatcherListeners) {
                    l.dispatcherInitialized(this);
                }
            }
            errorHandler.init(servletContext);

        } catch (Exception ex) {
            if (LOG.isErrorEnabled())
                LOG.error("Dispatcher initialization failed", ex);
            throw new StrutsException(ex);
        }
    }

初始化就在此告一段落了。

----------------------华丽的分割线-------------------------

3-1：访问某个action，StrutsPrepareAndExecuteFilter对所有的的请求都会过滤，此事就跟踪到；

public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {

        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;

        try {
            if (excludedPatterns != null && prepare.isUrlExcluded(request, excludedPatterns)) {
                chain.doFilter(request, response);
            } else {
                //设置类属性编码和国际化
                prepare.setEncodingAndLocale(request, response);
                //设置类属性action的上下文
                prepare.createActionContext(request, response);
                prepare.assignDispatcherToThread();
                //对request进行封装，继续跟踪下去代码会发现这里的作用就是根据不同的请求返回不同request的封装类(这里就是用到装饰者模式)
                request = prepare.wrapRequest(request);
　　　　　　　　　//返回ActionMapping：里面有通过struts.xml文件通过反射获取到action对应的类和方法
                ActionMapping mapping = prepare.findActionMapping(request, response, true);
　　　　　　　　　//若返回的ActionMapping为null，则表示不是调用action
                if (mapping == null) {
                    boolean handled = execute.executeStaticResourceRequest(request, response);
                    if (!handled) {
                        chain.doFilter(request, response);
                    }
                } else {

                    //这里进行了很多操作，比较重要就是页面参数值的注入，和执行action
                    execute.executeAction(request, response, mapping);
                }
            }
        } finally {
            prepare.cleanupRequest(request);
        }
    }

3-2：追踪代码-生成映射action的映射：

ActionMapping mapping = prepare.findActionMapping(request, response, true);
在PrepareOperations中,主要执行ActionMapper的getMapping(..)方法
public ActionMapping findActionMapping(HttpServletRequest request, HttpServletResponse response, boolean forceLookup) {
        ActionMapping mapping = (ActionMapping) request.getAttribute(STRUTS_ACTION_MAPPING_KEY);
        if (mapping == null || forceLookup) {
            try {
　　　　　　　　　//new一个ActionMapper实例并执行getMapping(..)方法
                mapping = dispatcher.getContainer().getInstance(ActionMapper.class).getMapping(request, dispatcher.getConfigurationManager());
                if (mapping != null) {
                    request.setAttribute(STRUTS_ACTION_MAPPING_KEY, mapping);
                }
            } catch (Exception ex) {
                dispatcher.sendError(request, response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ex);
            }
        }

        return mapping;
    }

3-2-1:追踪到ActionMapper的getMapping(..)方法；而ActionMapper是一个接口，方法由DefaultActionMapper类实现；

定位到DefaultActionMapper类的getMapping(..);

public ActionMapping getMapping(HttpServletRequest request, ConfigurationManager configManager) {
        ActionMapping mapping = new ActionMapping();
        //获取到请求的url
        String uri = RequestUtils.getUri(request);
        //截取url，把含有";"的后面的字符截取掉
        int indexOfSemicolon = uri.indexOf(";");
        uri = (indexOfSemicolon > -1) ? uri.substring(0, indexOfSemicolon) : uri;

        //继续截取url，url的后缀截取掉(如.action和.do等)，在这里就可以看见extensions变量，struts默认的后缀名就是.action
        uri = dropExtension(uri, mapping);
        if (uri == null) {
            return null;
        }
        //从url获取namespace和name并和mapping匹配
        parseNameAndNamespace(uri, mapping, configManager);
        handleSpecialParameters(request, mapping);
        return parseActionName(mapping);
    }

3-3：现在返回到doFilter方法，追踪到

execute.executeAction(request, response, mapping);方法；

 public void executeAction(HttpServletRequest request, HttpServletResponse response, ActionMapping mapping) throws ServletException {
        dispatcher.serviceAction(request, response, mapping);
    }

最终调用的是Dispatcher的serviceAction(...)方法，

public void serviceAction(HttpServletRequest request, HttpServletResponse response, ActionMapping mapping)
            throws ServletException {
        //封转上下文环境，主要将request、params、session等Map封装成为一个上下文Map、
        Map<String, Object> extraContext = createContextMap(request, response, mapping);

        // If there was a previous value stack, then create a new copy and pass it in to be used by the new Action
        ValueStack stack = (ValueStack) request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);
        boolean nullStack = stack == null;
        if (nullStack) {
            ActionContext ctx = ActionContext.getContext();
            if (ctx != null) {
                stack = ctx.getValueStack();
            }
        }
        if (stack != null) {
            extraContext.put(ActionContext.VALUE_STACK, valueStackFactory.createValueStack(stack));
        }

        String timerKey = "Handling request from Dispatcher";
        try {
            UtilTimerStack.push(timerKey);
            //从mapping(这里是已经封装好的mapping，struts.xml与请求url共同映射出来的数据)中获取命名空间
            String namespace = mapping.getNamespace();
　　　　　　  //从mapping中获取action的name
            String name = mapping.getName();
　　　　　　　//从mapping中获取请求方法（是获取动态的请求方法：在url后面加上 ‘!+方法名’）
            String method = mapping.getMethod();
　　　　　　　//生成action的代理类，执行页面参数值和根据反射执行请求方法
            ActionProxy proxy = getContainer().getInstance(ActionProxyFactory.class).createActionProxy(
                    namespace, name, method, extraContext, true, false);

            request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack());

            //如果配置文件中执行的这个action配置了result，就直接转到result
            if (mapping.getResult() != null) {
                Result result = mapping.getResult();
                result.execute(proxy.getInvocation());
            } else {
                proxy.execute();
            }

            // If there was a previous value stack then set it back onto the request
            if (!nullStack) {
                request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, stack);
            }
        } catch (ConfigurationException e) {
            logConfigurationException(request, e);
            sendError(request, response, HttpServletResponse.SC_NOT_FOUND, e);
        } catch (Exception e) {
            if (handleException || devMode) {
                sendError(request, response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e);
            } else {
                throw new ServletException(e);
            }
        } finally {
            UtilTimerStack.pop(timerKey);
        }
    }

3-3-1：追踪  ActionProxy proxy = getContainer().getInstance(ActionProxyFactory.class).createActionProxy(

namespace, name, method, extraContext, true, false);

创建ActionProxy是由ActionProxyFactory实现类完成

DefaultActionProxyFactory createActionProxy方法

public ActionProxy createActionProxy(String namespace, String actionName, String methodName, Map<String, Object> extraContext, boolean executeResult, boolean cleanupContext) {

        ActionInvocation inv = new DefaultActionInvocation(extraContext, true);
        container.inject(inv);
        //StrutsActionProxyFactory 的createActionProxy方法,   StrutsActionProxyFactory是DefaultActionProxyFactory的子类，调用的是StrutsActionProxyFactory的方法
        return createActionProxy(inv, namespace, actionName, methodName, executeResult, cleanupContext);
    }

--------- StrutsActionProxyFactory-----------------

public class StrutsActionProxyFactory extends DefaultActionProxyFactory {

    @Override
    public ActionProxy createActionProxy(ActionInvocation inv, String namespace, String actionName, String methodName, boolean executeResult, boolean cleanupContext) {

        StrutsActionProxy proxy = new StrutsActionProxy(inv, namespace, actionName, methodName, executeResult, cleanupContext);
        container.inject(proxy);
//继续跟踪代码: prepare()调用的是父类DefaultActionProxy的prepare()方法
        proxy.prepare();
        return proxy;
    }
}

--------------------DefaultActionProxy-------------------

protected void prepare() {
        String profileKey = "create DefaultActionProxy: ";
        try {
            UtilTimerStack.push(profileKey);
            config = configuration.getRuntimeConfiguration().getActionConfig(namespace, actionName);

            if (config == null && unknownHandlerManager.hasUnknownHandlers()) {
                config = unknownHandlerManager.handleUnknownAction(namespace, actionName);
            }
            if (config == null) {
                throw new ConfigurationException(getErrorMessage());
            }
              //获取执行method为空的方法名， 若为空则默认设置为"execute"
            resolveMethod();

            if (!config.isAllowedMethod(method)) {
                throw new ConfigurationException("Invalid method: " + method + " for action " + actionName);
            }
              //创建action
            invocation.init(this);

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

----------------- invocation.init(this)--------------

public void init(ActionProxy proxy) {
        this.proxy = proxy;
        Map<String, Object> contextMap = createContextMap();

        // Setting this so that other classes, like object factories, can use the ActionProxy and other
        // contextual information to operate
        ActionContext actionContext = ActionContext.getContext();

        if (actionContext != null) {
            actionContext.setActionInvocation(this);
        }
         //这里开始创建action
        createAction(contextMap);

        if (pushAction) {
            stack.push(action);
            contextMap.put("action", action);
        }

        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<InterceptorMapping> interceptorList = new ArrayList<InterceptorMapping>(proxy.getConfig().getInterceptors());
        interceptors = interceptorList.iterator();
    }

至此action就创建成功了，然后就是给action的属性赋值和执行action里的方法

3-4：重新回到Dispatcher的serviceAction(...)方法，当mapping.getResult() != null此时就跟踪到

proxy.execute();方法

ActionProxy是接口，execute()由StrutsActionProxy实现；

public String execute() throws Exception {
        ActionContext previous = ActionContext.getContext();
        ActionContext.setContext(invocation.getInvocationContext());
        try {
            //开始执行action和注入属性值，由DefaultActionInvocation实现这个方法
            return invocation.invoke();
        } finally {
            if (cleanupContext)
                ActionContext.setContext(previous);
        }
    }

---------------DefaultActionInvocation--------------------------------

.....其他代码省略
try {
　　　　//最主要执行了intercept方法，这里就是执行设置action的属性值和执行方法，由接口Interceptor的抽象类AbstractInterceptor的子类MethodFilterInterceptor执行intercept方法，
　　　　//由于AbstractInterceptor的实现类很多，所以这段代码会执行很多次，至于为什么会执行多次，本人也还在研究，若有仁兄了解可以给小弟一点指引
         resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);
    }
    finally {
    　　UtilTimerStack.pop(interceptorMsg);
    }
.....其他代码省略

---------------MethodFilterInterceptor---------------------------------

@Override
    public String intercept(ActionInvocation invocation) throws Exception {
        if (applyInterceptor(invocation)) {
          //执行了ParametersInterceptor的doIntercept方法，
 return doIntercept(invocation);
        }
        return invocation.invoke();
    }

---------------ParametersInterceptor---------------------

@Override
    public String doIntercept(ActionInvocation invocation) throws Exception {
        Object action = invocation.getAction();
        if (!(action instanceof NoParameters)) {
            ActionContext ac = invocation.getInvocationContext();
            final Map<String, Object> parameters = retrieveParameters(ac);

            if (LOG.isDebugEnabled()) {
                LOG.debug("Setting params " + getParameterLogMap(parameters));
            }

            if (parameters != null) {
                Map<String, Object> contextMap = ac.getContextMap();
                try {
                    ReflectionContextState.setCreatingNullObjects(contextMap, true);
                    ReflectionContextState.setDenyMethodExecution(contextMap, true);
                    ReflectionContextState.setReportingConversionErrors(contextMap, true);

                    ValueStack stack = ac.getValueStack();
//给action的参数赋值
                    setParameters(action, stack, parameters);
                } finally {
                    ReflectionContextState.setCreatingNullObjects(contextMap, false);
                    ReflectionContextState.setDenyMethodExecution(contextMap, false);
                    ReflectionContextState.setReportingConversionErrors(contextMap, false);
                }
            }
        }
//最后执行action
        return invocation.invoke();
    }

至此，整个action的请求就结束了；