浅谈：深入理解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核心过滤器，进入下面方法的源代码

这个方法是用来静态注入

静态注入：加载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-plugin.xml，这么ObjectFactory"加载就由spring产生，我们可以进入StrutsSpringObjectFactory源代码看看

// 进入 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的整合，把老师上课讲的内容总结了一些，希望对求知的人有用。第一次写博客，写的不好，请大家见谅