Spring Boot Shiro權限管理2

時間  2019-11-12
標籤 spring boot shiro 權限 管理 欄目 Spring 简体版
原文   原文鏈接

原文地址：https://412887952-qq-com.iteye.com/blog/2299777 前端

集成shiro大概分這麼一個步驟：java

(a) pom.xml中添加Shiro依賴；
(b) 注入Shiro Factory和SecurityManager。
(c) 身份認證
(d) 權限控制

 

 

(a) pom.xml中添加Shiro依賴；mysql

      要使用Shiro進行權限控制，那麼很明顯的就須要添加對Shiro的依賴包，在pom.xml中加入以下配置：web

 

Xml代碼  
  1. <!-- shiro spring. -->  
  2.        <dependency>  
  3.            <groupId>org.apache.shiro</groupId>  
  4.            <artifactId>shiro-spring</artifactId>  
  5.            <version>1.2.2</version>  
  6.        </dependency>  

 

 

 

(b) 注入Shiro Factory和SecurityManager：
算法

      在Spring中注入類都是使用配置文件的方式，在Spring Boot中是使用註解的方式，那麼應該如何進行實現呢？spring

      咱們在上一節說過，Shiro幾個核心的類，第一就是ShiroFilterFactory,第二就是SecurityManager，那麼最簡單的配置就是注入這兩個類就ok了，那麼如何注入呢？看以下代碼：sql

新建類 com.kfit.config.shiro.ShiroConfiguration：數據庫

 

Java代碼  
  1. package com.kfit.config.shiro;  
  2.    
  3. import java.util.LinkedHashMap;  
  4. import java.util.Map;  
  5.    
  6. import org.apache.shiro.mgt.SecurityManager;  
  7. import org.apache.shiro.spring.web.ShiroFilterFactoryBean;  
  8. import org.apache.shiro.web.mgt.DefaultWebSecurityManager;  
  9. import org.springframework.context.annotation.Bean;  
  10. import org.springframework.context.annotation.Configuration;  
  11.    
  12. /** 
  13.  * Shiro 配置 
  14.  * 
  15. Apache Shiro 核心經過 Filter 來實現，就好像SpringMvc 經過DispachServlet 來主控制同樣。 
  16. 既然是使用 Filter 通常也就能猜到，是經過URL規則來進行過濾和權限校驗，因此咱們須要定義一系列關於URL的規則和訪問權限。 
  17.  * 
  18.  * @author Angel(QQ:412887952) 
  19.  * @version v.0.1 
  20.  */  
  21. @Configuration  
  22. public class ShiroConfiguration {  
  23.         
  24.      
  25.     /** 
  26.      * ShiroFilterFactoryBean 處理攔截資源文件問題。 
  27.      * 注意：單獨一個ShiroFilterFactoryBean配置是或報錯的，覺得在 
  28.      * 初始化ShiroFilterFactoryBean的時候須要注入：SecurityManager 
  29.      * 
  30.         Filter Chain定義說明 
  31.        一、一個URL能夠配置多個Filter，使用逗號分隔 
  32.        二、當設置多個過濾器時，所有驗證經過，才視爲經過 
  33.        三、部分過濾器可指定參數，如perms，roles 
  34.      * 
  35.      */  
  36.     @Bean  
  37.     public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager){  
  38.        System.out.println("ShiroConfiguration.shirFilter()");  
  39.        ShiroFilterFactoryBean shiroFilterFactoryBean  = new ShiroFilterFactoryBean();  
  40.         
  41.         // 必須設置 SecurityManager   
  42.        shiroFilterFactoryBean.setSecurityManager(securityManager);  
  43.         
  44.         
  45.         
  46.        //攔截器.  
  47.        Map<String,String> filterChainDefinitionMap = new LinkedHashMap<String,String>();  
  48.         
  49.        //配置退出過濾器,其中的具體的退出代碼Shiro已經替咱們實現了  
  50.        filterChainDefinitionMap.put("/logout", "logout");  
  51.         
  52.        //<!-- 過濾鏈定義，從上向下順序執行，通常將 /**放在最爲下邊 -->:這是一個坑呢，一不當心代碼就很差使了;  
  53.         //<!-- authc:全部url都必須認證經過才能夠訪問; anon:全部url都均可以匿名訪問-->  
  54.        filterChainDefinitionMap.put("/**", "authc");  
  55.         
  56.        // 若是不設置默認會自動尋找Web工程根目錄下的"/login.jsp"頁面  
  57.         shiroFilterFactoryBean.setLoginUrl("/login");  
  58.         // 登陸成功後要跳轉的連接  
  59.         shiroFilterFactoryBean.setSuccessUrl("/index");  
  60.         //未受權界面;  
  61.         shiroFilterFactoryBean.setUnauthorizedUrl("/403");  
  62.         
  63.        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);  
  64.        returnshiroFilterFactoryBean;  
  65.     }  
  66.      
  67.      
  68.     @Bean  
  69.     public SecurityManager securityManager(){  
  70.        DefaultWebSecurityManager securityManager =  new DefaultWebSecurityManager();  
  71.        return securityManager;  
  72.     }  
  73.      
  74.      
  75.      
  76. }  

 

 

這裏說下：ShiroFilterFactory中已經由Shiro官方實現的過濾器：apache

Shiro內置的FilterChain編程

Filter Name

Class

anon

org.apache.shiro.web.filter.authc.AnonymousFilter

authc

org.apache.shiro.web.filter.authc.FormAuthenticationFilter

authcBasic

org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter

perms

org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter

port

org.apache.shiro.web.filter.authz.PortFilter

rest

org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter

roles

org.apache.shiro.web.filter.authz.RolesAuthorizationFilter

ssl

org.apache.shiro.web.filter.authz.SslFilter

user

