2. 程式人生 > >spring boot 整合shiro

spring boot 整合shiro

阿新 • • 發佈：2019-01-28

本文章參考http://www.vxzsk.com/769.html和http://www.cnblogs.com/ityouknow/p/7089177.html
shiro的使用者認證簡而言之就是對使用者登入進行管理，包括自動校驗使用者名稱和密碼，對密碼進行加密。必須登入成功後才能訪問其他的url，否則跳轉到登入的頁面。比如在沒有登入的情況下訪問http://127.0.0.1:8080/index會自動跳轉到http://127.0.0.1:8080/login頁面。
shiro的許可權控制就是給使用者新增一定的許可權，而每個許可權可以訪問對應的url就行相應的操作。通常每個使用者都有一個或多個角色，而每個角色都有一個或者多個許可權。這樣使用者就和許可權對應起來了。比如：角色為客服的使用者就不能刪除和更改資料，而只可以檢視資料。這些都需要在許可權控制中實現。

Apache Shiro的功能十分強大，使用者認證和許可權控制只是其中的兩個方面。

Apache Shiro 特性

  1. Authentication（認證）：使用者身份識別，通常被稱為使用者“登入”
  2. Authorization（授權）：訪問控制。比如某個使用者是否具有某個操作的使用許可權。
  3. Session Management（會話管理）：特定於使用者的會話管理,甚至在非web 或 EJB 應用程式
  4. Cryptography（加密）：在對資料來源使用加密演算法加密的同時，保證易於使用。

專案結構：

這裡寫圖片描述

pom包依賴：

<?xml version="1.0" encoding="UTF-8"?>
 

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ruying</groupId>
    <artifactId
 
>shiroTest</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>shiroTest</name>
    <description>這是一個shiro測試</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.7</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!--JPA  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--mysql資料庫連線池  -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    <!--shiro安全框架  -->
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-spring</artifactId>
        <version>1.2.2</version>
    </dependency>

    <dependency>
        <groupId>net.sourceforge.nekohtml</groupId>
        <artifactId>nekohtml</artifactId>
        <version>1.9.22</version>
    </dependency>

            <!-- thmleaf模板依賴. -->
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

配置檔案：

spring:
datasource:
url: jdbc:mysql://localhost:3306/study
username: root
password: root
driver-class-name: com.mysql.jdbc.Driver

jpa:
  database: mysql
  show-sql: true
  hibernate:
    ddl-auto: update
    naming:
      strategy: org.hibernate.cfg.DefaultComponentSafeNamingStrategy
  properties:
     hibernate:
        dialect: org.hibernate.dialect.MySQL5Dialect

thymeleaf:
   cache: false
   mode: LEGACYHTML5

thymeleaf的配置是為了去掉html的校驗

頁面：

403.html
error.html
index.html
login.html
userInfo.html
userInfoAdd.html
userInfoDel.html

403.html是使用者沒有授權時展示的頁面，error是springboot預設的錯誤頁面。

RBAC

RBAC 是基於角色的訪問控制（Role-Based Access Control ）在 RBAC 中，許可權與角色相關聯，使用者通過成為適當角色的成員而得到這些角色的許可權。這就極大地簡化了許可權的管理。這樣管理都是層級相互依賴的，許可權賦予給角色，而把角色又賦予使用者，這樣的許可權設計很清楚，管理起來很方便。

對於資料庫，使用jpa自動生成。對應的entity如下：

使用者表

@Entity
public class UserInfo implements Serializable{
    private static final long serialVersionUID = 1L;
    @Id@GeneratedValue
    private long uid;//使用者id;

    @Column(unique=true)
    private String username;//賬號.

    private String name;//名稱（暱稱或者真實姓名，不同系統不同定義）

    private String password; //密碼;
    private String salt;//加密密碼的鹽

    private byte state;//使用者狀態,0:建立未認證（比如沒有啟用，沒有輸入驗證碼等等）--等待驗證的使用者 , 1:正常狀態,2：使用者被鎖定.


