struts2源码的自我理解

1. 概述

Struts2是Apache提供的一个免费的重量级web层框架，其采用mvc设计模式。Struts2底层依赖的是WebWork。
**MVC设计模式：**
MVC是指从web层的角度看待整个web应用，可以将web应用分为3个部分:Model，view，Controller。
View 视图：            jsp         web层
Model 模型：       JavaBean        业务层，持久层
Controller 控制器： servlet     web层

2.使用

使用Struts2框架时，只需要在web.xml文件中注册struts2的核心过滤器并配置struts.xml文件，就能通过继承ActionSupport类来使用Struts2的功能。

<!-- struts2核心过滤器 -->
<filter>
<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>

3.Struts2框架的初始化：

注册StrutsPrepareAndExecuteFilter后，在web应用启动时，会先执行过滤器的init方法，对struts2进行初始化配置

public void init(FilterConfig filterConfig) throws ServletException {
//初始化器
//为struts2框架设置初始化参数
InitOperations init = new InitOperations();
//调度器
//核心类
Dispatcher dispatcher = null;
try {
//使用filterConfig构建struts2内部的config文件
//类似于装饰者模式，但父接口为HostConfig
//其缺少一个getFilterName()，因为没有必要
FilterHostConfig config = new FilterHostConfig(filterConfig);
//使用config文件进行初始化
init.initLogging(config);
//使用config文件对dispatcher进行初始化
dispatcher = init.initDispatcher(config);
//返回一个StaticContentLoader，但是没有保存这个对象的引用
//也没有静态方法可以获得其引用
//浪费内存？
init.initStaticContentLoader(config, dispatcher);

//创建预执行器
prepare = new PrepareOperations(dispatcher);
//创建执行器
execute = new ExecuteOperations(dispatcher);
//创建排除的正则表达式目录
this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);
//为他人扩展提供便利
postInit(dispatcher, filterConfig);
} finally {
if (dispatcher != null) {
//将ContainerHolder中缓存的container信息清除，节省内存
//因为是线程特有数据（ThreadLocal）
dispatcher.cleanUpAfterInit();
}
//将初始化时，存入ActionContext中的数据清空，节省内存
//因为是线程特有数据（ThreadLocal）
init.cleanup();
}
}
protected void postInit(Dispatcher dispatcher, FilterConfig filterConfig) {
}

3.1 init.initLogging(config);

该方法实现了对服务器日志文件的整合

public void initLogging( HostConfig filterConfig ) {
//获取服务器的loggerFactory
String factoryName = filterConfig.getInitParameter("loggerFactory");
if (factoryName != null) {
try {
//使用这个类的classLoader，来加载loggerFactory
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();
}
}
}

3.2 init.initDispatcher(config);

使用config中的数据对dispachter进行初始化

public Dispatcher initDispatcher( HostConfig filterConfig ) {
//创建一个dispachter
Dispatcher dispatcher = createDispatcher(filterConfig);
//执行dispacher的初始化设置
dispatcher.init();
return dispatcher;
}
private Dispatcher createDispatcher( HostConfig filterConfig ) {
//获取config里面的所有参数
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);
}
//将servletContext和所有参数传递给dispatcher的构造器
return new Dispatcher(filterConfig.getServletContext(), params);
}

3.3 init.buildExcludedPatternsList(dispatcher);

从配置文件中读取不需要使用struts2的路径

public List<Pattern> buildExcludedPatternsList( Dispatcher dispatcher ) {
return buildExcludedPatternsList(dispatcher.getContainer().getInstance(String.class, StrutsConstants.STRUTS_ACTION_EXCLUDE_PATTERN));
}

private List<Pattern> buildExcludedPatternsList( String patterns ) {
if (null != patterns && patterns.trim().length() != 0) {
List<Pattern> list = new ArrayList<Pattern>();
String[] tokens = patterns.split(",");
for ( String token : tokens ) {
list.add(Pattern.compile(token.trim()));
}
return Collections.unmodifiableList(list);
} else {
return null;
}
}

dispachter，prepare和execute的构造方法都十分简单，就不一一列出源码了。

3.4 dispatcher.init();

是一个十分重要的方法。对dispachter的相关参数，容器的参数等进行设置。