org.apache.shiro.web.filter.authc.UserFilter

anon:全部url都均可以匿名訪問;

authc: 須要認證才能進行訪問;

user:配置記住我或認證經過能夠訪問；

這幾個是咱們會用到的，在這裏說明下，其它的請自行查詢文檔進行學習。

這時候咱們運行程序，訪問/index頁面咱們會發現自動跳轉到了login頁面，固然這個時候輸入帳號和密碼是沒法進行訪問的。下面這纔是重點：任何身份認證，如何權限控制。

 

(c) 身份認證

      在認證、受權內部實現機制中都有提到，最終處理都將交給Real進行處理。由於在Shiro中，最終是經過Realm來獲取應用程序中的用戶、角色及權限信息的。一般狀況下，在Realm中會直接從咱們的數據源中獲取Shiro須要的驗證信息。能夠說，Realm是專用於安全框架的DAO.

 

 

認證明現

Shiro的認證過程最終會交由Realm執行，這時會調用Realm的getAuthenticationInfo(token)方法。

該方法主要執行如下操做:

一、檢查提交的進行認證的令牌信息

二、根據令牌信息從數據源(一般爲數據庫)中獲取用戶信息

三、對用戶信息進行匹配驗證。

四、驗證經過將返回一個封裝了用戶信息的AuthenticationInfo實例。

五、驗證失敗則拋出AuthenticationException異常信息。

而在咱們的應用程序中要作的就是自定義一個Realm類，繼承AuthorizingRealm抽象類，重載doGetAuthenticationInfo ()，重寫獲取用戶信息的方法。

 

 

既然須要進行身份權限控制，那麼少不了建立用戶實體類，權限實體類。

      在權限管理系統中，有這麼幾個角色很重要，這個要是不清楚的話，那麼就很難理解，咱們爲何這麼編碼了。第一是用戶表：在用戶表中保存了用戶的基本信息，帳號、密碼、姓名，性別等；第二是：權限表（資源+控制權限）：這個表中主要是保存了用戶的URL地址，權限信息；第三就是角色表：在這個表重要保存了系統存在的角色；第四就是關聯表：用戶-角色管理表（用戶在系統中都有什麼角色，好比admin，vip等），角色-權限關聯表（每一個角色都有什麼權限能夠進行操做）。依據這個理論，咱們進行來進行編碼，很明顯的咱們第一步就是要進行實體類的建立。在這裏咱們使用Mysql和JPA進行操做數據庫。

那麼咱們先在pom.xml中引入mysql和JPA的依賴：

 

Xml代碼  
  1. <!-- Spirng data JPA依賴; -->  
  2. <dependency>  
  3.     <groupId>org.springframework.boot</groupId>  
  4.     <artifactId>spring-boot-starter-data-jpa</artifactId>  
  5. </dependency>  
  6.   
  7. <!-- mysql驅動; -->  
  8. <dependency>  
  9.     <groupId>mysql</groupId>  
  10.     <artifactId>mysql-connector-java</artifactId>  
  11. </dependency>  

 

 

 

配置src/main/resouces/application.properties配置數據庫和jpa(application.properties新建一個便可):

 

Properties代碼  
  1. ########################################################  
  2. ###datasource  
  3. ########################################################  
  4. spring.datasource.url = jdbc:mysql://localhost:3306/test  
  5. spring.datasource.username = root  
  6. spring.datasource.password = root  
  7. spring.datasource.driverClassName = com.mysql.jdbc.Driver  
  8. spring.datasource.max-active=20  
  9. spring.datasource.max-idle=8  
  10. spring.datasource.min-idle=8  
  11. spring.datasource.initial-size=10  
  12.    
  13.    
  14.    
  15. ########################################################  
  16. ### Java Persistence Api  
  17. ########################################################  
  18. # Specify the DBMS  
  19. spring.jpa.database = MYSQL  
  20. # Show or not log for each sql query  
  21. spring.jpa.show-sql = true  
  22. # Hibernate ddl auto (create, create-drop, update)  
  23. spring.jpa.hibernate.ddl-auto = update  
  24. # Naming strategy  
  25. #[org.hibernate.cfg.ImprovedNamingStrategy | org.hibernate.cfg.DefaultNamingStrategy]  
  26. spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.DefaultNamingStrategy  
  27. # stripped before adding them to the entity manager)  
  28. spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect  

 

 

準備工做準備好以後，那麼就能夠編寫實體類了：

UserInfo.java、SysRole.java、SysPermission.java至於以前的關聯表咱們使用JPA進行自動生成。

用戶：com.kfit.core.bean.UserInfo ：

 

