Struts2(二)工作原理

一、概述

1、struts框架本身分为三个部分：核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。

2、struts2工作的基本流程：

• 客户端初始化一个指向Servlet容器的请求
• org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter被调用，该过滤器询问ActionMaper这个请求是否需要调用某个Action
• 如果ActionMapper决定需要调用某个Action，StrutsPrepareAndExecuteFilter把请求的处理交给ActionProxy
• ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类
• ActionProxy创建一个ActionProxy的实例
• ActionProxy实例使用命名模式来调用
• 一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果

二、源码分析

　　下面解析org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter类

public class StrutsPrepareAndExecuteFilter implements StrutsStatics, Filter
{
    /*
     * prepareOperation对象包含执行请求之前的准备工作
     * ExecuteOperations对象包含过滤器的执行操作
     */
    protected PrepareOperations prepare;
    protected ExecuteOperations execute;
    protected List<Pattern> excludedPatterns = null;

    public void init(FilterConfig filterConfig) throws ServletException 
    {
        //InitOperations类包含一些初始化操作
        InitOperations init = new InitOperations();
        Dispatcher dispatcher = null;
        try 
        {
            //封装filterConfig，其中有个主要方法getInitParameterNames将参数名字以String格式存储在List中
            FilterHostConfig config = new FilterHostConfig(filterConfig);
            //初始化struts内部日志
            init.initLogging(config);
            //创建dispatcher ，并初始化
            dispatcher = init.initDispatcher(config);
            init.initStaticContentLoader(config, dispatcher);
            //初始化类属性：prepare 、execute
            prepare = new PrepareOperations(dispatcher);
            execute = new ExecuteOperations(dispatcher);
            this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);
            //回调空的postInit方法
            postInit(dispatcher, filterConfig);
        } 
        finally
        {
            if (dispatcher != null) {
                dispatcher.cleanUpAfterInit();
            }
            init.cleanup();
        }
    }
    /**
     * Callback for post initialization
     */
    protected void postInit(Dispatcher dispatcher, FilterConfig filterConfig)
    {
    }

    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上下文
                //ActionContext是一个线程的本地变量，这意味着不同的action之间不会共享ActionContext，所以也不用考虑线程安全问题
                prepare.createActionContext(request, response);
                prepare.assignDispatcherToThread();
                request = prepare.wrapRequest(request);
                ActionMapping mapping = prepare.findActionMapping(request, response, true);
                //如果mapping为空，则认为不是调用action,会调用下一个过滤器链，直到获取到mapping才调用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);
        }
    }
    public void destroy() {
        prepare.cleanupDispatcher();
    }
}

　　上述源码的第23行：dispatcher = init.initDispatcher(config);

//创建并初始化Dispatcher对象
    public Dispatcher initDispatcher( HostConfig filterConfig ) 
　　{
        Dispatcher dispatcher = createDispatcher(filterConfig);
        dispatcher.init();
        return dispatcher;
    }

　　创建dispatcher，会读取 filterConfig 中的配置信息，将配置信息解析出来，封装成为一个Map，然后根绝servlet上下文和参数Map构造Dispatcher ：

 private Dispatcher createDispatcher( HostConfig filterConfig )
 {
        Map<String, String> params = new HashMap<String, String>();
        for(Iterator e = filterConfig.getInitParameterNames(); e.hasNext(); ) 
　　　　　　{
            String name = (String) e.next();
            String value = filterConfig.getInitParameter(name);
            params.put(name, value);
         }
        return new Dispatcher(filterConfig.getServletContext(), params);
 }

　　初始化dispatcher过程如下：

public void init()
{
    if (configurationManager == null)
        {
           configurationManager = createConfigurationManager(DefaultBeanSelectionProvider.DEFAULT_BEAN_NAME);
        }
         //初始化过程中，会加载一些配置文件，例如：default.properties,struts-default.xml,struts-plugin.xml,struts.xml等
       try 
           {
           init_FileManager();
           init_DefaultProperties(); // [1]
           init_TraditionalXmlConfigurations(); // [2]
           init_LegacyStrutsProperties(); // [3]
           init_CustomConfigurationProviders(); // [5]
           init_FilterInitParameters() ; // [6]
           init_AliasStandardObjects() ; // [7]
           Container container = init_PreloadConfiguration();
           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);
       }
}

