2. 程式人生 > >Shiro原始碼分析----認證流程

Shiro原始碼分析----認證流程

阿新 • • 發佈：2019-01-04
    由於本文是基於原始碼分析Shiro認證流程，所以假設閱讀者對Shiro已經有一定的瞭解，如果對Shiro還不大瞭解的話，推薦一下博文：跟我學Shiro目錄貼


Apache Shiro作為一個優秀的許可權框架，其最重要的兩項工作：其一是認證，即解決登入的使用者的身份是否合法；其二是使用者登入後有什麼樣的許可權。本文將基於Shiro原始碼來剖析Shiro的認證流程，只有深層次的理解Shiro認證流程，認證過程中各個元件的作用，才能在實際應用中靈活使用。由於Shiro一般用於Web環境且會與Spring整合使用，所以此次認證流程的分析的前提也是Web環境且Shiro已與Spring整合。


特別說明：本文使用的Shiro版本：1.2.2。


Shiro與Spring整合時，需要在web.xml中配置Shiro入口過濾器：

<filter>
    <filter-name>shiroFilter</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    <async-supported>true</async-supported>
    <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>

熟悉Spring的人應該都知道DelegatingFilterProxy的作用，該Spring提供的過濾器只起委託作用，執行流程委託給Spring容器中名為shiroFilter的過濾器。所以還需要在Spring配置檔案中配置shiroFilter，如下：
<!-- Shiro的Web過濾器 -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
    <property name="securityManager" ref="securityManager"/>
    <property name="loginUrl" value="/login.jsp"/>
    <property name="unauthorizedUrl" value="/unauthorized.jsp"/>
    <property name="filters">
        <util:map>
            <entry key="authc" value-ref="formAuthenticationFilter"/>
        </util:map>
    </property>
    <property name="filterChainDefinitions">
        <value>
            /index.jsp = anon
            /unauthorized.jsp = anon
            /login.jsp = authc
            /logout = logout
            /authenticated.jsp = authc 
            /** = user
        </value>
    </property>
</bean>

ShiroFilterFactoryBean實現了org.springframework.beans.factory.FactoryBean介面，所以shiroFilter物件是由ShiroFilterFactoryBean的getObject()方法返回的：
public Object getObject() throws Exception {
    if (instance == null) {
        instance = createInstance();
    }
    return instance;
}

protected AbstractShiroFilter createInstance() throws Exception {

    log.debug("Creating Shiro Filter instance.");
	// 獲取配置檔案中設定的安全管理器
    SecurityManager securityManager = getSecurityManager();
    if (securityManager == null) {
        String msg = "SecurityManager property must be set.";
        throw new BeanInitializationException(msg);
    }
	// 必須是Web環境的安全管理器
    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);

    // 返回SpringShiroFilter物件
    return new SpringShiroFilter((WebSecurityManager) securityManager, chainResolver);
}

從上述原始碼中可以看到，最終返回了一個SpringShiroFilter物件，即Spring配置檔案中的shiroFilter物件，該過濾器擁有三個重要物件：SecurityManager、PathMatchingFilterChainResolver、FilterChainManager。


由於在Spring配置中設定了filterChainDefinitions屬性，所以會呼叫setFilterChainDefinitions方法：
public void setFilterChainDefinitions(String definitions) {
    Ini ini = new Ini();
    ini.load(definitions);
    //did they explicitly state a 'urls' section?  Not necessary, but just in case:
    Ini.Section section = ini.getSection(IniFilterChainResolverFactory.URLS);
    if (CollectionUtils.isEmpty(section)) {
        //no urls section.  Since this _is_ a urls chain definition property, just assume the
        //default section contains only the definitions:
        section = ini.getSection(Ini.DEFAULT_SECTION_NAME);
    }
    /** 獲取預設section，也就是載入
    		/index.jsp = anon
            /unauthorized.jsp = anon
            /login.jsp = authc
            /logout = logout
            /authenticated.jsp = authc 
            /** = user
            這段配置，從這段配置中可以知道哪種URL需要應用上哪些Filter，像anon、authc、logout就是Filter的名稱，
            Ini.Section實現了Map介面，其key為URL匹配符，value為Filter名稱
    **/
    // 設定filterChainDefinitionMap
    setFilterChainDefinitionMap(section);
}