    @ManyToMany(fetch=FetchType.EAGER)//立即從資料庫中進行載入資料;
    @JoinTable(name = "SysUserRole", joinColumns = { @JoinColumn(name = "uid") }, inverseJoinColumns ={@JoinColumn(name = "roleId") })
    private List<SysRole> roleList;// 一個使用者具有多個角色

    public List<SysRole> getRoleList() {
       return roleList;
    }

    public void setRoleList(List<SysRole> roleList) {
       this.roleList = roleList;
    }

    public long getUid() {
       return uid;
    }

    public void setUid(long uid) {
       this.uid = uid;
    }

    public String getUsername() {
       return username;
    }

    public void setUsername(String username) {
       this.username = username;
    }

    public String getName() {
       return name;
    }

    public void setName(String name) {
       this.name = name;
    }

    public String getPassword() {
       return password;
    }

    public void setPassword(String password) {
       this.password = password;
    }

    public String getSalt() {
       return salt;
    }

    public void setSalt(String salt) {
       this.salt = salt;
    }

    public byte getState() {
       return state;
    }

    public void setState(byte state) {
       this.state = state;
    }

    /**
     * 密碼鹽.
     * @return
     */
    public String getCredentialsSalt(){
       return this.username+this.salt;
    }

    @Override
    public String toString() {
       return "UserInfo [uid=" + uid + ", username=" + username + ", name=" + name + ", password=" + password
              + ", salt=" + salt + ", state=" + state + "]";
    }
}

角色表

@Entity
public class SysRole implements Serializable{
    private static final long serialVersionUID = 1L;
    @Id@GeneratedValue
    private Long id; // 編號
    private String role; // 角色標識程式中判斷使用,如"admin",這個是唯一的:
    private String description; // 角色描述,UI介面顯示使用
    private Boolean available = Boolean.FALSE; // 是否可用,如果不可用將不會新增給使用者

    //角色 -- 許可權關係：多對多關係;
    @ManyToMany(fetch=FetchType.EAGER)
@JoinTable(name="SysRolePermission",joinColumns={@JoinColumn(name="roleId")},inverseJoinColumns={@JoinColumn(name="permissionId")})
    private List<SysPermission> permissions;

    // 使用者 - 角色關係定義;
    @ManyToMany
@JoinTable(name="SysUserRole",joinColumns={@JoinColumn(name="roleId")},inverseJoinColumns={@JoinColumn(name="uid")})
    private List<UserInfo> userInfos;// 一個角色對應多個使用者

    public List<UserInfo> getUserInfos() {
       return userInfos;
    }
    public void setUserInfos(List<UserInfo> userInfos) {
       this.userInfos = userInfos;
    }
    public Long getId() {
       return id;
    }
    public void setId(Long id) {
       this.id = id;
    }
    public String getRole() {
       return role;
    }
    public void setRole(String role) {
       this.role = role;
    }
    public String getDescription() {
       return description;
    }
    public void setDescription(String description) {
       this.description = description;
    }
    public Boolean getAvailable() {
       return available;
    }
    public void setAvailable(Boolean available) {
       this.available = available;
    }
    public List<SysPermission> getPermissions() {
       return permissions;
    }
    public void setPermissions(List<SysPermission> permissions) {
       this.permissions = permissions;
    }
    @Override
    public String toString() {
       return "SysRole [id=" + id + ", role=" + role + ", description=" + description + ", available=" + available
              + ", permissions=" + permissions + "]";
    }
}

許可權表

@Entity
public class SysPermission implements Serializable{
    private static final long serialVersionUID = 1L;

    @Id@GeneratedValue
    private long id;//主鍵.
    private String name;//名稱.

    @Column(columnDefinition="enum('menu','button')")
    private String resourceType;//資源型別，[menu|button]
    private String url;//資源路徑.
    private String permission; //許可權字串,menu例子：role:*，button例子：role:create,role:update,role:delete,role:view
    private Long parentId; //父編號
    private String parentIds; //父編號列表
    private Boolean available = Boolean.FALSE;

