1
package com.shiro.tutorial;
2

3
import org.apache.shiro.SecurityUtils;
4
import org.apache.shiro.authc.AuthenticationException;
5
import org.apache.shiro.authc.IncorrectCredentialsException;
6
import org.apache.shiro.authc.UnknownAccountException;
7
import org.apache.shiro.authc.UsernamePasswordToken;
8
import org.apache.shiro.mgt.DefaultSecurityManager;
9
import org.apache.shiro.realm.text.IniRealm;
10
import org.apache.shiro.subject.Subject;
11
import org.slf4j.Logger;
12
import org.slf4j.LoggerFactory;
13

14
/**
15
 * Apache Shiro 简单身份认证示例类
16
 * 开发思路：
17
 * 1. 首先配置安全管理器和领域（Realm）
18
 * 2. 获取当前用户主体（Subject）
19
 * 3. 创建身份令牌进行用户认证
20
 * 4. 处理各种认证异常情况
21
 *
22
 * @author 李昊哲 李胜龙
23
 * @version 1.0.0
24
 */
25
public class SimplifiedAuthExample {
26
  // 创建日志记录器，用于输出程序运行信息
27
  private static final Logger LOGGER = LoggerFactory.getLogger(SimplifiedAuthExample.class);
28

29
  /**
30
   * 程序入口方法
31
   * 开发过程：
32
   * 1. 初始化Shiro安全框架组件
33
   * 2. 进行用户身份认证
34
   * 3. 处理认证结果和异常情况
35
   *
36
   * @param args 命令行参数
37
   */
38
  public static void main(String[] args) {
39
    /*
40
    当前示例是如何工作的
41
      1. 在 SimplifiedAuthExample.java 中，认证流程如下：
42
      2. 首先检查用户是否已经认证过（通常在首次运行时返回 false）
43
      3. 如果未认证，提示用户输入用户名和密码
44
      4. 创建 UsernamePasswordToken 对象封装用户输入的凭据
45
      5. 调用 currentUser.login(token) 进行认证
46
      Shiro 在后台使用 IniRealm 读取 shiro.ini 文件中的用户信息，并与用户输入的凭据进行比较
47
      所以，系统是拿着用户输入的账号密码去数据源中验证的。shiro.ini 文件就是我们的"数据源"，虽然在实际项目中，我们会使用数据库或 LDAP 等更复杂的存储系统。
48
     */
49
    // 创建 IniRealm 实例，指定配置文件位置为classpath下的shiro.ini
50
    // IniRealm是Shiro提供的基于INI配置文件的身份认证和授权实现
51
    IniRealm iniRealm = new IniRealm("classpath:shiro.ini");
52

53
    // 创建 SecurityManager 安全管理器实例，并传入realm
54
    // SecurityManager是Shiro框架的核心，负责协调内部安全组件
55
    DefaultSecurityManager securityManager = new DefaultSecurityManager(iniRealm);
56

57
    // 将 SecurityManager 绑定到 SecurityUtils 工具类
58
    // 这样在整个应用程序中都可以通过SecurityUtils获取SecurityManager
59
    SecurityUtils.setSecurityManager(securityManager);
60

61
    // 获取当前执行用户（Subject），Subject代表当前正在与软件进行交互的用户
62
    Subject currentUser = SecurityUtils.getSubject();
63

64
    // 判断当前用户是否已经通过认证
65
    if (!currentUser.isAuthenticated()) {
66
      // 如果未认证，则创建UsernamePasswordToken令牌，用于封装用户身份信息
67
      // 这里使用预设的用户名"user"和密码"password"
68
      UsernamePasswordToken token = new UsernamePasswordToken("user", "password");
69

70
      try {
71
        // 使用令牌进行用户登录认证
72
        currentUser.login(token);
73
        // 认证成功后，记录用户登录成功的日志信息
74
        LOGGER.info("用户 {} 登录成功！", currentUser.getPrincipal());
75
      } catch (UnknownAccountException uae) {
76
        // 捕获用户名不存在异常
77
        LOGGER.error("用户名不存在", uae);
78
      } catch (IncorrectCredentialsException ice) {
79
        // 捕获密码错误异常
80
        LOGGER.error("密码错误", ice);
81
      } catch (AuthenticationException ae) {
82
        // 捕获其他身份认证相关异常
83
        LOGGER.error("认证失败", ae);
84
      }
85
    } else {
86
      // 如果用户已经通过认证，则记录相应日志
87
      LOGGER.info("用户已认证");
88
    }
89
  }
90
}