FilterChainManager用於管理當前Shiro應用的所有Filter，有Shiro預設使用的Filter，也可以是自定義的Filter。下面我們看看FilterChainManager是如何創建出來的：
protected FilterChainManager createFilterChainManager() {
	// 建立DefaultFilterChainManager
    DefaultFilterChainManager manager = new DefaultFilterChainManager();
    // 建立Shiro預設Filter，根據org.apache.shiro.web.filter.mgt.DefaultFilter建立
    Map<String, Filter> defaultFilters = manager.getFilters();
    //apply global settings if necessary:
    for (Filter filter : defaultFilters.values()) {
    	// 設定相關Filter的loginUrl、successUrl、unauthorizedUrl屬性
        applyGlobalPropertiesIfNecessary(filter);
    }

    // 獲取在Spring配置檔案中配置的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);
            }
            // 將配置的Filter新增至鏈中，如果同名Filter已存在則覆蓋預設Filter
            manager.addFilter(name, filter, false);
        }
    }

    //build up the chains:
    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();
            // 為配置的每一個URL匹配建立FilterChain定義，
            // 這樣當訪問一個URL的時候，一旦該URL配置上則就知道該URL需要應用上哪些Filter
            // 由於URL配置符會配置多個，所以以第一個匹配上的為準，所以越具體的匹配符應該配置在前面，越寬泛的匹配符配置在後面
            manager.createChain(url, chainDefinition);
        }
    }

    return manager;
}

PathMatchingFilterChainResolver物件職責很簡單，就是使用ant路徑匹配方法匹配訪問的URL，由於pathMatchingFilterChainResolver擁有FilterChainManager物件，所以URL匹配上後可以獲取該URL需要應用的FilterChain了。


通過上述分析可以知道，Shiro就是通過一系列的URL匹配符配置URL應該應用上的Filter，然後在Filter中完成相應的任務，所以Shiro的所有功能都是通過Filter完成的。當然認證功能也不例外，在上述配置中認證功能是由org.apache.shiro.web.filter.authc.FormAuthenticationFilter完成的。


下面我們就看看入口過濾器SpringShiroFilter的執行流程，是如何執行到FormAuthenticationFilter的。既然是Filter，那麼最重要的就是doFilter方法了，由於SpringShiroFilter繼承自OncePerRequestFilter，doFilter方法也是在OncePerRequestFilter中定義的：
public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
        throws ServletException, IOException {
    // 用於保證鏈中同一型別的Filter只會被執行一次
    String alreadyFilteredAttributeName = getAlreadyFilteredAttributeName();
    if ( request.getAttribute(alreadyFilteredAttributeName) != null ) {
        log.trace("Filter '{}' already executed.  Proceeding without invoking this filter.", getName());
        filterChain.doFilter(request, response);
    } else //noinspection deprecation
        if (/* added in 1.2: */ !isEnabled(request, response) ||
            /* retain backwards compatibility: */ shouldNotFilter(request) ) {
        log.debug("Filter '{}' is not enabled for the current request.  Proceeding without invoking this filter.",
                getName());
        filterChain.doFilter(request, response);
    } else {
        // Do invoke this filter...
        log.trace("Filter '{}' not yet executed.  Executing now.", getName());
        request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);

        try {
        	// 執行真正的功能程式碼
            doFilterInternal(request, response, filterChain);
        } finally {
            // Once the request has finished, we're done and we don't
            // need to mark as 'already filtered' any more.
            request.removeAttribute(alreadyFilteredAttributeName);
        }
    }
}


doFilterInternal方法定義AbstractShiroFilter中：
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);
		
		// 建立Subject物件，由此可見，每一個請求到來，都會呼叫createSubject方法
        final Subject subject = createSubject(request, response);

        // 通過Subject物件執行過濾器鏈，
        subject.execute(new Callable() {
            public Object call() throws Exception {
            	// 更新會話最後訪問時間，用於計算會話超時
                updateSessionLastAccessTime(request, response);
                // 執行過濾器鏈
                executeChain(request, response, chain);
                return null;
            }
        });
    } catch (ExecutionException ex) {
        t = ex.getCause();
    } catch (Throwable throwable) {
        t = throwable;
    }

    // 省略一些程式碼...
}

先看一下，Subject如果是如何建立的：
protected WebSubject createSubject(ServletRequest request, ServletResponse response) {
    return new WebSubject.Builder(getSecurityManager(), request, response).buildWebSubject();
}

