Shiro ShiroFilterFactoryBean

首先看下继承关系，实现了FactoryBean，BeanPostProcessor两个接口

 BeanPostProcessor 接口

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
	if (bean instanceof Filter) {
		log.debug("Found filter chain candidate filter '{}'", beanName);
		Filter filter = (Filter) bean;
		// 应用全局配置
		applyGlobalPropertiesIfNecessary(filter);
		// 将在Spring中注册(而不是在ShiroFilterFactoryBean中配置的)的Filter并入.
		// 这里面就牵扯出一个有趣的问题: FactoryBean<T>接口的getObject方法和BeanPostProcessor接口的postProcessBeforeInitialization的执行先后顺序？
		// 为了保证不遗漏Filter, 我们可以猜测后者必须优先于前者。
		getFilters().put(beanName, filter);
	} else {
		log.trace("Ignoring non-Filter bean '{}'", beanName);
	}
	return bean;
}

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
	return bean;
}

jwtFilter就是我自定义的过滤器，现在走bean的后置处理器，bean初始化前做的事。

 FactoryBean 接口

                
    public Object getObject() throws Exception {
        if (this.instance == null) {
            this.instance = this.createInstance();
        }

        return this.instance;
    }

    public Class getObjectType() {
        // 返回实例对象的类型
        return ShiroFilterFactoryBean.SpringShiroFilter.class;
    }

    public boolean isSingleton() {
        return true;
    }

ShiroFilterFactoryBean.SpringShiroFilter类就是作为FactoryBean<T>接口最终要返回的实例；

createInstance（）

protected AbstractShiroFilter createInstance() throws Exception {
        log.debug("Creating Shiro Filter instance.");
        // 将用户设置的securityManage配置进来
        SecurityManager securityManager = this.getSecurityManager();
        String msg;
        // 确保securityManage必须设置
        if (securityManager == null) {
            msg = "SecurityManager property must be set.";
            throw new BeanInitializationException(msg);
        } else if (!(securityManager instanceof WebSecurityManager)) {
            msg = "The security manager does not implement the WebSecurityManager interface.";
            throw new BeanInitializationException(msg);
        } else {
            FilterChainManager manager = this.createFilterChainManager();
            PathMatchingFilterChainResolver chainResolver = new PathMatchingFilterChainResolver();
            chainResolver.setFilterChainManager(manager);
             // 构造SpringShiroFilter实例,由Spring管理
            return new ShiroFilterFactoryBean.SpringShiroFilter((WebSecurityManager)securityManager, chainResolver);
        }
    }

createFilterChainManager（）

 protected FilterChainManager createFilterChainManager() {
        // 将shiro默认的filter加载FilterChainManager中
        DefaultFilterChainManager manager = new DefaultFilterChainManager();
        Map<String, Filter> defaultFilters = manager.getFilters();
        Iterator var3 = defaultFilters.values().iterator();

        while(var3.hasNext()) {
            Filter filter = (Filter)var3.next();
            // 为默认加载的Filter,应用上全局配置属性
            this.applyGlobalPropertiesIfNecessary(filter);
        }

        // 将用户配置的Filter并入; 所以如果用户配置了与上面同名的Filter, 则会进行覆盖操作.
        Map<String, Filter> filters = this.getFilters();
        String name;
        Filter filter;
        if (!CollectionUtils.isEmpty(filters)) {
            for(Iterator var10 = filters.entrySet().iterator(); var10.hasNext(); manager.addFilter(name, filter, false)) {
                Entry<String, Filter> entry = (Entry)var10.next();
                name = (String)entry.getKey();
                filter = (Filter)entry.getValue();
                this.applyGlobalPropertiesIfNecessary(filter);
                if (filter instanceof Nameable) {
                    ((Nameable)filter).setName(name);
                }
            }
        }

        // 这里将处理用户配置的ShiroFilterFactoryBean.filterChainDefinitions属性
        Map<String, String> chains = this.getFilterChainDefinitionMap();
        if (!CollectionUtils.isEmpty(chains)) {
            Iterator var12 = chains.entrySet().iterator();

            while(var12.hasNext()) {
                Entry<String, String> entry = (Entry)var12.next();
                String url = (String)entry.getKey();
                String chainDefinition = (String)entry.getValue();
                manager.createChain(url, chainDefinition);
            }
        }

        return manager;
    }

 

shiro默认的filter

 用户设置要过滤的url

DefaultFilterChainManager.createChain()

 public void createChain(String chainName, String chainDefinition) {
        if (!StringUtils.hasText(chainName)) {
            throw new NullPointerException("chainName cannot be null or empty.");
        } else if (!StringUtils.hasText(chainDefinition)) {
            throw new NullPointerException("chainDefinition cannot be null or empty.");
        } else {
            if (log.isDebugEnabled()) {
                log.debug("Creating chain [" + chainName + "] from String definition [" + chainDefinition + "]");
            }

            String[] filterTokens = this.splitChainDefinition(chainDefinition);
            String[] var4 = filterTokens;
            int var5 = filterTokens.length;

            for(int var6 = 0; var6 < var5; ++var6) {
                String token = var4[var6];
                String[] nameConfigPair = this.toNameConfigPair(token);
                this.addToChain(chainName, nameConfigPair[0], nameConfigPair[1]);
            }

        }
    }

addToChain()

 public void addToChain(String chainName, String filterName, String chainSpecificFilterConfig) {
        if (!StringUtils.hasText(chainName)) {
            throw new IllegalArgumentException("chainName cannot be null or empty.");
        } else {
            Filter filter = this.getFilter(filterName);
            if (filter == null) {
                throw new IllegalArgumentException("There is no filter with name '" + filterName + "' to apply to chain [" + chainName + "] in the pool of available Filters.  Ensure a " + "filter with that name/path has first been registered with the addFilter method(s).");
            } else {
                this.applyChainConfig(chainName, filter, chainSpecificFilterConfig);
                NamedFilterList chain = this.ensureChain(chainName);
                chain.add(filter);
            }
        }
    }