1
package com.shiro.tutorial;
2

3
import org.apache.shiro.SecurityUtils;
4
import org.apache.shiro.authc.UsernamePasswordToken;
5
import org.apache.shiro.mgt.DefaultSecurityManager;
6
import org.apache.shiro.realm.text.IniRealm;
7
import org.apache.shiro.subject.Subject;
8
import org.slf4j.Logger;
9
import org.slf4j.LoggerFactory;
10

11
/**
12
 * Apache Shiro 角色权限控制示例类
13
 * 开发思路：
14
 * 1. 首先配置安全管理器和领域（Realm）
15
 * 2. 获取当前用户主体（Subject）
16
 * 3. 创建身份令牌进行用户认证
17
 * 4. 验证用户角色
18
 *
19
 * @author 李昊哲 李胜龙
20
 * @version 1.0.0
21
 */
22
public class RoleExample {
23
  // 创建日志记录器，用于输出程序运行信息
24
  private static final Logger LOGGER = LoggerFactory.getLogger(RoleExample.class);
25

26
  /**
27
   * 程序入口方法
28
   * 开发过程：
29
   * 1. 初始化Shiro安全框架组件，加载角色配置
30
   * 2. 进行用户身份认证
31
   * 3. 验证用户角色权限检查功能
32
   *
33
   * @param args 命令行参数
34
   */
35
  public static void main(String[] args) {
36
    // 创建 IniRealm 实例，使用专门的角色配置文件shiro-role.ini
37
    // 该配置文件中包含了用户角色相关信息
38
    IniRealm iniRealm = new IniRealm("classpath:shiro-role.ini");
39

40
    // 创建 SecurityManager 安全管理器实例，并传入realm
41
    // SecurityManager是Shiro框架的核心，负责协调内部安全组件
42
    DefaultSecurityManager securityManager = new DefaultSecurityManager(iniRealm);
43

44
    // 将 SecurityManager 绑定到 SecurityUtils 工具类
45
    // 这样在整个应用程序中都可以通过SecurityUtils获取SecurityManager
46
    SecurityUtils.setSecurityManager(securityManager);
47

48
    // 获取当前执行用户（Subject），Subject代表当前正在与软件进行交互的用户
49
    Subject currentUser = SecurityUtils.getSubject();
50
    // 判断当前用户是否已经通过认证
51
    if (!currentUser.isAuthenticated()) {
52
      // 如果未认证，则创建UsernamePasswordToken令牌，用于封装用户身份信息
53
      // 这里使用预设的用户名"user"和密码"password"
54
      UsernamePasswordToken token = new UsernamePasswordToken("user", "password");
55
      // 使用令牌进行用户登录认证
56
      currentUser.login(token);
57
      // 认证成功后，记录用户登录成功的日志信息
58
      LOGGER.info("用户 {} 登录成功！", currentUser.getPrincipal());
59
    }
60

61
    // 检查用户是否具有"role"角色（与配置文件中定义的角色一致）
62
    // hasRole方法用于判断当前用户是否拥有指定角色
63
    if (currentUser.hasRole("role")){
64
      LOGGER.info("用户 {} 拥有角色 role", currentUser.getPrincipal());
65
    }else {
66
      LOGGER.info("用户 {} 没有角色 role", currentUser.getPrincipal());
67
    }
68

69
    // 检查用户是否具有"admin"角色（根据配置应该不存在此角色）
70
    if (currentUser.hasRole("admin")){
71
      LOGGER.info("用户 {} 拥有角色 admin", currentUser.getPrincipal());
72
    }else {
73
      LOGGER.info("用户 {} 没有角色 admin", currentUser.getPrincipal());
74
    }
75
  }
76
}

1
package com.shiro.tutorial;
2

3
import org.apache.shiro.SecurityUtils;
4
import org.apache.shiro.authc.UsernamePasswordToken;
5
import org.apache.shiro.mgt.DefaultSecurityManager;
6
import org.apache.shiro.realm.text.IniRealm;
7
import org.apache.shiro.subject.Subject;
8
import org.slf4j.Logger;
9
import org.slf4j.LoggerFactory;
10

11
/**
12
 * Apache Shiro 权限控制示例类
13
 * 开发思路：
14
 * 1. 配置支持权限的Realm和安全管理器
15
 * 2. 实现用户身份认证
16
 * 3. 验证用户细粒度权限控制功能
17
 *
18
 * @author 李昊哲 李胜龙
19
 * @version 1.0.0
20
 */
