webwork源码分析(一)FilterDispatcher和DispatcherUtils

public void init(FilterConfig filterConfig) throws ServletException {
this.filterConfig = filterConfig;
String param = filterConfig.getInitParameter("packages");
String packages = "com.opensymphony.webwork.static template com.opensymphony.webwork.interceptor.debugging";
if (param != null) {
packages = param + " " + packages;
}
this.pathPrefixes = parse(packages);
DispatcherUtils.initialize(filterConfig.getServletContext());
}


ps:

DispatcherUtils进行了初始化，参数为servletcontext，采用 单例模式。

初始化方法中对packages进行了parse，目前我还不知道在哪需要用到

DispatcherUtils.initialize(filterConfig.getServletContext());


方法中进行了xwork的一些处理 text的loacl处理 ObjectFactory的初始化处理

webwork 的Configuration 的处理

总而言之，这一句简简单单的initialize方法，让我们根据web.xml中得到的基本信息中初始化了

application级别的相关东西，xwork所需要的全局的东西也得到初始化，webwork 下的config目录也发挥了他的作用



接下来，我们看看dofilter 这个起核心作用的方法

public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {


HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
ServletContext servletContext = filterConfig.getServletContext();

// prepare the request no matter what - this ensures that the proper character encoding
// is used before invoking the mapper (see WW-9127)


DispatcherUtils du = DispatcherUtils.getInstance();


du.prepare(request, response);//正如这个方法名字一样进行locale、encoding以及特殊request parameters设置


try {
// Wrap request first, just in case it is multipart/form-data
// parameters might not be accessible through before encoding (ww-1278)
request = du.wrapRequest(request, servletContext);//对request进行包装
} catch (IOException e) {
String message = "Could not wrap servlet request with MultipartRequestWrapper!";
LOG.error(message, e);
throw new ServletException(message, e);
}


ActionMapperIF mapper = ActionMapperFactory.getMapper();//得到action的mapper
ActionMapping mapping = mapper.getMapping(request);// 得到action 的 mapping

if (mapping == null) {
// 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();
}

if ("true".equals(Configuration.get(WebWorkConstants.WEBWORK_SERVE_STATIC_CONTENT))
&& resourcePath.startsWith("/webwork")) {
String name = resourcePath.substring("/webwork".length());
findStaticResource(name, response);
} else {
// this is a normal request, let it pass through
chain.doFilter(request, response);
}
// WW did its job here
return;
}


Object o = null;
try {

//setupContainer(request);


o = beforeActionInvocation(request, servletContext);

//最核心的方法，这里通过ActionProxyFactory生成ActionProxy（包含actioninvocation actioncontext的信息供拦截器配合result一起发挥ww和xwork的作用）

du.serviceAction(request, response, servletContext, mapping);


} finally {
afterActionInvocation(request, servletContext, o);
ActionContext.setContext(null);
}
}



这里注意几个factory的使用

1、ActionMapperFactory

ActionMapperIF mapper = ActionMapperFactory.getMapper();
ActionMapping mapping = mapper.getMapping(request);

2、ActionProxyFactory

ActionProxy proxy = ActionProxyFactory.getFactory().createActionProxy(namespace, name, extraContext, true, false);
得到该action的代理实例

特别要注意的actioninvocation也是在proxy生成的时候初始化好了，

proxy包含了 action所需要的所有东西，完成接下来的一系列工作，

感觉其实这些东西也是比较简单的，通过传引用解决了哪需要就设置到哪去这种方式，不用担心对象的内容改变。


du.serviceAction(request, response, servletContext, mapping);该方法如下：

public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context, ActionMapping mapping) throws ServletException {
Map extraContext = createContextMap(request, response, mapping, context);

// If there was a previous value stack, then create a new copy and pass it in to be used by the new Action
OgnlValueStack stack = (OgnlValueStack) request.getAttribute(ServletActionContext.WEBWORK_VALUESTACK_KEY);
if (stack != null) {
extraContext.put(ActionContext.VALUE_STACK, new OgnlValueStack(stack));
}

try {
String namespace = mapping.getNamespace();
String name = mapping.getName();
String method = mapping.getMethod();

String id = request.getParameter(XWorkContinuationConfig.CONTINUE_PARAM);
if (id != null) {
// remove the continue key from the params - we don't want to bother setting
// on the value stack since we know it won't work. Besides, this breaks devMode!
Map params = (Map) extraContext.get(ActionContext.PARAMETERS);
params.remove(XWorkContinuationConfig.CONTINUE_PARAM);

// and now put the key in the context to be picked up later by XWork
extraContext.put(XWorkContinuationConfig.CONTINUE_KEY, id);
}

ActionProxy proxy = ActionProxyFactory.getFactory().createActionProxy(namespace, name, extraContext, true, false);
proxy.setMethod(method);
request.setAttribute(ServletActionContext.WEBWORK_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 (stack != null) {
request.setAttribute(ServletActionContext.WEBWORK_VALUESTACK_KEY, stack);
}
} catch (ConfigurationException e) {
LOG.error("Could not find action", e);
sendError(request, response, context, HttpServletResponse.SC_NOT_FOUND, e);
} catch (Exception e) {
String msg = "Could not execute action";
LOG.error(msg, e);
sendError(request, response, context, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e);
}
}


ps：webwork 其实是一个很简单的框架，实现servlet协议，包装httpreques\httpresponse\httpsession\\httpservletcontext进行解偶，通过xwork来处理核心逻辑，不过感觉其包结构不够好，框架虽简单新手入门却不容易。