package com.shiro.tutorial;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.realm.text.IniRealm;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

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

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

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

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

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

      try {
        // 使用令牌进行用户登录认证
        currentUser.login(token);
        // 认证成功后，记录用户登录成功的日志信息
        LOGGER.info("用户 {} 登录成功！", currentUser.getPrincipal());
      } catch (UnknownAccountException uae) {
        // 捕获用户名不存在异常
        LOGGER.error("用户名不存在", uae);
      } catch (IncorrectCredentialsException ice) {
        // 捕获密码错误异常
        LOGGER.error("密码错误", ice);
      } catch (AuthenticationException ae) {
        // 捕获其他身份认证相关异常
        LOGGER.error("认证失败", ae);
      }
    } else {
      // 如果用户已经通过认证，则记录相应日志
      LOGGER.info("用户已认证");
    }
  }
}

package com.shiro.tutorial;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.realm.text.IniRealm;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

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

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

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

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

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

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

package com.shiro.tutorial;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.realm.text.IniRealm;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

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

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

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

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

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

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

    // 正常退出程序
    System.exit(0);
  }
}

package com.shiro.tutorial;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.realm.text.IniRealm;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

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

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

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

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

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

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

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

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

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

    // ==================== 会话高级功能演示 ====================
    
    // 1. 会话标识与时间信息
    String sessionId = session.getId().toString();
    LOGGER.info("会话ID：{}", sessionId);
    
    long creationTime = session.getStartTimestamp().getTime();
    LOGGER.info("会话创建时间：{}", creationTime);
    
    long lastAccessTime = session.getLastAccessTime().getTime();
    LOGGER.info("会话最后访问时间：{}", lastAccessTime);
    
    // 2. 会话过期时间管理
    session.setTimeout(3600000); // 设置会话过期时间为1小时
    LOGGER.info("会话过期时间已设置为1小时");
    
    long timeout = session.getTimeout();
    LOGGER.info("当前会话过期时间：{}毫秒", timeout);
    
    // 3. 会话过期检查
    // Shiro中Session接口没有直接的isExpired()方法
    // 会话过期通常在访问时自动检查，过期会抛出ExpiredSessionException
    try {
        session.getAttribute("username"); // 尝试访问会话属性，自动检查过期
        LOGGER.info("会话未过期");
    } catch (org.apache.shiro.session.ExpiredSessionException e) {
        LOGGER.info("会话已过期");
    }
    
    // 4. 会话活动管理
    session.touch(); // 更新会话最后访问时间
    LOGGER.info("会话最后访问时间已更新");
    
    // 5. 会话失效处理
    session.stop(); // 手动使会话失效
    LOGGER.info("会话已失效");
    
    // 正常退出程序
    System.exit(0);
  }
}

package com.shiro.tutorial;

import org.apache.shiro.crypto.hash.SimpleHash;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

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

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

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

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

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

    if (hashedInput.equals(saltedHash)) {
      LOGGER.info("密码验证成功！");
    } else {
      LOGGER.info("密码验证失败！");
    }

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

    // 正常退出程序
    System.exit(0);
  }
}