21
public class PermissionExample {
22
  // 创建日志记录器，用于输出程序运行信息
23
  private static final Logger LOGGER = LoggerFactory.getLogger(PermissionExample.class);
24

25
  /**
26
   * 程序入口方法
27
   * 开发过程：
28
   * 1. 初始化Shiro安全框架组件，加载权限配置
29
   * 2. 进行用户身份认证
30
   * 3. 验证用户权限检查功能
31
   *
32
   * @param args 命令行参数
33
   */
34
  public static void main(String[] args) {
35
    // 创建 IniRealm 实例，使用专门的权限配置文件shiro-permission.ini
36
    // 该配置文件中包含了用户、角色及具体权限的映射关系
37
    IniRealm iniRealm = new IniRealm("classpath:shiro-permission.ini");
38

39
    // 创建 SecurityManager 安全管理器实例，并传入realm
40
    // SecurityManager是Shiro框架的核心，负责协调内部安全组件
41
    DefaultSecurityManager securityManager = new DefaultSecurityManager(iniRealm);
42

43
    // 将 SecurityManager 绑定到 SecurityUtils 工具类
44
    // 这样在整个应用程序中都可以通过SecurityUtils获取SecurityManager
45
    SecurityUtils.setSecurityManager(securityManager);
46

47
    // 获取当前执行用户（Subject），Subject代表当前正在与软件进行交互的用户
48
    Subject currentUser = SecurityUtils.getSubject();
49
    // 判断当前用户是否已经通过认证
50
    if (!currentUser.isAuthenticated()) {
51
      // 如果未认证，则创建UsernamePasswordToken令牌，用于封装用户身份信息
52
      // 这里使用预设的用户名"user"和密码"password"
53
      UsernamePasswordToken token = new UsernamePasswordToken("user", "password");
54
      // 使用令牌进行用户登录认证
55
      currentUser.login(token);
56
      // 认证成功后，记录用户登录成功的日志信息
57
      LOGGER.info("用户 {} 登录成功！", currentUser.getPrincipal());
58
    }
59

60
    // 检查用户是否具有"resource:action:object"权限
61
    // isPermitted方法用于判断当前用户是否拥有指定权限
62
    // 权限格式通常采用"资源:操作:对象"的形式表示
63
    if (currentUser.isPermitted("resource:action:object")) {
64
      LOGGER.info("用户 {} 拥有权限 resource:action:object", currentUser.getPrincipal());
65
    } else {
66
      LOGGER.info("用户 {} 没有权限 resource:action:object", currentUser.getPrincipal());
67
    }
68

69
    // 检查用户是否具有"another:resource:action"权限
70
    if (currentUser.isPermitted("another:resource:action")) {
71
      LOGGER.info("用户 {} 拥有权限 another:resource:action", currentUser.getPrincipal());
72
    } else {
73
      LOGGER.info("用户 {} 没有权限 another:resource:action", currentUser.getPrincipal());
74
    }
75

76
    // 正常退出程序
77
    System.exit(0);
78
  }
79
}

1
# 用户配置部分，用于定义系统中的用户、密码及其所属角色
2
[users]
3
# 格式: 用户名 = 密码, 角色1, 角色2...
4
# 示例配置了一个用户名为"user"，密码为"password"的用户
5
# 该用户同时属于"role1"和"role2"两个角色
6
user = password, role1, role2
7

8
# 角色权限配置部分，用于定义角色所拥有的权限
9
[roles]
10
# 格式: 角色名 = 权限表达式
11
# 权限表达式通常采用"资源:操作:对象"的格式来描述
12
# role1角色具有对资源(resource)执行动作(action)的权限，作用对象为object
13
role1 = resource:action:object
14
# role2角色具有对资源(another)执行动作(resource)的权限，作用对象为action
15
role2 = another:resource:action

1
package com.shiro.tutorial;
2

3
import org.apache.shiro.SecurityUtils;
4
import org.apache.shiro.authc.UsernamePasswordToken;
5
import org.apache.shiro.mgt.DefaultSecurityManager;
6
import org.apache.shiro.realm.text.IniRealm;
7
import org.apache.shiro.session.Session;
8
import org.apache.shiro.subject.Subject;
9
import org.slf4j.Logger;
10
import org.slf4j.LoggerFactory;
11

12
/**
13
 * Apache Shiro 会话管理示例类
14
 * 开发思路：
15
 * 1. 配置支持会话管理的Realm和安全管理器
16
 * 2. 实现用户身份认证
17
 * 3. 演示Shiro会话管理功能的使用
18
 *
19
 * @author 李昊哲 李胜龙
20
 * @version 1.0.0
21
 */