Java代碼  
  1. package com.kfit.core.bean;  
  2.    
  3. import java.io.Serializable;  
  4. import java.util.List;  
  5.    
  6. import javax.persistence.Column;  
  7. import javax.persistence.Entity;  
  8. import javax.persistence.FetchType;  
  9. import javax.persistence.GeneratedValue;  
  10. import javax.persistence.Id;  
  11. import javax.persistence.JoinColumn;  
  12. import javax.persistence.JoinTable;  
  13. import javax.persistence.ManyToMany;  
  14.    
  15. /** 
  16.  * 用戶信息. 
  17.  * @author Angel(QQ:412887952) 
  18.  * @version v.0.1 
  19.  */  
  20. @Entity  
  21. public class UserInfo implements Serializable{  
  22.     private static final long serialVersionUID = 1L;  
  23.     @Id@GeneratedValue  
  24.     privatelonguid;//用戶id;  
  25.      
  26.     @Column(unique=true)  
  27.     private String username;//帳號.  
  28.      
  29.     private String name;//名稱（暱稱或者真實姓名，不一樣系統不一樣定義）  
  30.      
  31.     private String password; //密碼;  
  32.     private String salt;//加密密碼的鹽  
  33.      
  34.     private byte state;//用戶狀態,0:建立未認證（好比沒有激活，沒有輸入驗證碼等等）--等待驗證的用戶 , 1:正常狀態,2：用戶被鎖定.  
  35.    
  36.      
  37.     @ManyToMany(fetch=FetchType.EAGER)//當即從數據庫中進行加載數據;  
  38.     @JoinTable(name = "SysUserRole", joinColumns = { @JoinColumn(name = "uid") }, inverseJoinColumns ={@JoinColumn(name = "roleId") })  
  39.     private List<SysRole> roleList;// 一個用戶具備多個角色  
  40.      
  41.     public List<SysRole> getRoleList() {  
  42.        return roleList;  
  43.     }  
  44.    
  45.     public void setRoleList(List<SysRole> roleList) {  
  46.        this.roleList = roleList;  
  47.     }  
  48.    
  49.     public long getUid() {  
  50.        return uid;  
  51.     }  
  52.    
  53.     public void setUid(longuid) {  
  54.        this.uid = uid;  
  55.     }  
  56.    
  57.     public String getUsername() {  
  58.        return username;  
  59.     }  
  60.    
  61.     public void setUsername(String username) {  
  62.        this.username = username;  
  63.     }  
  64.    
  65.     public String getName() {  
  66.        return name;  
  67.     }  
  68.    
  69.     publicvoid setName(String name) {  
  70.        this.name = name;  
  71.     }  
  72.    
  73.     public String getPassword() {  
  74.        return password;  
  75.     }  
  76.    
  77.     public void setPassword(String password) {  
  78.        this.password = password;  
  79.     }  
  80.    
  81.     public String getSalt() {  
  82.        return salt;  
  83.     }  
  84.    
  85.     public void setSalt(String salt) {  
  86.        this.salt = salt;  
  87.     }  
  88.    
  89.     public byte getState() {  
  90.        return state;  
  91.     }  
  92.    
  93.     public void setState(bytestate) {  
  94.        this.state = state;  
  95.     }  
  96.    
  97.     /** 
  98.      * 密碼鹽. 
  99.      * @return 
  100.      */  
  101.     public String getCredentialsSalt(){  
  102.        return this.username+this.salt;  
  103.     }  
  104.    
  105.     @Override  
  106.     public String toString() {  
  107.        return "UserInfo [uid=" + uid + ", username=" + username + ", name=" + name + ", password=" + password  
  108.               + ", salt=" + salt + ", state=" + state + "]";  
  109.     }  
  110.    
  111.      
  112. }  

 

 

在這裏salt主要是用來進行密碼加密的，固然也可使用明文進行編碼測試，實際開發中仍是建議密碼進行加密。

 

getCredentialsSalt()

這個方法從新對鹽從新進行了定義，用戶名+salt，這樣就更加不容易被破解了。

 

角色類 > com.kfit.core.bean.SysRole：

 

Java代碼  
  1. package com.kfit.core.bean;  
  2.    
  3. import java.io.Serializable;  
  4. import java.util.List;  
  5.    
  6. import javax.persistence.Entity;  
  7. import javax.persistence.FetchType;  
  8. import javax.persistence.GeneratedValue;  
  9. import javax.persistence.Id;  
  10. import javax.persistence.JoinColumn;  
  11. import javax.persistence.JoinTable;  
  12. import javax.persistence.ManyToMany;  
  13.    
  14.    
  15. /** 
  16.  * 系統角色實體類; 
  17.  * @author Angel(QQ:412887952) 
  18.  * @version v.0.1 
  19.  */  
  20. @Entity  
  21. public class SysRole implements Serializable{  
  22.     private static final long serialVersionUID = 1L;  
  23.     @Id@GeneratedValue  
  24.     private Long id; // 編號  
  25.     private String role; // 角色標識程序中判斷使用,如"admin",這個是惟一的:  
  26.     private String description; // 角色描述,UI界面顯示使用  
  27.     private Boolean available = Boolean.FALSE; // 是否可用,若是不可用將不會添加給用戶  
  28.      
  29.     //角色 -- 權限關係：多對多關係;  
  30.     @ManyToMany(fetch=FetchType.EAGER)  
  31. @JoinTable(name="SysRolePermission",joinColumns={@JoinColumn(name="roleId")},inverseJoinColumns={@JoinColumn(name="permissionId")})  
  32.     private List<SysPermission> permissions;  
  33.      
  34.     // 用戶 - 角色關係定義;  
  35.     @ManyToMany  
  36. @JoinTable(name="SysUserRole",joinColumns={@JoinColumn(name="roleId")},inverseJoinColumns={@JoinColumn(name="uid")})  
  37.     private List<UserInfo> userInfos;// 一個角色對應多個用戶  
  38.      
  39.     public List<UserInfo> getUserInfos() {  
  40.        return userInfos;  
  41.     }  
  42.     public void setUserInfos(List<UserInfo> userInfos) {  
  43.        this.userInfos = userInfos;  
  44.     }  
  45.     public Long getId() {  
  46.        return id;  
  47.     }  
  48.     publicvoid setId(Long id) {  
  49.        this.id = id;  
  50.     }  
  51.     public String getRole() {  
  52.        return role;  
  53.     }  
  54.     public void setRole(String role) {  
  55.        this.role = role;  
  56.     }  
  57.     public String getDescription() {  
  58.        return description;  
  59.     }  
  60.     public void setDescription(String description) {  
  61.        this.description = description;  
  62.     }  
  63.     public Boolean getAvailable() {  
  64.        return available;  
  65.     }  
  66.     public void setAvailable(Boolean available) {  
  67.        this.available = available;  
  68.     }  
  69.     public List<SysPermission> getPermissions() {  
  70.        return permissions;  
  71.     }  
  72.     public void setPermissions(List<SysPermission> permissions) {  
  73.        this.permissions = permissions;  
  74.     }  
  75.     @Override  
  76.     public String toString() {  
  77.        return "SysRole [id=" + id + ", role=" + role + ", description=" + description + ", available=" + available  
  78.               + ", permissions=" + permissions + "]";  
  79.     }  
  80. }  

 

 

 

