struts2源码解析二---struts2初始化

最新推荐文章于 2022-07-25 11:11:05 发布
最新推荐文章于 2022-07-25 11:11:05 发布
阅读量924 收藏
点赞数
分类专栏： struts2

转自：http://blog.csdn.net/a1969212650/article/details/34106533

首先，先看看怎么调试struts2源码吧，主要是以下步骤：

使用Myeclipse创建一个web工程

导入struts2需要的jar包

如图：



让jar包关联源文件

在上图中的jar包右键，选择properties->java source attach，如果关联成功，双击jar包下的某个class文件就会显示java源代码了。

双击.class文件，在源代码关键地方设置断点

部署工程到Tomcat

Tomcat以Debug方式启动

经过以上步骤，即可执行单步调试了，这样就可以很方便的查看代码的运行状态了。

struts2框架作为MVC框架，主要作用就是帮助处理请求，以一种与web容器无关的方式。也就是说，处理请求时可以不使用HttpServletRequest等类。struts2采用Filter来拦截请求，判断如果是struts2可以处理的，请求就进入struts2框架进行处理，否则请求进入下一个Filter。

先从Filter的初始化开始来看struts2吧，因为这也是struts2框架初始化的过程。

ok，我们看看struts2的StrutsPrepareAndExecuteFilter类的init()方法：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public void init(FilterConfig filterConfig) throws ServletException {  
  2.         InitOperations init = new InitOperations();  
  3.         Dispatcher dispatcher = null;  
  4.         try {  
  5.             FilterHostConfig config = new FilterHostConfig(filterConfig);//只是进行了一层薄薄的封装   
  6.             init.initLogging(config);//初始化用户在配置filter时定义的logger   
  7.             dispatcher = init.initDispatcher(config);//创建一个转发器，并初始化   
  8.             init.initStaticContentLoader(config, dispatcher);//初始化静态资源加载器   
  9.   
  10.             prepare = new PrepareOperations(filterConfig.getServletContext(), dispatcher);  
  11.             execute = new ExecuteOperations(filterConfig.getServletContext(), dispatcher);  
  12.             this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);  
  13.   
  14.             postInit(dispatcher, filterConfig);  
  15.         } finally {  
  16.             if (dispatcher != null) {  
  17.                 dispatcher.cleanUpAfterInit();  
  18.             }  
  19.             init.cleanup();  
  20.         }  
  21.     }  
public void init(FilterConfig filterConfig) throws ServletException {
        InitOperations init = new InitOperations();
        Dispatcher dispatcher = null;
        try {
            FilterHostConfig config = new FilterHostConfig(filterConfig);//只是进行了一层薄薄的封装
            init.initLogging(config);//初始化用户在配置filter时定义的logger
            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();
        }
    }


 

从以上代码可以归纳出，初始化主要完成以下这些事情：

1.封装init()的参数filterConfig成struts2定义的FilterHostConfig

只是进行了一层薄薄的封装，代码如下：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class FilterHostConfig implements HostConfig {  
  2.   
  3.     private FilterConfig config;  
  4.   
  5.     public FilterHostConfig(FilterConfig config) {  
  6.         this.config = config;  
  7.     }  
  8.     public String getInitParameter(String key) {  
  9.         return config.getInitParameter(key);  
  10.     }  
  11.   
  12.     public Iterator<String> getInitParameterNames() {  
  13.         return MakeIterator.convert(config.getInitParameterNames());  
  14.     }  
  15.   
  16.     public ServletContext getServletContext() {  
  17.         return config.getServletContext();  
  18.     }  
  19. }  
public class FilterHostConfig implements HostConfig {

    private FilterConfig config;

    public FilterHostConfig(FilterConfig config) {
        this.config = config;
    }
    public String getInitParameter(String key) {
        return config.getInitParameter(key);
    }

    public Iterator<String> getInitParameterNames() {
        return MakeIterator.convert(config.getInitParameterNames());
    }