22
public class SessionExample {
23
  // 创建日志记录器，用于输出程序运行信息
24
  private static final Logger LOGGER = LoggerFactory.getLogger(SessionExample.class);
25

26
  /**
27
   * 程序入口方法，演示Shiro会话管理功能
28
   * 功能流程：
29
   * 1. 初始化Shiro核心组件和配置
30
   * 2. 进行用户身份认证
31
   * 3. 演示会话的创建、属性操作、过期管理和失效处理
32
   *
33
   * @param args 命令行参数
34
   */
35
  public static void main(String[] args) {
36
    // 创建 IniRealm 实例，使用专门的权限配置文件shiro-session.ini
37
    // 该配置文件中包含了用户、角色及具体权限的映射关系
38
    IniRealm iniRealm = new IniRealm("classpath:shiro-session.ini");
39

40
    // 创建 SecurityManager 安全管理器实例，并传入realm
41
    // SecurityManager是Shiro框架的核心，负责协调内部安全组件
42
    DefaultSecurityManager securityManager = new DefaultSecurityManager(iniRealm);
43

44
    // 将 SecurityManager 绑定到 SecurityUtils 工具类
45
    // 这样在整个应用程序中都可以通过SecurityUtils获取SecurityManager
46
    SecurityUtils.setSecurityManager(securityManager);
47

48
    // 获取当前执行用户（Subject），Subject代表当前正在与软件进行交互的用户
49
    Subject currentUser = SecurityUtils.getSubject();
50
    // 判断当前用户是否已经通过认证
51
    if (!currentUser.isAuthenticated()) {
52
      // 如果未认证，则创建UsernamePasswordToken令牌，用于封装用户身份信息
53
      // 这里使用预设的用户名"user"和密码"password"
54
      UsernamePasswordToken token = new UsernamePasswordToken("user", "password");
55
      // 使用令牌进行用户登录认证
56
      currentUser.login(token);
57
      // 认证成功后，记录用户登录成功的日志信息
58
      LOGGER.info("用户 {} 登录成功！", currentUser.getPrincipal());
59
    }
60

61
    // 获取当前用户的会话（Session）对象
62
    // Session是Shiro提供的会话管理接口，类似于Web中的HttpSession
63
    Session session = currentUser.getSession();
64

65
    // 在会话中设置属性，存储用户相关信息
66
    session.setAttribute("username", "user");
67
    session.setAttribute("loginTime", System.currentTimeMillis());
68

69
    // 从会话中获取之前设置的属性值
70
    String username = (String) session.getAttribute("username");
71
    long loginTime = (Long) session.getAttribute("loginTime");
72

73
    // 输出从会话中获取的信息到日志
74
    LOGGER.info("用户 {} 登录时间：{}", username, loginTime);
75

76
    // 从会话中移除指定属性
77
    session.removeAttribute("loginTime");
78
    LOGGER.info("用户 {} 登录时间已移除", username);
79

80
    // ==================== 会话高级功能演示 ====================
81

82
    // 1. 会话标识与时间信息
83
    String sessionId = session.getId().toString();
84
    LOGGER.info("会话ID：{}", sessionId);
85

86
    long creationTime = session.getStartTimestamp().getTime();
87
    LOGGER.info("会话创建时间：{}", creationTime);
88

89
    long lastAccessTime = session.getLastAccessTime().getTime();
90
    LOGGER.info("会话最后访问时间：{}", lastAccessTime);
91

92
    // 2. 会话过期时间管理
93
    session.setTimeout(3600000); // 设置会话过期时间为1小时
94
    LOGGER.info("会话过期时间已设置为1小时");
95

96
    long timeout = session.getTimeout();
97
    LOGGER.info("当前会话过期时间：{}毫秒", timeout);
98

99
    // 3. 会话过期检查
100
    // Shiro中Session接口没有直接的isExpired()方法
101
    // 会话过期通常在访问时自动检查，过期会抛出ExpiredSessionException
102
    try {
103
        session.getAttribute("username"); // 尝试访问会话属性，自动检查过期
104
        LOGGER.info("会话未过期");
105
    } catch (org.apache.shiro.session.ExpiredSessionException e) {
106
        LOGGER.info("会话已过期");
107
    }
108

109
    // 4. 会话活动管理
110
    session.touch(); // 更新会话最后访问时间
111
    LOGGER.info("会话最后访问时间已更新");
112

113
    // 5. 会话失效处理
114
    session.stop(); // 手动使会话失效
115
    LOGGER.info("会话已失效");
116

117
    // 正常退出程序
118
    System.exit(0);
119
  }
120
}