權限 > com.kfit.core.bean.SysPermission ：

 

Java代碼  
  1. package com.kfit.core.bean;  
  2.    
  3. import java.io.Serializable;  
  4. import java.util.List;  
  5.    
  6. import javax.persistence.Column;  
  7. import javax.persistence.Entity;  
  8. import javax.persistence.GeneratedValue;  
  9. import javax.persistence.Id;  
  10. import javax.persistence.JoinColumn;  
  11. import javax.persistence.JoinTable;  
  12. import javax.persistence.ManyToMany;  
  13.    
  14. /** 
  15.  * 權限實體類; 
  16.  * @author Angel(QQ:412887952) 
  17.  * @version v.0.1 
  18.  */  
  19. @Entity  
  20. public class SysPermission implements Serializable{  
  21.     private static final long serialVersionUID = 1L;  
  22.      
  23.     @Id@GeneratedValue  
  24.     privatelongid;//主鍵.  
  25.     private String name;//名稱.  
  26.      
  27.     @Column(columnDefinition="enum('menu','button')")  
  28.     private String resourceType;//資源類型，[menu|button]  
  29.     private String url;//資源路徑.  
  30.     private String permission; //權限字符串,menu例子：role:*，button例子：role:create,role:update,role:delete,role:view  
  31.     private Long parentId; //父編號  
  32.     private String parentIds; //父編號列表  
  33.     private Boolean available = Boolean.FALSE;  
  34.      
  35.     @ManyToMany  
  36. @JoinTable(name="SysRolePermission",joinColumns={@JoinColumn(name="permissionId")},inverseJoinColumns={@JoinColumn(name="roleId")})  
  37.     private List<SysRole> roles;  
  38.      
  39.     public long getId() {  
  40.        return id;  
  41.     }  
  42.     public void setId(longid) {  
  43.        this.id = id;  
  44.     }  
  45.     public String getName() {  
  46.        return name;  
  47.     }  
  48.     publicvoid setName(String name) {  
  49.        this.name = name;  
  50.     }  
  51.     public String getResourceType() {  
  52.        return resourceType;  
  53.     }  
  54.     public void setResourceType(String resourceType) {  
  55.        this.resourceType = resourceType;  
  56.     }  
  57.     public String getUrl() {  
  58.        return url;  
  59.     }  
  60.     public void setUrl(String url) {  
  61.        this.url = url;  
  62.     }  
  63.     public String getPermission() {  
  64.        return permission;  
  65.     }  
  66.     public void setPermission(String permission) {  
  67.        this.permission = permission;  
  68.     }  
  69.     public Long getParentId() {  
  70.        return parentId;  
  71.     }  
  72.     public void setParentId(Long parentId) {  
  73.        this.parentId = parentId;  
  74.     }  
  75.     public String getParentIds() {  
  76.        return parentIds;  
  77.     }  
  78.     public void setParentIds(String parentIds) {  
  79.        this.parentIds = parentIds;  
  80.     }  
  81.     public Boolean getAvailable() {  
  82.        return available;  
  83.     }  
  84.     public void setAvailable(Boolean available) {  
  85.        this.available = available;  
  86.     }  
  87.     public List<SysRole> getRoles() {  
  88.        return roles;  
  89.     }  
  90.     publicvoid setRoles(List<SysRole> roles) {  
  91.        this.roles = roles;  
  92.     }  
  93.     @Override  
  94.     public String toString() {  
  95.        return "SysPermission [id=" + id + ", name=" + name + ", resourceType=" + resourceType + ", url=" + url  
  96.               + ", permission=" + permission + ", parentId=" + parentId + ", parentIds=" + parentIds + ", available="  
  97.               + available + ", roles=" + roles + "]";  
  98.     }  
  99.      
  100. }  

 

 

ok，到這裏實體類就編碼完畢了，在這裏咱們看到的是3個實體類，UserInfo,SysRole,SysPermission,對應的是數據庫的五張表：

1表UserInfo、2表SysUserRole、3表SysRole、4表SysRolePermission、5表SysPermission

這時候運行程序，就會自動建表，而後咱們添加一些數據：

 

Sql代碼  
  1. INSERT INTO `SysPermission` VALUES ('1', '1', '用戶管理', '0', '0/', 'userInfo:view', 'menu', 'userInfo/userList');  
  2. INSERT INTO `SysPermission` VALUES ('2', '1', '用戶添加', '1', '0/1', 'userInfo:add', 'button', 'userInfo/userAdd');  
  3. INSERT INTO `SysPermission` VALUES ('3', '1', '用戶刪除', '1', '0/1', 'userInfo:del', 'button', 'userInfo/userDel');  

 

 

 

 

Sql代碼  
  1. INSERT INTO `SysRole` VALUES ('1', '1', '管理員', 'admin');  
  2. INSERT INTO `SysRole` VALUES ('2', '1', 'VIP會員', 'vip');  

 

 

 

 

Sql代碼  
  1. INSERT INTO `SysRolePermission` VALUES ('1', '1');  
  2. INSERT INTO `SysRolePermission` VALUES ('1', '2');  

 

 

 

 

 

Sql代碼  
  1. INSERT INTO `SysUserRole` VALUES ('1', '1');  
  2. INSERT INTO `SysUserRole` VALUES ('1', '2');  

 

 

 

 