    @ManyToMany
@JoinTable(name="SysRolePermission",joinColumns={@JoinColumn(name="permissionId")},inverseJoinColumns={@JoinColumn(name="roleId")})
    private List<SysRole> roles;

    public long getId() {
       return id;
    }
    public void setId(long id) {
       this.id = id;
    }
    public String getName() {
       return name;
    }
    public void setName(String name) {
       this.name = name;
    }
    public String getResourceType() {
       return resourceType;
    }
    public void setResourceType(String resourceType) {
       this.resourceType = resourceType;
    }
    public String getUrl() {
       return url;
    }
    public void setUrl(String url) {
       this.url = url;
    }
    public String getPermission() {
       return permission;
    }
    public void setPermission(String permission) {
       this.permission = permission;
    }
    public Long getParentId() {
       return parentId;
    }
    public void setParentId(Long parentId) {
       this.parentId = parentId;
    }
    public String getParentIds() {
       return parentIds;
    }
    public void setParentIds(String parentIds) {
       this.parentIds = parentIds;
    }
    public Boolean getAvailable() {
       return available;
    }
    public void setAvailable(Boolean available) {
       this.available = available;
    }
    public List<SysRole> getRoles() {
       return roles;
    }
    public void setRoles(List<SysRole> roles) {
       this.roles = roles;
    }
    @Override
    public String toString() {
       return "SysPermission [id=" + id + ", name=" + name + ", resourceType=" + resourceType + ", url=" + url
              + ", permission=" + permission + ", parentId=" + parentId + ", parentIds=" + parentIds + ", available="
              + available + ", roles=" + roles + "]";
    }

}

啟動springboot後，會根據這些entity建立資料庫中的表。
根據以上的程式碼會自動生成user_info（使用者資訊表）、sys_role（角色表）、sys_permission（許可權表）、sys_user_role（使用者角色表）、sys_role_permission（角色許可權表）這五張表，為了方便測試我們給這五張表插入一些初始化資料：

INSERT INTO `sys_permission` (`id`,`available`,`name`,`parent_id`,`parent_ids`,`permission`,`resource_type`,`url`) VALUES (1,0,'使用者管理',0,'0/','userInfo:view','menu','userInfo/userList');
INSERT INTO `sys_permission` (`id`,`available`,`name`,`parent_id`,`parent_ids`,`permission`,`resource_type`,`url`) VALUES (2,0,'使用者新增',1,'0/1','userInfo:add','button','userInfo/userAdd');
INSERT INTO `sys_permission` (`id`,`available`,`name`,`parent_id`,`parent_ids`,`permission`,`resource_type`,`url`) VALUES (3,0,'使用者刪除',1,'0/1','userInfo:del','button','userInfo/userDel');
INSERT INTO `sys_role` (`id`,`available`,`description`,`role`) VALUES (1,'0','管理員','admin');
INSERT INTO `sys_role` (`id`,`available`,`description`,`role`) VALUES (2,'0','VIP會員','vip');INSERT INTO `sys_role_permission` VALUES ('1', '1');
INSERT INTO `sys_role_permission` (`permission_id`,`role_id`) VALUES (1,1);
INSERT INTO `sys_role_permission` (`permission_id`,`role_id`) VALUES (1,2);
INSERT INTO `sys_role_permission` (`permission_id`,`role_id`) VALUES (1,3);
INSERT INTO `sys_user_role` (`role_id`,`uid`) VALUES (1,1);
INSERT INTO `user_info` (`uid`,`username`,`name`,`password`,`salt`,`state`) VALUES ('1', 'admin', '管理員', 'd3c59d25033dbf980d29554025c23a75', '8d78869f470951332959580424d4bf4f', 0);

Shiro 配置

首先要配置的是ShiroConfig類，Apache Shiro 核心通過 Filter 來實現，就好像SpringMvc 通過DispachServlet 來主控制一樣。
既然是使用 Filter 一般也就能猜到，是通過URL規則來進行過濾和許可權校驗，所以我們需要定義一系列關於URL的規則和訪問許可權。

