2. 程式人生 > >shiroFilter設計原理與實現

shiroFilter設計原理與實現

阿新 • • 發佈：2019-02-05

本篇文章篇幅比較長，但是細看下去相信對學習Shiro應該會有幫助。好了，閒話不多說，直接進入正題：

Shiro提供了與Web整合的支援，其通過一個ShiroFilter入口來攔截需要安全控制的URL，然後進行相應的控制，ShiroFilter類似於如Strut2/SpringMVC這種web框架的前端控制器，其是安全控制的入口點，其負責讀取配置（如ini配置檔案），然後判斷URL是否需要登入/許可權等工作。

而要在中使用Shiro的話，可在web.xml中配置一個DelegatingFilterProxy，DelegatingFilterProxy作用是自動到Spring容器查詢名字為shiroFilter

（filter-name）的bean並把所有Filter的操作委託給它。

首先是在web.xml中配置DelegatingFilterProxy

<filter>
    <filter-name>shiroFilter</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    <init-param>
        <param-name>targetFilterLifecycle</param
 
-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>shiroFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

配置好DelegatingFilterProxy後，下面只要再把ShiroFilter

配置到Spring容器（此處為Spring的配置檔案）即可：

<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
    <property name="securityManager" ref="securityManager"/>
</bean>
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