    public ServletContext getServletContext() {
        return config.getServletContext();
    }
}


2.初始化日志记录器，如果用户在web.xml中配置filter时配置了loggerFactory参数的话

通过InitOperations类的initLogging()。InitOperations类主要是封装了一些初始化操作，以下是该类的所有方法，从名字也可以看出方法的功能。

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class InitOperations {  
  2.     public InitOperations()   
  3.     public void initLogging( HostConfig filterConfig )  
  4.     public Dispatcher initDispatcher( HostConfig filterConfig )  
  5.     public StaticContentLoader initStaticContentLoader( HostConfig filterConfig, Dispatcher dispatcher )  
  6.     public Dispatcher findDispatcherOnThread()  
  7.     private Dispatcher createDispatcher( HostConfig filterConfig )  
  8.     public void cleanup()  
  9.     public List<Pattern> buildExcludedPatternsList( Dispatcher dispatcher )  
  10.     private List<Pattern> buildExcludedPatternsList( String patterns )  
  11. }  
public class InitOperations {
    public InitOperations() 
    public void initLogging( HostConfig filterConfig )
    public Dispatcher initDispatcher( HostConfig filterConfig )
    public StaticContentLoader initStaticContentLoader( HostConfig filterConfig, Dispatcher dispatcher )
    public Dispatcher findDispatcherOnThread()
    private Dispatcher createDispatcher( HostConfig filterConfig )
    public void cleanup()
    public List<Pattern> buildExcludedPatternsList( Dispatcher dispatcher )
    private List<Pattern> buildExcludedPatternsList( String patterns )
}


3.创建Dispatcher并初始化

Dispatcher在struts2中是一个很重要的类，它的工作就是将filter拦截到的请求转入struts2的请求处理模块。当然，首先Dispatcher会被初始化，它的初始化方法init()可是干了很多的活呢。这部分在后面会细细的讲解，先看看大概是怎样一个过程吧。在InitOperations类中：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public Dispatcher initDispatcher( HostConfig filterConfig ) {  
  2.         Dispatcher dispatcher = createDispatcher(filterConfig);  
  3.         dispatcher.init();  
  4.         return dispatcher;  
  5.     }  
public Dispatcher initDispatcher( HostConfig filterConfig ) {
        Dispatcher dispatcher = createDispatcher(filterConfig);
        dispatcher.init();
        return dispatcher;
    }


 

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. private Dispatcher createDispatcher( HostConfig filterConfig ) {  
  2.         Map<String, String> params = new HashMap<String, String>();  
  3.         for ( Iterator e = filterConfig.getInitParameterNames(); e.hasNext(); ) {  
  4.             String name = (String) e.next();  
  5.             String value = filterConfig.getInitParameter(name);  
  6.             params.put(name, value);  
  7.         }  
  8.         return new Dispatcher(filterConfig.getServletContext(), params);  
  9.     }  
private Dispatcher createDispatcher( HostConfig filterConfig ) {
        Map<String, String> params = new HashMap<String, String>();
        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);
    }


这里filter配置的参数会被保存如Dispatcher对象中，配置如：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <filter>  
  2.       <filter-name>struts2</filter-name>  
  3.       <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>  
  4.       <init-param>  
  5.       <param-name>filterParam</param-name>  
  6.       <param-value>abc</param-value>  
  7.       </init-param>  
  8.   </filter>  
<filter>
      <filter-name>struts2</filter-name>
      <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
      <init-param>
      <param-name>filterParam</param-name>
	  <param-value>abc</param-value>
      </init-param>
  </filter>


4.初始化静态资源加载器

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public StaticContentLoader initStaticContentLoader( HostConfig filterConfig, Dispatcher dispatcher ) {  
  2.         StaticContentLoader loader = dispatcher.getContainer().getInstance(StaticContentLoader.class);  
  3.         loader.setHostConfig(filterConfig);  
  4.         return loader;  
  5.     }  