1
package com.shiro.tutorial;
2

3
import org.apache.shiro.crypto.hash.SimpleHash;
4
import org.slf4j.Logger;
5
import org.slf4j.LoggerFactory;
6

7
/**
8
 * Apache Shiro 加密示例类
9
 * 开发思路：
10
 * 1. 演示如何使用Shiro进行密码加密
11
 * 2. 展示盐值加密的重要性
12
 * 3. 演示加密密码的验证过程
13
 *
14
 * @author 李昊哲 李胜龙
15
 * @version 1.0.0
16
 */
17
public class EncryptionExample {
18
  // 创建日志记录器，用于输出程序运行信息
19
  private static final Logger LOGGER = LoggerFactory.getLogger(EncryptionExample.class);
20

21
  /**
22
   * 程序入口方法
23
   * 开发过程：
24
   * 1. 演示明文密码加密过程
25
   * 2. 展示带盐值的密码加密
26
   * 3. 演示加密密码的验证
27
   *
28
   * @param args 命令行参数
29
   */
30
  public static void main(String[] args) {
31
    // 原始密码
32
    String originalPassword = "password";
33

34
    // 使用MD5算法加密密码
35
    String md5Hash = new SimpleHash("MD5", originalPassword).toHex();
36
    LOGGER.info("原始密码：{}，MD5加密结果：{}", originalPassword, md5Hash);
37

38
    // 使用SHA-256算法加密密码
39
    String sha256Hash = new SimpleHash("SHA-256", originalPassword).toHex();
40
    LOGGER.info("原始密码：{}，SHA-256加密结果：{}", originalPassword, sha256Hash);
41

42
    // 使用盐值加密密码（增强安全性）
43
    String salt = "randomSalt123";
44
    String saltedHash = new SimpleHash("SHA-256", originalPassword, salt, 1024).toHex();
45
    LOGGER.info("原始密码：{}，盐值加密结果：{}", originalPassword, saltedHash);
46

47
    // 演示密码验证过程
48
    String inputPassword = "password";
49
    String hashedInput = new SimpleHash("SHA-256", originalPassword, salt, 1024).toHex();
50

51
    if (hashedInput.equals(saltedHash)) {
52
      LOGGER.info("密码验证成功！");
53
    } else {
54
      LOGGER.info("密码验证失败！");
55
    }
56

57
    // 错误密码验证示例
58
    String wrongPassword = "wrongPassword";
59
    String wrongHashedInput = new SimpleHash("SHA-256", wrongPassword, salt, 1024).toHex();
60
    if (wrongHashedInput.equals(saltedHash)) {
61
      LOGGER.info("错误密码验证成功！（不应该出现这种情况）");
62
    } else {
63
      LOGGER.info("错误密码验证失败！（这是预期的结果）");
64
    }
65

66
    // 正常退出程序
67
    System.exit(0);
68
  }
69
}

1
package com.shiro.tutorial;
2

3
import org.apache.shiro.SecurityUtils;
4
import org.apache.shiro.authc.*;
5
import org.apache.shiro.authz.AuthorizationInfo;
6
import org.apache.shiro.authz.SimpleAuthorizationInfo;
7
import org.apache.shiro.mgt.DefaultSecurityManager;
8
import org.apache.shiro.realm.AuthorizingRealm;
9
import org.apache.shiro.subject.PrincipalCollection;
10
import org.apache.shiro.subject.Subject;
11
import org.slf4j.Logger;
12
import org.slf4j.LoggerFactory;
13

14
import java.util.HashMap;
15
import java.util.HashSet;
16
import java.util.Set;
17

18
/**
19
 * Apache Shiro 自定义Realm示例类
20
 * 开发思路：
21
 * 1. 创建自定义Realm类继承AuthorizingRealm
22
 * 2. 实现认证和授权方法
23
 * 3. 配置安全管理器使用自定义Realm
24
 * 4. 验证自定义Realm功能
25
 *
26
 * @author 李昊哲 李胜龙
27
 * @version 1.0.0
28
 * @since 2025-12-15
29
 */
