[shiro] - 怎样使用shiro?
?shiro是什么?
Shiro是apache旗下的一個開源框架, 它將軟件系統的安全認證相關的功能抽取出來, 實現用戶身份認證, 權限授權, 加密, 會話管理等功能, 組成一個通用的安全認證框架.
為什么用它?
使用shiro就可以非常快速地完成認證,授權等功能的開發,降低系統成本時間.
shiro使用廣泛，shiro可以運行在web應用，非web應用，集群分布式應用中越來越多的用戶開始使用shiro。
模塊組成
Subject
Subject即主體,外部應用與subject進行交互,subject記錄了當前操作用戶,將用戶的概念理解為當前操作的主體,可能是一個通過瀏覽器請求的用戶,也可能是一個運行的程序.
Subject在shiro中是一個接口,接口中定義了很多認證授權相關的方法,外部程序通過subject進行認證授權,而subject是通過SecurityManager安全管理器進行認證授權.
SecurityManager
SecurityManager即安全管理器,對全部的subject進行安全管理,它是shiro的核心,負責對所有subject進行安全管理, 通過SecurityManager可以完成subject的認證,授權等,
實質上SecurityManager是通過Authenticator進行認證,通過Authorizer進行授權,通過SessionManager進行會話管理等.
SecurityManager是一個接口,繼承了Authenticator,Authorizer,SessionManager這三個接口.
Authenticator
Authenticator即認證器,對用戶身份進行認證,Authenticator是一個接口,shiro提供ModularRealmAuthenticator實現類,通過ModularRealmAuthenticator基本上可以滿足
大多數需求, 也可以自定義認證器.
Authorizer
Authorizer即授權器,用戶通過認證器認證通過,在訪問功能時需要通過授權器判斷用戶是否有此功能的操作權限.
Realm
Realm即領域,相當于datasource數據源,securityManager進行安全認證需要通過Realm獲取用戶權限數據,比如: 如果用戶身份數據在數據庫那么realm就需要從
數據庫獲取用戶身份信息.
注意: 不要把realm理解成只是從數據源取數據, 在realm中還有認證權限校驗的相關的代碼.
sessionManager
sessionManager即會話管理,shiro框架定義了一套會話管理, 它不依賴web容器的session, 所以shiro可以使用在非web應用上,也可以將分布式應用的會話集中
在一點管理,此特性可使它實現單點登錄.
SessionDAO
SessionDAO即會話dao,使對session會話操作的一套接口, 比如要將session存儲到數據庫, 可以通過jdbc將會話存儲到數據庫.
CacheManager
CacheManager即緩存管理,將用戶權限數據存儲在緩存,這樣可以提高性能.
Cryptography
Cryptography即密碼管理,shiro提供了一套加密/解密的組件,方便開發. 比如提供常用的散列, 加/解密等功能.
?
下面這個表是某系統的所有可操控菜單的數據,存儲了對應的訪問路徑.
下面的是角色表:表名了哪個id干什么事,比如id為4時,是只能使用采購員的事情,而不能修改管理員密碼的.因為那是系統管理員的操作.(1)
下面這個表是角色操控菜單表: 即哪些角色(id)操作哪些菜單menu(id)
?跟左側的id自增無關,我們查看menu_id對應的role_id. 這兩張表(menu,role)在上面都已經存在了,即表示通過這個role-menu表進行哪個角色可操作哪些菜單的設定.
菜單menu表中有對應的url, 將可以訪問的角色進行放行,否則進行攔截. (在前端頁面直接不予顯示)
?
下面是用戶表,沒有什么奇特的地方,我們在權限中將使用到它們的id
下面這個是比較關鍵的用戶角色表,該表定義了哪個用戶它屬于什么角色.可以看到有的用戶分飾多角,比如上面表的主管王大錘分飾了role(2,4,5){主管,采購員,銷售經理}
而王大錘可以操作哪些菜單?通過t-role-menu就可以查看到了.具體菜單是在哪些路徑呢?通過再查詢t_menu就可以獲取url字段了
?
?
相關博客1
相關博客2
相關博客3
?
|
|
?
新建一個springboot項目,引入shiro依賴
<!--shiro權限--><dependency><groupId>org.apache.shiro</groupId><artifactId>shiro-core</artifactId><version>1.4.0</version></dependency><!--shiro權限--><dependency><groupId>org.apache.shiro</groupId><artifactId>shiro-spring</artifactId><version>1.4.0</version></dependency>shiro相關博客
shiro相關博客
shiro論壇
github相關demo
?
簡單實用shiro
新建project
需要導入shiro-all的jar包
創建的shiro.ini為shiro的配置文件
shiro.ini內容:
#定義用戶 [users] #用戶名 zhang3 密碼是 12345， 角色是 admin zhang3 = 12345, admin #用戶名 li4 密碼是 abcde， 角色是 產品經理 li4 = abcde,productManager #定義角色 [roles] #管理員什么都能做 admin = * #產品經理只能做產品管理 productManager = addProduct,deleteProduct,editProduct,updateProduct,listProduct #訂單經理只能做訂單管理 orderManager = addOrder,deleteOrder,editOrder,updateOrder,listOrder用戶實體:
package com.how2java;public class User {private String name;private String password;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;}}測試類:
package com.how2java;import java.util.ArrayList; import java.util.List;import org.apache.shiro.SecurityUtils; import org.apache.shiro.authc.AuthenticationException; import org.apache.shiro.authc.UsernamePasswordToken; import org.apache.shiro.config.IniSecurityManagerFactory; import org.apache.shiro.mgt.SecurityManager; import org.apache.shiro.subject.Subject; import org.apache.shiro.util.Factory;public class TestShiro {public static void main(String[] args) {//用戶們User zhang3 = new User();zhang3.setName("zhang3");zhang3.setPassword("12345");User li4 = new User();li4.setName("li4");li4.setPassword("abcde");User wang5 = new User();wang5.setName("wang5");wang5.setPassword("wrongpassword");List<User> users = new ArrayList<>();users.add(zhang3);users.add(li4);users.add(wang5); //角色們String roleAdmin = "admin";String roleProductManager ="productManager";List<String> roles = new ArrayList<>();roles.add(roleAdmin);roles.add(roleProductManager);//權限們String permitAddProduct = "addProduct";String permitAddOrder = "addOrder";List<String> permits = new ArrayList<>();permits.add(permitAddProduct);permits.add(permitAddOrder);//登陸每個用戶for (User user : users) {if(login(user)) System.out.printf("%s \t成功登陸，用的密碼是 %s\t %n",user.getName(),user.getPassword());else System.out.printf("%s \t成功失敗，用的密碼是 %s\t %n",user.getName(),user.getPassword());}System.out.println("-------how2j 分割線------");//判斷能夠登錄的用戶是否擁有某個角色for (User user : users) {for (String role : roles) {if(login(user)) {if(hasRole(user, role)) System.out.printf("%s\t 擁有角色: %s\t%n",user.getName(),role);elseSystem.out.printf("%s\t 不擁有角色: %s\t%n",user.getName(),role);}} }System.out.println("-------how2j 分割線------");//判斷能夠登錄的用戶，是否擁有某種權限for (User user : users) {for (String permit : permits) {if(login(user)) {if(isPermitted(user, permit)) System.out.printf("%s\t 擁有權限: %s\t%n",user.getName(),permit);elseSystem.out.printf("%s\t 不擁有權限: %s\t%n",user.getName(),permit);}} }}private static boolean hasRole(User user, String role) {Subject subject = getSubject(user);return subject.hasRole(role);}private static boolean isPermitted(User user, String permit) {Subject subject = getSubject(user);return subject.isPermitted(permit);}private static Subject getSubject(User user) {//加載配置文件，并獲取工廠Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");//獲取安全管理者實例SecurityManager sm = factory.getInstance();//將安全管理者放入全局對象 SecurityUtils.setSecurityManager(sm);//全局對象通過安全管理者生成Subject對象Subject subject = SecurityUtils.getSubject();return subject;}private static boolean login(User user) {Subject subject= getSubject(user);//如果已經登錄過了，退出if(subject.isAuthenticated())subject.logout();//封裝用戶的數據UsernamePasswordToken token = new UsernamePasswordToken(user.getName(), user.getPassword());try {//將用戶的數據token 最終傳遞到Realm中進行對比 subject.login(token);} catch (AuthenticationException e) {//驗證錯誤return false;} return subject.isAuthenticated();}}測試輸出:
zhang3 成功登陸，用的密碼是 12345 li4 成功登陸，用的密碼是 abcde wang5 成功失敗，用的密碼是 wrongpassword -------how2j 分割線------ zhang3 擁有角色: admin zhang3 不擁有角色: productManager li4 不擁有角色: admin li4 擁有角色: productManager -------how2j 分割線------ zhang3 擁有權限: addProduct zhang3 擁有權限: addOrder li4 擁有權限: addProduct li4 不擁有權限: addOrder|
|
在上面的shiro簡單測試后,可以通過輸出查看到shiro究竟是用來做什么的.
但是在實際工作中,我們都會把權限相關的內容放在數據庫中,所以本知識點講解如何放在數據庫里來跑shiro.
[RBAC概念] : RBAC是當下權限系統的設計基礎,同時有兩種解釋:
一 : Role-Based Access Control , 基于角色的訪問控制, 即,你要能夠刪除產品,那么當前用戶就必須擁有產品經理這個角色
二 : Resource-Based Access Control , 基于資源的訪問控制, 即,你要能夠刪除產品,那么當前用戶就必須擁有刪除產品這樣的權限
基于角色的權限訪問控制(Role-Based Access Control) 作為傳統的訪問控制(自主訪問,強制訪問)的有前景的代替受到廣泛的關注.
在RBAC中,權限與角色相關聯, 用戶通過成為適當角色的成員而得到這些角色的權限. 這就極大地簡化了權限的管理.
在一個組織中, 角色就是為了完成各種工作而創造, 用戶則依據它的責任和資格來被指派相應的角色,用戶可以很容器地從一個角色
被派到另一個角色. 角色可依新的需求和系統的合并而賦予新的權限, 而權限也可根據需要而從某角色中回收. 角色與角色的關系
可以建立起來以囊括更廣泛的客觀情況.
[表結構] : 基于RBAC概念, 就會存在3張基礎表: 用戶,角色,權限, 以及2張中間表來建立用戶與角色的多對多關系, 角色與權限的多對多關系.
用戶與權限之間也是多對多關系,但是是通過角色間接建立的.
注: 補充多對多概念: 用戶和角色是多對多,即表示:
一個用戶可以有多種角色,一個角色也可以賦予多個用戶.
一個角色可以包含多種權限,一種權限也可以賦予多個角色.
建立shiro數據庫: 內含權限5表 (用戶,角色,權限,用戶角色,角色權限)
DROP DATABASE IF EXISTS shiro; CREATE DATABASE shiro DEFAULT CHARACTER SET utf8; USE shiro;drop table if exists user; drop table if exists role; drop table if exists permission; drop table if exists user_role; drop table if exists role_permission;create table user (id bigint auto_increment,name varchar(100),password varchar(100),constraint pk_users primary key(id) ) charset=utf8 ENGINE=InnoDB;create table role (id bigint auto_increment,name varchar(100),constraint pk_roles primary key(id) ) charset=utf8 ENGINE=InnoDB;create table permission (id bigint auto_increment,name varchar(100),constraint pk_permissions primary key(id) ) charset=utf8 ENGINE=InnoDB;create table user_role (uid bigint,rid bigint,constraint pk_users_roles primary key(uid, rid) ) charset=utf8 ENGINE=InnoDB;create table role_permission (rid bigint,pid bigint,constraint pk_roles_permissions primary key(rid, pid) ) charset=utf8 ENGINE=InnoDB;之后基于shiro.ini文件,插入一樣的用戶,角色和權限數據.
INSERT INTO `permission` VALUES (1,'addProduct'); INSERT INTO `permission` VALUES (2,'deleteProduct'); INSERT INTO `permission` VALUES (3,'editProduct'); INSERT INTO `permission` VALUES (4,'updateProduct'); INSERT INTO `permission` VALUES (5,'listProduct'); INSERT INTO `permission` VALUES (6,'addOrder'); INSERT INTO `permission` VALUES (7,'deleteOrder'); INSERT INTO `permission` VALUES (8,'editOrder'); INSERT INTO `permission` VALUES (9,'updateOrder'); INSERT INTO `permission` VALUES (10,'listOrder'); INSERT INTO `role` VALUES (1,'admin'); INSERT INTO `role` VALUES (2,'productManager'); INSERT INTO `role` VALUES (3,'orderManager'); INSERT INTO `role_permission` VALUES (1,1); INSERT INTO `role_permission` VALUES (1,2); INSERT INTO `role_permission` VALUES (1,3); INSERT INTO `role_permission` VALUES (1,4); INSERT INTO `role_permission` VALUES (1,5); INSERT INTO `role_permission` VALUES (1,6); INSERT INTO `role_permission` VALUES (1,7); INSERT INTO `role_permission` VALUES (1,8); INSERT INTO `role_permission` VALUES (1,9); INSERT INTO `role_permission` VALUES (1,10); INSERT INTO `role_permission` VALUES (2,1); INSERT INTO `role_permission` VALUES (2,2); INSERT INTO `role_permission` VALUES (2,3); INSERT INTO `role_permission` VALUES (2,4); INSERT INTO `role_permission` VALUES (2,5); INSERT INTO `role_permission` VALUES (3,6); INSERT INTO `role_permission` VALUES (3,7); INSERT INTO `role_permission` VALUES (3,8); INSERT INTO `role_permission` VALUES (3,9); INSERT INTO `role_permission` VALUES (3,10); INSERT INTO `user` VALUES (1,'zhang3','12345'); INSERT INTO `user` VALUES (2,'li4','abcde'); INSERT INTO `user_role` VALUES (1,1); INSERT INTO `user_role` VALUES (2,2);在原有的User類上加一個id字段,方便數據庫操作.
設置一個Dao層:
package com.how2java;import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.HashSet; import java.util.Set;public class DAO {public DAO() {try {Class.forName("com.mysql.jdbc.Driver");} catch (ClassNotFoundException e) {e.printStackTrace();}}public Connection getConnection() throws SQLException {return DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/shiro?characterEncoding=UTF-8", "root","yoursqlpassword");}public String getPassword(String userName) {String sql = "select password from user where name = ?";try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {ps.setString(1, userName);ResultSet rs = ps.executeQuery();if (rs.next())return rs.getString("password");} catch (SQLException e) {e.printStackTrace();}return null;}public Set<String> listRoles(String userName) {Set<String> roles = new HashSet<>();String sql = "select r.name from user u "+ "left join user_role ur on u.id = ur.uid "+ "left join Role r on r.id = ur.rid "+ "where u.name = ?";try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {ps.setString(1, userName);ResultSet rs = ps.executeQuery();while (rs.next()) {roles.add(rs.getString(1));}} catch (SQLException e) {e.printStackTrace();}return roles;}public Set<String> listPermissions(String userName) {Set<String> permissions = new HashSet<>();String sql = "select p.name from user u "+"left join user_role ru on u.id = ru.uid "+"left join role r on r.id = ru.rid "+"left join role_permission rp on r.id = rp.rid "+"left join permission p on p.id = rp.pid "+"where u.name =?";try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {ps.setString(1, userName);ResultSet rs = ps.executeQuery();while (rs.next()) {permissions.add(rs.getString(1));}} catch (SQLException e) {e.printStackTrace();}return permissions;}public static void main(String[] args) {System.out.println(new DAO().listRoles("zhang3"));System.out.println(new DAO().listRoles("li4"));System.out.println(new DAO().listPermissions("zhang3"));System.out.println(new DAO().listPermissions("li4"));} }Dao的主方法測試:
[admin] [productManager] [editOrder, addProduct, updateProduct, listProduct, listOrder, addOrder, updateOrder, deleteOrder, deleteProduct, editProduct] [addProduct, updateProduct, listProduct, deleteProduct, editProduct]可以看到zhang3的Roles為admin,li4的為productManager,zhang3的權限為editOrder.../ li4的權限為addProduct......
其中搜索用戶角色時進行3表聯查:
String sql = "select r.name from user u "+ "left join user_role ur on u.id = ur.uid "+ "left join Role r on r.id = ur.rid "+ "where u.name = ?";這里都使用了左連接,曾經有個面試官問我inner join和outer join的區別我沒答上來. 這里有篇博客整理得不錯. 注意是outer join
下面查到的編輯訂單,添加商品,更新商品等一系列操作權限集合通過5表聯查查詢:
String sql = "select p.name from user u "+"left join user_role ru on u.id = ru.uid "+"left join role r on r.id = ru.rid "+"left join role_permission rp on r.id = rp.rid "+"left join permission p on p.id = rp.pid "+"where u.name =?";其實這里如果牽扯到表過多,要做個小樣測試,進行記錄:
上圖使用了戰德臣老師的關系代表達式.如果多個表關系復雜時可以通過代數式清晰地展示出來.
[Realm概念] : 在Shiro中存在Realm這個概念,Realm這個單詞翻譯為 域, 其實是非常難以理解的.
域 是什么? 和權限有什么關系? 這個單詞挺讓人費解.
Realm 在 Shiro 里到底扮演什么角色呢?
當應用程序向Shiro提供了賬號和密碼之后,Shiro就會問Realm這個賬號密碼是否對, 如果對的話,其所對應的用戶擁有哪些角色,哪些權限.
所以Realm是什么? 其實就是個中介, Realm得到了Shiro給的用戶和密碼后, 有可能去找ini文件,就像之前的shiro.ini,也可以去找數據庫,
就如同上面Dao查詢信息.
Realm就是干這個用的,它才是真正進行用戶認證和授權的關鍵地方.
再看另一個類:
DatabaseRealm 它就是用來通過數據庫驗證用戶,和相關授權的類.
兩個方法分別做驗證和授權:
doGetAuthenticationInfo(), doGetAuthorizationInfo()
package com.how2java;import java.util.Set;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.authc.UsernamePasswordToken; import org.apache.shiro.authz.AuthorizationInfo; import org.apache.shiro.authz.SimpleAuthorizationInfo; import org.apache.shiro.realm.AuthorizingRealm; import org.apache.shiro.subject.PrincipalCollection;public class DatabaseRealm extends AuthorizingRealm {@Overrideprotected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {//能進入到這里，表示賬號已經通過驗證了String userName =(String) principalCollection.getPrimaryPrincipal();//通過DAO獲取角色和權限Set<String> permissions = new DAO().listPermissions(userName);Set<String> roles = new DAO().listRoles(userName);//授權對象SimpleAuthorizationInfo s = new SimpleAuthorizationInfo();//把通過DAO獲取到的角色和權限放進去 s.setStringPermissions(permissions);s.setRoles(roles);return s;}@Overrideprotected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {//獲取賬號密碼UsernamePasswordToken t = (UsernamePasswordToken) token;String userName= token.getPrincipal().toString();String password= new String( t.getPassword());//獲取數據庫中的密碼String passwordInDB = new DAO().getPassword(userName);//如果為空就是賬號不存在，如果不相同就是密碼錯誤，但是都拋出AuthenticationException，而不是拋出具體錯誤原因，免得給破解者提供幫助信息if(null==passwordInDB || !passwordInDB.equals(password)) throw new AuthenticationException();//認證信息里存放賬號密碼, getName() 是當前Realm的繼承方法,通常返回當前類名 :databaseRealmSimpleAuthenticationInfo a = new SimpleAuthenticationInfo(userName,password,getName());return a;}}注: DatabaseRealm這個類,用戶提供,但是不由用戶自己調用, 而是由Shiro去調用,就像Servlet的doPost方法,是被Tomcat調用一樣.
那么Shiro怎么找到這個Realm呢? 那么需要修改shiro.ini
[main] databaseRealm=com.how2java.DatabaseRealm securityManager.realms=$databaseRealm[JdbcRealm]?
Shiro提供了一個JdbcRealm, 它會默認去尋找 users, roles, permissions 三張表做類似于 Dao 中的查詢.
但是這里沒有使用,因為實際工作通常都會有更復雜的權限需要,以上3個表不夠用. JdbcRealm又封裝得太嚴實了.
[md5加密]
在之前,用戶密碼都是明文的,這樣有巨大的風險,一旦泄露,就不好了.
所以,通常都會采用非對稱加密,什么是非對稱呢?就是不可逆的,而md5就是這樣的一個算法(在之前接觸到的微信平臺開發與支付中同樣也會用到)
如TestEncryption
package com.how2java;import org.apache.shiro.crypto.hash.Md5Hash;public class TestEncryption {public static void main(String[] args) {String password = "123";String encodedPassword = new Md5Hash(password).toString();System.out.println(encodedPassword);} }123字符串通過md5加密后得到字符串202CB962AC59075B964B07152D234B70
這個字符串,卻無法通過計算,反過來得到源密碼 123
這個加密后的字符串就存在數據庫里了, 下次用戶再登錄,輸入密碼123, 同樣用md5加密后, 再和這個字符串一比較, 就知道密碼是否正確了.
如此這樣,既能保證用戶密碼校驗的功能, 又能保證不暴露密碼.
但是md5加密又有一些缺陷:
1.如果A的密碼是123, B的也是123, 那么md5的值是一樣的, 那么通過比較加密后的字符串, 我就可以反推過來, 原來你的密碼也是123.
2.與上述相同,雖然md5不可逆,但是可以進行窮舉法暴力破解. 為了解決這個問題,引入了鹽的概念, 鹽是什么呢? 比如炒菜,直接使用md5,
就是對食材(源密碼)進行炒菜,因為食材是一樣的,所以炒出來的味道都一樣,可是如果加了不同分量的鹽,那么即便食材一樣,炒出來的味道就
不一樣了.
所以,雖然每次123md5之后的密文都是202CB962AC59075B964B07152D234B70, 但是我加上鹽,即123+隨機數,那么md5的值就不一樣了~
這個隨機數,就是鹽,而這個隨機數也會在數據庫里保存下來,每個不同的用戶,隨機數也是不一樣的.
再就是加密次數,加密一次是202CB962AC59075B964B07152D234B70,我也可以加密兩次,就是另一個數了,而黑客即便是拿到了加密后的密碼,
如果不知道到底加密了多少次,也是很難辦的.
package com.how2java;import org.apache.shiro.crypto.SecureRandomNumberGenerator; import org.apache.shiro.crypto.hash.SimpleHash;public class TestEncryption {public static void main(String[] args) {String password = "123";String salt = new SecureRandomNumberGenerator().nextBytes().toString();int times = 2;String algorithmName = "md5";String encodedPassword = new SimpleHash(algorithmName,password,salt,times).toString();System.out.printf("原始密碼是 %s , 鹽是： %s, 運算次數是： %d, 運算出來的密文是：%s ",password,salt,times,encodedPassword);} }運行這些代碼:得到輸出:
原始密碼是 123 , 鹽是： Qf7STdEccXZtFkAujUDwSA==, 運算次數是： 2, 運算出來的密文是：e020da0e276e9f4f30f520fb3a225935 原始密碼是 123 , 鹽是： OlYiWbzKmyccksMQLMOcPg==, 運算次數是： 2, 運算出來的密文是：236d91c0a2e9d2ecb77e60f0d4050fef 原始密碼是 123 , 鹽是： 75MZpCeMIgf0F/v+RnCsSA==, 運算次數是： 2, 運算出來的密文是：46d77dc05d2fa0e48035ceed4333079f像上面得到了鹽的加密(作者比喻比較形象),這樣的字符串基本很難推算出來,從而加大了破譯密碼的難度.
而使用的生成隨機鹽的方法也是Shiro自帶的工具類.new SecureRandomNumberGenerator().nextBytes().toString();
[數據庫調整] : 有了以上基礎,那么就可以開始在原來的教程里加入對加密的支持了. 在開始之前, 要修改一下user表,
加上鹽字段: salt. 因為鹽是隨機數,得保留下來, 如果不知道鹽是多少, 我們也就沒法判斷密碼是否正確了.
?
alert table user add (salt varchar(100));?
package com.how2java;import org.apache.shiro.SecurityUtils; import org.apache.shiro.authc.AuthenticationException; import org.apache.shiro.authc.UsernamePasswordToken; import org.apache.shiro.config.IniSecurityManagerFactory; import org.apache.shiro.mgt.SecurityManager; import org.apache.shiro.subject.Subject; import org.apache.shiro.util.Factory;public class TestShiro {public static void main(String[] args) {//這里要釋放注釋，先注冊一個用戶new DAO().createUser("tom", "123");User user = new User();user.setName("tom");user.setPassword("123");if(login(user)) System.out.println("登錄成功");elseSystem.out.println("登錄失敗");}private static boolean hasRole(User user, String role) {Subject subject = getSubject(user);return subject.hasRole(role);}private static boolean isPermitted(User user, String permit) {Subject subject = getSubject(user);return subject.isPermitted(permit);}private static Subject getSubject(User user) {//加載配置文件，并獲取工廠Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");//獲取安全管理者實例SecurityManager sm = factory.getInstance();//將安全管理者放入全局對象 SecurityUtils.setSecurityManager(sm);//全局對象通過安全管理者生成Subject對象Subject subject = SecurityUtils.getSubject();return subject;}private static boolean login(User user) {Subject subject= getSubject(user);//如果已經登錄過了，退出if(subject.isAuthenticated())subject.logout();//封裝用戶的數據UsernamePasswordToken token = new UsernamePasswordToken(user.getName(), user.getPassword());try {//將用戶的數據token 最終傳遞到Realm中進行對比 subject.login(token);} catch (AuthenticationException e) {//驗證錯誤return false;} return subject.isAuthenticated();}}通過上述代碼,先注冊了一個用戶,然后進行登錄驗證
在Dao中,增加了兩個方法 createUser, getUser
package com.how2java;import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.HashSet; import java.util.Set;import org.apache.shiro.crypto.SecureRandomNumberGenerator; import org.apache.shiro.crypto.hash.SimpleHash;public class DAO {public DAO() {try {Class.forName("com.mysql.jdbc.Driver");} catch (ClassNotFoundException e) {e.printStackTrace();}}public Connection getConnection() throws SQLException {return DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/shiro?characterEncoding=UTF-8", "root","yourpassword");}public String createUser(String name, String password) {String sql = "insert into user values(null,?,?,?)";String salt = new SecureRandomNumberGenerator().nextBytes().toString(); //鹽量隨機String encodedPassword= new SimpleHash("md5",password,salt,2).toString();try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {ps.setString(1, name);ps.setString(2, encodedPassword);ps.setString(3, salt);ps.execute();} catch (SQLException e) {e.printStackTrace();}return null; }public String getPassword(String userName) {String sql = "select password from user where name = ?";try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {ps.setString(1, userName);ResultSet rs = ps.executeQuery();if (rs.next())return rs.getString("password");} catch (SQLException e) {e.printStackTrace();}return null;}public User getUser(String userName) {User user = null;String sql = "select * from user where name = ?";try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {ps.setString(1, userName);ResultSet rs = ps.executeQuery();if (rs.next()) {user = new User();user.setId(rs.getInt("id"));user.setName(rs.getString("name"));user.setPassword(rs.getString("password"));user.setSalt(rs.getString("salt"));}} catch (SQLException e) {e.printStackTrace();}return user;}public Set<String> listRoles(String userName) {Set<String> roles = new HashSet<>();String sql = "select r.name from user u "+ "left join user_role ur on u.id = ur.uid "+ "left join Role r on r.id = ur.rid "+ "where u.name = ?";try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {ps.setString(1, userName);ResultSet rs = ps.executeQuery();while (rs.next()) {roles.add(rs.getString(1));}} catch (SQLException e) {e.printStackTrace();}return roles;}public Set<String> listPermissions(String userName) {Set<String> permissions = new HashSet<>();String sql = "select p.name from user u "+"left join user_role ru on u.id = ru.uid "+"left join role r on r.id = ru.rid "+"left join role_permission rp on r.id = rp.rid "+"left join permission p on p.id = rp.pid "+"where u.name =?";try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {ps.setString(1, userName);ResultSet rs = ps.executeQuery();while (rs.next()) {permissions.add(rs.getString(1));}} catch (SQLException e) {e.printStackTrace();}return permissions;} }繼而修改DatabaseRealm,把用戶通過UsernamePasswordToken傳進來的密碼,以及數據庫里取出來的salt進行加密,加密之后再與數據庫里的
密文進行比較,判斷用戶是否能夠通過驗證.
package com.how2java;import java.util.Set;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.authc.UsernamePasswordToken; import org.apache.shiro.authz.AuthorizationInfo; import org.apache.shiro.authz.SimpleAuthorizationInfo; import org.apache.shiro.crypto.hash.SimpleHash; import org.apache.shiro.realm.AuthorizingRealm; import org.apache.shiro.subject.PrincipalCollection; import org.apache.shiro.util.ByteSource;public class DatabaseRealm extends AuthorizingRealm {@Overrideprotected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {//能進入到這里，表示賬號已經通過驗證了String userName =(String) principalCollection.getPrimaryPrincipal();//通過DAO獲取角色和權限Set<String> permissions = new DAO().listPermissions(userName);Set<String> roles = new DAO().listRoles(userName);//授權對象SimpleAuthorizationInfo s = new SimpleAuthorizationInfo();//把通過DAO獲取到的角色和權限放進去 s.setStringPermissions(permissions);s.setRoles(roles);return s;}@Overrideprotected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {//獲取賬號密碼UsernamePasswordToken t = (UsernamePasswordToken) token;String userName= token.getPrincipal().toString();String password =new String(t.getPassword());//獲取數據庫中的密碼 User user = new DAO().getUser(userName);String passwordInDB = user.getPassword();String salt = user.getSalt();String passwordEncoded = new SimpleHash("md5",password,salt,2).toString();if(null==user || !passwordEncoded.equals(passwordInDB))throw new AuthenticationException();//認證信息里存放賬號密碼, getName() 是當前Realm的繼承方法,通常返回當前類名 :databaseRealmSimpleAuthenticationInfo a = new SimpleAuthenticationInfo(userName,password,getName());return a;}}通過剛才的增加新用戶:
可以看到tom的密碼加密了,它的鹽在后面
另一個做法的DatabaseRealm中只是提供了密文和鹽,具體操作:
修改shiro.ini :
為DatabaseRealm指定credentialsMatcher, 其中就指定了算法是md5, 次數為2, storedCredentialsHexEncoded這個表示計算之后以密文為16進制.
這樣Shiro就拿著在subject.log()時傳入的UsernamePasswordToken中的源密碼,數據庫里的密文和鹽,以及配置文件里指定的算法參數,
自己去進行相關匹配了.
以下是shiro.ini
[main] credentialsMatcher=org.apache.shiro.authc.credential.HashedCredentialsMatcher credentialsMatcher.hashAlgorithmName=md5 credentialsMatcher.hashIterations=2 credentialsMatcher.storedCredentialsHexEncoded=truedatabaseRealm=com.how2java.DatabaseRealm databaseRealm.credentialsMatcher=$credentialsMatcher securityManager.realms=$databaseRealm好了,除了能看到md5加密和隨機鹽,shiro.ini馬上就不會用到了,所以上面的也不用太在意,可以查看下storedCredentialsHexEncoded,不過接下來接入jsp頁面查看下shiro的再實際點的作用.
既然是Web項目,那還是配置下web.xml :
<web-app><listener><listener-class>org.apache.shiro.web.env.EnvironmentLoaderListener</listener-class></listener><context-param><param-name>shiroEnvironmentClass</param-name><param-value>org.apache.shiro.web.env.IniWebEnvironment</param-value><!-- 默認先從/WEB-INF/shiro.ini，如果沒有找classpath:shiro.ini --></context-param><context-param><param-name>shiroConfigLocations</param-name><param-value>classpath:shiro.ini</param-value></context-param><filter><filter-name>shiroFilter</filter-name><filter-class>org.apache.shiro.web.servlet.ShiroFilter</filter-class></filter><filter-mapping><filter-name>shiroFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping> </web-app>這里有個Filter的DEMO,Filter說白了就是當調用一個url時之前要有一道關口,這個關口就是Filter.
其它的如User,DAO,DatabaseRealm都和之前的沒啥區別.
這里有一個Servlet
package com.how2java;import java.io.IOException;import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse;import org.apache.shiro.SecurityUtils; import org.apache.shiro.authc.AuthenticationException; import org.apache.shiro.authc.UsernamePasswordToken; import org.apache.shiro.session.Session; import org.apache.shiro.subject.Subject;@WebServlet(name = "loginServlet", urlPatterns = "/login") public class LoginServlet extends HttpServlet { protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { String name = req.getParameter("name"); String password = req.getParameter("password"); Subject subject = SecurityUtils.getSubject(); UsernamePasswordToken token = new UsernamePasswordToken(name, password); try { subject.login(token);Session session=subject.getSession();session.setAttribute("subject", subject);resp.sendRedirect("");} catch (AuthenticationException e) { req.setAttribute("error", "驗證失敗"); req.getRequestDispatcher("login.jsp").forward(req, resp); } } }LoginServlet映射路徑/login的訪問.
獲取賬號和密碼,然后組成UsernamePasswordToken對象,扔給Shiro進行判斷, 如果判斷不報錯, 即表示成功, 客戶端跳轉到根目錄,
否則返回login.jsp,并帶上錯誤信息
登錄成功之后還會把subject放在shiro的session對象里, shiro的這個session和httpsession是串通好了的, 所以在這里放了, 它會自動放在
httpsession里,它們之間是同步的. 可以看到這里登錄成功后,將用戶名和密碼通過Shiro的UsernamePasswordToken包裝為一個token對象
之后通過login方法進行用戶登錄,如果沒有異常則表示用戶名密碼正確, resp響應到了"",(并不是index.jsp,或mian.jsp不知道為什么)
下面是shiro.ini,之后到springboot應該不用配置了
[main] #使用數據庫進行驗證和授權 databaseRealm=com.how2java.DatabaseRealm securityManager.realms=$databaseRealm#當訪問需要驗證的頁面，但是又沒有驗證的情況下，跳轉到login.jsp authc.loginUrl=/login.jsp #當訪問需要角色的頁面，但是又不擁有這個角色的情況下，跳轉到noroles.jsp roles.unauthorizedUrl=/noRoles.jsp #當訪問需要權限的頁面，但是又不擁有這個權限的情況下，跳轉到noperms.jsp perms.unauthorizedUrl=/noPerms.jsp#users，roles和perms都通過前面知識點的數據庫配置了 [users] #urls用來指定哪些資源需要什么對應的授權才能使用 [urls] #doLogout地址就會進行退出行為 /doLogout=logout #login.jsp,noroles.jsp,noperms.jsp 可以匿名訪問 /login.jsp=anon /noroles.jsp=anon /noperms.jsp=anon#查詢所有產品,需要登錄后才可以查看 /listProduct.jsp=authc #增加商品不僅需要登錄，而且要擁有 productManager 權限才可以操作 /deleteProduct.jsp=authc,roles[productManager] #刪除商品，不僅需要登錄，而且要擁有 deleteProduct 權限才可以操作 /deleteOrder.jsp=authc,perms["deleteOrder"]?
下面是index.jsp, 通過${subject.principal}來判斷用戶是否登錄,if(登錄了){ 顯示退出選項 } else { 顯示登錄按鈕 } (與大多數的網站登錄一致)
index里提供了3個超鏈接,分別要登錄后才可以查看,有角色,有權限才能看,便于進行測試.
注: subject是在LoginServlet里放進session的
index.jsp使用了JSTL表達式,(說真的JSTL,EL表達式遠不及用ThymeLeaf前端模板來得好,JSTL,EL如果不在tomcat啟動就訪問不了了,而ThymeLeaf不同)
<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%><link rel="stylesheet" type="text/css" href="static/css/style.css" /></head> <body><div class="workingroom"><div class="loginDiv"><c:if test="${empty subject.principal}"><a href="login.jsp">登錄</a><br></c:if><c:if test="${!empty subject.principal}"><span class="desc">你好，${subject.principal}，</span><a href="doLogout">退出</a><br> </c:if><a href="listProduct.jsp">查看產品</a><span class="desc">(登錄后才可以查看) </span><br><a href="deleteProduct.jsp">刪除產品</a><span class="desc">(要有產品管理員角色, zhang3沒有，li4 有) </span><br><a href="deleteOrder.jsp">刪除訂單</a><span class="desc">(要有刪除訂單權限, zhang3有，li4沒有) </span><br> </div></body> </html>?
登錄 login.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8" import="java.util.*"%><!DOCTYPE html><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <link rel="stylesheet" type="text/css" href="static/css/style.css" /><div class="workingroom"><div class="errorInfo">${error}</div><form action="login" method="post">賬號： <input type="text" name="name"> <br>密碼： <input type="password" name="password"> <br><br><input type="submit" value="登錄"><br><br><div><span class="desc">賬號:zhang3 密碼:12345 角色:admin</span><br><span class="desc">賬號:li4 密碼:abcde 角色:productManager</span><br></div></form> </div>大體運行后是這樣一個干枯枯燥的頁面
在demo中,當用戶zhang3登錄后如果查看刪除產品的鏈接,就會提示錯誤,路徑轉到了http://localhost:8184/shiro/noRoles.jsp
而進入刪除訂單,則沒有問題,因為zhang3用戶有該權限.
?{經歷了一夜的休息,繼續跟shiro戰斗,將博客下方加上>>筆耕不輟<<,希望今年是個豐收年}
在登錄了li4這個角色后,可以看到刪除產品的可以進入,而刪除訂單的權限不足.
也就是說Shiro提供的這些Subject,SecurityManager,Authenticator(身份認證),Authorizer(授權認證),Realm,,,sessionManager等都是為了做這個工作,
即讓有權限的,有角色的才可能進入規定的地方. (其實就像現在編程這個行業,許多都是培訓班出來的,半路出家,而很多公司都是卡學歷的,如果你學歷不夠,那么就說明你沒有這個Role,繼而也就沒有這個權限)
listProduct.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8" import="java.util.*"%><!DOCTYPE html><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <link rel="stylesheet" type="text/css" href="static/css/style.css" /><div class="workingroom">listProduct.jsp ，能進來，就表示已經登錄成功了<br><a href="#" onClick="javascript:history.back()">返回</a> </div>deleteOrder.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8" import="java.util.*"%><!DOCTYPE html><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <link rel="stylesheet" type="text/css" href="static/css/style.css" /><div class="workingroom">deleteOrder.jsp ，能進來，就表示有deleteOrder權限<br><a href="#" onClick="javascript:history.back()">返回</a> </div>deleteProduct.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8" import="java.util.*"%><!DOCTYPE html><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <link rel="stylesheet" type="text/css" href="static/css/style.css" /><div class="workingroom">deleteProduct.jsp，能進來<br>就表示擁有 productManager 角色<br><a href="#" onClick="javascript:history.back()">返回</a> </div>noRoles.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8" import="java.util.*"%><!DOCTYPE html><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <link rel="stylesheet" type="text/css" href="static/css/style.css" /><div class="workingroom">角色不匹配<br><a href="#" onClick="javascript:history.back()">返回</a> </div>noPerms.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8" import="java.util.*"%><!DOCTYPE html><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <link rel="stylesheet" type="text/css" href="static/css/style.css" /><div class="workingroom">權限不足<br><a href="#" onClick="javascript:history.back()">返回</a> </div>?
?
轉載于:https://www.cnblogs.com/ukzq/p/10212413.html
總結
以上是生活随笔為你收集整理的[shiro] - 怎样使用shiro?的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Go语言中使用MySql数据库
- 下一篇： DS二叉树--左叶子数量