Springboot整合shiro（及yaml配置形式）

1.shiro是什麼?

Shiro是Apache下的一個開源項目。shiro屬於輕量級框架，相對於SpringSecurity簡單的多，也沒有SpringSecurity那麼複雜。以下是我自己學習之後的記錄。

官方架構圖如下：

2.主要功能

shiro主要有三大功能模塊：

1. Subject：主體，一般指用戶。

2. SecurityManager：安全管理器，管理所有Subject，可以配合內部安全組件。(類似於SpringMVC中的DispatcherServlet)

3. Realms：用於進行權限信息的驗證，一般需要自己實現。

3.細分功能

1. Authentication：身份認證/登錄(賬號密碼驗證)。

2. Authorization：授權，即角色或者權限驗證。

3. Session Manager：會話管理，用戶登錄後的session相關管理。

4. Cryptography：加密，密碼加密等。

5. Web Support：Web支持，集成Web環境。

6. Caching：緩存，用戶信息、角色、權限等緩存到如redis等緩存中。

7. Concurrency：多線程併發驗證，在一個線程中開啓另一個線程，可以把權限自動傳播過去。

8. Testing：測試支持；

9. Run As：允許一個用戶假裝爲另一個用戶（如果他們允許）的身份進行訪問。

10. Remember Me：記住我，登錄後，下次再來的話不用登錄了。

（更多關於shiro是什麼的文字請自行去搜索引擎找，本文主要記錄springboot與shiro的集成）
首先先創建springboot項目，此處不過多描述。

源代碼地址：github

pom.xml文件:

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

User.java(用戶實體類)：

package com.shiro.bean;

import java.util.Set;

public class User {
    private String id;
    private String userName;
    private String password;
    /**
     * 用戶對應的角色集合
     */
    private Set<Role> roles;
    //省略set、get方法等.....
}

Role.java(角色對應實體類)：

package com.shiro.bean;

import java.util.Set;

public class Role {

    private String id;
    private String roleName;
    /**
     * 角色對應權限集合
     */
    private Set<Permissions> permissions;
    //省略set、get方法等.....
}

Permissions.java(權限對應實體類):

public class Permissions {
    private String id;
    private String permissionsName;
    //省略set、get方法等.....
}

LoginServiceImpl.java:

package com.shiro.service.impl;

import com.shiro.bean.Permissions;
import com.shiro.bean.Role;
import com.shiro.bean.User;
import com.shiro.service.LoginService;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

@Service
public class LoginServiceImpl implements LoginService {

    @Override
    public User getUserByName(String getMapByName) {
        //模擬數據庫查詢，正常情況此處是從數據庫或者緩存查詢。
        return getMapByName(getMapByName);
    }

    /**
     * 模擬數據庫查詢
     * @param userName
     * @return
     */
    private User getMapByName(String userName){
        //共添加兩個用戶，兩個用戶都是admin一個角色，
        //wsl有query和add權限，zhangsan只有一個query權限
        Permissions permissions1 = new Permissions("1","query");
        Permissions permissions2 = new Permissions("2","add");
        Set<Permissions> permissionsSet = new HashSet<>();
        permissionsSet.add(permissions1);
        permissionsSet.add(permissions2);
        Role role = new Role("1","admin",permissionsSet);
        Set<Role> roleSet = new HashSet<>();
        roleSet.add(role);
        User user = new User("1","wmh","123456",roleSet);
        Map<String ,User> map = new HashMap<>();
        map.put(user.getUserName(), user);

        Permissions permissions3 = new Permissions("3","query");
        Set<Permissions> permissionsSet1 = new HashSet<>();
        permissionsSet1.add(permissions3);
        Role role1 = new Role("2","user",permissionsSet1);
        Set<Role> roleSet1 = new HashSet<>();
        roleSet1.add(role1);
        User user1 = new User("2","zhangsan","123456",roleSet1);
        map.put(user1.getUserName(), user1);
        return map.get(userName);
    }
}

自定義Realm用於查詢用戶的角色和權限信息並保存到權限管理器：

CustomRealm.java

package com.shiro.realm;

import com.shiro.bean.Permissions;
import com.shiro.bean.Role;
import com.shiro.bean.User;
import com.shiro.service.LoginService;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;

public class CustomRealm extends AuthorizingRealm {