public StaticContentLoader initStaticContentLoader( HostConfig filterConfig, Dispatcher dispatcher ) {
        StaticContentLoader loader = dispatcher.getContainer().getInstance(StaticContentLoader.class);
        loader.setHostConfig(filterConfig);
        return loader;
    }


在完成了Dispatcher的初始化之后，struts2维护的一个容器Container就创建完成了，可以使用了。这里通过container创建一个StaticContentLoader对象。

StaticContentLoader是接口，看看该接口声明了哪些方法：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public interface StaticContentLoader {  
  2.     public boolean canHandle(String path);  
  3.     public abstract void setHostConfig(HostConfig filterConfig);  
  4.     public abstract void findStaticResource(String path, HttpServletRequest request, HttpServletResponse response)  
  5.             throws IOException;  
  6. }  
public interface StaticContentLoader {
    public boolean canHandle(String path);
    public abstract void setHostConfig(HostConfig filterConfig);
    public abstract void findStaticResource(String path, HttpServletRequest request, HttpServletResponse response)
            throws IOException;
}


struts2有一个实现类为DefaultStaticContentLoader类。在一般情况下，struts2是不会处理静态资源的请求的，除非请求的路径是以struts或static开头，如有个test应用，那么请求必须是/test/struts/...或者/test/static/...这样才会处理。

如果struts2框架不处理静态资源的请求的话，谁来处理呢？自然是web容器了，比如tomcat。在StrutsPrepareAndExecuteFilter中：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {  
  2. <span style="white-space:pre">    </span>...  
  3.                 ActionMapping mapping = prepare.findActionMapping(request, response, true);  
  4.                 if (mapping == null) {  
  5.                     boolean handled = execute.executeStaticResourceRequest(request, response);  
  6.                     if (!handled) {  
  7.                         chain.doFilter(request, response);  
  8.                     }  
  9.                 } else {  
  10.                     execute.executeAction(request, response, mapping);  
  11.                 }  
  12.          ...  
  13.     }  
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
<span style="white-space:pre">	</span>...
                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);
                }
         ...
    }


可以看到，如果不处理，那么调用chain.doFilter()，请求也就不进入struts2框架了。

那么，如果要让struts2框架处理这样的请求，应该怎么做呢？

首先，自然是请求的路径要以struts或static开头了。

然后，静态资源应该存放在应用的如下几个包之一：

struts

org.apache.struts2.static

 template

org.apache.struts2.interceptor.debugging

也可以自己在filter配置参数指定包名：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <init-param>  
  2.         <param-name>packages</param-name>  
  3.         <param-value>abc</param-value>  
  4. </init-param>  
<init-param>
    	<param-name>packages</param-name>
    	<param-value>abc</param-value>
</init-param>


如果有多个包的话，可以用逗号分隔。

如此即可。

5.创建PrepareOperations对象和ExecuteOperations对象

PrepareOperations和ExecuteOperations有什么用呢？和InitOperations类似，封装一些操作。只不过InitOperations是封装初始化的操作，而前两者则是封装请求预处理和请求处理的操作，当处理请求时方法被调用。先看PrepareOperations有哪些操作：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class PrepareOperations {  
  2.     public PrepareOperations(ServletContext servletContext, Dispatcher dispatcher)  
  3.     public ActionContext createActionContext(HttpServletRequest request, HttpServletResponse response)  
  4.     public void cleanupRequest(HttpServletRequest request)  
  5.     public void assignDispatcherToThread()   
  6.     public void setEncodingAndLocale(HttpServletRequest request, HttpServletResponse response)  
  7.     public HttpServletRequest wrapRequest(HttpServletRequest oldRequest)   
  8.     public ActionMapping findActionMapping  
  9.     (HttpServletRequest request, HttpServletResponse response)  
  10.     public ActionMapping findActionMapping(HttpServletRequest request, HttpServletResponse response, boolean forceLookup)  
  11.     public void cleanupDispatcher()  
  12.     public boolean isUrlExcluded( HttpServletRequest request, List<Pattern> excludedPatterns )   
  13.     private String getUri( HttpServletRequest request )  
  14. }  
