struts2請求過程源碼分析

時間 2019-11-06

原文原文鏈接

Struts2是Struts社區和WebWork社區的共同成果，咱們甚至能夠說，Struts2是WebWork的升級版，他採用的正是WebWork的核心，因此，Struts2並非一個不成熟的產品，相反，構建在WebWork基礎之上的Struts2是一個運行穩定、性能優異、設計成熟的WEB框架。html

　　我這裏的struts2源碼是從官網下載的一個最新的struts-2.3.15.1-src.zip，將其解壓便可。裏面的目錄頁文件很是的多，咱們只須要定位到struts-2.3.15.1\src\core\src\main\java\org\apache\struts2查看源文件。目錄結構以下圖java

　　Struts2框架的正常運行，除了佔核心地位的xwork的支持之外，Struts2自己也提供了許多類，這些類被分門別類組織到不一樣的包中。從源代碼中發現，基本上每個Struts2類都訪問了WebWork提供的功能，從而也能夠看出Struts2與WebWork千絲萬縷的聯繫。但不管如何，Struts2的核心功能好比將請求委託給哪一個Action處理都是由xwork完成的，Struts2只是在WebWork的基礎上作了適當的簡化、增強和封裝，並少許保留Struts1.x中的習慣。web

如下是包說明：apache

struts2 架構圖以下圖所示：安全

依照上圖，咱們能夠看出一個請求在struts的處理大概有以下步驟：session

　　一、客戶端初始化一個指向Servlet容器（例如Tomcat）的請求；架構

　　二、這個請求通過一系列的過濾器（Filter）（這些過濾器中有一個叫作ActionContextCleanUp的可選過濾器，這個過濾器對於Struts2和其餘框架的集成頗有幫助，例如：SiteMesh Plugin）；app

　　三、接着StrutsPrepareAndExecuteFilter被調用，StrutsPrepareAndExecuteFilter詢問ActionMapper來決定這個請求是否須要調用某個Action；框架

　　四、若是ActionMapper決定須要調用某個Action，FilterDispatcher把請求的處理交給ActionProxy；ide

　　五、ActionProxy經過Configuration Manager詢問框架的配置文件，找到須要調用的Action類；

　　六、ActionProxy建立一個ActionInvocation的實例。

　　七、ActionInvocation實例使用命名模式來調用，在調用Action的過程先後，涉及到相關攔截器（Intercepter）的調用。

　　八、一旦Action執行完畢，ActionInvocation負責根據struts.xml中的配置找到對應的返回結果。返回結果一般是（但不老是，也多是另外的一個Action鏈）一個須要被表示的JSP或者FreeMarker的模版。在表示的過程當中可使用Struts2 框架中繼承的標籤。在這個過程當中須要涉及到ActionMapper。

strut2源碼分析：

　　首先咱們使用struts2框架都會在web.xml中註冊和映射struts2，配置內容以下：

<filter-name>struts2</filter-name>

<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>struts2</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

注：在早期的struts2中，都是使用FilterDispathcer，從Struts 2.1.3開始，它已不推薦使用。若是你使用的Struts的版本 >= 2.1.3，推薦升級到新的Filter，StrutsPrepareAndExecuteFilter。在此研究的是StrutsPrepareAndExecuteFilter。

　　StrutsPrepareAndExecuteFilter中的方法：