跟蹤程式碼最終呼叫DefaultWebSubjectFactory.createSubject方法：
public Subject createSubject(SubjectContext context) {
    if (!(context instanceof WebSubjectContext)) {
        return super.createSubject(context);
    }
    WebSubjectContext wsc = (WebSubjectContext) context;
    SecurityManager securityManager = wsc.resolveSecurityManager();
    Session session = wsc.resolveSession();
    boolean sessionEnabled = wsc.isSessionCreationEnabled();
    PrincipalCollection principals = wsc.resolvePrincipals();
    // 判斷是已經認證，如果是在沒有登入之前，明顯返回是false
    boolean authenticated = wsc.resolveAuthenticated();
    String host = wsc.resolveHost();
    ServletRequest request = wsc.resolveServletRequest();
    ServletResponse response = wsc.resolveServletResponse();

    return new WebDelegatingSubject(principals, authenticated, host, session, sessionEnabled,
            request, response, securityManager);
}

接下來看看過濾器鏈是如何建立與執行的：
protected void executeChain(ServletRequest request, ServletResponse response, FilterChain origChain)
        throws IOException, ServletException {
    // 獲取當前URL匹配的過濾器鏈
    FilterChain chain = getExecutionChain(request, response, origChain);
    // 執行過濾器鏈中的過濾器
    chain.doFilter(request, response);
}

protected FilterChain getExecutionChain(ServletRequest request, ServletResponse response, FilterChain origChain) {
    FilterChain chain = origChain;
	// 獲取過濾器鏈解析器，即上面建立的PathMatchingFilterChainResolver物件
    FilterChainResolver resolver = getFilterChainResolver();
    if (resolver == null) {
        log.debug("No FilterChainResolver configured.  Returning original FilterChain.");
        return origChain;
    }
	
	// 呼叫其getChain方法，根據URL匹配相應的過濾器鏈
    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;
}

根據上述Spring配置，假設現在第一次訪問URL: "/authenticated.jsp"，則會應用上名為authc的Filter，即FormAuthenticationFilter，根據FormAuthenticationFilter的繼承體系，先執行dviceFilter.doFilterInternal方法：
public void doFilterInternal(ServletRequest request, ServletResponse response, FilterChain chain)
            throws ServletException, IOException {
    Exception exception = null;

    try {
		// 執行preHandle
        boolean continueChain = preHandle(request, response);
        if (log.isTraceEnabled()) {
            log.trace("Invoked preHandle method.  Continuing chain?: [" + continueChain + "]");
        }
		// 如果preHandle返回false則過濾器鏈不再執行
        if (continueChain) {
            executeChain(request, response, chain);
        }

        postHandle(request, response);
        if (log.isTraceEnabled()) {
            log.trace("Successfully invoked postHandle method");
        }

    } catch (Exception e) {
        exception = e;
    } finally {
        cleanup(request, response, exception);
    }
}

接下來執行：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;
    }

    for (String path : this.appliedPaths.keySet()) {
        // 根據配置，訪問URL:"/authenticated.jsp"時，會匹配上FormAuthenticationFilter,
        // 而FormAuthenticationFilter繼承自PathMatchingFilter，所以返回true
        if (pathsMatch(path, request)) {
            log.trace("Current requestURI matches pattern '{}'.  Determining filter chain execution...", path);
            Object config = this.appliedPaths.get(path);
            // 執行isFilterChainContinued方法，該方法呼叫onPreHandle方法
            return isFilterChainContinued(request, response, path, config);
        }
    }

    //no path matched, allow the request to go through:
    return true;
}

接著執行AccessControlFilter.onPreHandle方法：
public boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
	// 如果isAccessAllowed方法返回false，則會執行onAccessDenied方法
    return isAccessAllowed(request, response, mappedValue) || onAccessDenied(request, response, mappedValue);
}

接著執行AuthenticatingFilter.isAccessAllowed方法：
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
    return super.isAccessAllowed(request, response, mappedValue) ||
            (!isLoginRequest(request, response) && isPermissive(mappedValue));
}
super.isAccessAllowed方法，即AuthenticationFilter.isAccessAllowed方法：
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
    Subject subject = getSubject(request, response);
    return subject.isAuthenticated();
}