public class PrepareOperations {
    public PrepareOperations(ServletContext servletContext, Dispatcher dispatcher)
    public ActionContext createActionContext(HttpServletRequest request, HttpServletResponse response)
    public void cleanupRequest(HttpServletRequest request)
    public void assignDispatcherToThread() 
    public void setEncodingAndLocale(HttpServletRequest request, HttpServletResponse response)
    public HttpServletRequest wrapRequest(HttpServletRequest oldRequest) 
    public ActionMapping findActionMapping
    (HttpServletRequest request, HttpServletResponse response)
    public ActionMapping findActionMapping(HttpServletRequest request, HttpServletResponse response, boolean forceLookup)
    public void cleanupDispatcher()
    public boolean isUrlExcluded( HttpServletRequest request, List<Pattern> excludedPatterns ) 
    private String getUri( HttpServletRequest request )
}


ExecuteOperations就简单得多了：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class ExecuteOperations {  
  2.     private ServletContext servletContext;  
  3.     private Dispatcher dispatcher;  
  4.   
  5.     public ExecuteOperations(ServletContext servletContext, Dispatcher dispatcher) {  
  6.         this.dispatcher = dispatcher;  
  7.         this.servletContext = servletContext;  
  8.     }  
  9.   
  10.     /** 
  11.      * Tries to execute a request for a static resource 
  12.      * @return True if it was handled, false if the filter should fall through 
  13.      * @throws IOException 
  14.      * @throws ServletException 
  15.      */  
  16.     public boolean executeStaticResourceRequest(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {  
  17.         // there is no action in this request, should we look for a static resource?   
  18.         String resourcePath = RequestUtils.getServletPath(request);  
  19.   
  20.         if ("".equals(resourcePath) && null != request.getPathInfo()) {  
  21.             resourcePath = request.getPathInfo();  
  22.         }  
  23.   
  24.         StaticContentLoader staticResourceLoader = dispatcher.getContainer().getInstance(StaticContentLoader.class);  
  25.         if (staticResourceLoader.canHandle(resourcePath)) {  
  26.             staticResourceLoader.findStaticResource(resourcePath, request, response);  
  27.             // The framework did its job here   
  28.             return true;  
  29.   
  30.         } else {  
  31.             // this is a normal request, let it pass through   
  32.             return false;  
  33.         }  
  34.     }  
  35.   
  36.     /** 
  37.      * Executes an action 
  38.      * @throws ServletException 
  39.      */  
  40.     public void executeAction(HttpServletRequest request, HttpServletResponse response, ActionMapping mapping) throws ServletException {  
  41.         dispatcher.serviceAction(request, response, servletContext, mapping);  
  42.     }  
  43. }  
public class ExecuteOperations {
    private ServletContext servletContext;
    private Dispatcher dispatcher;

    public ExecuteOperations(ServletContext servletContext, Dispatcher dispatcher) {
        this.dispatcher = dispatcher;
        this.servletContext = servletContext;
    }

    /**
     * Tries to execute a request for a static resource
     * @return True if it was handled, false if the filter should fall through
     * @throws IOException
     * @throws ServletException
     */
    public boolean executeStaticResourceRequest(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
        // there is no action in this request, should we look for a static resource?
        String resourcePath = RequestUtils.getServletPath(request);

        if ("".equals(resourcePath) && null != request.getPathInfo()) {
            resourcePath = request.getPathInfo();
        }

        StaticContentLoader staticResourceLoader = dispatcher.getContainer().getInstance(StaticContentLoader.class);
        if (staticResourceLoader.canHandle(resourcePath)) {
            staticResourceLoader.findStaticResource(resourcePath, request, response);
            // The framework did its job here
            return true;

        } else {
            // this is a normal request, let it pass through
            return false;
        }
    }

    /**
     * Executes an action
     * @throws ServletException
     */
    public void executeAction(HttpServletRequest request, HttpServletResponse response, ActionMapping mapping) throws ServletException {
        dispatcher.serviceAction(request, response, servletContext, mapping);
    }
}


关于请求的处理，后面详细讲。这里就当做是一个热身吧。

6.封装配置filter时指定的不处理的action请求的pattern成List<Pattern>

这个配置是通过STRUTS_ACTION_EXCLUDE_PATTERN这个常量设置的。在struts.xml或者struts.properties文件中配置。

7.完成一些清理工作

其实也没清理多少东西了。


ok，初始化的基本流程分析完了，但其中Dispatcher的初始化还是一个黑盒。所以下一篇struts2源码学习之初始化（二）就详细分析Dispatcher的初始化。

 

xyy511
关注
专栏目录
struts2源码解析，个人感觉很不错
11-23
### Struts2源码解析及工作原理 #### Struts2简介 Struts2是一个流行的Java Web应用程序框架，它继承和发展了Struts1.x的一些特性，同时又采用了WebWork框架的核心技术，使得Struts2在设计理念和技术实现上都有了...
Applet 类常用方法
qq_42177755的博客
08-19 2526
Applet 类是浏览器类库中最为重要的类，同时也是所有 JAVA 小应用程序的基本类。 一个 Applet 应用程序从开始运行到结束时所经历的过程被称为 Applet 的生命周期。 Applet 的生命周期涉及 init() 、 start() 、 stop() 和 destroy() 四种方法，这 4 种方法都是 Applet 类的成员，可以继承这些方法，也可以重写这些方法，覆盖原来定义的这些方法。除此之外，为了在 Applet 程序中实现输出功能，每个 Applet 程序中还需要重载 paint()
Struts2框架运行过程研究--init方法
went_java的专栏
04-21 665
最近突然对struts2的执行过程产生了兴趣。所以花了几个晚上看了看源码。将心得记录在这里。     本文是StrutsPrepareAndExecuteFileter中的init方法的介绍。时间有限，先写这些吧。有错误的地方希望有人能够批评指正 public void init(FilterConfig filterConfig) throws ServletException {
Java学习笔记（一）
q503385724的博客
04-24 143
1、在实际项目设计中，常把实现一个面向接口的对象（俗称面向接口编程），设置成一个私有类型，如下：private IStudentDAO dao;//设置为私有类型 @Override public void init() throws ServletException { //IStudentDAO dao=new StudentDAOImpl(); dao=new Studen...
Spring基础篇
Lucky_xiang
03-19 199
Spring基础 spring容器是什么？ 用于管理对象的 如何启动spring容器？ 1.导包 2.添加配置文件 这个配置文件用于告诉spring容器创建哪些对象 如何创建对象？（如何让容器帮我们创建对象？）. 方式一：使用无参构造器（重点） 第一步：给类添加无参构造器. 第二步：在配置文件中配置bean元素. 第三步：调用容器的getBean方法来获得对象. 方式二：使用静态工厂方法（使用较...
Servlet——常用类
Yellow_Star的博客
09-03 390
ServletConfig类 说明 一个Servlet程序在初始化时，会自动创建一个ServletConfig对象 方法 获取当前Servlet程序的别名 获取初始化参数init-param 获取ServletContext对象 如何使用 方式一 //在Servlet程序中的init()方法中可以调用以上方法 @Override public void init(ServletConfig servletConfig) throws ServletException {
Struts2源码阅读
12-23
4. `ConfigurationProvider`和`Configuration`：`ConfigurationProvider`解析Struts2的配置文件，如`struts.xml`。默认实现`XmlConfigurationProvider`和`StrutsXmlConfigurationProvider`负责读取和解析这些配置。 ...
Struts2源码分析
09-13
`Dispatcher`类在Struts2中扮演着重要角色，它负责框架的初始化和Action的执行。`FilterDispatcher`则是一个Servlet Filter，根据配置文件来决定哪些请求需要经过Struts2处理。如果配置不当，可能会导致问题，如将...
struts2源码分析总结
05-16
在`Dispatcher`的初始化过程中，它会读取`web.xml`或其他配置文件，解析Struts2的配置信息，如Action、结果类型、拦截器等。这些配置信息被加载到内存中的容器中，供后续请求处理时使用。`Dispatcher`还负责初始化...
struts2 源码分析
07-02
从 org.apache.struts2.dispatcher.FilterDispatcher 开始 Java 代码阅读，我们可以看到 FilterDispatcher 的 init 方法，它负责初始化 Dispatcher 对象，并创建了一个 ActionMapper 实例，以便对请求进行处理。...
struts2入门学习源码
10-15
struts2学习笔记和源码，struts2原理。文件上传、i18n等等
struts2_源码学习_init()
Onion的博客
05-19 280
续struts2_源码学习_目录 作为一个过滤器类，请求到达的第一步就是进行初始化，即init()操作。 StrutsPrepareAndExecuteFilter.init public void init(FilterConfig filterConfig) throws ServletException { //初始化InitOperations ...
JSP开发Servlet重写init（）方法实例详解
qq_39533140的博客
06-07 2068
写一个Servlet时，有时需要我们重写该Servlet的初始化方法，然后，究竟是重写init(ServletConfig config)，还是重写init()，这是个问题。要明了这一点，首先要知道Servlet的几个类和接口的联系： ServletConfig接口:其中有getServletName();getServletContext();getInitParameter(String n...
java代码中init method和destroy method的三种使用方式
热门推荐
程序员涂小哥的技术博客
12-12 4万+
在java的实际开发过程中，我们可能常常需要使用到init method和destroy method，比如初始化一个对象（bean）后立即初始化（加载）一些数据，在销毁一个对象之前进行垃圾回收等等。 周末对这两个方法进行了一点学习和整理，倒也不是专门为了这两个方法，而是在巩固spring相关知识的时候提到了，然后感觉自己并不是很熟悉这个，便好好的了解一下。 根据特意的去了解后，发现实际上可以有
【JAVAEE基础学习（12）】--springMVC常用配置篇
lixxkv的博客
07-25 223
【JAVAEE基础学习（12）】--springMVC常用配置篇
SSH分页（1）
ABoLuoTaMei的专栏
03-14 150
工具类pageBean package com.move.util; import java.util.List; import com.move.entity.MoveBooking; public class pageBean{ private List moveList;//要返回的某一页的记录列表 private int allRow;//总记录数 pr...
servlet介绍
weixin_30872867的博客
02-20 286
简介 Servlet 为创建基于 web 的应用程序提供了基于组件、独立于平台的方法，可以不受 CGI 程序的性能限制。Servlet 有权限访问所有的 Java API，包括访问企业级数据库的 JDBC API。 Java Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间...
Struts2源码浅析-初始化（转载）
weixin_30835933的博客
07-17 143
本文参考自：http://blog.csdn.net/java2000_wl/article/details/7572828 如果有侵犯您知识产权的地方，烦请通知本人，本人将即刻停止侵权行为 --------begin 在web.xml中配置的StrutsPrepareAndExecuteFilter类是struts2的入口类，它实现了Filter接口 ，它的init 方法为初始化入...
struts源码之四
老男人
12-14 94
初始化Dispatcher完成，   init.initStaticContentLoader(config, dispatcher);  继续初始化filter配置信息的静态内容加载器 public StaticContentLoader initStaticContentLoader( HostConfig filterConfig, Dispatcher dispatcher ) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值