@Configuration
public class ShiroConfiguration {


    /**
     * ShiroFilterFactoryBean 處理攔截資原始檔問題。
     * 注意：單獨一個ShiroFilterFactoryBean配置是或報錯的，以為在
     * 初始化ShiroFilterFactoryBean的時候需要注入：SecurityManager
     *
        Filter Chain定義說明
       1、一個URL可以配置多個Filter，使用逗號分隔
       2、當設定多個過濾器時，全部驗證通過，才視為通過
       3、部分過濾器可指定引數，如perms，roles
     *
     */
    @Bean
    public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager){
       System.out.println("ShiroConfiguration.shirFilter()");
       ShiroFilterFactoryBean shiroFilterFactoryBean  = new ShiroFilterFactoryBean();

        // 必須設定 SecurityManager 
       shiroFilterFactoryBean.setSecurityManager(securityManager);
       //攔截器.
       Map<String,String> filterChainDefinitionMap = new LinkedHashMap<String,String>();
       //所有的靜態資源都可以匿名訪問
       filterChainDefinitionMap.put("/static/**", "anon");
       //配置退出過濾器,其中的具體的退出程式碼Shiro已經替我們實現了
       filterChainDefinitionMap.put("/logout", "logout");


        // authc:所有url都必須認證通過才可以訪問; anon:所有url都都可以匿名訪問
        //所有的url需要認真後才能發訪問
       filterChainDefinitionMap.put("/**", "authc");

       // 如果不設定預設會自動尋找Web工程根目錄下的"/login.jsp"頁面
        shiroFilterFactoryBean.setLoginUrl("/login");
        // 登入成功後要跳轉的連結
        shiroFilterFactoryBean.setSuccessUrl("/index");
        //未授權介面;（需要額外配置，否則未授權拋異常不會彈出該頁面）
        shiroFilterFactoryBean.setUnauthorizedUrl("/403");

       shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
       return shiroFilterFactoryBean;
    }


    @Bean
    public SecurityManager securityManager(){
       DefaultWebSecurityManager securityManager =  new DefaultWebSecurityManager();
       //設定realm.
       securityManager.setRealm(myShiroRealm());

       return securityManager;
    }

    /**
     * 身份認證realm;
     * (這個需要自己寫，賬號密碼校驗；許可權等)
     * @return
     */
    @Bean
    public MyShiroRealm myShiroRealm(){
       MyShiroRealm myShiroRealm = new MyShiroRealm();
       myShiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());;
       return myShiroRealm;
    }

    /**
     * 憑證匹配器
     * （由於我們的密碼校驗交給Shiro的SimpleAuthenticationInfo進行處理了
     *  所以我們需要修改下doGetAuthenticationInfo中的程式碼;
     * ）
     * @return
     */
    @Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher(){
       HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();

       hashedCredentialsMatcher.setHashAlgorithmName("md5");//雜湊演算法:這裡使用MD5演算法;
       hashedCredentialsMatcher.setHashIterations(2);//雜湊的次數，比如雜湊兩次，相當於 md5(md5(""));

       return hashedCredentialsMatcher;
    }

    /**
     *  開啟shiro aop註解支援.
     *  使用代理方式;所以需要開啟程式碼支援;
     * @param securityManager
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager){
       AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
       authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
       return authorizationAttributeSourceAdvisor;
    }

}

anon:所有url都都可以匿名訪問
authc: 需要認證才能進行訪問
user:配置記住我或認證通過可以訪問

Dao和Service

@Repository
public interface UserInfoRepository extends CrudRepository<UserInfo,Long> {
    /**通過username查詢使用者資訊;*/
    public UserInfo findByUsername(String username);

}
@Service
public class UserInfoServiceImpl implements UserInfoService{

    @Resource
    private UserInfoRepository userInfoRepository;