    @Autowired
    private LoginService loginService;

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //獲取登錄用戶名
        String name = (String) principalCollection.getPrimaryPrincipal();
        //根據用戶名去數據庫查詢用戶信息
        User user = loginService.getUserByName(name);
        //添加角色和權限
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        for (Role role : user.getRoles()) {
            //添加角色
            simpleAuthorizationInfo.addRole(role.getRoleName());
            //添加權限
            for (Permissions permissions : role.getPermissions()) {
                simpleAuthorizationInfo.addStringPermission(permissions.getPermissionsName());
            }
        }
        return simpleAuthorizationInfo;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //加這一步的目的是在Post請求的時候會先進認證，然後在到請求
        if (authenticationToken.getPrincipal() == null) {
            return null;
        }
        //獲取用戶信息
        String name = authenticationToken.getPrincipal().toString();
        User user = loginService.getUserByName(name);
        if (user == null) {
            //這裏返回後會報出對應異常
            return null;
        } else {
            //這裏驗證authenticationToken和simpleAuthenticationInfo的信息
            SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(name, user.getPassword(), getName());
            return simpleAuthenticationInfo;
        }
    }
}

把CustomRealm和SecurityManager等加入到spring容器：

ShiroConfig.java:

package com.shiro.config;

import com.shiro.configuration.ShiroProperties;
import com.shiro.realm.CustomRealm;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ShiroConfig {

    //從容器中拿去url配置規則
    @Autowired
    private ShiroProperties shiroProperties;

    @Bean
    @ConditionalOnMissingBean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAAP = new DefaultAdvisorAutoProxyCreator();
        defaultAAP.setProxyTargetClass(true);
        return defaultAAP;
    }

    //將自己的驗證方式加入容器
    @Bean
    public CustomRealm myShiroRealm() {
        CustomRealm customRealm = new CustomRealm();
        return customRealm;
    }

    //權限管理，配置主要是Realm的管理認證
    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(myShiroRealm());
        return securityManager;
    }

    //Filter工廠，設置對應的過濾條件和跳轉條件
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        //以下注釋部分，還可以將配置定義到yaml中
        Map<String, String> map = new HashMap<>();
        //登出
        map.put("/logout", "logout");
        //對所有用戶認證
        map.put("/**", "authc");//authc表示需要認證纔可以訪問,anon表示可以匿名訪問
        //表示可以匿名訪問
        map.put("/index2","anon"); //詳細規則請見本目錄下URL匹配規則.md文件

        //登錄
        shiroFilterFactoryBean.setLoginUrl("/login");
        //首頁
        shiroFilterFactoryBean.setSuccessUrl("/index");
        //錯誤頁面，認證不通過跳轉
        shiroFilterFactoryBean.setUnauthorizedUrl("/error");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;
    }

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }
}

LoginController.java:

package com.shiro.controller;

import com.shiro.bean.User;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.AuthorizationException;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.apache.shiro.subject.Subject;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class LoginController {

    @RequestMapping("/login")
    public String login(User user) {
        //添加用戶認證信息
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(
                user.getUserName(),
                user.getPassword()
        );
        try {
            //進行驗證，這裏可以捕獲異常，然後返回對應信息
            subject.login(usernamePasswordToken);
//            subject.checkRole("admin");
//            subject.checkPermissions("query", "add");
        } catch (AuthorizationException e) {
            e.printStackTrace();
            return "賬號或密碼錯誤！";
        } catch (AuthenticationException e) {
            e.printStackTrace();
            return "沒有權限";
        }
        return "login success";
    }
     //註解驗角色和權限
    @RequiresRoles("admin") //需要admin角色的用戶
    @RequiresPermissions("add")//需要有add權限的方可訪問
    @RequestMapping("/index")
    public String index() {
        return "index!";
    }

    @RequestMapping("/index2")
    public String index2() {
        return "匿名訪問!";
    }
}

註解驗證角色和權限的話無法捕捉異常，從而無法正確的返回給前端錯誤信息，所以我加了一個類用於攔截異常，具體代碼如下

MyExceptionHandler.java

package com.shiro.filter;

import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.AuthorizationException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
@Slf4j
public class MyExceptionHandler {

    @ExceptionHandler
    @ResponseBody
    public String ErrorHandler(AuthorizationException e) {
        log.error("沒有通過權限驗證！", e);
        return "沒有通過權限驗證！";
    }
}

App.java

package com.shiro;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

/**
 * @author: create by wangmh
 * @projectName: Shiro_example
 * @packageName: com.shiro
 * @description:
 * @date: 2019/10/9
 **/
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

