JavaWeb中的Struts2概述

Struts2是一种基于MVC模式的javaWeb框架，本质上相当于Servlet。

所谓MVC，就是模型-视图-控制器。

Model（模型）表示应用程序核心（比如数据库记录列表）。

View（视图）显示数据（数据库记录）。

Controller（控制器）处理输入（写入数据库记录）

而Struts的作用实际上是作为控制器，建立模型层和视图层的数据交互（就是通常所说控制model和jsp之间的数据交互）

上面都是废话，你只要知道struts2能控制model和jsp之间的数据交互即可。

web程序想要使用struts2框架，除了要引用相关jar包外，还要在web.xml中对struts2进行配置，只有配置后，struts2才能对浏览器的请求进行一系列处理。

怎么在web应用中配置struts2?

首先在web.xml中添加struts2的使用，代码如下：

	<!-- 配置Struts2 核心 Filter -->
	<filter>
		<filter-name>action2</filter-name>
		<filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
	</filter>

	<filter-mapping>
		<filter-name>action2</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

上述代码使用了Filter，那我们就回顾一下Filter的作用。

回顾：Filter，中文名为过滤器，通过Filter可以对web服务器的资源进行管理，例如Jsp,Servlet, 静态图片文件等进行拦截，从而实现一些特殊的功能。

实现URL级别的权限访问控制、过滤敏感词汇、压缩响应信息等一些高级功能

从代码层面来讲，只要创建一个实现了Filter接口的实现类，然后将这个类在web.xml进行配置，那么这个类就可以让用户在访问某个目标资源之前，对访问的请求和响应进行拦截。

更多介绍可以看我的另外一篇文章：http://blog.csdn.net/u012605477/article/details/75258358

注意：Struts2在web.xml中看来就是一个Filter，只不过其实现类StrutsPrepareAndExecuteFilter不是我们写的，是Struts2的。

为了验证StrutsPrepareAndExecuteFilter也实现了Filter接口，我们将其和我们自写的过滤器进行对比：

下面是自写的过滤器FilterA配置：

	<filter>
		<filter-name>FilterA</filter-name>
		<filter-class>com.strategy.jpa.FilterA</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>FilterA</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

自写FilterA的代码：

package com.strategy.jpa;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class FilterA implements Filter {

	public void init(FilterConfig filterConfig) throws ServletException {

	}

	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		
		
		chain.doFilter(request, response);
		response.reset();
		
	}

	public void destroy() {

	}

}

web中配置Struts2的代码：

 * $Id: DefaultActionSupport.java 651946 2008-04-27 13:41:38Z apetrelli $
package org.apache.struts2.dispatcher.filter;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.struts2.RequestUtils;
import org.apache.struts2.StrutsStatics;
import org.apache.struts2.dispatcher.Dispatcher;
import org.apache.struts2.dispatcher.mapper.ActionMapping;
import org.apache.struts2.dispatcher.ExecuteOperations;
import org.apache.struts2.dispatcher.InitOperations;
import org.apache.struts2.dispatcher.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;

/**
 * Handles both the preparation and execution phases of the Struts dispatching process.  This filter is better to use
 * when you don't have another filter that needs access to action context information, such as Sitemesh.
 */
public class StrutsPrepareAndExecuteFilter implements StrutsStatics, Filter {

    private static final Logger LOG = LogManager.getLogger(StrutsPrepareAndExecuteFilter.class);

    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
     *
     * @param dispatcher the dispatcher
     * @param filterConfig the filter config
     */
    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 {
            String uri = RequestUtils.getUri(request);
            if (excludedPatterns != null && prepare.isUrlExcluded(request, excludedPatterns)) {
                LOG.trace("Request {} is excluded from handling by Struts, passing request to other filters", uri);
                chain.doFilter(request, response);
            } else {
                LOG.trace("Checking if {} is a static resource", uri);
                boolean handled = execute.executeStaticResourceRequest(request, response);
                if (!handled) {
                    LOG.trace("Assuming uri {} as a normal action", uri);
                    prepare.setEncodingAndLocale(request, response);
                    prepare.createActionContext(request, response);
                    prepare.assignDispatcherToThread();
                    request = prepare.wrapRequest(request);
                    ActionMapping mapping = prepare.findActionMapping(request, response, true);
                    if (mapping == null) {
                        LOG.trace("Cannot find mapping for {}, passing to other filters", uri);
                        chain.doFilter(request, response);
                    } else {
                        LOG.trace("Found mapping {} for {}", mapping, uri);
                        execute.executeAction(request, response, mapping);
                    }
                }
            }
        } finally {
            prepare.cleanupRequest(request);
        }
    }

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

}