    @Override
    public UserInfo findByUsername(String username) {
        System.out.println("UserInfoServiceImpl.findByUsername()");
        return userInfoRepository.findByUsername(username);
    }

}

Realm

在認證、授權最終處理都將交給Real進行處理。因為在Shiro中，最終是通過Realm來獲取應用程式中的使用者、角色及許可權資訊的。通常情況下，在Realm中會直接從我們的資料來源中獲取Shiro需要的驗證資訊。可以說，Realm是專用於安全框架的DAO.

認證實現

Shiro的認證過程最終會交由Realm執行，這時會呼叫Realm的getAuthenticationInfo(token)方法。
該方法主要執行以下操作:
1、檢查提交的進行認證的令牌資訊
2、根據令牌資訊從資料來源(通常為資料庫)中獲取使用者資訊
3、對使用者資訊進行匹配驗證。
4、驗證通過將返回一個封裝了使用者資訊的AuthenticationInfo例項。
5、驗證失敗則丟擲AuthenticationException異常資訊。
而在我們的應用程式中要做的就是自定義一個Realm類，繼承AuthorizingRealm抽象類，過載doGetAuthenticationInfo ()，重寫獲取使用者資訊的方法。

授權實現

shiro的許可權授權是通過繼承AuthorizingRealm抽象類，過載doGetAuthorizationInfo();當訪問到頁面的時候，連結配置了相應的許可權或者shiro標籤才會執行此方法否則不會執行，所以如果只是簡單的身份認證沒有許可權的控制的話，那麼這個方法可以不進行實現，直接返回null即可。在這個方法中主要是使用類：SimpleAuthorizationInfo進行角色的新增和許可權的新增。

public class MyShiroRealm extends AuthorizingRealm{
     @Resource
    private UserInfoService userInfoService;

     @Override
     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)
             throws AuthenticationException {
         System.out.println("MyShiroRealm.doGetAuthenticationInfo()");
         //獲取使用者的輸入的賬號.
         String username = (String)token.getPrincipal();
         System.out.println(token.getCredentials());
         //通過username從資料庫中查詢 User物件，如果找到，沒找到.
         //實際專案中，這裡可以根據實際情況做快取，如果不做，Shiro自己也是有時間間隔機制，2分鐘內不會重複執行該方法
         UserInfo userInfo = userInfoService.findByUsername(username);
         System.out.println("----->>userInfo="+userInfo);
         if(userInfo == null){
             return null;
         }
         SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
                 userInfo, //使用者名稱
                 userInfo.getPassword(), //密碼
                 ByteSource.Util.bytes(userInfo.getCredentialsSalt()),//salt=username+salt
                 getName()  //realm name
         );
         return authenticationInfo;
     }

     //給AuthorizationInfo物件新增角色和許可權
     @Override
     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
         System.out.println("許可權配置-->MyShiroRealm.doGetAuthorizationInfo()");
         SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
         //在後臺操作中，可以通過選單等方式給特定使用者授權，然後資料持久化到資料庫。Realm會從資料庫中讀取許可權，判斷使用者的操作
         //是否有對應的許可權。
         UserInfo userInfo  = (UserInfo)principals.getPrimaryPrincipal();
         for(SysRole role:userInfo.getRoleList()){
             authorizationInfo.addRole(role.getRole());
             for(SysPermission p:role.getPermissions()){
                 authorizationInfo.addStringPermission(p.getPermission());
             }
         }
         return authorizationInfo;
     }

}

繼承AuthorizingRealm主要需要實現兩個方法：
doGetAuthenticationInfo();
doGetAuthorizationInfo();
身份認證需要返回SimpleAuthenticationInfo物件，它有兩種構造方式，分別對使用者做不同的處理。

密碼進行加密驗證：

SimpleAuthenticationInfo authenticationInfo =
 new SimpleAuthenticationInfo(
                userInfo, //使用者名稱
                userInfo.getPassword(), //密碼
                ByteSource.Util.bytes(userInfo.getCredentialsSalt()),//salt=username+salt
                getName()  //realm name
        );