public void init() {

if (configurationManager == null) {
//创建一个默认的configurationManager，xwrok中的类
configurationManager = createConfigurationManager(DefaultBeanSelectionProvider.DEFAULT_BEAN_NAME);//DefaultBeanSelectionProvider.DEFAULT_BEAN_NAME="struts"
}

try {
//将相关参数设置到configurationManager中
//所有的ContainerProvider
init_FileManager();
init_DefaultProperties(); // [1]
init_TraditionalXmlConfigurations(); // [2]
init_LegacyStrutsProperties(); // [3]
init_CustomConfigurationProviders(); // [5]
init_FilterInitParameters() ; // [6]
init_AliasStandardObjects() ; // [7]

//xwork中的类
//即在ConfigurationManager中配置的List<ContainerProvider>
//上面7个init的配置内容的总和
//即容器本身
Container container = init_PreloadConfiguration();
//将dispatcher注入配置好的容器中
container.inject(this);
//检查是否需要支持WebLogic服务器的特殊设置
init_CheckWebLogicWorkaround(container);

//dispatcher的监听器，但在源码中并没有使用
//可能是扩展用的
if (!dispatcherListeners.isEmpty()) {
for (DispatcherListener l : dispatcherListeners) {
l.dispatcherInitialized(this);
}
}
//从头到尾没有看见赋值
//应该报NullPointerException啊？
//可能与configurationManager或container有关
errorHandler.init(servletContext);

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

4.执行action请求

每次有请求到来就会执行过滤器的doFilter方法，对请求相关数据进行包装

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 {
//不是
//设置请求响应编码
//底层依赖dispatcher的prepare(request, response)方法
prepare.setEncodingAndLocale(request, response);
//给值栈和ActionContext域赋值
prepare.createActionContext(request, response);
//将dispatcher与线程绑定
//方便静态方法获取
//底层依赖Dispatcher.setInstance(dispatcher)静态方法
prepare.assignDispatcherToThread();
//替换request
//底层依赖dispatcher的wrapRequest(request)方法
request = prepare.wrapRequest(request);
//获取对应的解析结果对象
ActionMapping mapping = prepare.findActionMapping(request, response, true);
if (mapping == null) {
//true：struts2自己的一些东西
//false：只是普通的静态资源
boolean handled = execute.executeStaticResourceRequest(request, response);
if (!handled) {
//是静态资源
chain.doFilter(request, response);
}
} else {
//执行action
//底层依赖dispatcher.serviceAction(request, response, mapping)
execute.executeAction(request, response, mapping);
}
}
} finally {
//清除action的相关缓存资源
prepare.cleanupRequest(request);
}
}

由于prepare和execute的许多方法都是依赖于底层的dispatcher，所以只列出部分方法

4.1 prepare.createActionContext(request, response);

根据request，response创建相应的ActionContext

public ActionContext createActionContext(HttpServletRequest request, HttpServletResponse response) {
ActionContext ctx;
//需要循环递归的次数
//不大明白存在的意义
Integer counter = 1;
//初次访问时为null
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<String, Object>(oldContext.getContextMap()));
} else {
//是初次访问
//获取一个新的值栈
ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
//将request，session，application，page放入值栈
//供OGNL表达式使用
stack.getContext().putAll(dispatcher.createContextMap(request, response, null));
//将值栈中的数据放入ActionContext域
//供Action使用
ctx = new ActionContext(stack.getContext());
}
request.setAttribute(CLEANUP_RECURSION_COUNTER, counter);
//在Action中使用ActionContext的静态方法获取
//使用了ThreadLocal<ActionContext>避免多线程问题
ActionContext.setContext(ctx);
return ctx;
}

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

使用ActionMapper类对url地址进行解析，使其变为ActionMapping对象

public ActionMapping findActionMapping(HttpServletRequest request, HttpServletResponse response, boolean forceLookup) {
//ActionMapping代表的是一个请求的所有数据
//http://localhost:8080/sss/login.action?clzjxkl=asda
//namespace   name   params   method GET/POST
//ActionMapper：创建ActionMapping的类
//对url的进行解析
ActionMapping mapping = (ActionMapping) request.getAttribute(STRUTS_ACTION_MAPPING_KEY);    //STRUTS_ACTION_MAPPING_KEY = "struts.actionMapping"
if (mapping == null || forceLookup) {
try {
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;
}

4.3 dispatcher.prepare(request, response)

对request和response进行相关设置

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 //是ajax请求就设置为utf-8
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) {
//当有默认编码，或是ajax请求时执行
//为请求设置编码
applyEncoding(request, encoding);
}

if (locale != null) {
//当有默认环境时执行
//为相应设置环境
response.setLocale(locale);
}

//当服务器是WebLogic时执行
if (paramsWorkaroundEnabled) {
request.getParameter("foo"); // simply read any parameter (existing or not) to "prime" the request
}
}

4.4 dispatcher.createContextMap(request, response, null)

根据相关数据创建ContextMap，返回后设置在ActionContext中

public Map<String,Object> createContextMap(HttpServletRequest request, HttpServletResponse response,
ActionMapping mapping) {

// request map wrapping the http request objects
//request域中的数据
Map requestMap = new RequestMap(request);

// parameters map wrapping the http parameters.  ActionMapping parameters are now handled and applied separately
//page域中的数据
Map params = new HashMap(request.getParameterMap());

// session map wrapping the http session
//session域中的数据
Map session = new SessionMap(request);

// application map wrapping the ServletContext
//application域中的数据
Map application = new ApplicationMap(servletContext);

//生成值栈中的数据
Map<String,Object> extraContext = createContextMap(requestMap, params, session, application, request, response);

if (mapping != null) {
extraContext.put(ServletActionContext.ACTION_MAPPING, mapping);
}
return extraContext;
}

4.5 dispatcher.wrapRequest(request)

替换request，如果有必要

public HttpServletRequest wrapRequest(HttpServletRequest request) throws IOException {
// don't wrap more than once
//是StrutsRequestWrapper类的子类
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
request = new MultiPartRequestWrapper(mpr, request, getSaveDir(), provider, disableRequestAttributeValueStackLookup);
} else {
request = new StrutsRequestWrapper(request, disableRequestAttributeValueStackLookup);
}

return request;
}

4.6 dispatcher.serviceAction(request, response, mapping)

执行请求的核心代码，通过创建代理来执行请求

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

//创建一个action代理
ActionProxy proxy = getContainer().getInstance(ActionProxyFactory.class).createActionProxy(
namespace, name, method, extraContext, true, false);
//将代理的值栈放入request
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);
}
}