shiro源碼篇 - shiro認證與受權，你值得擁有

時間 2019-11-12

標籤 shiro 源碼認證受權值得擁有简体版

原文原文鏈接

前言

　　開心一刻　css

　　　　我和兒子有個共同的心願，出國旅遊。昨天兒子考試得了全班第一，我跟媳婦合計着帶他出國見見世面，吃晚飯的時候，一家人開始了討論這個。我：「兒子，你的心願是什麼？」，兒子：「吃漢堡包」，我：「往大了說」，兒子：「變形金剛」，我：「今天你爹說了算，想一想咱倆共同的心願」，兒子怯生生的瞅了媳婦一眼說：「換個媽？"，我內心咯噔一下：「這虎犢子，坑本身也就算了，怎麼還坑爹呢」。html

牛：小子，你的殺氣過重，我早就看穿一切，吃我一腳！git

　　路漫漫其修遠兮，吾將上下而求索！github

　　github：https://github.com/youzhibingspring

　　碼雲(gitee)：https://gitee.com/youzhibing數據庫

前情回顧與補充

　　回顧

　　　　在上篇博文中，咱們講到了SpringShiroFilter是如何註冊到servlet容器的：SpringShiroFilter首先註冊到spring容器，而後被包裝成FilterRegistrationBean，最後經過FilterRegistrationBean註冊到servlet容器，至此shiro的Filter加入到了servlet容器的FilterChain中。另外還講到了shiro的代理FilterChain：ProxiedFilterChain，請求來到shiro的Filter後，會先通過shiro的Filter鏈，再接着走servlet容器的Filter鏈，以下圖所示編程

　　　　若是請求經PathMatchingFilterChainResolver匹配成功，那麼請求會先通過shiro Filter鏈（ProxiedFilterChain），以後再走剩下的servlet Filter鏈，若是匹配不成功，則直接走剩下的servlet Filter鏈。每一次請求都會通過shiro Filter，shiro Filter來控制filter鏈的走向（有點相似springmvc的DispatcherServlet），先生成ProxiedFilterChain，請求先走ProxiedFilterChain，而後再走接着走servlet filter鏈。緩存

　　　　上圖中，在單獨的shiro工程中，shiro Filter是ShiroFilter，而在與spring的集成工程中則是SpringShiroFilter。安全

　　補充

　　　　shiro的Filter關係圖session

shiro filter關係圖

　　　　　　此關係圖中涉及到了shiro的入口：ShiroFilter或SpringShiroFilter，認證攔截器：FormAuthenticationFilter，沒有涉及受權Filter（PermissionsAuthorizationFilter、RolesAuthorizationFilter），由於shiro的受權咱們通常用的是註解的方式，而不是Filter方式。

　　　　ShiroFilterFactoryBean中的createFilterChainManager()

protected FilterChainManager createFilterChainManager() {

    DefaultFilterChainManager manager = new DefaultFilterChainManager();
    Map<String, Filter> defaultFilters = manager.getFilters();
    //apply global settings if necessary:    應用全局設置
    for (Filter filter : defaultFilters.values()) {
        applyGlobalPropertiesIfNecessary(filter);
    }

    //Apply the acquired and/or configured filters: 應用和配置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);
            }
            //'init' argument is false, since Spring-configured filters should be initialized
            //in Spring (i.e. 'init-method=blah') or implement InitializingBean:
            manager.addFilter(name, filter, false);
        }
    }

    //build up the chains:  構建shiro filter鏈
    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;
}

View Code

　　　　　　一、給shiro默認的filter應用全局配置

//apply global settings if necessary:
for (Filter filter : defaultFilters.values()) {
    applyGlobalPropertiesIfNecessary(filter);
}


private void applyGlobalPropertiesIfNecessary(Filter filter) {
    applyLoginUrlIfNecessary(filter);            // 設置filter的loginUrl
    applySuccessUrlIfNecessary(filter);            // 設置filter的successUrl
    applyUnauthorizedUrlIfNecessary(filter);    // 這個咱們通常沒有配置
}

private void applyLoginUrlIfNecessary(Filter filter) {
    String loginUrl = getLoginUrl();    // shiroFilterFactoryBean.setLoginUrl("/login"); 設置的loginUrl
    if (StringUtils.hasText(loginUrl) && (filter instanceof AccessControlFilter)) {
        AccessControlFilter acFilter = (AccessControlFilter) filter;
        //only apply the login url if they haven't explicitly configured one already:
        String existingLoginUrl = acFilter.getLoginUrl();
        if (AccessControlFilter.DEFAULT_LOGIN_URL.equals(existingLoginUrl)) {
            acFilter.setLoginUrl(loginUrl);
        }
    }
}

