struts2基本构成

struts2框架构成

　　1.核心控制器 StrutsPrepareAndExecutefilter

　　2.业务控制器

　　3.业务逻辑组件(用户实现)

struts2 流程图

 

一 核心控制器  StrutsPrepareAndExecuteFilter

　　StrutsPrepareAndExecutefilter作为一个filter运行在web应用中, 负责拦截所有用户请求.

　　实现类  org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter.  (源码在最后)

　　struts2 获得用户请求后, 根据请求名字决定调用的逻辑组件.       一个表单头<form action="Login" method="post">  ====>  调用Login.action

　　action处理用户请求过程: 用户实现的业务控制器(action)与servletAPI不耦合, 无法直接处理用户请求.所以用户请求需先经过拦截器将HttpServletRequest解析出来,

　　　　传入至action中,回调该动作的execute()方法.

　　关于解析,在action中可以通过ActionContext.getContext().getSession()方法获取到session,但是此处Session并非HttpSession,而是一个具有它的值的Map.

二 业务控制器

　　业务控制器就是用户实现的Action类的实例, execute()方法会返回一个字符串.根据不同的字符串可以返回不同的视图.

　　一个action的配置文件

<action name="Login" class="slowalker.LoginAction">
    <result name="success">/jsps/Success.jsp</result>
    <result name="error">/jsps/Error.jsp</result>    
</action>

     result标签中的name即为execute返回值,其后标签体中指定了当返回值为该值是,需要返回的视图.

核心控制器源码:

package org.apache.struts2.dispatcher.ng.filter;

import org.apache.struts2.StrutsStatics;
import org.apache.struts2.dispatcher.Dispatcher;
import org.apache.struts2.dispatcher.mapper.ActionMapping;
import org.apache.struts2.dispatcher.ng.ExecuteOperations;
import org.apache.struts2.dispatcher.ng.InitOperations;
import org.apache.struts2.dispatcher.ng.PrepareOperations;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import java.util.regex.Pattern;

public class StrutsPrepareAndExecuteFilter implements StrutsStatics, Filter {  //实现filter接口, 可见其本质便为filter
    protected PrepareOperations prepare;
    protected ExecuteOperations execute;
    protected List<Pattern> excludedPatterns = null;

    public void init(FilterConfig filterConfig) throws ServletException {
        InitOperations init = new InitOperations();
        Dispatcher dispatcher = null;
        try {
            FilterHostConfig config = new FilterHostConfig(filterConfig);
            init.initLogging(config);
            dispatcher = init.initDispatcher(config);
            init.initStaticContentLoader(config, dispatcher);

            prepare = new PrepareOperations(dispatcher);
            execute = new ExecuteOperations(dispatcher);
            this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);

            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);
                prepare.createActionContext(request, response);
                prepare.assignDispatcherToThread();
                request = prepare.wrapRequest(request);
                ActionMapping mapping = prepare.findActionMapping(request, response, true);
                if (mapping == null) {
                    boolean handled = execute.executeStaticResourceRequest(request, response);
                    if (!handled) {
                        chain.doFilter(request, response);
                    }
                } else {
                    execute.executeAction(request, response, mapping);
                }
            }
        } finally {
            prepare.cleanupRequest(request);
        }
    }

    public void destroy() {
        prepare.cleanupDispatcher();
    }

}