30
public class CustomRealmExample {
31
  // 创建日志记录器，用于输出程序运行信息
32
  private static final Logger LOGGER = LoggerFactory.getLogger(CustomRealmExample.class);
33

34
  /**
35
   * 程序入口方法
36
   * 开发过程：
37
   * 1. 初始化自定义Realm
38
   * 2. 配置安全管理器
39
   * 3. 进行用户身份认证和授权验证
40
   *
41
   * @param args 命令行参数
42
   */
43
  public static void main(String[] args) {
44
    // 创建自定义 Realm 实例
45
    UserRealm userRealm = new UserRealm();
46

47
    // 创建 SecurityManager 安全管理器实例，并传入realm
48
    // SecurityManager是Shiro框架的核心，负责协调内部安全组件
49
    DefaultSecurityManager securityManager = new DefaultSecurityManager(userRealm);
50

51
    // 将 SecurityManager 绑定到 SecurityUtils 工具类
52
    // 这样在整个应用程序中都可以通过SecurityUtils获取SecurityManager
53
    SecurityUtils.setSecurityManager(securityManager);
54

55
    // 获取当前执行用户（Subject），Subject代表当前正在与软件进行交互的用户
56
    Subject currentUser = SecurityUtils.getSubject();
57

58
    // 判断当前用户是否已经通过认证
59
    if (!currentUser.isAuthenticated()) {
60
      // 如果未认证，则创建UsernamePasswordToken令牌，用于封装用户身份信息
61
      // 这里使用预设的用户名"user"和密码"password"
62
      UsernamePasswordToken token = new UsernamePasswordToken("admin", "admin123");
63
      try {
64
        // 使用令牌进行用户登录认证
65
        currentUser.login(token);
66
        // 认证成功后，记录用户登录成功的日志信息
67
        LOGGER.info("用户 {} 登录成功！", currentUser.getPrincipal());
68
      } catch (UnknownAccountException uae) {
69
        // 捕获用户名不存在异常
70
        LOGGER.error("用户名不存在", uae);
71
      } catch (IncorrectCredentialsException ice) {
72
        // 捕获密码错误异常
73
        LOGGER.error("密码错误", ice);
74
      } catch (AuthenticationException ae) {
75
        // 捕获其他身份认证相关异常
76
        LOGGER.error("认证失败", ae);
77
      }
78
    } else {
79
      // 如果用户已经通过认证，则记录相应日志
80
      LOGGER.info("用户已认证");
81
    }
82

83
    // 验证用户是否有 admin 角色
84
    if (currentUser.hasRole("admin")) {
85
      LOGGER.info("用户具有 admin 角色");
86
    } else {
87
      LOGGER.info("用户不具有 admin 角色");
88
    }
89

90
    // 验证用户是否有user:delete权限
91
    if (currentUser.isPermitted("user:delete")) {
92
      LOGGER.info("用户有删除用户的权限");
93
    } else {
94
      LOGGER.info("用户没有删除用户的权限");
95
    }
96

97
    // 验证用户是否有product:create权限
98
    if (currentUser.isPermitted("product:create")) {
99
      LOGGER.info("用户有创建产品的权限");
100
    } else {
101
      LOGGER.info("用户没有创建产品的权限");
102
    }
103

104
    // 正常退出程序
105
    System.exit(0);
106
  }
107

108
  public static class UserRealm extends AuthorizingRealm {
109
    // 模拟用户数据库
110
    private static final HashMap<String, String> userDatabase = new HashMap<>();
111
    // 模拟角色数据库
112
    private static final HashMap<String, Set<String>> roleDatabase = new HashMap<>();
113
    // 模拟权限数据库
114
    private static final HashMap<String, Set<String>> permissionDatabase = new HashMap<>();
115

116
    // 初始化模拟数据
117
    static {
118
      // 添加用户（用户名:密码）
119
      userDatabase.put("admin", "admin123");
120
      userDatabase.put("user", "user123");
121

122
      // 添加用户角色
123
      Set<String> adminRoles = new HashSet<>();
124
      adminRoles.add("admin");
125
      adminRoles.add("user");
126
      roleDatabase.put("admin", adminRoles);
127

128
      Set<String> userRoles = new HashSet<>();
129
      userRoles.add("user");
130
      roleDatabase.put("user", userRoles);
131

132
      // 添加角色权限
133
      Set<String> adminPermissions = new HashSet<>();
134
      adminPermissions.add("user:*");
135
      adminPermissions.add("product:*");
136
      permissionDatabase.put("admin", adminPermissions);
137

138
      Set<String> userPermissions = new HashSet<>();
139
      userPermissions.add("product:view");
140
      userPermissions.add("product:create");
141
      permissionDatabase.put("user", userPermissions);
142
    }
143

144
    /**
145
     * 认证方法：获取认证信息
146
     *
147
     * @param authenticationToken 认证令牌
148
     * @return 认证信息
149
     * @throws AuthenticationException 认证异常
150
     */
151
    @Override
152
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
153
      // 获取用户名
154
      String username = (String) authenticationToken.getPrincipal();
155

156
      // 从模拟数据库中获取用户密码
157
      String password = userDatabase.get(username);
158

159
      // 检查用户是否存在
160
      if (password == null) {
161
        throw new UnknownAccountException("用户不存在");
162
      }
163
      // 返回认证信息
164
      return new SimpleAuthenticationInfo(username, password, getName());
165
    }
166

167
    /**
168
     * 授权方法：获取授权信息
169
     *
170
     * @param principalCollection 身份信息
171
     * @return 授权信息
172
     */
173
    @Override
174
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
175
      // 获取用户名
176
      String username = (String) principalCollection.getPrimaryPrincipal();
177

178
      // 创建授权信息对象
179
      SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
180

181
      // 添加角色
182
      authorizationInfo.addRoles(roleDatabase.get(username));
183

184
      // 添加权限
185
      authorizationInfo.addStringPermissions(permissionDatabase.get(username));
186

187
      // 返回授权信息
188
      return authorizationInfo;
189
    }
