你的位置:首页 > ASP.net教程

[ASP.net教程]浅谈:深入理解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_Traditional// [2]//按照顺序加载下面三个配置文件struts-default. 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.里面的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类,在上面,我说过,l,struts.

ObjectFactory在struts-default.l

在里面把它替换掉

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