package com.shiro.tutorial;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

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

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

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

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

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

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

    // 验证用户是否有 admin 角色
    if (currentUser.hasRole("admin")) {
      LOGGER.info("用户具有 admin 角色");
    } else {
      LOGGER.info("用户不具有 admin 角色");
    }

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

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

    // 正常退出程序
    System.exit(0);
  }

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

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

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

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

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

      Set<String> userPermissions = new HashSet<>();
      userPermissions.add("product:view");
      userPermissions.add("product:create");
      permissionDatabase.put("user", userPermissions);
    }

    /**
     * 认证方法：获取认证信息
     *
     * @param authenticationToken 认证令牌
     * @return 认证信息
     * @throws AuthenticationException 认证异常
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
      // 获取用户名
      String username = (String) authenticationToken.getPrincipal();

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

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

    /**
     * 授权方法：获取授权信息
     *
     * @param principalCollection 身份信息
     * @return 授权信息
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
      // 获取用户名
      String username = (String) principalCollection.getPrimaryPrincipal();

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

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

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

      // 返回授权信息
      return authorizationInfo;
    }

  }
}

package com.shiro.tutorial;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.cache.MemoryConstrainedCacheManager;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.realm.text.IniRealm;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

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

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

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

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

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

    // 判断当前用户是否已经通过认证
    if (!currentUser.isAuthenticated()) {
      // 如果未认证，则创建UsernamePasswordToken令牌
      UsernamePasswordToken token = new UsernamePasswordToken("user", "password");
      
      try {
        // 执行用户登录认证
        currentUser.login(token);
        // 认证成功后，记录用户登录成功的日志信息
        log.info("用户 {} 登录成功！", currentUser.getPrincipal());
      } catch (Exception e) {
        log.error("认证失败", e);
      }
    }
    
    // 检查用户角色（第一次）
    boolean hasRoleFirst = currentUser.hasRole("admin");
    log.info("第一次检查用户是否有admin角色: {}", hasRoleFirst);
    
    // 再次检查用户角色（应该从缓存中获取）
    boolean hasRoleSecond = currentUser.hasRole("admin");
    log.info("第二次检查用户是否有admin角色: {}", hasRoleSecond);
    
    // 检查用户权限（第一次）
    boolean isPermittedFirst = currentUser.isPermitted("user:create");
    log.info("第一次检查用户是否有'user:create'权限: {}", isPermittedFirst);
    
    // 再次检查用户权限（应该从缓存中获取）
    boolean isPermittedSecond = currentUser.isPermitted("user:create");
    log.info("第二次检查用户是否有'user:create'权限: {}", isPermittedSecond);
    
    log.info("=== 缓存说明 ===");
    log.info("1. Shiro提供了多种缓存管理器实现:");
    log.info("   - MemoryConstrainedCacheManager: 基于内存的简单缓存管理器");
    log.info("   - EhCacheManager: 基于Ehcache的缓存管理器");
    log.info("   - SpringCacheManager: 基于Spring Cache的缓存管理器");
    log.info("   - RedisCacheManager: 基于Redis的缓存管理器");
    log.info("");
    log.info("2. 缓存配置要点:");
    log.info("   - 启用认证缓存: setAuthenticationCachingEnabled(true)");
    log.info("   - 启用授权缓存: setAuthorizationCachingEnabled(true)");
    log.info("   - 设置缓存名称: setAuthenticationCacheName() 和 setAuthorizationCacheName()");
    log.info("");
    log.info("3. 缓存的好处:");
    log.info("   - 减少数据库访问次数");
    log.info("   - 提高认证和授权检查的速度");
    log.info("   - 降低系统负载");

    // 正常退出程序
    System.exit(0);
  }
}

package com.shiro.tutorial.jwt;

import io.jsonwebtoken.Jwts;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.crypto.SecretKey;
import java.util.Date;

/**
 * JWT工具类
 * 用于生成和验证JWT令牌
 *
 * @author 李昊哲 李胜龙
 * @version 2.0.6
 */
public class JwtUtils {

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

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

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

  /**
   * 生成 JWT 令牌
   *
   * @param username 用户名
   * @return JWT 令牌字符串
   */
  public static String generateToken(String username) {
    Date now = new Date();
    Date expirationDate = new Date(now.getTime() + EXPIRATION_TIME);
    // 参数含义 ：主题、签发时间、过期时间、密钥
    // compact 方法将JWT令牌转换为字符串并返回
    return Jwts.builder()
        .subject(username)
        .issuedAt(now)
        .expiration(expirationDate)
        .signWith(SECRET_KEY)
        .compact();
  }

  /**
   * 从 JWT 令牌中提取用户名
   *
   * @param token JWT 令牌
   * @return 用户名
   */
  public static String getUsernameFromToken(String token) {
    try {
      return Jwts.parser()
          .verifyWith(SECRET_KEY)
          .build()
          .parseSignedClaims(token)
          .getPayload()
          .getSubject();
    } catch (Exception e) {
      log.error("解析 JWT 令牌失败", e);
      return null;
    }
  }

  /**
   * 验证 JWT 令牌的有效性
   *
   * @param token JWT 令牌
   * @return 令牌是否有效
   */
  public static boolean validateToken(String token) {
    try {
      Jwts.parser()
          .verifyWith(SECRET_KEY)
          .build()
          .parseSignedClaims(token);
      return true;
    } catch (Exception e) {
      log.error("JWT 令牌验证失败", e);
      return false;
    }
  }
}

package com.shiro.tutorial.jwt;

import org.apache.shiro.authc.AuthenticationToken;

/**
 * JWT令牌类
 * 用于封装JWT令牌信息，实现Shiro的AuthenticationToken接口
 *
 * @author 李昊哲 李胜龙
 * @version 2.0.6
 */