可以看到我們使用了ShiroFilterFactoryBean來建立shiroFilter，這裡用到了Spring中一種特殊的Bean——FactoryBean。當需要得到名為”shiroFilter“的bean時，會呼叫其getObject()來獲取例項。下面我們通過分析ShiroFilterFactoryBean建立例項的過程來探究Shiro是如何實現安全攔截的：

    public Object getObject() throws Exception {
        if (instance == null) {
            instance = createInstance();
        }
        return instance;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

其中呼叫了createInstance()來建立例項：

  protected AbstractShiroFilter createInstance() throws Exception {

        // 這裡是通過FactoryBean注入的SecurityManager（必須）
        SecurityManager securityManager = getSecurityManager();
        if (securityManager == null) {
            String msg = "SecurityManager property must be set.";
            throw new BeanInitializationException(msg);
        }

        if (!(securityManager instanceof WebSecurityManager)) {
            String msg = "The security manager does not implement the WebSecurityManager interface.";
            throw new BeanInitializationException(msg);
        }

        FilterChainManager manager = createFilterChainManager();

        PathMatchingFilterChainResolver chainResolver = new PathMatchingFilterChainResolver();
        chainResolver.setFilterChainManager(manager);

        return new SpringShiroFilter((WebSecurityManager) securityManager, chainResolver);
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

可以看到建立SpringShiroFilter時用到了兩個元件：SecurityManager和ChainResolver。

  • SecurityManager：我們知道其在Shiro中的地位，類似於一個“安全大管家”，相當於SpringMVC中的DispatcherServlet或者Struts2中的FilterDispatcher，是Shiro的心臟，所有具體的互動都通過SecurityManager進行控制，它管理著所有Subject、且負責進行認證和授權、及會話、快取的管理。
  • ChainResolver：Filter鏈解析器，用來解析出該次請求需要執行的Filter鏈。
  • PathMatchingFilterChainResolver：ChainResolver的實現類，其中還包含了兩個重要元件FilterChainManager、PatternMatcher
  • FilterChainManager：管理著Filter和Filter鏈，配合PathMatchingFilterChainResolver解析出Filter鏈
  • PatternMatcher：用來進行請求路徑匹配，預設為Ant風格的路徑匹配

先有一個大體的瞭解，那麼對於原始碼分析會有不少幫助。下面會對以上兩個重要的元件進行分析，包括PathMatchingFilterChainResolver和FilterChainManager。首先貼一段ShiroFilter的在配置檔案中的定義：

<!-- Shiro的Web過濾器 -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager" />
        <property name="loginUrl" value="/login" />
        <property name="unauthorizedUrl" value="/special/unauthorized" />
        <property name="filters">
            <util:map>
                <entry key="authc" value-ref="formAuthenticationFilter" />
                <entry key="logout" value-ref="logoutFilter" />
                <entry key="ssl" value-ref="sslFilter"></entry>
            </util:map>
        </property>
        <property name="filterChainDefinitions">
            <value>
                /resources/** = anon
                /plugin/** = anon
                /download/** = anon
                /special/unauthorized = anon
                /register = anon
                /login = ssl,authc
                /logout = logout
                /admin/** = roles[admin]

                /** = user
            </value>
        </property>
    </bean>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

再來看看PathMatchingFilterChainResolver和FilterChainManager的建立過程：

  protected FilterChainManager createFilterChainManager() {

        // 預設使用的FilterChainManager是DefaultFilterChainManager
        DefaultFilterChainManager manager = new DefaultFilterChainManager();
        // DefaultFilterChainManager預設會註冊的filters(後面會列出)
        Map<String, Filter> defaultFilters = manager.getFilters();

        // 將ShiroFilterFactoryBean配置的一些公共屬性(上面配置的loginUrl,successUrl,unauthorizeUrl)應用到預設註冊的filter上去
        for (Filter filter : defaultFilters.values()) {
            applyGlobalPropertiesIfNecessary(filter);
        }

        // 處理自定義的filter（上面配置的filters屬性），步驟類似上面
        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);
                }
                // 將Filter新增到manager中去，可以看到對於Filter的管理是依賴於FilterChainManager的
                manager.addFilter(name, filter, false);
            }
        }

        // 根據FilterChainDefinition的配置來構建Filter鏈（上面配置的filterChainDefinitions屬性）
        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();
                // 後面會分析該步的原始碼，功能上就是建立Filter鏈
                manager.createChain(url, chainDefinition);
            }
        }

        return manager;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

下面有必要來看看DefaultFilterChainManager的原始碼，分析一下上面呼叫到的方法。先來看看他的幾個重要的屬性：

    private FilterConfig filterConfig;

    private Map<String, Filter> filters; //pool of filters available for creating chains

    private Map<String, NamedFilterList> filterChains; //key: chain name, value: chain
  • 1
  • 2
  • 3
  • 4
  • 5
  • 1
  • 2
  • 3
  • 4
  • 5

其中filterConfig僅在初始化Filter時有效，而我們自定義的Filter都不是init的，所以該屬性可以暫時忽略（）。
而後面兩張map就重要了：filters中快取了所有新增的filter，filterChains則快取了所有的filterChain。其中前者的key是filter name，value是Filter。而後者的key是chain name，value是NamedFilterList。
有的童鞋可能會問NamedFilterList是怎麼樣的結構呢，你可以把它當成List<Filter>，這樣就好理解了吧。下面再分析剛才createFilterChainManager()中呼叫過的manager的幾個方法：

  • addFilter（快取filter讓manager來管理）
    public void addFilter(String name, Filter filter, boolean init) {
        addFilter(name, filter, init, true);
    }

    protected void addFilter(String name, Filter filter, boolean init, boolean overwrite) {
        Filter existing = getFilter(name);
        if (existing == null || overwrite) {
            if (filter instanceof Nameable) {
                ((Nameable) filter).setName(name);
            }
            if (init) {
                initFilter(filter);
            }
            this.filters.put(name, filter);
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

將filter快取到filters這張map裡，不管是預設註冊的還是自定義的都需要FilterChainManager來統一管理。

  • createChain：建立filterChain並將定義的filter都加進去
    // chainName就是攔截路徑"/resources/**"，chainDefinition就是多個過濾器名的字串
    public void createChain(String chainName, String chainDefinition) {
        if (!StringUtils.hasText(chainName)) {
            throw new NullPointerException("chainName cannot be null or empty.");
        }
        if (!StringUtils.hasText(chainDefinition)) {
            throw new NullPointerException("chainDefinition cannot be null or empty.");
        }

        if (log.isDebugEnabled()) {
            log.debug("Creating chain [" + chainName + "] from String definition [" + chainDefinition + "]");
        }

        // 先分離出配置的各個filter，比如 
        // "authc, roles[admin,user], perms[file:edit]" 分離後的結果是：
        // { "authc", "roles[admin,user]", "perms[file:edit]" }
        String[] filterTokens = splitChainDefinition(chainDefinition);

        // 進一步分離出"[]"內的內容，其中nameConfigPair是一個長度為2的陣列
        // 比如 roles[admin,user] 經過解析後的nameConfigPair 為{"roles", "admin,user"}
        for (String token : filterTokens) {
            String[] nameConfigPair = toNameConfigPair(token);

            // 得到了 攔截路徑、filter以及可能的"[]"中的值，那麼執行addToChain
            addToChain(chainName, nameConfigPair[0], nameConfigPair[1]);
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • addToChain
   public void addToChain(String chainName, String filterName, String chainSpecificFilterConfig) {
        if (!StringUtils.hasText(chainName)) {
            throw new IllegalArgumentException("chainName cannot be null or empty.");
        }
        Filter filter = 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).");
        }

        // 將匹配關係註冊到filter中，後續會提到
        applyChainConfig(chainName, filter, chainSpecificFilterConfig);

        // 確保chain已經被加到filterChains這張map中了
        NamedFilterList chain = ensureChain(chainName);
        // 將該filter加入當前chain
        chain.add(filter);
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

至此，FilterChainManager就建立完了，它無非就是快取了兩張map，沒有什麼邏輯上的操作。下面將FilterChainManager設定到PathMatchingFilterChainResolver中。PathMatchingFilterChainResolver實現了FilterChainResolver介面，該介面中只定義了一個方法：

FilterChain getChain(ServletRequest request, ServletResponse response, FilterChain originalChain);
  • 1
  • 1

通過解析請求來得到一個新的FilterChain。而PathMatchingFilterChainResolver實現了該介面，依靠了FilterChainManager中儲存的chainFilters和filters這兩張map來根據請求路徑解析出相應的filterChain，並且和originalChain組合起來使用。下面具體看看PathMatchingFilterChainResolver中的實現：

   public FilterChain getChain(ServletRequest request, ServletResponse response, FilterChain originalChain) {
        // 得到 FilterChainManager 
        FilterChainManager filterChainManager = getFilterChainManager();
        if (!filterChainManager.hasChains()) {
            return null;
        }

        String requestURI = getPathWithinApplication(request);

        // chainNames就是剛定義的filterChains的keySet，也就是所有的路徑集合(比如：["/resources/**","/login"])
        for (String pathPattern : filterChainManager.getChainNames()) {

            // 請求路徑是否匹配某個 定義好的路徑:
            if (pathMatches(pathPattern, requestURI)) {
                if (log.isTraceEnabled()) {
                    log.trace("Matched path pattern [" + pathPattern + "] for requestURI [" + requestURI + "].  " + "Utilizing corresponding filter chain...");
                }
                // 找到第一個匹配的Filter鏈，那麼就返回一個ProxiedFilterChain
                return filterChainManager.proxy(originalChain, pathPattern);
            }
        }

        return null;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

這裡返回只有兩種情況，要麼是null，要麼就是一個ProxiedFilterChain。返回null並不表示中斷FilterChain，而是隻用originChain。而關於ProxiedFilterChain，它實現了FilterChain，內部維護了兩份FilterChain（其實一個是FilterChain，另一個是List<Filter>）
FilterChain也就是web.xml中註冊的Filter形成的FilterChain，我們稱之為originChain。而另一個List<Filter>則是我們在Shiro中註冊的Filter鏈了，下面看看ProxiedFilterChain中關於doFilter(...)的實現：

 public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
        if (this.filters == null || this.filters.size() == this.index) {
            //we've reached the end of the wrapped chain, so invoke the original one:
            if (log.isTraceEnabled()) {
                log.trace("Invoking original filter chain.");
            }
            this.orig.doFilter(request, response);
        } else {
            if (log.isTraceEnabled()) {
                log.trace("Invoking wrapped filter at index [" + this.index + "]");
            }
            this.filters.get(this.index++).doFilter(request, response, this);
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

可以看到，它會先執行Shiro中執行的filter，然後再執行web.xml中的Filter。不過要注意的是，需要等到originChain執行到ShiroFilter之後才會執行Shiro中的Filter鏈。
至此，兩個元件的建立過程差不多都介紹完了，那麼當這兩個元件建立完畢後，是如何工作的呢？
先從ShiroFilter入手，因為它是總的攔截器，看看其中的doFilterInternal(...)方法：

  protected void doFilterInternal(ServletRequest servletRequest, ServletResponse servletResponse, final FilterChain chain)
            throws ServletException, IOException {

        Throwable t = null;

        try {
            final ServletRequest request = prepareServletRequest(servletRequest, servletResponse, chain);
            final ServletResponse response = prepareServletResponse(request, servletResponse, chain);

            final Subject subject = createSubject(request, response);

            //noinspection unchecked
            subject.execute(new Callable() {
                public Object call() throws Exception {
                    // 其實需要關心的就在這裡
                    // touch一下session
                    updateSessionLastAccessTime(request, response);
                    // 執行Filter鏈
                    executeChain(request, response, chain);
                    return null;
                }
            });
        } catch (ExecutionException ex) {
            t = ex.getCause();
        } catch (Throwable throwable) {
            t = throwable;
        }

        if (t != null) {
            if (t instanceof ServletException) {
                throw (ServletException) t;
            }
            if (t instanceof IOException) {
                throw (IOException) t;
            }
            //otherwise it's not one of the two exceptions expected by the filter method signature - wrap it in one:
            String msg = "Filtered request failed.";
            throw new ServletException(msg, t);
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

跟進executeChain(...)方法：

    protected void executeChain(ServletRequest request, ServletResponse response, FilterChain origChain)
            throws IOException, ServletException {
        FilterChain chain = getExecutionChain(request, response, origChain);
        chain.doFilter(request, response);
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 1
  • 2
  • 3
  • 4
  • 5

如何得到FilterChain的呢？如果你認真的看到這裡，那麼你應該不難想到其中肯定利用了剛才註冊的ChainResolver：

   protected FilterChain getExecutionChain(ServletRequest request, ServletResponse response, FilterChain origChain) {
        FilterChain chain = origChain;

        FilterChainResolver resolver = getFilterChainResolver();
        if (resolver == null) {
            log.debug("No FilterChainResolver configured.  Returning original FilterChain.");
            return origChain;
        }

        FilterChain resolved = resolver.getChain(request, response, origChain);
        if (resolved != null) {
            log.trace("Resolved a configured FilterChain for the current request.");
            chain = resolved;
        } else {
            log.trace("No FilterChain configured for the current request.  Using the default.");
        }

        return chain;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

猜對了~並且也驗證了當resolver.getChain(...)返回null時，直接使用originChain了。然後執行返回的FilterChain的doFilter(...)方法。這個過程我們再脫離程式碼來分析一下：當我們從瀏覽器發出一個請求，究竟發生了什麼？
這裡只站在Filter的層面來分析。伺服器啟動後，讀取web.xml中的filter、filter-mapping節點後組成FilterChain，對請求進行攔截。攔截的順序按照filter節點的定義順序，Shiro利用ShiroFilter來充當一個總的攔截器來分發所有需要被Shiro攔截的請求，所以我們看到在Shiro中我們還可以自定義攔截器。ShiroFilter根據它在攔截器中的位置，只要執行到了那麼就會暫時中斷原FilterChain的執行，先執行Shiro中定義的Filter，最後再執行原FilterChian。可以打個比方，比如說本來有一條鐵鏈，一直螞蟻從鐵鏈的開端往末端爬，其中某一環叫ShiroFilter，那麼當螞蟻爬到ShiroFilter這一環時，將鐵鏈打斷，並且接上另一端鐵鏈（Shiro中自定義的Filter），這樣就構成了一條新的鐵鏈。然後螞蟻繼續爬行（後續的執行過程）。

到這裡，我們已經根據請求路徑找到了一條Filter鏈（originChain + shiroChain），之後就是對鏈上的Filter做doFilter，其中關於如何
就是filter後配置的[]部分是如何生效的，我們可以看PathMatchingFilter中的Prehandle(...)方法：

    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {

        if (this.appliedPaths == null || this.appliedPaths.isEmpty()) {
            if (log.isTraceEnabled()) {
                log.trace("appliedPaths property is null or empty.  This Filter will passthrough immediately.");
            }
            return true;
        }

        // appliedPaths中儲存了該filter中能攔截的路徑和該路徑配置的key-value對，比如{key="/admin/**", value="[admin]"}
        for (String path : this.appliedPaths.keySet()) {
            // 首先是匹配路徑
            if (pathsMatch(path, request)) {
                log.trace("Current requestURI matches pattern '{}'.  Determining filter chain execution...", path);
                // 然後開始驗證“[]”中的字串
                Object config = this.appliedPaths.get(path);
                return isFilterChainContinued(request, response, path, config);
            }
        }

        //no path matched, allow the request to go through:
        return true;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

下面跟蹤isFilterChainContinued(...)：

 private boolean isFilterChainContinued(ServletRequest request, ServletResponse response,
                                           String path, Object pathConfig) throws Exception {

        if (isEnabled(request, response, path, pathConfig)) { //isEnabled check added in 1.2
            if (log.isTraceEnabled()) {
                 // log
            }
            return onPreHandle(request, response, pathConfig);
        }

        if (log.isTraceEnabled()) {
            // log
        }
        return true;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

基本也就是交給onPreHandle(...)來處理，所以一般需要驗證”[]“中字串的filter都會擴充套件這個方法，比如AccessControlFilter：

    public boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
        return isAccessAllowed(request, response, mappedValue) || onAccessDenied(request, response, mappedValue);
    }
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

而RolesAuthorizationFilter中：

    public boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws IOException {

        Subject subject = getSubject(request, response);
        String[] rolesArray = (String[]) mappedValue;

        if (rolesArray == null || rolesArray.length == 0) {
            //no roles specified, so nothing to check - allow access.
            return true;
        }

        Set<String> roles = CollectionUtils.asSet(rolesArray);
        return subject.hasAllRoles(roles);
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

最後附上預設註冊的filters：

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);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

水平有限，寫得蠻不容易，看原始碼加寫花了整整2天。希望對大家能有幫助~

相關推薦

shiroFilter設計原理與實現

本篇文章篇幅比較長，但是細看下去相信對學習Shiro應該會有幫助。好了，閒話不多說，直接進入正題： Shiro提供了與Web整合的支援，其通過一個ShiroFilter入口來攔截需要安全控制的URL，然後進行相應的控制，ShiroFilter類似於如Strut2/SpringMVC這種web框架的前端控制器

線上防雪崩利器——熔斷器設計原理與實現

data 沒有 保障系統 狀態模式 熔斷器 data- 雪崩 form cimage 前言 這是一篇根據工作中遇到的問題總結出的最佳實踐。 上周六，我負責的業務在淩晨00-04點的支付全部失敗了。 結果一查，MD，晚上銀行維護，下遊支付系統沒有掛維護公告，在此期間一直請求維

架構設計 | 線上防雪崩利器—熔斷器設計原理與實現

上週六，我負責的業務在凌晨00-04點的支付全部失敗了。 結果一查，MD，晚上銀行維護，下游支付系統沒有掛維護公告，在此期間一直請求維護中的銀行，當然所有返回就是失敗了，有種欲哭無淚的感覺，鍋讓業務來背。 為了杜絕在此出現這種大面積批量的支付失敗情況發生，保障系

SpringMVC框架設計原理與實現

一、SpringMVC框架是什麼springmvc是一套封裝網路請求的半封裝Servlet框架，是站在巨人肩膀（JDK javax.servlet.*）上做下層類的結構圖：二、Servlet規範開發的時候讀取很多專案原始碼部署--->肯定存在Servlet規範Sprin

HotSpot設計原理與實現：一、初識HotSpot

global 生命周期 類型系統 png 內存 分享圖片 tro bsp http 題註：《揭秘Java虛擬機（JVM設計原理與實現）》和《HotSpot實戰》的讀書筆記一、HotSpot內核模塊組成和功能框架1、HotSpot內核模塊圖

實現求解線性方程（矩陣、高斯消去法）------c++程序設計原理與實踐（進階篇）

ipy 類型 cat sys sca solution gaussian 拷貝 img 步驟： 其中A是一個n*n的系數方陣 向量x和b分別是未知數和常量向量： 這個系統可能有0個、1個或者無窮多個解，這取決於系數矩陣A和向量b。求解線性系統的方法有很多，這裏使用一種經典

Atitit spirngboot 訪問 html檔案總結 自設計web伺服器原理與實現 Url路由壓力，讀取url，獲得專案更路徑絕對路徑，拼接為檔案路徑。讀取文建內容輸出即可 目錄路徑 u

Atitit spirngboot  訪問 html檔案總結 自設計web伺服器原理與實現   Url路由壓力，讀取url，獲得專案更路徑絕對路徑，拼接為檔案路徑。讀取文建內容輸出即可   目錄路徑  upload。Html在專案跟目錄

責任鏈設計模式的原理與實現

基本概念 當一個請求可能需要被多個物件處理時，我們可以將這些處理物件鏈成一條鏈，並在這條鏈上傳遞該請求，直到該請求被處理完畢，這種設計模式就叫做責任鏈設計模式。 原理與實現 場景模擬：                  公司的報銷流程如下：由員工在OA系統填寫報銷申請單，

Lucene 4.X 倒排索引原理與實現: (1) 詞典的設計

詞典的格式設計 詞典中所儲存的資訊主要是三部分： Term字串 Term的統計資訊，比如文件頻率(Document Frequency) 倒排表的位置資訊 其中Term字串如何儲存是一個很大的問題，根據上一章基本原理的表述中，我們知道，寫入檔案的Term是按照字典順序排好序的，那麼如何將這些

Java 線程池的原理與實現

控制 try 所在 使用 urn str waiting media .info 這幾天主要是狂看源程序，在彌補了一些曾經知識空白的同一時候，也學會了不少新的知識（比方 NIO）。或者稱為新技術吧。 線程池就是當中之中的一個，一提到線程。我們會想到曾經《操作系統》的

防盜鏈的基本原理與實現

rec eal limit ole 站點 new exceptio stub text 1． 我的實現防盜鏈的做法，也是參考該位前輩的文章。基本原理就是就是一句話：通過判斷request請求頭的refer是否來源於本站。（當然請求頭是來自於客戶端的，是可偽造的，暫不在本文

最小二乘法多項式曲線擬合原理與實現 zz

博客 del p s 並且 多項式 聯網 python mar 程序 概念 最小二乘法多項式曲線擬合，根據給定的m個點,並不要求這條曲線精確地經過這些點，而是曲線y=f(x)的近似曲線y= φ(x)。 原理 [原理部分由個人根據互聯網上的資料進行總結，希望對大

無限極分類原理與實現（轉）

轉換 完成 外灘 獲得 意思 容易 set 導航 另一個 　　前言 　　無限極分類是我很久前學到知識，今天在做一個項目時，發現對其概念有點模糊，所以今天就來說說無限極分類。 　　首先來說說什麽是無限極分類。按照我的理解，就是對數據完成多次分類，如同一棵樹一樣，從根開始，

編碼原則實例------c++程序設計原理與實踐（進階篇）

組類型 運算 奇怪 head 不能 gui 簡單的 版本 布局 編碼原則： 一般原則 預處理原則 命名和布局原則 類原則 函數和表達式原則 硬實時原則 關鍵系統原則 （硬實時原則、關鍵系統原則僅用於硬實時和關鍵系統程序設計） （嚴格原則都用一個大寫字母R及其編號標識，而

有符號數和無符號數------c++程序設計原理與實踐（進階篇）

效果 進階 str 二進制位 bsp () 都是 有符號 重新 有符號數與無符號數的程序設計原則： 當需要表示數值時，使用有符號數（如 int）。 當需要表示位集合時，使用無符號數（如unsigned int）。 有符號數和無符號數混合運算有可能會帶來災難性的後果。例如

動態內存分配存在的問題（內存空洞）------c++程序設計原理與實踐（進階篇）

我們 程序 動態 height ++ idt 很多 alt 空間 new的問題究竟在哪裏呢？實際上問題出在new和delete的結合使用上。考察下面程序中內存分配和釋放過程： while(1){ Big* p=new big;　　//...... Smal

數值限制------c++程序設計原理與實踐（進階篇）

c++程序 its positive size true 設置 malle 設計原理 硬件 每種c++的實現都在<limits>、<climits>、<limits.h>和<float.h>中指明了內置類型的屬性，因此程序

（c++11）隨機數------c++程序設計原理與實踐（進階篇）

ber linear 而在 希望 double 元素 light eal 區間 　　隨機數既是一個實用工具，也是一個數學問題，它高度復雜，這與它在現實世界中的重要性是相匹配的。在此我們只討論隨機數哦最基本的內容，這些內容可用於簡單的測試和仿真。在<random>

java監聽器的原理與實現

來看 class copyto 圖片 http size stat 順序 方法 監聽器模型涉及以下三個對象，模型圖如下： （1）事件：用戶對組件的一個操作，稱之為一個事件 （2）事件源：發生事件的組件就是事件源 （3）事件監聽器（處理器）：監聽並負責處理事件的方法 執行順序

Redis實現分布式鎖原理與實現分析

數據表 防止 中一 csdn 訂單 not 產生 www 整體 一、關於分布式鎖 關於分布式鎖，可能絕大部分人都會或多或少涉及到。 我舉二個例子： 場景一：從前端界面發起一筆支付請求，如果前端沒有做防重處理，那麽可能在某一個時刻會有二筆一樣的單子同時到達系統後臺。 場