使用明文進行驗證：

SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
             userInfo, //使用者名稱
             userInfo.getPassword(), //密碼
             getName()  //realm name
      );

這兩種方式都可可以使用。

至於doGetAuthorizationInfo()是許可權控制，當訪問到頁面的時候，使用了相應的註解或者shiro標籤才會執行此方法否則不會執行，所以如果只是簡單的身份認證沒有許可權的控制的話，那麼這個方法可以不進行實現，直接返回null即可。

在這個方法中主要是使用類：SimpleAuthorizationInfo
進行角色的新增和許可權的新增。
authorizationInfo.addRole(role.getRole());
authorizationInfo.addStringPermission(p.getPermission());

當然也可以新增集合：
authorizationInfo.setRoles(roles);
authorizationInfo.setStringPermissions(stringPermissions);

一般都是通過頁面的選單控制權限，資料持久化後。在doGetAuthorizationInfo（）方法通過user物件得到其角色和許可權資訊。user物件是從資料庫中讀到的。

需要注意的是我們自定義的Realm需要注入到SecurityManager中。

controller

@Controller
public class HomeController {
    // 登入提交地址和applicationontext-shiro.xml配置的loginurl一致。 (配置檔案方式的說法)
    @RequestMapping({"/","/index"})
    public String index(){
        return "/index";
    }

    @RequestMapping(value="/login",method=RequestMethod.GET)
    public String login(){
        return "login";
    }

    @PostMapping(value="/login")
    public String login(HttpServletRequest request, Map<String, Object> map) throws Exception {
       System.err.println("HomeController.login()");
       // 登入失敗從request中獲取shiro處理的異常資訊。
       // shiroLoginFailure:就是shiro異常類的全類名.
       String exception = (String) request.getAttribute("shiroLoginFailure");

       System.out.println("exception=" + exception);
       String msg = "";
       if (exception != null) {
           if (UnknownAccountException.class.getName().equals(exception)) {
              System.out.println("UnknownAccountException -- > 賬號不存在：");
              msg = "UnknownAccountException -- > 賬號不存在：";
           } else if (IncorrectCredentialsException.class.getName().equals(exception)) {
              System.out.println("IncorrectCredentialsException -- > 密碼不正確：");
              msg = "IncorrectCredentialsException -- > 密碼不正確：";
           } else if ("kaptchaValidateFailed".equals(exception)) {
              System.out.println("kaptchaValidateFailed -- > 驗證碼錯誤");
              msg = "kaptchaValidateFailed -- > 驗證碼錯誤";
           } else {
              msg = "else >> "+exception;
              System.out.println("else -- >" + exception);
           }
       }
       map.put("msg", msg);
       // 此方法不處理登入成功,由shiro進行處理.
        return "login";
    }

}
@Controller
@RequestMapping("/userInfo")
public class UserInfoController {

    /**
     * 使用者查詢.如果不設定@RequiresPermissions，那麼所有使用者都可以訪問
     * @return
     */
    @RequestMapping("/userList")
    @RequiresPermissions("userInfo:view")
    public String userInfo(){
       return "userInfo";
    }

    /**
     * 使用者新增;
     * @return
     */
    @RequestMapping("/userAdd")
    @RequiresPermissions("userInfo:add")//許可權管理;
    public String userInfoAdd(){
       return "userInfoAdd";
    }

    /**
     * 使用者刪除;
     * @return
     */
    @RequestMapping("/userDel")
    public String userDel(){
       return "userInfoDel";
    }
}

啟動springboot後，在瀏覽器地址輸入欄輸入http://127.0.0.1:8080/index，會發現頁面並沒有顯示首頁，而是跳到了登入的頁面。因為在ShiroConfiguration，我們設定了所有的url必須經過認證後才能訪問。也就是說必須登入（需要注意的是，註冊的url應該可以保證匿名訪問）。

在使用者認證過程中，如果使用了密文，那麼需要注入HashedCredentialsMatcher。（已經在ShiroConfiguration中實現）
對於許可權控制，還需要開啟shiro aop註解支援。（ShiroConfiguration已經開啟）