private void applySuccessUrlIfNecessary(Filter filter) {
    String successUrl = getSuccessUrl();    // shiroFilterFactoryBean.setSuccessUrl("/index"); 設置的successUrl
    if (StringUtils.hasText(successUrl) && (filter instanceof AuthenticationFilter)) {
        AuthenticationFilter authcFilter = (AuthenticationFilter) filter;
        //only apply the successUrl if they haven't explicitly configured one already:
        String existingSuccessUrl = authcFilter.getSuccessUrl();
        if (AuthenticationFilter.DEFAULT_SUCCESS_URL.equals(existingSuccessUrl)) {
            authcFilter.setSuccessUrl(successUrl);
        }
    }
}

private void applyUnauthorizedUrlIfNecessary(Filter filter) {
    String unauthorizedUrl = getUnauthorizedUrl();
    if (StringUtils.hasText(unauthorizedUrl) && (filter instanceof AuthorizationFilter)) {
        AuthorizationFilter authzFilter = (AuthorizationFilter) filter;
        //only apply the unauthorizedUrl if they haven't explicitly configured one already:
        String existingUnauthorizedUrl = authzFilter.getUnauthorizedUrl();
        if (existingUnauthorizedUrl == null) {
            authzFilter.setUnauthorizedUrl(unauthorizedUrl);
        }
    }
}

View Code

shiro 默認11個filter

　　　　　　　　標紅的的filter的loginUrl和successUrl會被設置成咱們在ShiroFilterFactoryBean配置的，loginUrl會被設置成"/login",successUrl被設置成"index"；這裏咱們須要關注下AnonymousFilter、LogoutFilter和FormAuthenticationFilter，咱們目前只用到了這三個filter。

　　　　　　二、應用和配置咱們在ShiroFilterFactoryBean設置的Filters

