第一步:在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"加载就由sprin*生，我们可以进入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的整合，把老师上课讲的内容总结了一些，希望对求知的人有用。第一次写博客，写的不好，请大家见谅