public class JwtToken implements AuthenticationToken {

  /**
   * JWT 令牌字符串
   */
  private final String token;

  /**
   * 构造函数
   *
   * @param token JWT 令牌字符串
   */
  public JwtToken(String token) {
    this.token = token;
  }

  /**
   * 获取用户身份信息
   *
   * @return JWT 令牌字符串
   */
  @Override
  public Object getPrincipal() {
    return token;
  }

  /**
   * 获取用户凭据信息
   *
   * @return JWT 令牌字符串
   */
  @Override
  public Object getCredentials() {
    return token;
  }
}

package com.shiro.tutorial.jwt;

import io.jsonwebtoken.JwtException;
import io.jsonwebtoken.Jwts;
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.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashSet;
import java.util.Set;

/**
 * JWT Realm类
 * 用于处理JWT令牌的认证和授权
 *
 * @author 李昊哲 李胜龙
 * @version 2.0.6
 */
public class JwtRealm extends AuthorizingRealm {

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

  /**
   * 设置 Realm 支持的AuthenticationToken类型
   *
   * @param token 认证令牌
   * @return 是否支持该令牌类型
   */
  @Override
  public boolean supports(AuthenticationToken token) {
    return token instanceof JwtToken;
  }

  /**
   * 认证方法：获取认证信息
   *
   * @param authToken 认证令牌
   * @return 认证信息
   * @throws AuthenticationException 认证异常
   */
  @Override
  protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authToken) throws AuthenticationException {
    log.info("JWT Realm 开始认证...");

    // 获取 JWT 令牌
    String token = (String) authToken.getCredentials();

    // 验证 JWT 令牌
    if (!validateToken(token)) {
      throw new AuthenticationException("无效的 JWT 令牌");
    }

    // 从 JWT 令牌中获取用户名
    String username = getUsernameFromToken(token);

    // 返回认证信息
    return new SimpleAuthenticationInfo(username, token, getName());
  }

  /**
   * 授权方法：获取授权信息
   *
   * @param principals 身份信息
   * @return 授权信息
   */
  @Override
  protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
    log.info("JWT Realm 开始授权...");

    // 获取用户名
    String username = (String) principals.getPrimaryPrincipal();

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

    // 添加角色（模拟数据）
    Set<String> roles = getUserRoles(username);
    authorizationInfo.setRoles(roles);

    // 添加权限（模拟数据）
    Set<String> permissions = getUserPermissions(username);
    authorizationInfo.setStringPermissions(permissions);

    return authorizationInfo;
  }

  /**
   * 从 JWT 令牌中提取用户名
   *
   * @param token JWT 令牌
   * @return 用户名
   */
  private String getUsernameFromToken(String token) {
    try {
      return Jwts.parser()
          .verifyWith(JwtUtils.SECRET_KEY)
          .build()
          .parseSignedClaims(token)
          .getPayload()
          .getSubject();
    } catch (JwtException e) {
      log.error("解析 JWT 令牌失败", e);
      return null;
    }
  }

  /**
   * 验证 JWT 令牌的有效性
   *
   * @param token JWT 令牌
   * @return 令牌是否有效
   */
  private boolean validateToken(String token) {
    try {
      Jwts.parser()
          .verifyWith(JwtUtils.SECRET_KEY)
          .build()
          .parseSignedClaims(token);
      return true;
    } catch (JwtException e) {
      log.error("JWT 令牌验证失败", e);
      return false;
    }
  }

  /**
   * 获取用户角色（模拟实现）
   *
   * @param username 用户名
   * @return 用户角色集合
   */
  private Set<String> getUserRoles(String username) {
    Set<String> roles = new HashSet<>();

    // 模拟用户角色数据
    if ("admin".equals(username)) {
      roles.add("admin");
      roles.add("user");
    } else if ("user".equals(username)) {
      roles.add("user");
    }

    return roles;
  }

  /**
   * 获取用户权限（模拟实现）
   *
   * @param username 用户名
   * @return 用户权限集合
   */
  private Set<String> getUserPermissions(String username) {
    Set<String> permissions = new HashSet<>();

    // 模拟用户权限数据
    if ("admin".equals(username)) {
      permissions.add("user:*");
      permissions.add("product:*");
    } else if ("user".equals(username)) {
      permissions.add("product:view");
      permissions.add("product:create");
    }

    return permissions;
  }
}