Shiro笔记02-基本使用

环境准备

Shiro不依赖容器，直接创建一个Maven工程即可，添加Shiro相关依赖。

<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-coreartifactId>
    <version>1.9.0version>
dependency>
<dependency>
    <groupId>commons-logginggroupId>
    <artifactId>commons-loggingartifactId>
    <version>1.2version>
dependency>
1
2
3
4
5
6
7
8
9
10

INI文件

Shiro获取权限相关信息可以通过数据库获取，也可以通过ini配置文件获取，这里使用ini配置文件，在resources目录下创建shiro.ini文件，其中users要小写，key-value分别代表用户名-密码。

[users]
zhangsan=z3
lisi=l4
1
2
3

登录认证

登录认证概念

1. 身份验证：一般需要提供如身份ID等一些标识信息来表明登录者的身份，如提供email，用户名/密码来证明
2. 在Shiro中，用户需要提供principals（身份）和credentials（证明）给Shiro，从而应用能验证用户身份
3. principals：身份，即主体的标识属性，可以是任何属性，如用户名、邮箱等，唯一即可。一个主体可以有多个principals，但只有一个Primary principals，一般是用户名/邮箱/手机号
4. credentials：证明/凭证，即只有主体知道的安全值，如密码/数字证书等
5. 最常见的principals和credentials组合就是用户名/密码

登录认证基本流程

1. 收集用户身份/凭证，即如用户名/密码
2. 调用 Subject.login 进行登录，如果失败将得到相应的AuthenticationException异常，根据异常提示用户 错误信息；否则登录成功
3. 创建自定义的 Realm 类，继承org.apache.shiro.realm.AuthenticatingRealm类，实现doGetAuthenticationInfo()方法
   

登录认证实例

package com.demo.demo;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;