Sql代碼  
  1. INSERT INTO `UserInfo` VALUES ('1', '管理員', 'admin', 'd3c59d25033dbf980d29554025c23a75', '8d78869f470951332959580424d4bf4f', '0');  

  

 

 

這時候數據都準備完畢了，那麼接下來就應該編寫Repository進行訪問數據了（在下載源碼中有shiro.sql文件，可自行導入使用便可）。

com.kfit.core.repository.UserInfoRepository ：

 

Java代碼  
  1. package com.kfit.core.repository;  
  2.    
  3. import org.springframework.data.repository.CrudRepository;  
  4.    
  5. import com.kfit.core.bean.UserInfo;  
  6.    
  7. /** 
  8.  * UserInfo持久化類; 
  9.  * @author Angel(QQ:412887952) 
  10.  * @version v.0.1 
  11.  */  
  12. public interface UserInfoRepository extends CrudRepository<UserInfo,Long>{  
  13.      
  14.     /**經過username查找用戶信息;*/  
  15.     public UserInfo findByUsername(String username);  
  16.      
  17. }  

 

 

      在這裏你會發現咱們只編寫了UserInfo的數據庫操做，那麼咱們怎麼獲取咱們的權限信息了，經過userInfo.getRoleList()能夠獲取到對應的角色信息，而後在經過對應的角色能夠獲取到權限信息，固然這些都是JPA幫咱們實現了，咱們也能夠進行直接獲取到權限信息，只要寫一個關聯查詢而後過濾掉重複的權限便可，這裏不進行實現。

編寫一個業務處理類UserInfoService>

 

com.kfit.core.service.UserInfoService :

 

Java代碼  
  1. package com.kfit.core.service;  
  2.    
  3. import com.kfit.core.bean.UserInfo;  
  4.    
  5. public interface UserInfoService {  
  6.      
  7.     /**經過username查找用戶信息;*/  
  8.     public UserInfo findByUsername(String username);  
  9.      
  10. }  

 

 

 

com.kfit.core.service.impl.UserInfoServiceImpl :

 

Java代碼  
  1. package com.kfit.core.service.impl;  
  2.    
  3. import javax.annotation.Resource;  
  4.    
  5. import org.springframework.stereotype.Service;  
  6.    
  7. import com.kfit.core.bean.UserInfo;  
  8. import com.kfit.core.repository.UserInfoRepository;  
  9. import com.kfit.core.service.UserInfoService;  
  10.    
  11. @Service  
  12. public class UserInfoServiceImpl implements UserInfoService{  
  13.      
  14.     @Resource  
  15.     private UserInfoRepository userInfoRepository;  
  16.      
  17.     @Override  
  18.     public UserInfo findByUsername(String username) {  
  19.        System.out.println("UserInfoServiceImpl.findByUsername()");  
  20.        return userInfoRepository.findByUsername(username);  
  21.     }  
  22.      
  23. }  

 

 

這裏主要是爲了知足MVC編程模式，在例子中直接訪問DAO層也何嘗不可，實際開發中建議仍是遵循MVC開發模式，至於有什麼好處，請自行百度MVC。

      好了以上都是爲了實現身份認證，權限控制的準備工做，想必你們看了也有點困惑了，堅持住，這個技術點不是每一個人都能進行編碼的，你會發如今一個公司裏都是技術領導幫你實現了這一部分很複雜的編碼，你只須要經過界面進行配置而已，因此嘛，要作一個技術領導這一部分不掌握好像還不行了。好了，說重點吧，基本工做準備好以後，剩下的纔是重點，shiro的認證最終是交給了Realm進行執行了，因此咱們須要本身從新實現一個Realm，此Realm繼承AuthorizingRealm。

com.kfit.config.shiro.MyShiroRealm ：

 