190

191
  }
192
}

1
package com.shiro.tutorial;
2

3
import org.apache.shiro.SecurityUtils;
4
import org.apache.shiro.authc.UsernamePasswordToken;
5
import org.apache.shiro.cache.MemoryConstrainedCacheManager;
6
import org.apache.shiro.mgt.DefaultSecurityManager;
7
import org.apache.shiro.realm.text.IniRealm;
8
import org.apache.shiro.subject.Subject;
9
import org.slf4j.Logger;
10
import org.slf4j.LoggerFactory;
11

12
/**
13
 * Apache Shiro 缓存支持示例类
14
 * 开发思路：
15
 * 1. 配置支持缓存的Realm和安全管理器
16
 * 2. 实现用户身份认证
17
 * 3. 演示Shiro缓存功能的使用
18
 */
19
public class CacheExample {
20

21
  // 创建日志记录器，用于输出程序运行信息
22
  private static final Logger log = LoggerFactory.getLogger(CacheExample.class);
23

24
  /**
25
   * 程序入口方法
26
   * 开发过程：
27
   * 1. 初始化Shiro安全框架组件，配置缓存管理器
28
   * 2. 进行用户身份认证
29
   * 3. 演示缓存功能
30
   */
31
  public static void main(String[] args) {
32
    // 创建 IniRealm 实例，使用专门的会话配置文件shiro-session.ini
33
    IniRealm iniRealm = new IniRealm("classpath:shiro-session.ini");
34

35
    // 启用缓存 - 设置缓存管理器
36
    iniRealm.setCacheManager(new MemoryConstrainedCacheManager());
37
    // 启用认证缓存
38
    iniRealm.setAuthenticationCachingEnabled(true);
39
    // 启用授权缓存
40
    iniRealm.setAuthorizationCachingEnabled(true);
41

42
    // 创建 SecurityManager 安全管理器实例，并传入realm
43
    DefaultSecurityManager securityManager = new DefaultSecurityManager(iniRealm);
44

45
    // 将 SecurityManager 绑定到 SecurityUtils 工具类
46
    SecurityUtils.setSecurityManager(securityManager);
47

48
    // 获取当前执行用户（Subject）
49
    Subject currentUser = SecurityUtils.getSubject();
50

51
    // 判断当前用户是否已经通过认证
52
    if (!currentUser.isAuthenticated()) {
53
      // 如果未认证，则创建UsernamePasswordToken令牌
54
      UsernamePasswordToken token = new UsernamePasswordToken("user", "password");
55

56
      try {
57
        // 执行用户登录认证
58
        currentUser.login(token);
59
        // 认证成功后，记录用户登录成功的日志信息
60
        log.info("用户 {} 登录成功！", currentUser.getPrincipal());
61
      } catch (Exception e) {
62
        log.error("认证失败", e);
63
      }
64
    }
65

66
    // 检查用户角色（第一次）
67
    boolean hasRoleFirst = currentUser.hasRole("admin");
68
    log.info("第一次检查用户是否有admin角色: {}", hasRoleFirst);
69

70
    // 再次检查用户角色（应该从缓存中获取）
71
    boolean hasRoleSecond = currentUser.hasRole("admin");
72
    log.info("第二次检查用户是否有admin角色: {}", hasRoleSecond);
73

74
    // 检查用户权限（第一次）
75
    boolean isPermittedFirst = currentUser.isPermitted("user:create");
76
    log.info("第一次检查用户是否有'user:create'权限: {}", isPermittedFirst);
77

78
    // 再次检查用户权限（应该从缓存中获取）
79
    boolean isPermittedSecond = currentUser.isPermitted("user:create");
80
    log.info("第二次检查用户是否有'user:create'权限: {}", isPermittedSecond);
81

82
    log.info("=== 缓存说明 ===");
83
    log.info("1. Shiro提供了多种缓存管理器实现:");
84
    log.info("   - MemoryConstrainedCacheManager: 基于内存的简单缓存管理器");
85
    log.info("   - EhCacheManager: 基于Ehcache的缓存管理器");
86
    log.info("   - SpringCacheManager: 基于Spring Cache的缓存管理器");
87
    log.info("   - RedisCacheManager: 基于Redis的缓存管理器");
88
    log.info("");
89
    log.info("2. 缓存配置要点:");
90
    log.info("   - 启用认证缓存: setAuthenticationCachingEnabled(true)");
91
    log.info("   - 启用授权缓存: setAuthorizationCachingEnabled(true)");
92
    log.info("   - 设置缓存名称: setAuthenticationCacheName() 和 setAuthorizationCacheName()");
93
    log.info("");
94
    log.info("3. 缓存的好处:");
95
    log.info("   - 减少数据库访问次数");
96
    log.info("   - 提高认证和授权检查的速度");
97
    log.info("   - 降低系统负载");
98

99
    // 正常退出程序
100
    System.exit(0);
101
  }
102
}