對於需要許可權才能訪問的url，需要新增@RequiresPermissions註解。如：

/**
     * 使用者新增;
     * @return
     */
    @RequestMapping("/userAdd")
    @RequiresPermissions("userInfo:add")//新增許可權;
    public String userInfoAdd(){
       return "userInfoAdd";
    }

訪問該url時，使用者必須得有userInfo:add許可權。（shiro通過在資料庫中進行查詢，判斷使用者是否有該許可權。如果給url不新增RequiresPermissions許可權註解，那麼任何型別的使用者都可以訪問）如果沒有則會丟擲異常或者跳到未授權頁面（需要對未授權異常就行捕獲，才能跳到未授權頁面，否則會跳到error頁面）。

shiroFilterFactoryBean.setUnauthorizedUrl("/403");

這句程式碼貌似沒什麼用。如果對異常不進行處理，只會跳到error頁面，而不是設定的403頁面。

未授權跳轉的頁面

如果使用者訪問的url時沒有許可權，那麼會拋異常並且跳到error頁面，這個頁面並不友好。通常我們都自定義未授權頁面。
需要建立一個可以捕獲異常的類，當捕獲到AuthorizationException異常時，跳轉到未授權頁面。

/**
 * 捕獲所有的異常並且進行處理。
 * shiro未授權頁面需要通過捕獲異常來開啟
 * @author liang
 *
 * 2017年9月12日
 */
@ControllerAdvice
class GlobalExceptionHandler {

    public static final String DEFAULT_ERROR_VIEW = "error";

    @ExceptionHandler(value = Exception.class)
    public ModelAndView defaultErrorHandler(HttpServletRequest req, AuthorizationException e) throws Exception {
        ModelAndView mav = new ModelAndView();
        System.err.println("發生異常了");
        mav.setViewName("/403");
        return mav;
    }

}

相關推薦

spring boot整合shiro 簡單許可權控制

package me.config; import javax.annotation.Resource; import me.domain.entity.CmsUser; import me.service.UserService; import me.utils.MD5Util

Spring Boot 整合 Shiro實現許可權控制,親測可用,附帶sql

前提： 本文主要講解Spring Boot 與 Shiro的整合 與許可權控制的實現方式（主要以程式碼實現功能為主），主要用到的技術Spring Boot+Shiro+Jpa（通過Maven構建），並不會涉及到Shiro框架的原始碼分析 如果有想要學習Shiro框架的小夥伴可以去http://shiro.

spring-boot整合shiro

概述 許可權體系在現代任何IT系統中都是很基礎但又非常重要的部分，無論是傳統MIS系統還是網際網路系統，出於保護業務資料和應用自身的安全，都會設計自己的授權鑑權策略。 最近專案中也需要用到許可權驗證功能，專案為spring-boot工程，現成的許可權驗證框架有shiro和spri

Spring Boot整合shiro

shiro面世已經有很長時間了，相比Spring security更加精簡一些，也更容易上手，因此就想分享下這段時間的學習成果，就當是學習筆記了1 pom檔案如下<project xmlns="http://maven.apache.org/POM/4.0.0" xml

spring boot 整合shiro(使用者授權和許可權控制)

(1) pom.xml中新增Shiro依賴 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId>

spring boot整合Shiro實現單點登入

前面的部落格中，我們說道了Shiro的兩個最大的特點，認證和授權，而單點登入也是屬於認證的一部分，預設情況下，Shiro已經為我們實現了和Cas的整合，我們加入整合的一些配置就ok了。 1、加入shiro-cas包 <!-- shiro整合cas單點 -->

Spring Boot整合shiro，出現UnavailableSecurityManagerException 異常

問題描述：由於在java過濾器中通過User token = (User) SecurityUtils.getSubject().getPrincipal();獲取當前的登入使用者的資訊，報UnavailableSecurityManagerException這個異常。spr

