.net到Java那些事儿--structs做了那些事(二)
一、跟着项目先来看下structs怎么执行的
首先看下web.xml配置文件，下面有如下代码
<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>
这是一个过滤器，过滤器不管是Java还是.net的人都清楚，简单说一下拦截Http的请求，所以上面这段配置就很清楚启动一个Filter来拦截自与客户端的请求，这里我们先不关心源码方面的东西就在表面上走，之后在下面说Struts2内部怎么处理的；
接下来我们看下struts.xml下面的配置
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd"> <struts> <constant name="struts.objectFactory" value="spring" /> <constant name="struts.ui.theme" value="simple"/> <constant name="struts.devMode" value="true" /> <constant name="struts.i18n.encoding" value="UTF-8" /> <package name="store" namespace="/" extends="struts-default"> <action name="login" method="login" class="userAction"> <result name="success">/WEB-INF/login.jsp</result> </action> </package> </struts>
这里我也不讲那些属性是那些意思，网上很多自己查，我们就看下action配置，这里我们是通过Spring集成的所以我们那个class属性放入了bean那个id的名字，当然这里我就不进行替换成文件的全限定名了，我就解释下下面这段话的意思，查找一个叫做userAction类下面有个叫llogin方法名的方法，如果返回success就转发到login.jsp的页面上。
这个地方加一下Struts页面跳转方式的介绍吧：
1.dispather这个是默认的配置转发，页面跳转属于同一个线程，Action中数据始终存在，简单一点说这是一个请求；
2.redirect这个当接收到状态码的时候，重新请求服务器资源返回到客户端，这个地方意味是产生两个请求，原来请求的数据是无法访问到的；
3.redirectAction 这个相当于重新定向到另外一个Action，这个与redirect方式都是重新生成一个新的请求，但是这个redirectAction是使用ActionMapperFactory提供的ActionMapper来重定向请求。
4.chain这个可以在多个action之间跳转，处于chain中的action属于同一个http请求，共享一个ActionContext，由于是同一个请求所以请求参数和属性都可以保留，可以理解为2和3的增强版，新增功能保留请求的数据。
5.stream 这个文件下载时候使用的
基本上就是上面这个样子，中间少了一个过滤器，没事下面重点就是他；
二、structs内部是怎么匹配的
上面我们再看web.xml配置的时候我们看到过滤器配置，现在我们就把他解剖一下；
// 这里继承Filter进行实现，那么我们就按照Filter的方式来读一下这个源码
public class StrutsPrepareAndExecuteFilter implements StrutsStatics, Filter { protected PrepareOperations prepare; protected ExecuteOperations execute; protected List<Pattern> excludedPatterns = null; //init实现初始化配置信息 public void init(FilterConfig filterConfig) throws ServletException { InitOperations init = new InitOperations(); Dispatcher dispatcher = null;//这个是初始配置时候的重点对象 try {//主要用来存储filter 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(); } } protected void postInit(Dispatcher dispatcher, FilterConfig filterConfig) { }
*/ public Dispatcher initDispatcher( HostConfig filterConfig ) { Dispatcher dispatcher = createDispatcher(filterConfig);
//主要用来加载配置文件 dispatcher.init(); return dispatcher; } /** * Initializes the static content loader with the filter configuration */ public StaticContentLoader initStaticContentLoader( HostConfig filterConfig, Dispatcher dispatcher ) { StaticContentLoader loader = dispatcher.getContainer().getInstance(StaticContentLoader.class); loader.setHostConfig(filterConfig); return loader; }/** * Create a {@link Dispatcher} */ private Dispatcher createDispatcher( HostConfig filterConfig ) { Map<String, String> params = new HashMap<String, String>();
//将参数存放到Map中 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); }
/** * Load configurations, including both XML and zero-configuration strategies, * and update optional settings, including whether to reload configurations and resource files. */
//这个主要初始化加载一些文件，我是感觉这里写的代码真好起码比我写的好太多了，一个人是否优秀在代码确实能看出很多来我自愧不如 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) { if (LOG.isErrorEnabled()) LOG.error("Dispatcher initialization failed", ex); throw new StrutsException(ex); } }
以上基本上加载配置文件的过程，这里面有几个值得学习的方法，日志加载的抽象类可以兼容日志插件，还有init方法中清晰明了一步一步，我感觉这可能就是看源码的好处；最近正在Bob大叔的代码的整洁之道，在这里我算是看到了。
接下来我们看重点，请求拦截到以后Struts帮我们做了什么吧！
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);//创建Action请求的上下文 prepare.assignDispatcherToThread();//将这个对象放入线程 request = prepare.wrapRequest(request);//包装请求对象 ActionMapping mapping = prepare.findActionMapping(request, response, true);//查找action 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); } }
设置编码这块就不要看了挺简单的封装，我们这里看创建action这个作者玩的高招，学习下哈哈
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这个对象，并做相同的初始化，改地方使用了ThreadLocal ActionContext oldContext = ActionContext.getContext(); if (oldContext != null) { // 这个地方我认为可能是分开部署的时候这个可能是跳转过来的Action ctx = new ActionContext(new HashMap<String, Object>(oldContext.getContextMap())); } else {
//这里创建值栈 ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
//创建ContextMap,并加入值栈， stack.getContext().putAll(dispatcher.createContextMap(request, response, null)); ctx = new ActionContext(stack.getContext());//使用值栈创建上下文 } request.setAttribute(CLEANUP_RECURSION_COUNTER, counter); ActionContext.setContext(ctx);//绑定到本地线程 return ctx; }
以上创建请求上下文基本是可以了，通过使用ThreadLocal保证线程安全，主要是为了将Dispatcher绑定到本地线程
public ActionMapping findActionMapping(HttpServletRequest request, HttpServletResponse response, boolean forceLookup) { ActionMapping mapping = (ActionMapping) request.getAttribute(STRUTS_ACTION_MAPPING_KEY); if (mapping == null || forceLookup) { try {
//通过反射去容器中查找action创建ActionMapping对象 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; }
这里需要说一下ActionMapping这个对象，对比下下面2段代码，相信你瞬间就明白了这个对象的作用；
@Override public String toString() { return "ActionMapping{" + "name='" + name + '\'' + ", namespace='" + namespace + '\'' + ", method='" + method + '\'' + ", extension='" + extension + '\'' + ", params=" + params + ", result=" + (result != null ? result.getClass().getName() : "null") + '}'; }
<package name="store" namespace="/" extends="struts-default"> <action name="userAction" method="login" class="userAction"> <result name="success">/WEB-INF/login.jsp</result> </action> </package>
这里简单总结下这个对象作用，主要功能是管理Action信息和管理Action执行完以后的重定向，都是通过初始化配置容器中查找到的。说到这里我感觉就对Struts有了一个整体上的认知了，Struts就是帮我们造了一个巨大容器，里面放了几张网，每张网的作用就是为了找到合适自己的对象，找到以后就展示出来，基本都这样就后面的Spring也是这样。
最后就是显示到网页上了呗，我们看下这里也玩的比较好，这块玩了一个代理工厂；
public void serviceAction(HttpServletRequest request, HttpServletResponse response, ActionMapping mapping) throws ServletException { Map<String, Object> extraContext = createContextMap(request, response, mapping); // 这个地方如果有就创建一个新的值栈，然后将值栈的信息放入extraContext中 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();//这2个就是获取属性的值然后到下面的代理中找到自己action中的方法 //代理工厂找见合适的action ActionProxy proxy = getContainer().getInstance(ActionProxyFactory.class).createActionProxy( namespace, name, method, extraContext, true, false); //更新对应值栈属性 request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack()); // 如果有就执行就好了 if (mapping.getResult() != null) { Result result = mapping.getResult(); result.execute(proxy.getInvocation()); } else { proxy.execute(); } // 如果有值栈，设置值栈的值 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); } }
这里的重点就在ActionFactory了，来来我们看看这里搞了什么，这里通过ActionProxyFactory这个工厂反射创建，我们看下这个接口是有DeafultActionFactory这个类实现的，那我们看下这里面做了什么好玩的事情；
public ActionProxy createActionProxy(String namespace, String actionName, String methodName, Map<String, Object> extraContext, boolean executeResult, boolean cleanupContext) { ActionInvocation inv = new DefaultActionInvocation(extraContext, true); container.inject(inv); return createActionProxy(inv, namespace, actionName, methodName, executeResult, cleanupContext); } public ActionProxy createActionProxy(ActionInvocation inv, String namespace, String actionName, boolean executeResult, boolean cleanupContext) { return createActionProxy(inv, namespace, actionName, null, executeResult, cleanupContext); } public ActionProxy createActionProxy(ActionInvocation inv, String namespace, String actionName, String methodName, boolean executeResult, boolean cleanupContext) { //这里重点 DefaultActionProxy proxy = new DefaultActionProxy(inv, namespace, actionName, methodName, executeResult, cleanupContext); container.inject(proxy); proxy.prepare();//这里事执行 return proxy; }
看到这里会发现我们真正的重点就要到来了，DedaultActionProxy这个实现了ActionProxy这个接口的类，里面是怎么找到Action，我们把重点放到这里；
protected void prepare() { String profileKey = "create DefaultActionProxy: "; try { UtilTimerStack.push(profileKey);
//这里主要事根据命名空间和Action寻找到正确的Action config = configuration.getRuntimeConfiguration().getActionConfig(namespace, actionName); if (config == null && unknownHandlerManager.hasUnknownHandlers()) {
//寻找未知的Action config = unknownHandlerManager.handleUnknownAction(namespace, actionName); } if (config == null) { throw new ConfigurationException(getErrorMessage()); } //寻找方法 resolveMethod(); if (!config.isAllowedMethod(method)) { throw new ConfigurationException("Invalid method: " + method + " for action " + actionName); } //初始化创建 invocation.init(this); } finally { UtilTimerStack.pop(profileKey); } }
private void resolveMethod() { // 没有就执行默认的execite方法 if (StringUtils.isEmpty(this.method)) { this.method = config.getMethodName(); if (StringUtils.isEmpty(this.method)) { this.method = ActionConfig.DEFAULT_METHOD; } methodSpecified = false; } }
public void init(ActionProxy proxy) { this.proxy = proxy; Map<String, Object> contextMap = createContextMap(); // Setting this so that other classes, like object factories, can use the ActionProxy and other // contextual information to operate ActionContext actionContext = ActionContext.getContext(); if (actionContext != null) { actionContext.setActionInvocation(this); } //创建Action类 createAction(contextMap); if (pushAction) { stack.push(action); contextMap.put("action", action); } invocationContext = new ActionContext(contextMap); invocationContext.setName(proxy.getActionName()); // 生成一个迭代器列表 List<InterceptorMapping> interceptorList = new ArrayList<InterceptorMapping>(proxy.getConfig().getInterceptors()); interceptors = interceptorList.iterator(); }
protected void createAction(Map<String, Object> contextMap) { // load action String timerKey = "actionCreate: " + proxy.getActionName(); try { UtilTimerStack.push(timerKey); action = objectFactory.buildAction(proxy.getActionName(), proxy.getNamespace(), proxy.getConfig(), contextMap); } catch (InstantiationException e) { throw new XWorkException("Unable to intantiate Action!", e, proxy.getConfig()); } catch (IllegalAccessException e) { throw new XWorkException("Illegal access to constructor, is it public?", e, proxy.getConfig()); } catch (Exception e) { String gripe; if (proxy == null) { gripe = "Whoa! No ActionProxy instance found in current ActionInvocation. This is bad ... very bad"; } else if (proxy.getConfig() == null) { gripe = "Sheesh. Where'd that ActionProxy get to? I can't find it in the current ActionInvocation!?"; } else if (proxy.getConfig().getClassName() == null) { gripe = "No Action defined for '" + proxy.getActionName() + "' in namespace '" + proxy.getNamespace() + "'"; } else { gripe = "Unable to instantiate Action, " + proxy.getConfig().getClassName() + ", defined for '" + proxy.getActionName() + "' in namespace '" + proxy.getNamespace() + "'"; } gripe += (((" -- " + e.getMessage()) != null) ? e.getMessage() : " [no message in exception]"); throw new XWorkException(gripe, e, proxy.getConfig()); } finally { UtilTimerStack.pop(timerKey); } if (actionEventListener != null) { action = actionEventListener.prepare(action, stack); } }
所有的准备工作都完成了，接下来就是执行方法了
public String execute() throws Exception { ActionContext nestedContext = ActionContext.getContext(); ActionContext.setContext(invocation.getInvocationContext()); String retCode = null; String profileKey = "execute: "; try { UtilTimerStack.push(profileKey); //这里就是执行，，这里面又玩一朵花 retCode = invocation.invoke(); } finally { if (cleanupContext) { ActionContext.setContext(nestedContext); } UtilTimerStack.pop(profileKey); } return retCode; }
这里将拦截遍历一遍，最后输出Action的实例方法，然后在返回拦截器的情况，这个地方我不解释了，我也是看了一位大神得解释明悟哈哈
public String invoke() throws Exception { String profileKey = "invoke: "; try { UtilTimerStack.push(profileKey); if (executed) { throw new IllegalStateException("Action has already executed"); } if (interceptors.hasNext()) { final InterceptorMapping interceptor = interceptors.next(); String interceptorMsg = "interceptor: " + interceptor.getName(); UtilTimerStack.push(interceptorMsg); try { resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this); } finally { UtilTimerStack.pop(interceptorMsg); } } else { resultCode = invokeActionOnly(); } // this is needed because the result will be executed, then control will return to the Interceptor, which will // return above and flow through again if (!executed) { if (preResultListeners != null) { for (Object preResultListener : preResultListeners) { PreResultListener listener = (PreResultListener) preResultListener; String _profileKey = "preResultListener: "; try { UtilTimerStack.push(_profileKey); listener.beforeResult(this, resultCode); } finally { UtilTimerStack.pop(_profileKey); } } } // now execute the result, if we're supposed to if (proxy.getExecuteResult()) { executeResult(); } executed = true; } return resultCode; } finally { UtilTimerStack.pop(profileKey); } }
三、总结
推荐博客:http://blog.csdn.net/fcbayernmunchen/article/details/8441210
看了这个我感觉我理解得就是小儿科，这个大神上一篇也值得看下。结合整体得架构图，加上我中间提到得几个重要得对象，相信应该基本对Struts会有个整体印象；
这里欢迎大家加一下我的群438836709，欢迎大家一起学习！