1
package com.shiro.tutorial.jwt;
2

3
import io.jsonwebtoken.Jwts;
4
import org.slf4j.Logger;
5
import org.slf4j.LoggerFactory;
6

7
import javax.crypto.SecretKey;
8
import java.util.Date;
9

10
/**
11
 * JWT工具类
12
 * 用于生成和验证JWT令牌
13
 *
14
 * @author 李昊哲 李胜龙
15
 * @version 2.0.6
16
 */
17
public class JwtUtils {
18

19
  // 创建日志记录器，用于输出程序运行信息
20
  private static final Logger log = LoggerFactory.getLogger(JwtUtils.class);
21

22
  // JWT 签名密钥
23
  public static final SecretKey SECRET_KEY = Jwts.SIG.HS256.key().build();
24

25
  // 令牌过期时间（24小时）
26
  private static final long EXPIRATION_TIME = 86400000;
27

28
  /**
29
   * 生成 JWT 令牌
30
   *
31
   * @param username 用户名
32
   * @return JWT 令牌字符串
33
   */
34
  public static String generateToken(String username) {
35
    Date now = new Date();
36
    Date expirationDate = new Date(now.getTime() + EXPIRATION_TIME);
37
    // 参数含义 ：主题、签发时间、过期时间、密钥
38
    // compact 方法将JWT令牌转换为字符串并返回
39
    return Jwts.builder()
40
        .subject(username)
41
        .issuedAt(now)
42
        .expiration(expirationDate)
43
        .signWith(SECRET_KEY)
44
        .compact();
45
  }
46

47
  /**
48
   * 从 JWT 令牌中提取用户名
49
   *
50
   * @param token JWT 令牌
51
   * @return 用户名
52
   */
53
  public static String getUsernameFromToken(String token) {
54
    try {
55
      return Jwts.parser()
56
          .verifyWith(SECRET_KEY)
57
          .build()
58
          .parseSignedClaims(token)
59
          .getPayload()
60
          .getSubject();
61
    } catch (Exception e) {
62
      log.error("解析 JWT 令牌失败", e);
63
      return null;
64
    }
65
  }
66

67
  /**
68
   * 验证 JWT 令牌的有效性
69
   *
70
   * @param token JWT 令牌
71
   * @return 令牌是否有效
72
   */
73
  public static boolean validateToken(String token) {
74
    try {
75
      Jwts.parser()
76
          .verifyWith(SECRET_KEY)
77
          .build()
78
          .parseSignedClaims(token);
79
      return true;
80
    } catch (Exception e) {
81
      log.error("JWT 令牌验证失败", e);
82
      return false;
83
    }
84
  }
85
}