spring boot 整合shiro 配置類報錯問題

這裡傳入的是下邊返回的自定義Realm,下邊是報錯，報的是該類不能被裝載，由jdk自己裝載，這裡不是太懂，記錄一下，由於錯誤太長，不好截圖，直接複製錯誤內容 >>>>>>>>>>>>>>&

Spring Boot 整合Shiro給Swagger&Druid放行資源

shiro的過濾器鏈配置： //放行靜態資源 filterChainDefinitionMap.put("/static/**", "anon");

spring boot整合shiro之shiro過濾器介紹

過濾器鏈條配置說明 1、一個URL可以配置多個Filter，使用逗號分隔 2、當設定多個過濾器時，全部驗證通過，才視為通過 3、部分過濾器可指定引數，如perms，roles Shiro內建的FilterChain anon(org.apac

Spring Boot 整合 Shiro 進行登入認證

安全無處不在，趁著放假讀了一下 Shiro 文件，並記錄一下 Shiro 整合 Spring Boot 在資料庫中根據角色控制訪問許可權 簡介 Apache Shiro是一個功能強大、靈活的，開源的安全框架。它可以乾淨利落地處理身份驗證、授權、企業會話管理和

spring boot 整合shiro詳細教程

我們開發時候有時候要把傳統spring shiro轉成spring boot專案，或者直接整合，那麼我們要搞清楚一個知識，就是 xml配置和spring bean程式碼配置的關係，這一點很重要，因為spring boot是沒有xml配置檔案的(也不絕對，spring boot

Spring Boot 整合Shiro攔截Ajax請求

上一篇文章：Spring Boot 整合Shiro實現登陸認證和許可權控制，我們對shiro進行了整合。這一次我們具體來講一下shiro中的攔截器。 Shiro在處理非法請求比如沒有通過登入認證的請求

spring boot 整合shiro,swagger 加入攔截器後 swagger 不能訪問

在shiro的配置檔案中放行swagger： filterMap.put("/swagger-ui.html", "anon"); filterMap.put("/

spring boot 整合shiro的配置

spring boot提供了一個自帶的認證框架，同時也提供自定義的javaconfig配置擴充套件，spring-sercurity同樣也是優秀的框架，但是習慣了用apache shiro框架，而且原專案就是整合的shiro框架，到網上找了一下配置方式，沒找到完

spring boot 整合 shiro

版本說明： spring boot : 1.5.8.RELEASE shiro: 1.4.0 在沒有shiro-spring-boot-web-stater之前，我們通常的做法是把xx-shiro.xml中bean在configuration中定義，或者就是xml中進行定義

Spring Boot 整合Shiro和CAS

請大家在看本文之前，先了解如下知識點： 1、Shiro 是什麼？怎麼用？ 2、Cas 是什麼？怎麼用？ 3、最好有Spring基礎 首先看一下下面這張圖： 第一個流程是單純使用Shiro的流程。 第二個流程是單純使用Cas的流程。 第三個圖是Shiro整合Cas後的流程。 PS：流程圖急急

Spring Boot 整合Shiro和Redis關於@Cacheble註解無效的解決方法

在我做專案的時候，在Spring Boot 中對Shiro和Redis進行了整合，但實際發現Spring boot中Shiro和Redis整合後，Spring的@cacheble註解無效。 出現的情況如下： 如果只是Spring boot和Redis整合，

spring boot 整合shiro

本文章參考http://www.vxzsk.com/769.html和http://www.cnblogs.com/ityouknow/p/7089177.html shiro的使用者認證簡而言之就是對使用者登入進行管理，包括自動校驗使用者名稱和密碼，對密碼進

Spring boot整合shiro使用Ajax方式，最詳細教程

最近一直在自己的個人專案中整合進shiro這個許可權控制框架，踩了不少的坑，sb（允許我這麼叫他把，方便簡潔）整合shiro的教程不少，但是使用ajax方式的還真的不是很多，下面把我自己的經驗分享給大家。 1、在pom中加入shiro的包 <