public class Demo {
    public static void main(String[] args) {
        // 初试化获取SecurityManager
        IniSecurityManagerFactory iniSecurityManagerFactory = new IniSecurityManagerFactory("classpath:shiro.ini");
        SecurityManager securityManager = iniSecurityManagerFactory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);
        // 获取Subject对象
        Subject subject = SecurityUtils.getSubject();
        // 创建token对象，web应用的用户名密码可以从页面传递
        AuthenticationToken authenticationToken = new UsernamePasswordToken("zhangsan", "z3");
//        AuthenticationToken authenticationToken = new UsernamePasswordToken("zhangsan123", "z3");// 触发UnknownAccountException
//        AuthenticationToken authenticationToken = new UsernamePasswordToken("zhangsan", "z4");// 触发IncorrectCredentialsException
        // 完成登录
        try {
            subject.login(authenticationToken);
            System.out.println("登录成功");
        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户不存在");
        } catch (IncorrectCredentialsException e) {
            e.printStackTrace();
            System.out.println("密码错误");
        } catch (AuthenticationException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

身份认证流程

1. 首先调用Subject.login(token)进行登录，其会自动委托给SecurityManager
2. SecurityManager负责真正的身份验证逻辑；它会委托给Authenticator进行身份验证
3. Authenticator才是真正的身份验证者，Shiro API中核心的身份认证入口点，此处可以自定义插入自己的实现
4. Authenticator可能会委托给相应的AuthenticationStrategy进行多Realm身份验证，默认ModularRealmAuthenticator会调AuthenticationStrategy 进行多Realm身份验证
5. Authenticator会把相应的token传入Realm，从Realm获取身份验证信息，如果没有返回/抛出异常表示身份验证失败了。此处可以配置多个Realm，将按照相应的顺序及策略进行访问

在生产环境中，更多的还是通过数据库记录这些用户信息，所以这里再加一种通过数据库来验证用户名密码，所以这里加上这种方式。
创建数据表，表名必须叫user，添加两个字段：username和password，不能叫别的名字，否则会对不上，这就是规定，记住即可。后面还会有user_role表和role_permission表，同样也有一些规定写法。

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for role_permission
-- ----------------------------
DROP TABLE IF EXISTS `role_permission`;
CREATE TABLE `role_permission`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `role_name` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `permission` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `idx_role_permission`(`role_name`, `permission`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of role_permission
-- ----------------------------
INSERT INTO `role_permission` VALUES (2, 'role1', 'video:get');
INSERT INTO `role_permission` VALUES (1, 'role1', 'video:list');
INSERT INTO `role_permission` VALUES (3, 'role2', 'video:*');
INSERT INTO `role_permission` VALUES (4, 'role3', '*');
INSERT INTO `role_permission` VALUES (5, 'role4', '*');

-- ----------------------------
-- Table structure for user_role
-- ----------------------------
DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `role_name` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `idx_user_role`(`username`, `role_name`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user_role
-- ----------------------------
INSERT INTO `user_role` VALUES (1, 'username1', 'role1');
INSERT INTO `user_role` VALUES (2, 'username1', 'role2');
INSERT INTO `user_role` VALUES (3, 'username2', 'role3');
INSERT INTO `user_role` VALUES (4, 'username2', 'role4');

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `password` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `password_salt` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `idx_user_username`(`username`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, 'username1', 'password1', NULL);
INSERT INTO `user` VALUES (2, 'username2', 'username2', NULL);

SET FOREIGN_KEY_CHECKS = 1;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

然后，添加几条测试数据，回到代码开发环境，添加pom依赖。

<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-coreartifactId>
    <version>1.2.4version>
dependency>
<dependency>
    <groupId>org.slf4jgroupId>
    <artifactId>slf4j-log4j12artifactId>
    <version>1.7.13version>
dependency>
<dependency>
    <groupId>c3p0groupId>
    <artifactId>c3p0artifactId>
    <version>0.9.1.2version>
dependency>
<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>8.0.18version>
dependency>
<dependency>
    <groupId>commons-logginggroupId>
    <artifactId>commons-loggingartifactId>
    <version>1.2version>
dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

新建jdbc.ini。

[main]
#注意 文件格式必须为ini，编码为ANSI
#声明Realm，指定realm类型
jdbcRealm=org.apache.shiro.realm.jdbc.JdbcRealm
#配置数据源
dataSource=com.mchange.v2.c3p0.ComboPooledDataSource
# mysql-connector-java 5用的驱动url是com.mysql.jdbc.Driver，mysql-connector-java 6以后用的是com.mysql.cj.jdbc.Driver
dataSource.driverClass=com.mysql.cj.jdbc.Driver
#避免安全警告
dataSource.jdbcUrl=jdbc:mysql://127.0.0.1:3306/demo?characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
dataSource.user=root
dataSource.password=root
#指定数据源
jdbcRealm.dataSource=$dataSource
#开启查找权限
jdbcRealm.permissionsLookupEnabled=true
#指定SecurityManager的Realms实现，设置realms，可以有多个，用逗号隔开
securityManager.realms=$jdbcRealm
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

然后是Java代码，用于测试。

package com.demo.demo;

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 Demo {
    public static void main(String[] args) {
        // 获取SecurityManager工厂，此处使用Ini配置文件初始化SecurityManager
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:jdbc.ini");
        // 获得SecurityManager实例
        SecurityManager securityManager = factory.getInstance();
        // 绑定给SecurityUtils
        SecurityUtils.setSecurityManager(securityManager);
        // 得到Subject及创建用户名/密码身份验证Token（即用户身份/凭证）
        Subject subject= SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "z3");
        try {
            subject.login(token);
            System.out.println("Succeed!");
        } catch (AuthenticationException e) {
            e.printStackTrace();
            System.out.println("Fail!");
        }
        subject.logout();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

角色、授权

授权概念

1. 授权，也叫访问控制，即在应用中控制谁访问哪些资源（如访问页面/编辑数据/页面操作等）。在授权中需了解的几个关键对象：主体（Subject）、资源（Resource）、权限 （Permission）、角色（Role）
2. 主体（Subject）：访问应用的用户，在Shiro中使用Subject代表该用户。用户只有授权后才允许访问相应的资源
3. 资源（Resource）：在应用中用户可以访问的URL，比如访问JSP页面、查看/编辑某些数据、访问某个业务方法、打印文本等等都是资源。用户只要授权后才能访问
4. 权限（Permission）：安全策略中的原子授权单位，通过权限我们可以表示在应用中用户有没有操作某个资源的权力。即权限表示在应用中用户能不能访问某个资源，如：访问用户列表页面查看/新增/修改/删除用户数据（即很多时候都是CRUD（增查改删）式权限控制）等。权限代表了用户有没有操作某个资源的权利，即反映在某个资源上的操作允不允许
5. Shiro支持粗粒度权限（如用户模块的所有权限）和细粒度权限（操作某个用户的权限， 即实例级别的）
6. 角色（Role）：权限的集合，一般情况下会赋予用户角色而不是权限，即这样用户可以拥有一组权限，赋予权限时比较方便。典型的如：项目经理、技术总监、CTO、开发工程师等都是角色，不同的角色拥有一组不同的权限

授权方式

• 编程式，通过代码里的if、else来判断有没有权限：

if (subject.hasRole("admin")) {
} else {
}
1
2
3

• 注解式，通过判断Java方法上的注解，判断有没有权限执行该方法，如果没有权限就会抛出异常：

@RequiredRoles("admin")
public void function() {
}
1
2
3

• JSP/GSP标签式，在JSP/GSP页面通过标签完成：

<shiro:hasRole name="admin">
shiro:hasRole>
1
2

授权流程

1. 首先调用Subject.isPermitted*/hasRole*接口，其会委托给SecurityManager，而SecurityManager接着会委托给Authorizer
2. Authorizer是真正的授权者，如果调用如isPermitted(“user:view”)，其首先会通过PermissionResolver把字符串转换成相应的Permission实例
3. 在进行授权之前，其会调用相应的Realm获取Subject相应的角色/权限用于匹配传入的角色/权限
4. Authorizer会判断Realm的角色/权限是否和传入的匹配，如果有多个Realm，会委托给ModularRealmAuthorizer进行循环判断，如果匹配如isPermitted*/hasRole*会返回true，否则返回false表示授权失败
   
   在代码中找到subject.login(authenticationToken)，点进去，找到this.securityManager.login()方法，也就是将认证流程交给securityManager来处理了，点进去，找到authenticate()方法，点进去，找到AbstractAuthenticator类的authenticate()方法里的doAuthenticate()，点进去，就看到了熟悉的Realm，这里会分单个Realm和多个Realm，我们点击doSingleRealmAuthentication()方法，点击realm.getAuthenticationInfo()方法，点击this.doGetAuthenticationInfo()方法的实现，就来到了我们自定义Realm里的doGetAuthenticationInfo()方法。

授权实例

在ini文件里，给用户添加角色。

[users]
zhangsan=z3,role1,role2
lisi=l4
1
2
3

在代码里通过subject.hasRole("role1")来判断用户是否拥有角色。
在ini文件里，给角色添加权限。

[users]
zhangsan=z3,role1,role2
lisi=l4
[roles]
role1=user:insert,user:select
1
2
3
4
5

在代码里通过subject.isPermitted("user:insert")判断用户是否有权限，还可以通过subject.checkPermission("user:select")来判断，如果有权限，正常执行，如果没有权限，会抛异常。

Shiro加密

实际系统开发中，一些敏感信息需要进行加密，比如说用户的密码。Shiro内嵌很多常用的加密算法，比如MD5加密。Shiro可以很简单的使用信息加密。

package com.demo.demo;

import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.crypto.hash.SimpleHash;

public class ShiroEncryption {
    public static void main(String[] args) {
        String password = "password";// 密码明文
        System.out.println(new Md5Hash(password));// md5加密
        System.out.println(new Md5Hash(password, "salt"));// md5加盐加密
        System.out.println(new Md5Hash(password, "salt", 3));// md5加盐迭代加密
        System.out.println(new SimpleHash("MD5", password, "salt", 3));// 父类md5加盐迭代加密
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

看了看SimpleHash的子类，有：Md2Hash、Sha512Hash、Sha384Hash、Md5Hash、Sha256Hash、Sha1Hash。

Shiro自定义登录认证

Shiro默认的登录认证是不带加密的，如果想要实现加密认证需要自定义登录认证，自定义Realm继承AuthenticatingRealm并重写doGetAuthenticationInfo方法。
目前，没有集成SpringBoot，所以，配置信息，还要在ini文件里写，我们自定义了Realm，就要告诉Shiro，使用自定义的Realm，这个配置是写在ini文件里的。
还是要回到刚才的Demo.java。

package com.demo.demo;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;

public class Demo {
    public static void main(String[] args) {
        // 初试化获取SecurityManager
        IniSecurityManagerFactory iniSecurityManagerFactory = new IniSecurityManagerFactory("classpath:shiro.ini");
        SecurityManager securityManager = iniSecurityManagerFactory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);
        // 获取Subject对象
        Subject subject = SecurityUtils.getSubject();
        // 创建token对象，web应用的用户名密码可以从页面传递
        AuthenticationToken authenticationToken = new UsernamePasswordToken("username1", "password1");
//        AuthenticationToken authenticationToken = new UsernamePasswordToken("zhangsan123", "z3");// 触发UnknownAccountException
//        AuthenticationToken authenticationToken = new UsernamePasswordToken("zhangsan", "z4");// 触发IncorrectCredentialsException
        // 完成登录
        try {
            subject.login(authenticationToken);
            System.out.println("登录成功");
        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户不存在");
        } catch (IncorrectCredentialsException e) {
            e.printStackTrace();
            System.out.println("密码错误");
        } catch (AuthenticationException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

编写自己的实现类MyRealm.java

package com.demo.demo;

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.realm.AuthenticatingRealm;
import org.apache.shiro.util.ByteSource;

public class MyRealm extends AuthenticatingRealm {
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        // 获取身份信息
        String principal = authenticationToken.getPrincipal().toString();
        // 获取凭证信息
        String credentials = new String((char[]) authenticationToken.getCredentials());
        System.out.println("要验证的用户名：" + principal + "，要验证的密码：" + credentials);
        // 获取数据库信息
        String passwordFromDB = "68e63f21326b3c358bb018102724820c";// new Md5Hash("password1", "salt", 3)// 根据principle查库里加密的密码
        return new SimpleAuthenticationInfo(principal, passwordFromDB, ByteSource.Util.bytes("salt"), principal);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

编写ini配置文件

[main]
md5CredentialsMatcher=org.apache.shiro.authc.credential.Md5CredentialsMatcher
md5CredentialsMatcher.hashIterations=3
myRealm=com.demo.demo.MyRealm
myRealm.credentialsMatcher=$md5CredentialsMatcher
securityManager.realms=$myRealm
1
2
3
4
5
6

最后运行Demo.java测试效果，发现程序已经走了我们自定义的验证类：MyRealm.java。