　　上述分析的是StrutsPrepareAndExecuteFilter类的init方法，该方法在web容器启动的时候就会被调用，当用户访问某个action时，首先调用StrutsPrepareAndExecuteFilter类的doFilter方法，下面具体分析下这个方法：

• 首先是设置编码格式和地点：

　　prepare.setEncodingAndLocale(request, response);

• 创建ActionContext，ActionContext(com.opensymphony.xwork.ActionContext)是Action执行时的上下文,上下文可以看作是一个容器(其实我们这里的容器就是一个Map而已),它存放的是Action在执行时需要用到的对象，比如Session、Application、Request、Locale、ValueStack等。

　　 prepare.createActionContext(request, response);

• 分配调度到本地线程调度

　　  prepare.assignDispatcherToThread();

• request进行包装，如果content_type是multipart/form-data类型，则将request包装成MultiPartRequestWrapper对象，否则包装成StrutsRequestWrapper对象

 request = prepare.wrapRequest(request);

public HttpServletRequest wrapRequest(HttpServletRequest request) throws IOException
{
    // don't wrap more than once
    if (request instanceof StrutsRequestWrapper)
    {
        return request;
    }
    String content_type = request.getContentType();
    if (content_type != null && content_type.contains("multipart/form-data"))
    {
        MultiPartRequest mpr = getMultiPartRequest();
        LocaleProvider provider = getContainer().getInstance(LocaleProvider.class);
        request = new MultiPartRequestWrapper(mpr, request, getSaveDir(), provider, disableRequestAttributeValueStackLookup);
    }
    else 
    {
        request = new StrutsRequestWrapper(request, disableRequestAttributeValueStackLookup);
    }
    return request;
}

• 然后通过ActionMapper的getMapping()方法得到请求的Action，Action的配置信息存储在ActionMapping对象中，

　　ActionMapping mapping = prepare.findActionMapping(request, response, true);

　　我们找到prepare对象的findActionMapping方法：

public ActionMapping findActionMapping(HttpServletRequest request, HttpServletResponse response, boolean forceLookup) 
{
    //首先从request对象中取mapping对象，看是否存在
    ActionMapping mapping = (ActionMapping) request.getAttribute(STRUTS_ACTION_MAPPING_KEY); //struts.actionMapping
    //不存在就创建一个
    if (mapping == null || forceLookup)
    {
        try 
        {
            //首先创建ActionMapper对象，通过ActionMapper对象创建mapping对象
            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;
}

　　ActionMapper接口的实现类DefaultActionMapper的getMapping()方法的源代码：

public ActionMapping getMapping(HttpServletRequest request, ConfigurationManager configManager)
{
          ActionMapping mapping = new ActionMapping();
          //获得请求的uri，即请求路径URL中工程名以后的部分，如/HelloWorld.action
          String uri = getUri(request);
          int indexOfSemicolon = uri.indexOf(";");
          uri = (indexOfSemicolon > -1) ? uri.substring(0, indexOfSemicolon) : uri;
          //删除扩展名，如.action或者.do
          uri = dropExtension(uri, mapping);
          if (uri == null) 
          {
             return null;
          }
         //从uri中分离得到请求的action名、命名空间。
         parseNameAndNamespace(uri, mapping, configManager);
         //处理特殊的请求参数
         handleSpecialParameters(request, mapping);
         //如果允许动态方法调用，即形如/HelloWorldAction!getAll.action的请求，分离action名和方法名
         return parseActionName(mapping);
}

• 如果mapping为空，则认为不是调用action,会调用下一个过滤器链，直到获取到mapping才调用action

if (mapping == null) 
   {
      boolean handled = execute.executeStaticResourceRequest(request, response);
      if (!handled)
         {
            chain.doFilter(request, response);
         }
   } 

• 如果mapping对象不为空，则会执行action

　　 execute.executeAction(request, response, mapping);

　　其源码为：

public void serviceAction(HttpServletRequest request, HttpServletResponse response, ActionMapping mapping) throws ServletException 
{
        //封转上下文环境，主要将requestMap、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);
            String namespace = mapping.getNamespace();//从mapping对象获取命名空间
            String name = mapping.getName(); //获取请求的action名
            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);
        }
    }
}

• 最后通过Result完成页面跳转。