web容器一啓動，就會初始化核心過濾器StrutsPrepareAndExecuteFilter，並執行初始化方法，初始化方法以下：

 1 public void init(FilterConfig filterConfig) throws ServletException { 2         InitOperations init = new InitOperations(); 3         Dispatcher dispatcher = null; 4         try { 5             //封裝filterConfig，其中有個主要方法getInitParameterNames將參數名字以String格式存儲在List中 6             FilterHostConfig config = new FilterHostConfig(filterConfig); 7             //初始化struts內部日誌 8             init.initLogging(config); 9             //建立dispatcher ，並初始化10             dispatcher = init.initDispatcher(config);11             init.initStaticContentLoader(config, dispatcher);12             //初始化類屬性：prepare 、execute13             prepare = new PrepareOperations(filterConfig.getServletContext(), dispatcher);14             execute = new ExecuteOperations(filterConfig.getServletContext(), dispatcher);15             this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);16             //回調空的postInit方法17             postInit(dispatcher, filterConfig);18         } finally {19             if (dispatcher != null) {20                 dispatcher.cleanUpAfterInit();21             }22             init.cleanup();23         }24     }

關於封裝filterConfig，首先看下FilterHostConfig ，源碼以下：

 1 public class FilterHostConfig implements HostConfig { 2  3     private FilterConfig config; 4     //構造方法 5     public FilterHostConfig(FilterConfig config) { 6         this.config = config; 7     } 8     //根據init-param配置的param-name獲取param-value的值   9     public String getInitParameter(String key) {10         return config.getInitParameter(key);11     }12     //返回初始化參數名的迭代器 13     public Iterator<String> getInitParameterNames() {14         return MakeIterator.convert(config.getInitParameterNames());15     }16     //返回Servlet上下文17     public ServletContext getServletContext() {18         return config.getServletContext();19     }20 }

　　只有短短的幾行代碼，getInitParameterNames是這個類的核心，將Filter初始化參數名稱有枚舉類型轉爲Iterator。此類的主要做爲是對filterConfig 封裝。

　　接下來，看下StrutsPrepareAndExecuteFilter中init方法中dispatcher = init.initDispatcher(config);這是初始化dispatcher的，是經過init對象的initDispatcher方法來初始化的，init是InitOperations類的對象，咱們看看InitOperations中initDispatcher方法：

1  public Dispatcher initDispatcher( HostConfig filterConfig ) {2         Dispatcher dispatcher = createDispatcher(filterConfig);3         dispatcher.init();4         return dispatcher;5     }

　　建立Dispatcher，會讀取 filterConfig 中的配置信息，將配置信息解析出來，封裝成爲一個Map，而後根絕servlet上下文和參數Map構造Dispatcher ：

 1 private Dispatcher createDispatcher( HostConfig filterConfig ) { 2         //存放參數的Map 3         Map<String, String> params = new HashMap<String, String>(); 4         //將參數存放到Map 5         for ( Iterator e = filterConfig.getInitParameterNames(); e.hasNext(); ) { 6             String name = (String) e.next(); 7             String value = filterConfig.getInitParameter(name); 8             params.put(name, value); 9         }10         //根據servlet上下文和參數Map構造Dispatcher 11         return new Dispatcher(filterConfig.getServletContext(), params);12     }

　　這樣dispatcher對象建立完成，接着就是dispatcher對象的初始化，打開Dispatcher類，看到它的init方法以下：

 1 public void init() { 2  3         if (configurationManager == null) { 4             configurationManager = createConfigurationManager(BeanSelectionProvider.DEFAULT_BEAN_NAME); 5         } 6  7         try { 8             init_FileManager(); 9             //加載org/apache/struts2/default.properties10             init_DefaultProperties(); // [1]11             //加載struts-default.xml,struts-plugin.xml,struts.xml12             init_TraditionalXmlConfigurations(); // [2]13             init_LegacyStrutsProperties(); // [3]14             //用戶本身實現的ConfigurationProviders類 15             init_CustomConfigurationProviders(); // [5]16             //Filter的初始化參數 17             init_FilterInitParameters() ; // [6]18             init_AliasStandardObjects() ; // [7]19 20             Container container = init_PreloadConfiguration();21             container.inject(this);22             init_CheckWebLogicWorkaround(container);23 24             if (!dispatcherListeners.isEmpty()) {25                 for (DispatcherListener l : dispatcherListeners) {26                     l.dispatcherInitialized(this);27                 }28             }29         } catch (Exception ex) {30             if (LOG.isErrorEnabled())31                 LOG.error("Dispatcher initialization failed", ex);32             throw new StrutsException(ex);33         }34     }

　　這裏主要是加載一些配置文件的，將按照順序逐一加載：default.properties，struts-default.xml,struts-plugin.xml,struts.xml，……關於文件是如何加載的，你們能夠本身取看源文件，主要是由xwork核心類加載的，代碼在xwork-core\src\main\java\com\opensymphony\xwork2\config\providers包裏面。

　　如今，咱們回到StrutsPrepareAndExecuteFilter類中，剛纔咱們分析了StrutsPrepareAndExecuteFilter類的init方法，該方法在web容器一啓動就會調用的，當用戶訪問某個action的時候，首先調用核心過濾器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);

//建立action上下文

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);

//若是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);

}

下面對doFilter方法中的重點部分一一講解：

(1)prepare.setEncodingAndLocale(request, response);

　　第8行是調用prepare對象的setEncodingAndLocale方法，prepare是PrepareOperations類的對象，PrepareOperations類是用來作請求準備工做的。咱們看下PrepareOperations類中的setEncodingAndLocale方法：

public void setEncodingAndLocale(HttpServletRequest request, HttpServletResponse response) {2         dispatcher.prepare(request, response);3     }

在這方法裏面咱們能夠看到它只是調用了dispatcher的prepare方法而已，下面咱們看看dispatcher的prepare方法：

public void prepare(HttpServletRequest request, HttpServletResponse response) {

String encoding = null;

if (defaultEncoding != null) {

encoding = defaultEncoding;

}

// check for Ajax request to use UTF-8 encoding strictly http://www.w3.org/TR/XMLHttpRequest/#the-send-method

if ("XMLHttpRequest".equals(request.getHeader("X-Requested-With"))) {

encoding = "UTF-8";

}

Locale locale = null;

if (defaultLocale != null) {

locale = LocalizedTextUtil.localeFromString(defaultLocale, request.getLocale());

}

if (encoding != null) {

applyEncoding(request, encoding);

}

if (locale != null) {

response.setLocale(locale);

}

if (paramsWorkaroundEnabled) {

request.getParameter("foo"); // simply read any parameter (existing or not) to "prime" the request

}

咱們能夠看到該方法只是簡單的設置了encoding 和locale ，作的只是一些輔助的工做。

(2)prepare.createActionContext(request, response)

　　咱們回到StrutsPrepareAndExecuteFilter的doFilter方法，看到第10行代碼：prepare.createActionContext(request, response);這是action上下文的建立，ActionContext是一個容器，這個容易主要存儲request、session、application、parameters等相關信息.ActionContext是一個線程的本地變量，這意味着不一樣的action之間不會共享ActionContext，因此也不用考慮線程安全問題。其實質是一個Map，key是標示request、session、……的字符串，值是其對應的對象，咱們能夠看到com.opensymphony.xwork2.ActionContext類中時以下定義的：

1 static ThreadLocal<ActionContext> actionContext = new ThreadLocal<ActionContext>();

咱們看下PrepareOperations類的createActionContext方法：

/**

* Creates the action context and initializes the thread local

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;

}

//此處是從ThreadLocal中獲取此ActionContext變量

ActionContext oldContext = ActionContext.getContext();

if (oldContext != null) {

// detected existing context, so we are probably in a forward

ctx = new ActionContext(new HashMap<String, Object>(oldContext.getContextMap()));

} else {

ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();

stack.getContext().putAll(dispatcher.createContextMap(request, response, null, servletContext));

//stack.getContext()返回的是一個Map<String，Object>，根據此Map構造一個ActionContext

ctx = new ActionContext(stack.getContext());

}

request.setAttribute(CLEANUP_RECURSION_COUNTER, counter);

//將ActionContext存到ThreadLocal

ActionContext.setContext(ctx);

return ctx;

}

上面第18行代碼中dispatcher.createContextMap，如何封裝相關參數：

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 parameters. ActionMapping parameters are now handled and applied separately

Map params = new HashMap(request.getParameterMap());

// session map wrapping the http session

Map session = new SessionMap(request);

// application map wrapping the ServletContext

Map application = new ApplicationMap(context);

//requestMap、params、session等Map封裝成爲一個上下文Map

Map<String,Object> extraContext = createContextMap(requestMap, params, session, application, request, response, context);

if (mapping != null) {

extraContext.put(ServletActionContext.ACTION_MAPPING, mapping);

}

return extraContext;

}

(3)request = prepare.wrapRequest(request)

　　咱們再次回到StrutsPrepareAndExecuteFilter的doFilter方法中，看到第15行：request = prepare.wrapRequest(request);這一句是對request進行包裝的，咱們看下prepare的wrapRequest方法：

 1 public HttpServletRequest wrapRequest(HttpServletRequest oldRequest) throws ServletException { 2         HttpServletRequest request = oldRequest; 3         try { 4             // Wrap request first, just in case it is multipart/form-data 5             // parameters might not be accessible through before encoding (ww-1278) 6             request = dispatcher.wrapRequest(request, servletContext); 7         } catch (IOException e) { 8             throw new ServletException("Could not wrap servlet request with MultipartRequestWrapper!", e); 9         }10         return request;11     }

由第6行咱們能夠看到它裏面調用的是dispatcher的wrapRequest方法，而且將servletContext對象也傳進去了，咱們看下dispatcher的wrapRequest：

public HttpServletRequest wrapRequest(HttpServletRequest request, ServletContext servletContext) throws IOException {

// don't wrap more than once

if (request instanceof StrutsRequestWrapper) {

return request;

}

String content_type = request.getContentType();

//若是content_type是multipart/form-data類型，則將request包裝成MultiPartRequestWrapper對象，不然包裝成StrutsRequestWrapper對象

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(servletContext), provider);

} else {

request = new StrutsRequestWrapper(request, disableRequestAttributeValueStackLookup);

}

return request;

}

這次包裝根據請求內容的類型不一樣，返回不一樣的對象，若是爲multipart/form-data類型，則返回MultiPartRequestWrapper類型的對象，該對象服務於文件上傳，不然返回StrutsRequestWrapper類型的對象，MultiPartRequestWrapper是StrutsRequestWrapper的子類，而這兩個類都是HttpServletRequest接口的實現。

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

　　包裝request後，經過ActionMapper的getMapping()方法獲得請求的Action，Action的配置信息存儲在ActionMapping對象中，如StrutsPrepareAndExecuteFilter的doFilter方法中第16行：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);

//不存在就建立一個

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, servletContext, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ex);

}

return mapping;

}

下面是ActionMapper接口的實現類DefaultActionMapper的getMapping()方法的源代碼：

public ActionMapping getMapping(HttpServletRequest request, ConfigurationManager configManager) {

ActionMapping mapping = new ActionMapping();

//得到請求的uri，即請求路徑URL中工程名之後的部分，如/userAction.action

String uri = getUri(request);

//修正url的帶;jsessionid 時找不到的bug

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);

//若是容許動態方法調用，即形如/userAction!getAll.action的請求，分離action名和方法名

return parseActionName(mapping);

}

下面對getMapping方法中的重要部分一一講解：

　　①：parseNameAndNamespace(uri, mapping, configManager)

　　咱們主要看下第14行的parseNameAndNamespace(uri, mapping, configManager);這個方法的主要做用是分離出action名和命名空間：

 1 protected void parseNameAndNamespace(String uri, ActionMapping mapping, ConfigurationManager configManager) { 2         String namespace, name; 3         int lastSlash = uri.lastIndexOf("/"); //最後的斜杆的位置 4         if (lastSlash == -1) { 5             namespace = ""; 6             name = uri; 7         } else if (lastSlash == 0) { 8             // ww-1046, assume it is the root namespace, it will fallback to 9             // default10             // namespace anyway if not found in root namespace.11             namespace = "/";12             name = uri.substring(lastSlash + 1);13         //容許採用完整的命名空間,即設置命名空間是否必須進行精確匹配14         } else if (alwaysSelectFullNamespace) {15             // Simply select the namespace as everything before the last slash16             namespace = uri.substring(0, lastSlash);17             name = uri.substring(lastSlash + 1);18         } else {19             // Try to find the namespace in those defined, defaulting to ""20             Configuration config = configManager.getConfiguration();21             String prefix = uri.substring(0, lastSlash); //臨時的命名空間，將會用來進行匹配22             namespace = "";//將命名空間暫時設爲""23             boolean rootAvailable = false;//rootAvailable做用是判斷配置文件中是否配置了命名空間"/"24             // Find the longest matching namespace, defaulting to the default25             for (Object cfg : config.getPackageConfigs().values()) { //循環遍歷配置文件中的package標籤26                 String ns = ((PackageConfig) cfg).getNamespace();    //獲取每一個package標籤的namespace屬性27                 //進行匹配28                 if (ns != null && prefix.startsWith(ns) && (prefix.length() == ns.length() || prefix.charAt(ns.length()) == '/')) {29                     if (ns.length() > namespace.length()) {30                         namespace = ns;31                     }32                 }33                 if ("/".equals(ns)) {34                     rootAvailable = true;35                 }36             }37 38             name = uri.substring(namespace.length() + 1);39 40             // Still none found, use root namespace if found41             if (rootAvailable && "".equals(namespace)) {42                 namespace = "/";43             }44         }45 46         if (!allowSlashesInActionNames) {47             int pos = name.lastIndexOf('/');48             if (pos > -1 && pos < name.length() - 1) {49                 name = name.substring(pos + 1);50             }51         }52         //將分離後的acion名和命名空間保存到mapping對象53         mapping.setNamespace(namespace);54         mapping.setName(cleanupActionName(name));55     }

　　看到上面代碼的第14行，參數alwaysSelectFullNamespace咱們能夠經過名字就能大概猜出來"容許採用完整的命名空間"，即設置命名空間是否必須進行精確匹配，true必須，false能夠模糊匹配，默認是false。進行精確匹配時要求請求url中的命名空間必須與配置文件中配置的某個命名空間必須相同，若是沒有找到相同的則匹配失敗。這個參數可經過struts2的"struts.mapper.alwaysSelectFullNamespace"常量配置，如：<constant name="struts.mapper.alwaysSelectFullNamespace" value="true" />。當alwaysSelectFullNamespace爲true時，將uri以lastSlash爲分割，左邊的爲namespace，右邊的爲name。如：http://localhost:8080/myproject/home/actionName!method.action,此時uri爲/home/actionName!method.action(不過前面把後綴名去掉了，變成/home/actionName!method)，lastSlash的,當前值是5，這樣namespace爲"/home", name爲actionName!method。

　　咱們再看到上面代碼第18行到第44行：當上面的全部條件都不知足時，其中包括alwaysSelectFullNamespace 爲false(命名空間進行模糊匹配)，將由此部分處理，進行模糊匹配。第1句，經過configManager.getConfiguration()從配置管理器中得到配置對象Configuration，Configuration中存放着struts2的全部配置，形式是將xml文檔的相應元素封裝爲java bean，如<package>元素被封裝到PackageConfig類中，這個一下子會用到。第2句按lastSlash將uri截取出prefix，這是一個臨時的命名空間，以後將會拿prefix進行模糊匹配。第3句namespace = ""，將命名空間暫時設爲""。第4句建立並設置rootAvailable，rootAvailable做用是判斷配置文件中是否配置了命名空間"/"，true爲配置了，false未配置，下面for語句將會遍歷咱們配置的全部包(<package>)，同時設置rootAvailable。第5句for，經過config.getPackageConfigs()得到全部已經配置的包，而後遍歷。String ns = ((PackageConfig) cfg).getNamespace()得到當前包的命名空間ns，以後的if句是進行模糊匹配的核心，我摘出來單獨說，以下：

1 if (ns != null && prefix.startsWith(ns) && (prefix.length() == ns.length() || prefix.charAt(ns.length()) == '/')) {2                     if (ns.length() > namespace.length()) {3                         namespace = ns;4                     }5                 }

　　ns != null && prefix.startsWith(ns)這部分判斷當ns不等於空而且ns是prefix的前綴。prefix.length() == ns.length()當兩者長度相等時，結合前面部分就是ns是prefix的前綴而且兩者長度相等，最終結論就是ns和prefix相等。若是前面的條件不成立，則說明prefix的長度大於ns。prefix.charAt(ns.length()) == '/')意思是prefix中與ns不相等的字符中的第一個字符必須是"/"，也就是說，在命名空間採用斜槓分級的形式中，ns必須是prefix的某一子集，如：/common/home 是用戶配置的命名空間，則在http的請求url中，/common/home/index一、/common/home/index2、/common/home/index/aaa 都是正確的，均可以成功的匹配到/common/home，而/common/homeaa、/common/homea/aaa都是錯誤的。接着if (ns.length() > namespace.length()) 句，目的是找出字符長度最長的。由於命名空間採用的是分級的，則長度越長所表示的越精確，如/common/home/index比/common/home精確。以後將namespace = ns。

　　咱們接着往下看if ("/".equals(ns)) 當咱們配置了"/"這個命名空間時，將rootAvailable = true。name = uri.substring(namespace.length() + 1)句不涉及到命名空間就不說了。if (rootAvailable && "".equals(namespace))若是經過上面的for循環沒有找到匹配的命名空間即namespace的值仍然是當初設置的""，但卻配置了"/"時，將命名空間設爲"/"。

　　咱們再看到第46到51行那個if語句：

1 if (!allowSlashesInActionNames) {2      int pos = name.lastIndexOf('/');3      if (pos > -1 && pos < name.length() - 1) {4           name = name.substring(pos + 1);5      }6 }

　　allowSlashesInActionNames表明是否容許"/"出如今Action的名稱中，默認爲false，若是不容許"/"出如今Action名中，而且這時的Action名中有"/"，則取"/"後面的部分。

下面是命名空間匹配規則的總結：

(1). 若是請求url中沒有命名空間時，將採用"/"做爲命名空間。

(2). 當咱們將常量 struts.mapper.alwaysSelectFullNamespace設爲true時，那麼請求url的命名空間必須和配置文件配置的徹底相同才能匹配。

當將常量 struts.mapper.alwaysSelectFullNamespace設爲false時，那麼請求url的命名空間和配置文件配置的可按模糊匹配。規則：

　　a.若是配置文件中配置了/common 而url中的命名空間/common、/common/home、/common/home/index等等都是可匹配的，即子命名空間可匹配父命名空間。

　　b.若是對於某個url請求中的命名空間同時匹配了倆個或倆個以上的配置文件中配置的命名空間，則選字符最長的，如：當前請求的命名空間爲/common/home/index/aaaa, 而咱們在配置時同時配置了/common/home、/common/home/index 則將會匹配命名空間最長的，即/common/home/index。

(3).最後，若是請求的命名空間在配置中沒有匹配到時，將採用""做爲命名空間。若是沒有設置爲""的命名空間將拋出404錯誤。

　　②：parseActionName(mapping)

　　好了，到這裏parseNameAndNamespace方法已經分析完了，咱們再次回到getMapping方法中去，看到16行：handleSpecialParameters(request, mapping);好像是處理特殊參數的函數吧，裏面有點看不懂，暫時就無論，之後有時間再研究。咱們看到18行：return parseActionName(mapping);主要是用來處理形如/userAction!getAll.action的請求，分離action名和方法名：

 1 protected ActionMapping parseActionName(ActionMapping mapping) { 2         if (mapping.getName() == null) { 3             return null; 4         } 5         //若是容許動態方法調用 6         if (allowDynamicMethodCalls) { 7             // handle "name!method" convention. 8             String name = mapping.getName(); 9             int exclamation = name.lastIndexOf("!");10             //若是包含"!"就進行分離11             if (exclamation != -1) {12                 //分離出action名13                 mapping.setName(name.substring(0, exclamation));14                 //分離出方法名15                 mapping.setMethod(name.substring(exclamation + 1));16             }17         }18         return mapping;19     }

　　到此爲止getMapping方法已經分析結束了！

(5)execute.executeAction(request, response, mapping)

　　上面咱們分析完了mapping的獲取，繼續看doFilter方法：

 1 //若是mapping爲空，則認爲不是調用action,會調用下一個過濾器鏈，直到獲取到mapping才調用action 2                 if (mapping == null) { 3                     boolean handled = execute.executeStaticResourceRequest(request, response); 4                     if (!handled) { 5                         chain.doFilter(request, response); 6                     } 7                 } else { 8                     //執行action 9                     execute.executeAction(request, response, mapping);10                 }

　　若是mapping對象不爲空，則會執行action，咱們看到上面代碼第9行：execute是ExecuteOperations類的對象，ExecuteOperations類在包org.apache.struts2.dispatcher.ng下面，咱們找到它裏面的executeAction方法：

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

咱們能夠看到它裏面只是簡單的調用了dispatcher的serviceAction方法：咱們找到dispatcher的serviceAction方法：

 1 public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context, 2                               ActionMapping mapping) throws ServletException { 3         //封轉上下文環境，主要將requestMap、params、session等Map封裝成爲一個上下文Map 4         Map<String, Object> extraContext = createContextMap(request, response, mapping, context); 5  6         // If there was a previous value stack, then create a new copy and pass it in to be used by the new Action 7         ValueStack stack = (ValueStack) request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY); 8         boolean nullStack = stack == null; 9         if (nullStack) {10             ActionContext ctx = ActionContext.getContext();11             if (ctx != null) {12                 stack = ctx.getValueStack();13             }14         }15         if (stack != null) {16             extraContext.put(ActionContext.VALUE_STACK, valueStackFactory.createValueStack(stack));17         }18 19         String timerKey = "Handling request from Dispatcher";20         try {21             UtilTimerStack.push(timerKey);22             String namespace = mapping.getNamespace();//從mapping對象獲取命名空間23             String name = mapping.getName();          //獲取請求的action名24             String method = mapping.getMethod();      //獲取請求方法25             //獲得配置對象26             Configuration config = configurationManager.getConfiguration();27             //根據執行上下文參數，命名空間，名稱等建立用戶自定義Action的代理對象  28             ActionProxy proxy = config.getContainer().getInstance(ActionProxyFactory.class).createActionProxy(29                     namespace, name, method, extraContext, true, false);30 31             request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack());32 33             // if the ActionMapping says to go straight to a result, do it!34             //若是配置文件中執行的這個action配置了result，就直接轉到result35             if (mapping.getResult() != null) {36                 Result result = mapping.getResult();37                 result.execute(proxy.getInvocation());38             } else {39                 proxy.execute();40             }41 42             // If there was a previous value stack then set it back onto the request43             if (!nullStack) {44                 request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, stack);45             }46         } catch (ConfigurationException e) {47             // WW-2874 Only log error if in devMode48             if (devMode) {49                 String reqStr = request.getRequestURI();50                 if (request.getQueryString() != null) {51                     reqStr = reqStr + "?" + request.getQueryString();52                 }53                 LOG.error("Could not find action or result\n" + reqStr, e);54             } else {55                 if (LOG.isWarnEnabled()) {56                     LOG.warn("Could not find action or result", e);57                 }58             }59             sendError(request, response, context, HttpServletResponse.SC_NOT_FOUND, e);60         } catch (Exception e) {61             if (handleException || devMode) {62                 sendError(request, response, context, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e);63             } else {64                 throw new ServletException(e);65             }66         } finally {67             UtilTimerStack.pop(timerKey);68         }69     }

　　最後經過Result完成頁面跳轉！

總結：之前老是隻會用struts2框架，對裏面的原理沒有一個很清晰的認識，這兩天花時間把struts2框架的源碼分析了一下，對它的工做原理有個更深的認識。既然是開源框架，有時間久得去研究研究它的源碼，否則開源就失去了意義了，不要只停留在會用的層面上！

轉自：http://www.cnblogs.com/liuling/p/2013-8-10-01.html