由以上程式碼可知，由於是第一次訪問URL:"/authenticated.jsp"，所以isAccessAllowed方法返回false，所以接著執行FormAuthenticationFilter.onAccessDenied方法：
protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
	// 第一次訪問自然不是登入請求
    if (isLoginRequest(request, response)) {
    	// 判斷是否是POST請求
        if (isLoginSubmission(request, response)) {
            if (log.isTraceEnabled()) {
                log.trace("Login submission detected.  Attempting to execute login.");
            }
            return executeLogin(request, response);
        } else {
            if (log.isTraceEnabled()) {
                log.trace("Login page view.");
            }
            //allow them to see the login page ;)
            return true;
        }
    } else {
        if (log.isTraceEnabled()) {
            log.trace("Attempting to access a path which requires authentication.  Forwarding to the " +
                    "Authentication url [" + getLoginUrl() + "]");
        }
		// 所以執行該方法
        saveRequestAndRedirectToLogin(request, response);
        return false;
    }
}

protected void saveRequestAndRedirectToLogin(ServletRequest request, ServletResponse response) throws IOException {
	// 將request物件儲存在session中，以便登入成功後重新轉至上次訪問的URL
    saveRequest(request);
    // 重定向至登入頁面，即："/login.jsp"
    redirectToLogin(request, response);
}

根據配置，訪問URL:"/login.jsp"時也會應用上FormAuthenticationFilter，由於是重定向所以發起的是GET請求，所以isLoginSubmission()返回false，所以沒有執行executeLogin方法，所以能夠訪問/login.jsp頁面。在登入表單中應該設定action=""，這樣登入請求會提交至/login.jsp，這時為POST請求，所以會執行executeLogin方法：
protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
	// 根據表單填寫的使用者名稱密碼建立AuthenticationToken
    AuthenticationToken token = createToken(request, response);
    if (token == null) {
        String msg = "createToken method implementation returned null. A valid non-null AuthenticationToken " +
                "must be created in order to execute a login attempt.";
        throw new IllegalStateException(msg);
    }
    try {
    	// 獲取Subject物件
        Subject subject = getSubject(request, response);
        // 執行Subject.login方法進行登入
        subject.login(token);
        // 如果登入成功，重定向至上次訪問的URL
        return onLoginSuccess(token, subject, request, response);
    } catch (AuthenticationException e) {
    	// 如果登入失敗，則設定錯誤資訊至request，並重新返回登入頁面
        return onLoginFailure(token, e, request, response);
    }
}

protected boolean onLoginSuccess(AuthenticationToken token, Subject subject,
                                     ServletRequest request, ServletResponse response) throws Exception {
    // 重定向至上次訪問的URL
    issueSuccessRedirect(request, response);
    // 由於返回false，所以過濾器鏈不再執行
    return false;
}

protected boolean onLoginFailure(AuthenticationToken token, AuthenticationException e,
                                 ServletRequest request, ServletResponse response) {
    // 設定錯誤資訊至request
    setFailureAttribute(request, e);
    // 由於返回true，所以過濾器鏈繼續執行，所以又返回了登入頁面
    return true;
}

至此，認證流程大致流程就是這樣了，限於篇幅，登入的流程具體，請期待下篇博文。

相關推薦

Shiro原始碼分析----認證流程

    由於本文是基於原始碼分析Shiro認證流程，所以假設閱讀者對Shiro已經有一定的瞭解，如果對Shiro還不大瞭解的話，推薦一下博文：跟我學Shiro目錄貼 Apache Shiro作為一個優秀的許可權框架，其最重要的兩項工作：其一是認證，即解決登入的使用者的身份是

Shiro原始碼分析(3) - 認證器(Authenticator)