Java代碼  
  1. package com.kfit.config.shiro;  
  2.    
  3. import javax.annotation.Resource;  
  4.    
  5. import org.apache.shiro.authc.AuthenticationException;  
  6. import org.apache.shiro.authc.AuthenticationInfo;  
  7. import org.apache.shiro.authc.AuthenticationToken;  
  8. import org.apache.shiro.authc.SimpleAuthenticationInfo;  
  9. import org.apache.shiro.authc.UsernamePasswordToken;  
  10. import org.apache.shiro.authz.AuthorizationInfo;  
  11. import org.apache.shiro.authz.SimpleAuthorizationInfo;  
  12. import org.apache.shiro.realm.AuthorizingRealm;  
  13. import org.apache.shiro.subject.PrincipalCollection;  
  14. import org.apache.shiro.util.ByteSource;  
  15.    
  16. import com.kfit.core.bean.SysPermission;  
  17. import com.kfit.core.bean.SysRole;  
  18. import com.kfit.core.bean.UserInfo;  
  19. import com.kfit.core.service.UserInfoService;  
  20.    
  21. /** 
  22.  *  身份校驗覈心類; 
  23.  * @author Angel(QQ:412887952) 
  24.  * @version v.0.1 
  25.  */  
  26. public class MyShiroRealm extends AuthorizingRealm{  
  27.    
  28.          
  29.     @Resource  
  30.     private UserInfoService userInfoService;  
  31.      
  32.     /** 
  33.      * 認證信息.(身份驗證) 
  34.      * : 
  35.      * Authentication 是用來驗證用戶身份 
  36.      * @param token 
  37.      * @return 
  38.      * @throws AuthenticationException 
  39.      */  
  40.     @Override  
  41.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
  42.        System.out.println("MyShiroRealm.doGetAuthenticationInfo()");  
  43.         
  44.         
  45.        //獲取用戶的輸入的帳號.  
  46.        String username = (String)token.getPrincipal();  
  47.        System.out.println(token.getCredentials());  
  48.         
  49.        //經過username從數據庫中查找 User對象，若是找到，沒找到.  
  50.        //實際項目中，這裏能夠根據實際狀況作緩存，若是不作，Shiro本身也是有時間間隔機制，2分鐘內不會重複執行該方法  
  51.        UserInfo userInfo = userInfoService.findByUsername(username);  
  52.        System.out.println("----->>userInfo="+userInfo);  
  53.        if(userInfo == null){  
  54.            return null;  
  55.        }  
  56.         
  57.        /* 
  58.         * 獲取權限信息:這裏沒有進行實現， 
  59.         * 請自行根據UserInfo,Role,Permission進行實現； 
  60.         * 獲取以後能夠在前端for循環顯示全部連接; 
  61.         */  
  62.        //userInfo.setPermissions(userService.findPermissions(user));  
  63.         
  64.         
  65.        //帳號判斷;  
  66.         
  67.        //加密方式;  
  68.        //交給AuthenticatingRealm使用CredentialsMatcher進行密碼匹配，若是以爲人家的很差能夠自定義實現  
  69.        SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(  
  70.               userInfo, //用戶名  
  71.               userInfo.getPassword(), //密碼  
  72.                 ByteSource.Util.bytes(userInfo.getCredentialsSalt()),//salt=username+salt  
  73.                 getName()  //realm name  
  74.         );  
  75.         
  76.         //明文: 若存在，將此用戶存放到登陸認證info中，無需本身作密碼對比，Shiro會爲咱們進行密碼對比校驗  
  77. //      SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(  
  78. //           userInfo, //用戶名  
  79. //           userInfo.getPassword(), //密碼  
  80. //             getName()  //realm name  
  81. //      );  
  82.         
  83.        return authenticationInfo;  
  84.     }  
  85.      
  86.      
  87.      
  88.     /** 
  89.      * 此方法調用  hasRole,hasPermission的時候纔會進行回調. 
  90.      * 
  91.      * 權限信息.(受權): 
  92.      * 一、若是用戶正常退出，緩存自動清空； 
  93.      * 二、若是用戶非正常退出，緩存自動清空； 
  94.      * 三、若是咱們修改了用戶的權限，而用戶不退出系統，修改的權限沒法當即生效。 
  95.      * （須要手動編程進行實現；放在service進行調用） 
  96.      * 在權限修改後調用realm中的方法，realm已經由spring管理，因此從spring中獲取realm實例， 
  97.      * 調用clearCached方法； 
  98.      * :Authorization 是受權訪問控制，用於對用戶進行的操做受權，證實該用戶是否容許進行當前操做，如訪問某個連接，某個資源文件等。 
  99.      * @param principals 
  100.      * @return 
  101.      */  
  102.     @Override  
  103.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
  104.        /* 
  105.         * 當沒有使用緩存的時候，不斷刷新頁面的話，這個代碼會不斷執行， 
  106.         * 當其實沒有必要每次都從新設置權限信息，因此咱們須要放到緩存中進行管理； 
  107.         * 當放到緩存中時，這樣的話，doGetAuthorizationInfo就只會執行一次了， 
  108.         * 緩存過時以後會再次執行。 
  109.         */  
  110.        System.out.println("權限配置-->MyShiroRealm.doGetAuthorizationInfo()");  
  111.         
  112.        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();  
  113.        UserInfo userInfo  = (UserInfo)principals.getPrimaryPrincipal();  
  114.         
  115.        //實際項目中，這裏能夠根據實際狀況作緩存，若是不作，Shiro本身也是有時間間隔機制，2分鐘內不會重複執行該方法  
  116. //     UserInfo userInfo = userInfoService.findByUsername(username)  
  117.         
  118.         
  119.        //權限單個添加;  
  120.        // 或者按下面這樣添加  
  121.         //添加一個角色,不是配置意義上的添加,而是證實該用戶擁有admin角色     
  122. //     authorizationInfo.addRole("admin");   
  123.         //添加權限   
  124. //     authorizationInfo.addStringPermission("userInfo:query");  
  125.         
  126.         
  127.         
  128.        ///在認證成功以後返回.  
  129.        //設置角色信息.  
  130.        //支持 Set集合,  
  131.        //用戶的角色對應的全部權限，若是隻使用角色定義訪問權限，下面的四行能夠不要  
  132. //        List<Role> roleList=user.getRoleList();  
  133. //        for (Role role : roleList) {  
  134. //            info.addStringPermissions(role.getPermissionsName());  
  135. //        }  
  136.        for(SysRole role:userInfo.getRoleList()){  
  137.            authorizationInfo.addRole(role.getRole());  
  138.            for(SysPermission p:role.getPermissions()){  
  139.               authorizationInfo.addStringPermission(p.getPermission());  
  140.            }  
  141.        }  
  142.         
  143.        //設置權限信息.  
  144. //     authorizationInfo.setStringPermissions(getStringPermissions(userInfo.getRoleList()));  
  145.         
  146.        return authorizationInfo;  
  147.     }  
  148.      
  149.      
  150.     /** 
  151.      * 將權限對象中的權限code取出. 
  152.      * @param permissions 
  153.      * @return 
  154.      */  
  155. //  public Set<String> getStringPermissions(Set<SysPermission> permissions){  
  156. //     Set<String> stringPermissions = new HashSet<String>();  
  157. //     if(permissions != null){  
  158. //         for(SysPermission p : permissions) {  
  159. //            stringPermissions.add(p.getPermission());  
  160. //          }  
  161. //     }  
  162. //       return stringPermissions;  
  163. //  }  
  164.      
  165. }  

 

 

繼承AuthorizingRealm主要須要實現兩個方法：

 

 

doGetAuthenticationInfo();

doGetAuthorizationInfo();

其中doGetAuthenticationInfo主要是用來進行身份認證的，也就是說驗證用戶輸入的帳號和密碼是否正確。

 

 