　　　　　　　　ShiroFilterFactoryBean類有個setFilters(Map<String,Filter> filters>方法，能夠經過此方法向shiro註冊filter，不過咱們通常沒有用到。

　　　　　　三、構建filter鏈

　　　　　　　　會將ShiroFilterFactoryBean中private Map<String, String> filterChainDefinitionMap的元素逐個放到DefaultFilterChainManager的private Map<String, NamedFilterList> filterChains中，最終filterChains的內容以下

　　　　　　　　咱們配置的filterChainDefinitionMap中涉及到3個Filter，LogoutFilter負責/logout，AnonymousFilter負責（/login,/favicon.ico,/js/**,/css/**,/img/**,/fonts/**），FormAuthenticationFilter負責/**。至此，filter鏈準備工做完成。

認證

　　身份認證，即在應用中誰能證實他就是他本人。認證方式有不少，用的最多的就是用戶名/密碼來證實。shiro中，用戶須要提供pricipals（身份）和credentials（證實）給shiro，從而應用可以驗證用戶身份。一個主體（Subject）能夠有多個principals，但只有一個Primary principals，通常是用戶名/手機號，credentials是一個只有主體知道的安全值，通常是用戶名/數字證書。最多見的principals和credentials組合就是用戶名 / 密碼了。

　　接下來咱們來看看一次完整的請求：未登陸 - 登陸 - 登陸成功。還記得是哪一個filter註冊到了servlet filter鏈嗎？，就是SpringShiroFilter，每次請求都會通過SpringShiroFilter；從shiro filter關係圖中可知，請求確定會通過OncePerRequestFilter的doFilter方法，咱們就今後方法開始

　　未登陸

　　　　url請求：http://localhost:8881/

　　　　那麼此時的url與咱們配置的哪一個filterChainDefinition匹配呢？很顯然是filterChainDefinitionMap.put("/**", "authc")。authc是shiro中默認11個filter中FormAuthenticationFilter的名字，那麼也就是說生成的ProxiedFilterChain以下所示

　　　　也就是請求會先通過FormAuthenticationFilter，以後再回到servlet filter鏈：orig。那咱們接着看請求到FormAuthenticationFilter中後作了些什麼處理（注意看shiro filter關係圖）

　　　　executeChain(request, response, chain)繼續執行filter鏈以前有個preHandle(request, response)處理，來判斷時候須要繼續執行filter鏈。跟進去會來到onPreHandle方法

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

protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
    return super.isAccessAllowed(request, response, mappedValue) ||
            (!isLoginRequest(request, response) && isPermissive(mappedValue));
}

// super.isAccessAllowed判斷時候已經認證過，有個標誌字段:authenticated
// isLoginRequest判斷是不是登陸請求，很顯然不是，登陸請求是/login，目前是/
// isPermissive 沒搞明白，可能應對一些特殊的filter


protected boolean onAccessDenied(ServletRequest request, 
    ServletResponse response, Object mappedValue) throws Exception {
    return onAccessDenied(request, response);
}

protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
    if (isLoginRequest(request, response)) {    // 是不是登陸請求
        if (isLoginSubmission(request, response)) {    // 是不是post請求
            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;    // get方式的登陸請求則繼續執行filter鏈，最終會來到咱們的controller的登陸get請求
        }
    } else {
        if (log.isTraceEnabled()) {
            log.trace("Attempting to access a path which requires authentication.  Forwarding to the " +
                    "Authentication url [" + getLoginUrl() + "]");
        }

        saveRequestAndRedirectToLogin(request, response); // 重定向到/login
        return false;    // 返回false，表示filter鏈不繼續執行了
    }
}

View Code

　　　　最終會重定向到/login，這又是一次新的get請求，會從新將上面的流程走一遍，只是url變成了：http://localhost:8881/login。此時的ProxiedFilterChain以下所示

　　　　請求來到AnonymousFilter以後，onPreHandler直接返回true，接着走剩下的servlet Filter鏈，最終來到咱們的controller

@GetMapping("/login")
public String loginPage() {
    return "login";
}

　　　　將登陸頁返回回去

　　登陸

　　　　url請求：http://localhost:8881/login，請求方式是post

　　　　流程與上面未登陸差很少，此時的ProxiedFilterChain以下所示

　　　　AnonymousFilter的onPreHandler方法直接返回的true，請求會接着走剩下的servlet Filter鏈，最終來到咱們的controller

@PostMapping("/login")
@ResponseBody
public OwnResult dologin(String username, String password) {
    username = username.trim();
    // 判斷當前用戶是否可用
    User user = userService.findUserByUsername(username);
    if(user == null) {
        return OwnResult.build(RespCode.ERROR_USER_NOT_EXIST.getCode(), username + " 用戶不存在");
    }
    if (user.getStatus() == Constants.USER_DISABLED) {
        return OwnResult.build(RespCode.ERROR_USER_DISABLED.getCode(), "帳號已被禁用, 請聯繫管理員");
    }

    UsernamePasswordToken token = new UsernamePasswordToken(username, password);
    Subject subject = SecurityUtils.getSubject();
    try {
        subject.login(token);        // 登陸認證交給shiro
        return OwnResult.ok();
    } catch (AuthenticationException e) {
        return OwnResult.build(RespCode.ERROR_USERNAME_PASSWORD.getCode(), "用戶名或密碼錯誤");
    }
}

View Code

　　　　登陸認證過程委託給了shiro，咱們來看看具體的認證過程

　　　　若是開啓了認證緩存（authenticationCachingEnabled=true），則會先從緩存中獲取authenticationInfo，若沒有則調用咱們自定義Realm的doGetAuthenticationInfo方法獲取數據庫中用戶的信息，並緩存起來；而後將authenticationInfo與登陸頁面輸入的用戶信息（封裝成UsernamePasswordToken）進行匹配驗證。登陸認證失敗會拋出AuthenticationException；登陸成功則會將subject的authenticated設置成true，表示已經認證過了。

　　　　注意：登陸認證沒有徹底交給shiro，而是在咱們的controller中委託給shiro了，這與徹底交由shiro仍是有區別的（具體能夠看下FormAuthenticationFilter的onAccessDenied方法）。

　　登陸成功

　　　　登陸成功後，咱們每每會請求主頁，url請求：http://localhost:8881/index

　　　　流程與上面兩個差很少，此時的ProxiedFilterChain以下所示

　　　　此時authenticated已經爲true，會接着走餘下的servlet Filler鏈，最終請求會來到咱們的controller

@RequestMapping({"/","/index"})
public String index(Model model){

    List<Menu> menus = menuService.listMenu();
    model.addAttribute("menus", menus);
    model.addAttribute("username", getUsername());
    return "index_v1";
}

View Code

　　　　將index_v1.html返回回去

受權

　　受權，也叫訪問控制，即在應用中控制誰能訪問哪些資源（如訪問頁面/編輯數據/頁面操做等）。受權中有幾個須要瞭解的關鍵對象：主體（Subject）、資源（Resource）、權限（Permission）、角色（Role）。主體：即訪問應用的用戶，shiro中使用Subject表明該用戶；資源：應用中用戶能夠訪問的任何東西，好比訪問JSP頁面、查看/編輯某些數據、訪問某個業務方法等；權限：表示在應用中用戶有沒有操做某個資源的權力，能不能訪問某個資源；角色：能夠理解成權限的集合，通常狀況下咱們會賦予用戶角色而不是權限，這樣用戶能夠擁有一組權限，賦予權限時比較方便。

　　shiro支持三種方式的受權

　　　　一、編程式，經過寫if/else受權代碼塊

Subject subject = SecurityUtils.getSubject();
if(subject.hasRole("admin")) {
    // 有權限，執行相關業務
} else {
    // 無權限，給相關提示
}

　　　　二、註解式，經過在執行的Java方法上放置相應的註解完成

@RequiresPermissions("sys:user:user")
public List<User> listUser() {
    // 有權限，獲取數據  
}

　　　　三、JSP/GSP標籤，在JSP/GSP頁面經過相應的標籤完成

<shiro:hasRole name="admin">
    <!-- 有權限 -->
</shiro:hashRole>

　　　　通常而言，編程式基本不用，註解方式比較廣泛，標籤方式用的很少；那麼咱們就來看看註解方式，它是如何實現權限控制的。一看到註解，咱們就要想到aop（動態代理），在目標對象的先後能夠織入加強處理，具體咱們往下看。

　　註解權限控制

　　　　authorizationInfo獲取

　　　　　　執行目標方法前（也就是@RequiresPermissions("xxx")修飾的方法），會先調用assertAuthorized(methodInvocation)進行權限的驗證，分兩步：先獲取authorizationInfo，再進行權限的檢查。上圖展現了authorizationInfo，權限的檢查請往下看。

　　　　　　先從緩存中獲取authorizationInfo，若沒有則調用咱們自定義Realm的doGetAuthorizationInfo方法來獲取authorizationInfo（設置了roles與stringPermissions），並將其放入緩存中，而後返回authorizationInfo；若從緩存中獲取到了authorizationInfo，則直接返回，而不須要經過Realm從數據庫中獲取了。通常狀況下，權限緩存是開啓的：myShiroRealm.setAuthorizationCachingEnabled(true);

　　　　權限檢查

　　　　　　當authorizationInfo獲取到以後，進行來就是須要檢查authorizationInfo中是否含有@RequiresPermissions("xxx")中的xxx了，咱們往下看

　　　　　　能夠看到，檢查過程過程就是將authorizationInfo中的Permission集合組個與xxx進行匹對，一旦匹對成功，則權限檢查經過，流程往下走即執行目標方法（也就是咱們的業務方法），若是一個都沒匹對成功，則會拋出UnauthorizedException異常

　　　　上述講了Permission的方式進行權限的控制，經過Role控制的方式大同小異，有興趣的朋友能夠本身去跟一跟。固然還有其餘的方式，但用的最多的是Permission和Role。

總結

　　一、SpringShiroFilter做用就是生成shiro的代理filter鏈：ProxiedFilterChain，並將請求交給ProxiedFilterChain；

　　二、anon：匿名訪問，不須要認證，通常就是針對遊客能夠訪問的資源；authc：登陸認證；

　　三、咱們全部的請求通常由shiro中3個Filter：LogoutFilter、AnonymousFilter、FormAuthenticationFilter分攤了，LogoutFilter負責/logout，AnonymousFilter負責/login和靜態資源，FormAuthenticationFilter則負責剩下的（/**）;

　　四、未登陸的請求會由FormAuthenticationFilter重定向/login，登陸成功後會將authenticated設置成true，那麼以後的請求會正常走剩下的servlet filter鏈，最終來到咱們的controller；登陸認證過程會先從緩存獲取authenticationInfo，沒有則經過realm從數據庫獲取並放入緩存，而後將頁面輸入的用戶信息UsernamePasswordToken與authenticationInfo進行匹配驗證。我的不建議開啓認證緩存，當修改用戶信息後刷新緩存中的認證信息，很差處理，另外認證頻率原本就不高，緩存的意義不大；

　　五、受權通常採用註解方式，註解每每配合aop來實現目標方法先後的加強織入，shiro的權限註解就是在目標方法前的加強處理。校驗過程與認證過程相似，先從緩存中獲取authorizationInfo，沒有則經過realm從數據庫獲取，而後放入緩存，看authorizationInfo中是否有@RequiresPermissions("xxx")中的xxx來完成權限的驗證。我的建議開啓權限緩存，權限的驗證仍是挺多的，若是不開啓緩存，那麼會給數據庫形成必定的壓力；

　　留個疑問，有興趣的朋友能夠去查看下源碼：假如session過時後，咱們再請求，shiro是如何處理並跳轉到登陸頁的