struts源码之四

初始化Dispatcher完成，

 

 init.initStaticContentLoader(config, dispatcher);

 继续初始化filter配置信息的静态内容加载器

public StaticContentLoader initStaticContentLoader( HostConfig filterConfig, Dispatcher dispatcher ) {
        StaticContentLoader loader = dispatcher.getContainer().getInstance(StaticContentLoader.class);
        loader.setHostConfig(filterConfig);
        return loader;
    }

 

StaticContentLoader

通过一个路径加载静态资源，

我们看看StaticContentLoader类的定义

public interface StaticContentLoader {

    /**
     * @param path Requested resource path
     * @return true if this loader is able to load this type of resource, false otherwise
     */
    public boolean canHandle(String path);

    /**
     * @param filterConfig The filter configuration
     */
    public abstract void setHostConfig(HostConfig filterConfig);

    /**
     * Locate a static resource and copy directly to the response, setting the
     * appropriate caching headers.
     *
     * @param path     The resource name
     * @param request  The request
     * @param response The response
     * @throws IOException If anything goes wrong
     */
    public abstract void findStaticResource(String path, HttpServletRequest request, HttpServletResponse response)
            throws IOException;

}

 

他的默认实现是DefaultStaticContentLoader

 public void setHostConfig(HostConfig filterConfig) {
        String param = filterConfig.getInitParameter("packages");
        String packages = getAdditionalPackages();
        if (param != null) {
            packages = param + " " + packages;
        }
        this.pathPrefixes = parse(packages);
        initLogging(filterConfig);
    }

 

 protected String getAdditionalPackages() {
        return "org.apache.struts2.static template org.apache.struts2.interceptor.debugging static";
    }

 

初始化struts内部所有的静态资源信息,说白了就是初始化sturts自带的标签库.

看图

 

 

 

初始化基本完成，剩下三件事，

 prepare = new PrepareOperations(filterConfig.getServletContext(), dispatcher);
            execute = new ExecuteOperations(filterConfig.getServletContext(), dispatcher);
			this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);

 

PrepareOperations是预处理操作,在一个request请求到来之前的预处理操作

 

然后是初始化ExecuteOperations,包含执行操作过滤器

以上初始化只是创建了该对象，当struts2拦截器收到请求的时候才会处理，那是后话。

接下来

this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);

public List<Pattern> buildExcludedPatternsList( Dispatcher dispatcher ) {
        return buildExcludedPatternsList(dispatcher.getContainer().getInstance(String.class, StrutsConstants.STRUTS_ACTION_EXCLUDE_PATTERN));
    }
            
    private List<Pattern> buildExcludedPatternsList( String patterns ) {
        if (null != patterns && patterns.trim().length() != 0) {
            List<Pattern> list = new ArrayList<Pattern>();
            String[] tokens = patterns.split(",");
            for ( String token : tokens ) {
                list.add(Pattern.compile(token.trim()));
            }
            return Collections.unmodifiableList(list);
        } else {
            return null;
        }
    }

 用来取出不需要处理的请求。

看doFilter就可以明白

 

 public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {

        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;

        try {
            prepare.setEncodingAndLocale(request, response);
            prepare.createActionContext(request, response);
            prepare.assignDispatcherToThread();
			if ( excludedPatterns != null && prepare.isUrlExcluded(request, excludedPatterns)) {
				chain.doFilter(request, response);
			} else {
				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);
        }
    }

 注意上面代码中if ( excludedPatterns != null && prepare.isUrlExcluded(request, excludedPatterns))

如果包含了不需要处理的请求，直接chain.doFilter(request, response);

否则进入struts内部，

 

这样，所有的初始化类创建工作依然是完成了。