本文在於分析Shiro原始碼，對於新學習的朋友可以參考 [開濤部落格](http://jinnianshilongnian.iteye.com/blog/2018398)進行學習。 Authenticator就是認證器，在Shiro中負責認證使用者提交的資訊，

Shiro原始碼分析(2) - 會話管理器(SessionManager)

本文在於分析Shiro原始碼，對於新學習的朋友可以參考 [開濤部落格](http://jinnianshilongnian.iteye.com/blog/2018398)進行學習。 本文對Shiro中的SessionManager進行分析，SessionMan

django rest_fremework原始碼之認證流程剖析

1.緒言         上一篇中講了django rest_framework總體流程，整個流程中最關鍵的一步就是執行dispatch方法。在dispatch方法中，在呼叫了一個initial方法，所有的認證、許可權檢查、訪問頻率控制都是在這個方法中進行的。下面程式

shiro原始碼分析之自定義註解RequiredPermission(可代替RequiresPermissions)

1.現象 shiro使用RequiresPermissions等註解必須新增如下切面，否則不生效 @Bean public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(Security

Shiro原始碼分析(1)

簡介 SecurityManager：安全管理器，Shiro最核心元件。Shiro通過SecurityManager來管理內部元件例項，並通過它來提供安全管理的各種服務。 Authenticator：認證器，認證AuthenticationToken是否有

shiro原始碼分析篇5:結合redis實現session跨域

相信大家對session跨域也比較瞭解了。以前單臺伺服器session本地快取就可以了，現在分散式後，session集中管理，那麼用redis來管理是一個非常不錯的選擇。 在結合redis做session快取的時候，也遇到了很多坑，不過還算是解決了。 和上篇講述一樣，實現自定義快

shiro原始碼分析篇4:自定義快取

這篇講解shiro如何管理session，如何與ehcache結合。我們自己如何寫個簡單的快取替換ehcache。 首先來看看配置 <!-- 快取管理器 使用Ehcache實現 --> <bean id="cacheManagerShiro" cla

shiro原始碼分析篇3:使用者登入快取登入資訊

上篇講了shiro是如何過濾請求連結，判斷使用者是否已經登入。 這篇就是講解shiro使用者登入時，如何把登入資訊快取起來，下次使用者登入其他需要登入的連結時，如何判斷已經登入了。 RetryLimitHashedCredentialsMatcher自定義的登入憑據，也就是登入的

shiro原始碼分析篇2:請求過濾，登入判斷

下面是我的配置檔案 spring-shiro.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"

shiro原始碼分析篇1:前言

目的：通過這幾篇shiro原始碼分析，用redis代替ehache做session快取。 相信大家對shiro也不陌生了，網上對shiro原始碼分析的也比較多了。筆者也看多很多優秀的部落格。這幾篇shiro原始碼分析的目的，就是弄明白，shiro是如何管理session的，如何通過r

Tendermint原始碼分析——啟動流程分析

準備引數 cli引數： node --proxy_app=dummy --home "C:\Users\Administrator\datadir\tendermint" Tendermint的cli解析使用cobra庫！ flags vs arg

spring mvc原始碼分析(整個流程)

寫在前面       正本講述了spring mvc整個初始化過程以及應用時請求分發的整個過程。      本文參考了《spring技術內幕》和spring 4.0.5原始碼以及http://jinnianshilongnian.iteye.com/blog/159480

kubernetes元件kubelet之原始碼分析 啟動流程

1.kubelet簡介 kubelet是在每個節點上執行的主要“節點代理”。 kubelet的工作原理是PodSpec。 kubelet採用一組通過各種機制提供的PodSpecs（主要通過apiserver），並確保這些PodSpec中描述的容器執行正常

hbase客戶端原始碼分析--put流程

—client 的呼叫流程 table.put(put); 操作 HTable table = new HTable(conf, Bytes.toBytes(tableName)); 呼叫流程如上面的delete流程一樣 首先建立一個muti的操作物件

fescar 原始碼分析-執行流程

com.alibaba.fescar.spring.annotation.GlobalTransactionalInt

原始碼分析shiro認證授權流程

1. shiro介紹 Apache Shiro是一個強大易用的Java安全框架，提供了認證、授權、加密和會話管理等功能：  認證 - 使用者身份識別，常被稱為使用者“登入”； 授權 - 訪問控制； 密碼加密 - 保護或隱藏資料防止被偷窺； 會話管理 - 每使用者相關的時間敏感的狀態。 對於

shiro認證流程原始碼分析--練氣初期

## 寫在前面 在上一篇文章當中，我們通過一個簡單的例子，簡單地認識了一下shiro。在這篇文章當中，我們將通過閱讀原始碼的方式瞭解shiro的認證流程。 *建議大家邊讀文章邊動手除錯程式碼，這樣效果會更好。* ## 認證異常分析 shiro中的異常主要分為兩類，一類是`AuthenticationE

Django rest framework 的認證流程(原始碼分析一)

一、基本流程舉例: urlpatterns = [ url(r'^admin/', admin.site.urls), url(r'^users/', views.HostView.as_view()), ] urls

spring-security-oauth2(三) 認證流程原始碼分析

認證流程原始碼分析 之前的程式碼中，我們自定義了登陸路徑，自定義成功和失敗處理器以及自定義的使用者登陸資訊校驗，下面我們通過簡單的原始碼分析，來把這些串聯起來 認證流程處理說明 認證結果如何在多個請求之間共享 獲取認證使用者資訊 認證處理流程說明 spring-