Java代碼  
  1. SimpleAuthenticationInfoauthenticationInfo =  
  2.  new SimpleAuthenticationInfo(  
  3.                 userInfo, //用戶名  
  4.                 userInfo.getPassword(), //密碼  
  5.                 ByteSource.Util.bytes(userInfo.getCredentialsSalt()),//salt=username+salt  
  6.                 getName()  //realm name  
  7.         );  

 

 

交給AuthenticatingRealm使用CredentialsMatcher進行密碼匹配，若是以爲人家的很差能夠自定義實現

      若是你是進行明文進行編碼的話，那麼使用使用以下方式：

 

Java代碼  
  1. SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(  
  2.             userInfo, //用戶名  
  3.             userInfo.getPassword(), //密碼  
  4.             getName()  //realm name  
  5.      );  

 

 

 

至於doGetAuthorizationInfo()是權限控制，當訪問到頁面的時候，使用了相應的註解或者shiro標籤纔會執行此方法不然不會執行，因此若是隻是簡單的身份認證沒有權限的控制的話，那麼這個方法能夠不進行實現，直接返回null便可。

在這個方法中主要是使用類：SimpleAuthorizationInfo

進行角色的添加和權限的添加。

authorizationInfo.addRole(role.getRole());

authorizationInfo.addStringPermission(p.getPermission());

固然也能夠添加集合：

authorizationInfo.setRoles(roles);

authorizationInfo.setStringPermissions(stringPermissions);

 

到這裏咱們還須要有一個步驟很重要就是將咱們自定義的Realm注入到SecurityManager中。

在com.kfit.config.shiro.ShiroConfiguration中添加方法：

 

Java代碼  
  1. /** 
  2.      * 身份認證realm; 
  3.      * (這個須要本身寫，帳號密碼校驗；權限等) 
  4.      * @return 
  5.      */  
  6.     @Bean  
  7.     public MyShiroRealm myShiroRealm(){  
  8.        MyShiroRealm myShiroRealm = new MyShiroRealm();  
  9.        return myShiroRealm;  
  10.     }  

 

 

將myShiroRealm注入到securityManager中：

 

Java代碼  
  1. @Bean  
  2.     public SecurityManager securityManager(){  
  3.        DefaultWebSecurityManager securityManager =  new DefaultWebSecurityManager();  
  4.        //設置realm.  
  5.        securityManager.setRealm(myShiroRealm());  
  6.        return securityManager;  
  7.     }  

 

 

 

到這裏的話身份認證權限控制基本是完成了，最後咱們在編寫一個登陸的時候，登陸的處理：

在com.kfit.root.controller.HomeController中添加login post處理：

 

Java代碼  
  1. // 登陸提交地址和applicationontext-shiro.xml配置的loginurl一致。 (配置文件方式的說法)  
  2.     @RequestMapping(value="/login",method=RequestMethod.POST)  
  3.     public String login(HttpServletRequest request, Map<String, Object> map) throws Exception {  
  4.        System.out.println("HomeController.login()");  
  5.        // 登陸失敗從request中獲取shiro處理的異常信息。  
  6.        // shiroLoginFailure:就是shiro異常類的全類名.  
  7.        String exception = (String) request.getAttribute("shiroLoginFailure");  
  8.    
  9.        System.out.println("exception=" + exception);  
  10.        String msg = "";  
  11.        if (exception != null) {  
  12.            if (UnknownAccountException.class.getName().equals(exception)) {  
  13.               System.out.println("UnknownAccountException -- > 帳號不存在：");  
  14.               msg = "UnknownAccountException -- > 帳號不存在：";  
  15.            } elseif (IncorrectCredentialsException.class.getName().equals(exception)) {  
  16.               System.out.println("IncorrectCredentialsException -- > 密碼不正確：");  
  17.               msg = "IncorrectCredentialsException -- > 密碼不正確：";  
  18.            } elseif ("kaptchaValidateFailed".equals(exception)) {  
  19.               System.out.println("kaptchaValidateFailed -- > 驗證碼錯誤");  
  20.               msg = "kaptchaValidateFailed -- > 驗證碼錯誤";  
  21.            } else {  
  22.               msg = "else >> "+exception;  
  23.               System.out.println("else -- >" + exception);  
  24.            }  
  25.        }  
  26.        map.put("msg", msg);  
  27.        // 此方法不處理登陸成功,由shiro進行處理.  
  28.        return "/login";  
  29.     }  

 

 

 

這時候咱們啓動應用程序，訪問http://127.0.0.1:8080/index

會自動跳轉到http://127.0.0.1:8080/login 界面，而後輸入帳號和密碼：admin/123456,這時候會提示：IncorrectCredentialsException -- > 密碼不正確。

這主要是由於咱們在上面進行了密文的方式，那麼怎麼加密方式，咱們並無告訴Shiro，因此認證失敗了。

在這裏咱們須要編寫一個加密算法類，固然Shiro也已經有了具體的實現HashedCredentialsMatcher

咱們只須要進行注入使用便可：

在com.kfit.config.shiro.ShiroConfiguration中加入方法：

Java代碼  
  1. /** 
  2.      * 憑證匹配器 
  3.      * （因爲咱們的密碼校驗交給Shiro的SimpleAuthenticationInfo進行處理了 
  4.      *  因此咱們須要修改下doGetAuthenticationInfo中的代碼; 
  5.      * ） 
  6.      * @return 
  7.      */  
  8.     @Bean  
  9.     public HashedCredentialsMatcher hashedCredentialsMatcher(){  
  10.        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();  
  11.         
  12.        hashedCredentialsMatcher.setHashAlgorithmName("md5");//散列算法:這裏使用MD5算法;  
  13.        hashedCredentialsMatcher.setHashIterations(2);//散列的次數，好比散列兩次，至關於 md5(md5(""));  
  14.         
  15.        return hashedCredentialsMatcher;  
  16.     }  

 