对比可知，struts2也实现了Filter接口，只是他比我们自己写的FilterA多实现了一个接口StrutsStatics，其它的没有变化。

我们对上面的代码进行了解：

在Init方法里面，我们看到有一个config对象，该类对象的作用是对FilterConfig进行封装。

package org.apache.struts2.dispatcher.filter;

import org.apache.struts2.util.MakeIterator;

import javax.servlet.FilterConfig;
import javax.servlet.ServletContext;
import java.util.Iterator;

import org.apache.struts2.dispatcher.HostConfig;

/**
 * Host configuration that wraps FilterConfig
 */
public class FilterHostConfig implements HostConfig {

    private FilterConfig config;

    public FilterHostConfig(FilterConfig config) {
        this.config = config;
    }
    public String getInitParameter(String key) {
        return config.getInitParameter(key);
    }

    public Iterator<String> getInitParameterNames() {
        return MakeIterator.convert(config.getInitParameterNames());
    }

    public ServletContext getServletContext() {
        return config.getServletContext();
    }
}

然后又在Init方法里面通过创建的config对象，并调用initDispatcher方法创建了转发器对象dispatcher对象。以及通过initLogging方法初始化日志记录器。

    private Dispatcher createDispatcher( HostConfig filterConfig ) {
        Map<String, String> params = new HashMap<>();
        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);
    }

    public void cleanup() {
        ActionContext.setContext(null);
    }

    public void initLogging( HostConfig filterConfig ) {
        String factoryName = filterConfig.getInitParameter("loggerFactory");
        if (factoryName != null) {
            try {
                Class cls = ClassLoaderUtil.loadClass(factoryName, this.getClass());
                LoggerFactory fac = (LoggerFactory) cls.newInstance();
                LoggerFactory.setLoggerFactory(fac);
            } catch ( InstantiationException e ) {
                System.err.println("Unable to instantiate logger factory: " + factoryName + ", using default");
                e.printStackTrace();
            } catch ( IllegalAccessException e ) {
                System.err.println("Unable to access logger factory: " + factoryName + ", using default");
                e.printStackTrace();
            } catch ( ClassNotFoundException e ) {
                System.err.println("Unable to locate logger factory class: " + factoryName + ", using default");
                e.printStackTrace();
            }
        }
    }

接下来调用了init对象initStaticContentLoader(config, dispatcher);方法加载一些静态资源。

    public StaticContentLoader initStaticContentLoader( HostConfig filterConfig, Dispatcher dispatcher ) {
        StaticContentLoader loader = dispatcher.getContainer().getInstance(StaticContentLoader.class);
        loader.setHostConfig(filterConfig);
        return loader;
    }

最重要的就是dispatcher，它主要将filter拦截到的请求转入struts2的请求处理模块，我们必须知道这一点。

其次是FilterConfig，它将我们在web.xml中的Filter的配置信息也保存到了dispatcher中。下面是该对象的构造方法。

    public Dispatcher(ServletContext servletContext, Map<String, String> initParams) {
        this.servletContext = servletContext;
        this.initParams = initParams;
    }

