浅谈：深入理解struts2的流程已经spring和struts2的整合
第一步:在tomcat启动的时候
1、在tomcat启动的时候，首先会加载struts2的核心过滤器StrutsPrepareAndExecuteFilter
<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>
我们打开源代码，进入核心过滤器
在核心过滤器里面有init()方法，用于在启动tomcat的时候初始化struts2用的
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(filterConfig.getServletContext(), dispatcher); execute = new ExecuteOperations(filterConfig.getServletContext(), dispatcher); this.excludedPatterns = init.buildExcludedPatternsList(dispatcher); postInit(dispatcher, filterConfig); } finally { if (dispatcher != null) { dispatcher.cleanUpAfterInit(); } init.cleanup(); } }
首先我们去看一下如何去加载配置文件，打开下面方法的源代码
dispatcher = init.initDispatcher(config);//用于加载配置文件
就会进入initDispatcher方法，在打开注释对应的源代码
public Dispatcher initDispatcher( HostConfig filterConfig ) { Dispatcher dispatcher = createDispatcher(filterConfig); dispatcher.init();//打开他的源代码 return dispatcher; }
然后你就会发现，在这个init方法中
public void init() { if (configurationManager == null) { configurationManager = createConfigurationManager(DefaultBeanSelectionProvider.DEFAULT_BEAN_NAME); } try {
//有兴趣的朋友可以自己再去看更深层次的源代码，这里就不深究了 init_FileManager(); init_DefaultProperties(); // [1]//加载struts.properties配置文件 init_TraditionalXmlConfigurations(); // [2]//按照顺序加载下面三个配置文件struts-default.xml(一个),struts-plugin.xml(可能有多个),struts.xml(一个) 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); } } } catch (Exception ex) { if (LOG.isErrorEnabled()) LOG.error("Dispatcher initialization failed", ex); throw new StrutsException(ex); } }
看完加载配置文件以后，在回到我们的StrutsPrepareAndExecuteFilter核心过滤器，进入下面方法的源代码
public void init(FilterConfig filterConfig) throws ServletException { InitOperations init = new InitOperations(); Dispatcher dispatcher = null; try { FilterHostConfig config = new FilterHostConfig(filterConfig); init.initLogging(config); init.initStaticContentLoader(config, dispatcher);//用于静态注入 }
这个方法是用来静态注入
静态注入：加载struts-defalut.xml里面的bean属性的java类,把这些类加载进入struts2
就是下面这些内容(部分)
<struts> <bean class="com.opensymphony.xwork2.ObjectFactory" name="struts"/> <bean type="com.opensymphony.xwork2.factory.ResultFactory" name="struts" class="org.apache.struts2.factory.StrutsResultFactory" /> <bean type="com.opensymphony.xwork2.factory.ActionFactory" name="struts" class="com.opensymphony.xwork2.factory.DefaultActionFactory"/> <bean type="com.opensymphony.xwork2.factory.ConverterFactory" name="struts" class="com.opensymphony.xwork2.factory.DefaultConverterFactory" /> <bean type="com.opensymphony.xwork2.factory.InterceptorFactory" name="struts" class="com.opensymphony.xwork2.factory.DefaultInterceptorFactory" /> <bean type="com.opensymphony.xwork2.factory.ValidatorFactory" name="struts" class="com.opensymphony.xwork2.factory.DefaultValidatorFactory" /> <bean type="com.opensymphony.xwork2.FileManager" class="com.opensymphony.xwork2.util.fs.DefaultFileManager" name="system" scope="singleton"/> <bean type="com.opensymphony.xwork2.FileManagerFactory" class="com.opensymphony.xwork2.util.fs.DefaultFileManagerFactory" name="struts" scope="singleton"/> ...................................
经过配置文件的加载和静态注入，struts2容器基本上就启动了
在请求一个url的时候
回到我们的过滤器，在请求url的时候，struts2首先会执行doFilter(ServletRequest, ServletResponse, FilterChain)方法
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);//创建actionContext prepare.assignDispatcherToThread(); request = prepare.wrapRequest(request); ActionMapping mapping = prepare.findActionMapping(request, response, true); 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之前，会先创建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; } //在进入getContext()的源代码 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));
ctx = new ActionContext(stack.getContext());
}
request.setAttribute(CLEANUP_RECURSION_COUNTER, counter);
ActionContext.setContext(ctx);
return ctx;
public static ActionContext getContext() { //在进get()的源代码 return actionContext.get(); }
public T get() { Thread t = Thread.currentThread();//获取当前线程 ThreadLocalMap map = getMap(t);//从当前线程中获取 if (map != null) {//如果当前线程中不存在，就创建，并且放入当前线程中 ThreadLocalMap.Entry e = map.getEntry(this);//到这里说明了actionContext存放在当前线程中，所以里面的数据是线程安全的 if (e != null) return (T)e.value; } return setInitialValue(); }
通过上述的源代码分析，就可以看出struts2是如何创建actionContext的，并且在创建actionContext之前，值栈就已经创建好了，而且值栈里面map和actionContext里面的
map是一样的。
在看完了了如果创建actionContext以后，我们就应该去看如何去创建action代理对象了。创建action对象的方法有很多，一种是利用struts2本身的反射机制，通过ObjectFactory来创建action对象。第二个把创建对象委托给其他容器，例如spring。下面来说一下使用struts2本身反射机制来创建对象的过程
首先说一下struts2本身来创建action对象，使用代理的方法来生成action代理对象。这里的action是代理对象
在struts2中，拦截器成为aop的切面，而我们自己写的action里面的方法是目标方法(这里设计面向切面编程aop的思想，在这里就不在多叙述)
在struts2中，有一个核心类，为ObjectFactory,这个类负责所有struts2类的创建，我们可以看一下他的方法体系
这里面有buildAction(创建action对象)，buildResult(创建结果集对象)等一系列创建struts2所需要对象的方法
也就是说，如果要使用其他容器来创建action，必须重新继承ObjectFactory，然后重新buildAction等方法。
首先我们打开executeAction这个方法
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException { ....................................................................
//打开executeAction方法的源代码 execute.executeAction(request, response, mapping); .................................................................... }
然后进入下面代码
public void executeAction(HttpServletRequest request, HttpServletResponse response, ActionMapping mapping) throws ServletException { //在打开这个方法的源代码 dispatcher.serviceAction(request, response, servletContext, mapping); }
public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context, ActionMapping mapping) throws ServletException { ................................................................. try { UtilTimerStack.push(timerKey); String namespace = mapping.getNamespace(); String name = mapping.getName(); String method = mapping.getMethod(); Configuration config = configurationManager.getConfiguration(); //获取action代理对象 ActionProxy proxy = config.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 {
//打开execute()方法的源代码，要是DefaultActionProxy这个类下面的这个方法 proxy.execute(); } ................................................................. }
public String execute() throws Exception { ActionContext nestedContext = ActionContext.getContext(); ActionContext.setContext(invocation.getInvocationContext()); String retCode = null; String profileKey = "execute: "; try { UtilTimerStack.push(profileKey); //进行invoke()源代码，invoke方法是DefaultActionInvocation类下面的 retCode = invocation.invoke();/ } finally { if (cleanupContext) { ActionContext.setContext(nestedContext); } UtilTimerStack.pop(profileKey); } return retCode; }
invoke方法就是拦截器struts2的关键方法，跟着注释走，可以看到是先执行拦截器，在执行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();//执行action里面的方法 } // 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); } }
通过结果集对象返回到页面，就执行了一次请求的过程。上面介绍的
如果是使用spring容器来作为action的产生，那么就需要对action里面ObjectFactory类继承继承，然后重写里面的方法
我们来看一下首先怎么覆盖ObjectFactory类，在上面，我说过，xml文件的加载顺序是：struts-default.xml,struts-plugin.xml,struts.xml
ObjectFactory在struts-default.xml默认加载的，查看静态注入可以发现，ObjectFactory被默认加载，如果想成spring的话，可以新建一个struts-plugin.xml
在里面把它替换掉
<struts> <bean class="com.opensymphony.xwork2.ObjectFactory" name="struts"/>
下面把文件替换掉，新建一个struts-plugin.xml，这么ObjectFactory"加载就由spring产生，我们可以进入StrutsSpringObjectFactory源代码看看
<struts> <!-- 在struts配置文件中引入spring,并且把由struts2自己产生action的 方法，变成由Spring容器产生，覆盖本身有struts2本身产生的ObjectFactory，进入class源代码 --> <bean type="com.opensymphony.xwork2.ObjectFactory" name="spring" class="org.apache.struts2.spring.StrutsSpringObjectFactory" /> <!-- Make the Spring object factory the automatic default --> <constant name="struts.objectFactory" value="spring" /> <constant name="struts.class.reloading.watchList" value="" /> <constant name="struts.class.reloading.acceptClasses" value="" /> <constant name="struts.class.reloading.reloadConfig" value="false" /> <package name="spring-default"> <interceptors> <interceptor name="autowiring" class="com.opensymphony.xwork2.spring.interceptor.ActionAutowiringInterceptor"/> <interceptor name="sessionAutowiring" class="org.apache.struts2.spring.interceptor.SessionContextAutowiringInterceptor"/> </interceptors> </package> </struts>
// 进入 SpringObjectFactory
public class StrutsSpringObjectFactory extends SpringObjectFactory {
private static final Logger LOG = LoggerFactory.getLogger(StrutsSpringObjectFactory.class);
这样就进入了SpringObjectFactory，实现了ObjectFactory并且重写了ObjectFactory里面的一些方法
public class SpringObjectFactory extends ObjectFactory implements ApplicationContextAware { private static final Logger LOG = LoggerFactory.getLogger(SpringObjectFactory.class);
我可可以看一下的他的方法体系
在这些方法中，我们来看一下buildBean方法
public Object buildBean(String beanName, Map<String, Object> extraContext, boolean injectInternal) throws Exception { Object o; if (appContext.containsBean(beanName)) { /* 首先从spring容器中获取action对象，如果获取不到 就利用反射机制去获取action，这里的反射机制，和struts2本身的反射机制应该差不多 */ o = appContext.getBean(beanName); } else { //利用反射机制，实现创建action Class beanClazz = getClassInstance(beanName); o = buildBean(beanClazz, extraContext); } if (injectInternal) { injectInternalBeans(o); } return o; }
通过spring容器，只是action产生方式和以前不同而已，其余的步骤和方法都相同。我们就分析到这里了。大家可以试着跟着我的注释去找源码，然后设置断点，使用debug调试，很轻松
就可以得到结果。
我也才刚刚学到struts2和spring的整合，把老师上课讲的内容总结了一些，希望对求知的人有用。第一次写博客，写的不好，请大家见谅