在myShiroRealm()方法中注入憑證匹配器：

Java代碼  
  1. /** 
  2.      * 身份認證realm; 
  3.      * (這個須要本身寫，帳號密碼校驗；權限等) 
  4.      * @return 
  5.      */  
  6.     @Bean  
  7.     public MyShiroRealm myShiroRealm(){  
  8.        MyShiroRealm myShiroRealm = new MyShiroRealm();  
  9.        myShiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());;  
  10.        return myShiroRealm;  
  11.     }  

 

 

這時候在訪問/login進行登陸就能夠登錄到/index界面了。

這一節就先到這裏吧，實在是有點頭大了是吧。到時候奉上源代碼。

 

(d) 權限控制

      在上一小節咱們已經能夠登陸了。

在咱們新建一個UserInfoController

com.kfit.core.controller.UserInfoController ：

Java代碼  
  1. package com.kfit.core.controller;  
  2.    
  3. import org.apache.shiro.authz.annotation.RequiresPermissions;  
  4. import org.springframework.stereotype.Controller;  
  5. import org.springframework.web.bind.annotation.RequestMapping;  
  6.    
  7. @Controller  
  8. @RequestMapping("/userInfo")  
  9. public class UserInfoController {  
  10.      
  11.     /** 
  12.      * 用戶查詢. 
  13.      * @return 
  14.      */  
  15.     @RequestMapping("/userList")  
  16.     public String userInfo(){  
  17.        return "userInfo";  
  18.     }  
  19.      
  20.     /** 
  21.      * 用戶添加; 
  22.      * @return 
  23.      */  
  24.     @RequestMapping("/userAdd")  
  25.     public String userInfoAdd(){  
  26.        return "userInfoAdd";  
  27.     }  
  28.      
  29. }  

 

而後運行登陸進行訪問：http://127.0.0.1:8080/userInfo/userAdd

並無執行doGetAuthorizationInfo()打印信息，因此咱們會發現咱們的身份認證是好使了，可是權限控制好像沒有什麼做用哦。

咱們少了幾部分代碼，

第一就是開啓shiro aop註解支持，這個只須要在com.kfit.config.shiro.ShiroConfiguration加入以下方法進行開啓便可：

Java代碼  
  1. /** 
  2.      *  開啓shiro aop註解支持. 
  3.      *  使用代理方式;因此須要開啓代碼支持; 
  4.      * @param securityManager 
  5.      * @return 
  6.      */  
  7.     @Bean  
  8.     public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager){  
  9.        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();  
  10.        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);  
  11.        return authorizationAttributeSourceAdvisor;  
  12.     }  

 

 

第二就是在controller方法中加入相應的註解：

Java代碼  
  1. /** 
  2.      * 用戶添加; 
  3.      * @return 
  4.      */  
  5.     @RequestMapping("/userAdd")  
  6.     @RequiresPermissions("userInfo:add")//權限管理;  
  7.     public String userInfoAdd(){  
  8.        return "userInfoAdd";  
  9.     }  

 

 

這時候在訪問http://127.0.0.1:8080/userInfo/userAdd 會看到控制檯打印信息：

權限配置-->MyShiroRealm.doGetAuthorizationInfo()

若是訪問：http://127.0.0.1:8080/userInfo/userDel 會看到

Exception代碼  
  1. Whitelabel Error Page  
  2. This application has no explicit mapping for /error, so you are seeing this as a fallback.  
  3. Sat May 21 22:17:55 CST 2016  
  4. There was an unexpected error (type=Internal Server Error, status=500).  
  5. Subject does not have permission [userInfo:del]  

 

固然咱們須要在UserInfoController方法中加入：

Java代碼  
  1. /** 
  2.      * 用戶刪除; 
  3.      * @return 
  4.      */  
  5.     @RequestMapping("/userDel")  
  6.     @RequiresPermissions("userInfo:del")//權限管理;  
  7.     public String userDel(){  
  8.        return "userInfoDel";  
  9.     }  

 

在上面的錯誤信息中Subject does not have permission能夠看出此用戶沒有這個權限。好了，至此Shiro的權限控制到此先告一段落。在這裏我先拋出一個問題：咱們不斷的訪問http://127.0.0.1:8080/userInfo/userAdd 你會看到

Console代碼  
  1. 權限配置-->MyShiroRealm.doGetAuthorizationInfo()  
  2. 2016-05-21 22:20:26.263  INFO 11692 --- [nio-8080-exec-1] org.apache.shiro.realm.AuthorizingRealm  : No cache or cacheManager properties have been set.  Authorization cache cannot be obtained.  
  3. 權限配置-->MyShiroRealm.doGetAuthorizationInfo()  
  4. 2016-05-21 22:20:26.385  INFO 11692 --- [nio-8080-exec-2] org.apache.shiro.realm.AuthorizingRealm  : No cache or cacheManager properties have been set.  Authorization cache cannot be obtained.  
  5. 權限配置-->MyShiroRealm.doGetAuthorizationInfo()  
  6. 2016-05-21 22:20:26.538  INFO 11692 --- [nio-8080-exec-3] org.apache.shiro.realm.AuthorizingRealm  : No cache or cacheManager properties have been set.  Authorization cache cannot be obtained.  
  7. 權限配置-->MyShiroRealm.doGetAuthorizationInfo()  

 

這說明咱們不斷的訪問權限信息，可是實際中咱們的權限信息是不怎麼會改變的，因此咱們但願是第一次訪問，而後進行緩存處理，那麼Shiro是否支持呢，答案是確定的，咱們在下一小節進行講解，如何在Shiro中加入緩存機制。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程