打開網頁 http://localhost:8080/login?userName=wmh&password=123456 顯示login success

然後輸入index地址：http://localhost:8080/index 顯示index

index訪問成功

使用zhangsan賬號登錄後再訪問index
http://localhost:8080/login?userName=zhangsan&password=123456
http://localhost:8080/index 顯示無權限

4.URL規則

1.配置url匹配規則時，我們可以將其配置到yaml文件中

創建application.yaml文件

## 通過yaml文件配置url匹配規則
shiro:
  filterChainDefinitionMap:
    /logout: logout
    /**: authc
    /index2: anon

創建配置類ShiroProperties，並將其注入到容器中

package com.shiro.configuration;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.Map;

/**
 * @author: create by wangmh
 * @projectName: Shiro_example   從yaml文件中獲取url匹配規則
 * @packageName: com.shiro.configuration
 * @description:
 * @date: 2019/10/9
 **/
@Data
@Component
@ConfigurationProperties(prefix = "shiro")
public class ShiroProperties {
    private Map<String,String> filterChainDefinitionMap;
}

將ShiroConfig.java中url配置代碼註釋掉，如下：

//      Map<String, String> map = new HashMap<>();
//        //登出
//        map.put("/logout", "logout");
//        //對所有用戶認證
//        map.put("/**", "authc");//authc表示需要認證纔可以訪問,anon表示可以匿名訪問
//        //表示可以匿名訪問
//        map.put("/index2","anon"); //詳細規則請見本目錄下URL匹配規則.md文件

添加，並修改如下：

//添加  
@Autowired
private ShiroProperties shiroProperties;

//修改 shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
shiroFilterFactoryBean.setFilterChainDefinitionMap(shiroProperties.getFilterChainDefinitionMap());

2.url匹配規則

（1）“?”：匹配一個字符，如”/admin?”，將匹配“ /admin1”、“/admin2”，但不匹配“/admin”

（2）“*”：匹配零個或多個字符串，如“/admin*”，將匹配“ /admin”、“/admin123”，但不匹配“/admin/1”

（3）“**”：匹配路徑中的零個或多個路徑，如“/admin/**”，將匹配“/admin/a”、“/admin/a/b”

3.shiro過濾器

（1）anon：匿名過濾器，表示通過了url配置的資源都可以訪問，例：“/statics/**=anon”表示statics目錄下所有資源都能訪問

（2）authc：基於表單的過濾器，表示通過了url配置的資源需要登錄驗證，否則跳轉到登錄，例：“/unauthor.jsp=authc”如果用戶沒有登錄訪問unauthor.jsp則直接跳轉到登錄

（3）authcBasic：Basic的身份驗證過濾器，表示通過了url配置的資源會提示身份驗證，例：“/welcom.jsp=authcBasic”訪問welcom.jsp時會彈出身份驗證框

（4）perms：權限過濾器，表示訪問通過了url配置的資源會檢查相應權限，例：“/statics/**=perms["user:add:*,user:modify:*"]“表示訪問statics目錄下的資源時只有新增和修改的權限

（5）port：端口過濾器，表示會驗證通過了url配置的資源的請求的端口號，例：“/port.jsp=port[8088]”訪問port.jsp時端口號不是8088會提示錯誤

（6）rest：restful類型過濾器，表示會對通過了url配置的資源進行restful風格檢查，例：“/welcom=rest[user:create]”表示通過restful訪問welcom資源時只有新增權限

（7）roles：角色過濾器，表示訪問通過了url配置的資源會檢查是否擁有該角色，例：“/welcom.jsp=roles[admin]”表示訪問welcom.jsp頁面時會檢查是否擁有admin角色

（8）ssl：ssl過濾器，表示通過了url配置的資源只能通過https協議訪問，例：“/welcom.jsp=ssl”表示訪問welcom.jsp頁面如果請求協議不是https會提示錯誤

（9）user：用戶過濾器，表示可以使用登錄驗證/記住我的方式訪問通過了url配置的資源，例：“/welcom.jsp=user”表示訪問welcom.jsp頁面可以通過登錄驗證或使用記住我後訪問，否則直接跳轉到登錄

（10）logout：退出攔截器，表示執行logout方法後，跳轉到通過了url配置的資源，例：“/logout.jsp=logout”表示執行了logout方法後直接跳轉到logout.jsp頁面

4.5、過濾器分類

（1）認證過濾器：anon、authcBasic、auchc、user、logout

（2）授權過濾器：perms、roles、ssl、rest、port