接下来就是prepare和execute对象，和InitOperations类似，也是进行了封装一些操作，都是截取一部分重要的代码。

    public PrepareOperations(Dispatcher dispatcher) {
        this.dispatcher = dispatcher;
    }
    public ActionContext createActionContext(HttpServletRequest request, HttpServletResponse response) {
        ActionContext ctx;
        Integer counter = 1;
        Integer oldCounter = (Integer) request.getAttribute(CLEANUP_RECURSION_COUNTER);
        if (oldCounter != null) {
            counter = oldCounter + 1;
        }
        
        ActionContext oldContext = ActionContext.getContext();
        if (oldContext != null) {
            // detected existing context, so we are probably in a forward
            ctx = new ActionContext(new HashMap<>(oldContext.getContextMap()));
        } else {
            ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
            stack.getContext().putAll(dispatcher.createContextMap(request, response, null));
            ctx = new ActionContext(stack.getContext());
        }
        request.setAttribute(CLEANUP_RECURSION_COUNTER, counter);
        ActionContext.setContext(ctx);
        return ctx;
    }

execute对象

    public ExecuteOperations(Dispatcher dispatcher) {
        this.dispatcher = dispatcher;
    }

    public boolean executeStaticResourceRequest(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
        // there is no action in this request, should we look for a static resource?
        String resourcePath = RequestUtils.getServletPath(request);

        if ("".equals(resourcePath) && null != request.getPathInfo()) {
            resourcePath = request.getPathInfo();
        }

        StaticContentLoader staticResourceLoader = dispatcher.getContainer().getInstance(StaticContentLoader.class);
        if (staticResourceLoader.canHandle(resourcePath)) {
            staticResourceLoader.findStaticResource(resourcePath, request, response);
            // The framework did its job here
            return true;

        } else {
            // this is a normal request, let it pass through
            return false;
        }
    }

从上面的代码可以看出，这两个对象封装了请求预处理和请求处理的操作，当处理请求时方法被调用

在上述的代码中有个很重要的方法未罗列出来，那就是Disptcher中得init方法，该方法初始读取一些配置文件，包含我们想要知道的读取struts2.xml的方法。

    public void init() {

    	if (configurationManager == null) {
    		configurationManager = createConfigurationManager(DefaultBeanSelectionProvider.DEFAULT_BEAN_NAME);
    	}

        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) {
            LOG.error("Dispatcher initialization failed", ex);
            throw new StrutsException(ex);
        }
    }

上面是init方法，里面调用了诸多读取配置文件的方法，包含我们想要知道的读取struts.xml的方法：

    private void init_TraditionalXmlConfigurations() {
        String configPaths = initParams.get("config");
        if (configPaths == null) {
            configPaths = DEFAULT_CONFIGURATION_PATHS;
        }
        String[] files = configPaths.split("\\s*[,]\\s*");
        for (String file : files) {
            if (file.endsWith(".xml")) {
                if ("xwork.xml".equals(file)) {
                    configurationManager.addContainerProvider(createXmlConfigurationProvider(file, false));
                } else {
                    configurationManager.addContainerProvider(createStrutsXmlConfigurationProvider(file, false, servletContext));
                }
            } else {
                throw new IllegalArgumentException("Invalid configuration file name");
            }
        }
    }

在上面的代码中，设定了读取struts.xml的默认路径，其内容如下：

private static final String DEFAULT_CONFIGURATION_PATHS = "struts-default.xml,struts-plugin.xml,struts.xml";

至此，web应用配置struts2框架，以及struts2如何将Filter封装成struts2的，甚至如何读取struts.xml以及其他配置，并进行相关struts2参数初始化都有了大概了解，接下来说一下Action。

