Shiro权限管理框架（三）：Shiro中权限过滤器的初始化流程和实现原理

protected AbstractShiroFilter createInstance() throws Exception {
       SecurityManager securityManager = getSecurityManager();
       FilterChainManager manager = createFilterChainManager();
       PathMatchingFilterChainResolver chainResolver = new PathMatchingFilterChainResolver();
       chainResolver.setFilterChainManager(manager);
       return new SpringShiroFilter((WebSecurityManager) securityManager, chainResolver);
   }

protected FilterChainManager createFilterChainManager() {
    DefaultFilterChainManager manager = new DefaultFilterChainManager();
    Map<String, Filter> defaultFilters = manager.getFilters();
    for (Filter filter : defaultFilters.values()) {
        applyGlobalPropertiesIfNecessary(filter);
    }
    Map<String, Filter> filters = getFilters();
    if (!CollectionUtils.isEmpty(filters)) {
        for (Map.Entry<String, Filter> entry : filters.entrySet()) {
            String name = entry.getKey();
            Filter filter = entry.getValue();
            applyGlobalPropertiesIfNecessary(filter);
            if (filter instanceof Nameable) {
                ((Nameable) filter).setName(name);
            }
            manager.addFilter(name, filter, false);
        }
    }
    Map<String, String> chains = getFilterChainDefinitionMap();
    if (!CollectionUtils.isEmpty(chains)) {
        for (Map.Entry<String, String> entry : chains.entrySet()) {
            String url = entry.getKey();
            String chainDefinition = entry.getValue();
            manager.createChain(url, chainDefinition);
        }
    }
    return manager;
}

public DefaultFilterChainManager() {
    this.filters = new LinkedHashMap<String, Filter>();
    this.filterChains = new LinkedHashMap<String, NamedFilterList>();
    addDefaultFilters(false);
}

protected void addDefaultFilters(boolean init) {
    for (DefaultFilter defaultFilter : DefaultFilter.values()) {
        addFilter(defaultFilter.name(), defaultFilter.newInstance(), init, false);
    }
}

public enum DefaultFilter {
    anon(AnonymousFilter.class),
    authc(FormAuthenticationFilter.class),
    authcBasic(BasicHttpAuthenticationFilter.class),
    logout(LogoutFilter.class),
    noSessionCreation(NoSessionCreationFilter.class),
    perms(PermissionsAuthorizationFilter.class),
    port(PortFilter.class),
    rest(HttpMethodPermissionFilter.class),
    roles(RolesAuthorizationFilter.class),
    ssl(SslFilter.class),
    user(UserFilter.class);
}

private void applyGlobalPropertiesIfNecessary(Filter filter) {
    applyLoginUrlIfNecessary(filter);
    applySuccessUrlIfNecessary(filter);
    applyUnauthorizedUrlIfNecessary(filter);
}

private void applyLoginUrlIfNecessary(Filter filter) {
    String loginUrl = getLoginUrl();
    if (StringUtils.hasText(loginUrl) && (filter instanceof AccessControlFilter)) {
        AccessControlFilter acFilter = (AccessControlFilter) filter;
        String existingLoginUrl = acFilter.getLoginUrl();
        if (AccessControlFilter.DEFAULT_LOGIN_URL.equals(existingLoginUrl)) {
            acFilter.setLoginUrl(loginUrl);
        }
    }
}

public void createChain(String chainName, String chainDefinition) {
    String[] filterTokens = splitChainDefinition(chainDefinition);
    for (String token : filterTokens) {
        String[] nameConfigPair = toNameConfigPair(token);
        addToChain(chainName, nameConfigPair[0], nameConfigPair[1]);
    }
}

public void addToChain(String chainName, String filterName, String chainSpecificFilterConfig) {
    Filter filter = getFilter(filterName);
    applyChainConfig(chainName, filter, chainSpecificFilterConfig);
    NamedFilterList chain = ensureChain(chainName);
    chain.add(filter);
}

protected NamedFilterList ensureChain(String chainName) {
    NamedFilterList chain = getChain(chainName);
    if (chain == null) {
        chain = new SimpleNamedFilterList(chainName);
        this.filterChains.put(chainName, chain);
    }
    return chain;
}

public FilterChain getChain(ServletRequest request, ServletResponse response, FilterChain originalChain) {
    FilterChainManager filterChainManager = getFilterChainManager();
    if (!filterChainManager.hasChains()) {
        return null;
    }
    String requestURI = getPathWithinApplication(request);
    for (String pathPattern : filterChainManager.getChainNames()) {
        if (pathMatches(pathPattern, requestURI)) {
            return filterChainManager.proxy(originalChain, pathPattern);
        }
    }
    return null;
}

protected void doFilterInternal(ServletRequest servletRequest, ServletResponse servletResponse, 
                                final FilterChain chain) throws ServletException, IOException {
        final ServletRequest request = prepareServletRequest(servletRequest, servletResponse, chain);
        final ServletResponse response = prepareServletResponse(request, servletResponse, chain);
        final Subject subject = createSubject(request, response);
        subject.execute(new Callable() {
            public Object call() throws Exception {
                updateSessionLastAccessTime(request, response);
                executeChain(request, response, chain);
                return null;
            }
        });
}

protected void executeChain(ServletRequest request, ServletResponse response, FilterChain origChain)
        throws IOException, ServletException {
    FilterChain chain = getExecutionChain(request, response, origChain);
    chain.doFilter(request, response);
}

protected FilterChain getExecutionChain(ServletRequest request, ServletResponse response, FilterChain origChain) {
    FilterChain chain = origChain;
    FilterChainResolver resolver = getFilterChainResolver();
    if (resolver == null) {
        return origChain;
    }
    FilterChain resolved = resolver.getChain(request, response, origChain);
    if (resolved != null) {
        chain = resolved;
    } else {
    }
    return chain;
}