回到StrutsPrepareAndExecuteFilter类的doFilter中，

    //每次发送一个Request，StrutsPrepareAndExecuteFilter都会调用doFilter方法  
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {  
  
        HttpServletRequest request = (HttpServletRequest) req;  
        HttpServletResponse response = (HttpServletResponse) res;  
  
        try {  
            //设置编码和国际化    
            prepare.setEncodingAndLocale(request, response);  
            //ActionContext创建  
            prepare.createActionContext(request, response);  
            prepare.assignDispatcherToThread();  
            if ( excludedPatterns != null && prepare.isUrlExcluded(request, excludedPatterns)) {  
                chain.doFilter(request, response);  
            } else {  
                request = prepare.wrapRequest(request);  
                ActionMapping mapping = prepare.findActionMapping(request, response, true);  
                //如果找不到对应的action配置  
                if (mapping == null) {  
                    /* 
                     * 就是如果path是以“/struts”开头，则到初始参数packages配置的包路径去查找对应的静态资源并输出到页面流中， 
                     * 当然.class文件除外。如果再没有则跳转到404 
                     */  
                    boolean handled = execute.executeStaticResourceRequest(request, response);  
                    if (!handled) {  
                        chain.doFilter(request, response);  
                    }  
                } else {  
                    /* 
                     * 找到对应action配置文件后，调用ExecuteOperations类中executeAction， 
                     * 开始谳用Action的方法。 
                     */  
                    execute.executeAction(request, response, mapping);  
                }  
            }  
        } finally {  
            prepare.cleanupRequest(request);  
        }  
    }

相关准备（prepare）方法，设置编码的方法不再叙述（setEncodingAndLocale），我们主要说一下ActionContext。

prepare.createActionContext(request, response);

ActionContext是一个struts2容器，主要存储request、session、application、parameters等相关信息。

ActionContext是一个线程的本地变量，这意味着不同的action之间不会共享ActionContext，所以也不用考虑线程安全问题

    public ActionContext createActionContext(HttpServletRequest request, HttpServletResponse response) {
        ActionContext ctx;
        Integer counter = 1;
        Integer oldCounter = (Integer) request.getAttribute(CLEANUP_RECURSION_COUNTER);
        if (oldCounter != null) {
            counter = oldCounter + 1;
        }
        
        ActionContext oldContext = ActionContext.getContext();
        if (oldContext != null) {
            // detected existing context, so we are probably in a forward
            ctx = new ActionContext(new HashMap<>(oldContext.getContextMap()));
        } else {
            ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
            stack.getContext().putAll(dispatcher.createContextMap(request, response, null));
            ctx = new ActionContext(stack.getContext());
        }
        request.setAttribute(CLEANUP_RECURSION_COUNTER, counter);
        ActionContext.setContext(ctx);
        return ctx;
    }

我们再看一下ActionContext是什么，取部分代码，由此可知ActionContext是一个键值对集合，跟Spring中的bean类似：

public class ActionContext implements Serializable {

    static ThreadLocal<ActionContext> actionContext = new ThreadLocal<>();
    
    private Map<String, Object> context;

    public ActionContext(Map<String, Object> context) {
        this.context = context;
    }

有了创建Action的方法，肯定有使用Action的方法，我们现在去找使用的方法：

    public void serviceAction(HttpServletRequest request, HttpServletResponse response, ActionMapping mapping)
            throws ServletException {

        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();
            String name = mapping.getName();
            String method = mapping.getMethod();

            ActionProxy proxy = getContainer().getInstance(ActionProxyFactory.class).createActionProxy(
                    namespace, name, method, extraContext, true, false);

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

            // if the ActionMapping says to go straight to a result, do it!
            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);
        }
    }

在上面的try语句里面我们可以得知，struts是怎么通过命名空间，读取action的配置，以及action的method方法，

尤其是如何从容器中获得ActionProxyFactory代理工厂，是怎么创建ActionProxy来执行一个特定的命名空间和动作的。

以及怎么通过我们在struts2中设定的跳转方法，跳转到指定页面的。

            //执行execute方法，并转向结果   
            if (mapping.getResult() != null) {  
                Result result = mapping.getResult();  
                result.execute(proxy.getInvocation());  
            } else {  
                proxy.execute();  
            }

至此，对于Struts2是如何工作的，怎么读取xml的，如何搭建在web应用中基本叙述完了，更详细的实在说不完，各位大佬可以看下下面这位大神的博客，很给力，就是看起来太繁琐。

另外，本文部分来源于该大神，未通知，深表歉意。

http://blog.csdn.net/yuan_xw/article/details/7838123

JavaWeb中的Struts2概述

猜你喜欢