shiro的使用与JWT整合

Posted 2021-10-02 前度吖

Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理的框架，当与JWT整合后，会使得我们的身份鉴权、角色管理、单点登录更加的简单

一、shiro入门

两大框架对比：安全框架Shiro和SpringSecurity的比较

了解shiro

什么是Shiro

1. Apache Shiro是一个Java的安全（权限）框架。|
2. Shiro可以完成，认证，授权，加密，会话管理，Web集成，缓存等。

shiro的功能

Authentication:身份认证、登录，验证用户是不是拥有相应的身份;
Authorization:授权，即权限验证，验证某个已认证的用户是否拥有某个权限，即判断用户能否进行什么操作，如:验证某个用户是否拥有某个角色，或者细粒度的验证某个用户对某个资源是否具有某个权限!
Session Manager:会话管理，即用户登录后就是第一次会话，在没有退出之前，它的所有信息都在会话中;会话可以是普通的JavaSE环境，也可以是Web环境;
Cryptography:加密，保护数据的安全性，如密码加密存储到数据库中，而不是明文存储;
# ------------------------------------------------------------------------------------
Web Support: Web支持，可以非常容易的集成到Web环境;
Caching:缓存，比如用户登录后，其用户信息，拥有的角色、权限不必每次去查，这样可以提高效率
Concurrency: Shiro支持多线程应用的并发验证，即，如在一个线程中开启另一个线程，能把权限自动的传播过去
Testing:提供测试支持;
Run As:允许一个用户假装为另一个用户（如果他们允许）的身份进行访问;
Remember Me:记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了

优点

• 简单的身份认证, 支持多种数据源
• 对角色的简单的授权, 支持细粒度的授权(方法级) c、支持一级缓存，以提升应用程序的性能
• 适用于 Web 以及非 Web 的环境e、非常简单的加密 API
• 不跟任何的框架或者容器捆绑, 可以独立运行

Shiro的架构

功能	描述
Subject	用户、主体
Securitymanager	管理所有用户
Authorizer	认证器、是一个接口
Authorizer	授权器、判断操作权限
Realm	连接数据

注意:Shiro 不会去维护用户、_维护权限;这些需要我们自己去设计/提供:然后通过相应的接口沣入给Sniro即可

依赖与配置

• 依赖

 <!-- shiro -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.7.1</version>
        </dependency>

• 日志配置（log4j）

#Default Shiro Logging
1og4j.1ogger.org.apache.shiro=INFO

#Disable verbose logging
log4j.logger.org.apache.shiro.util.ThreadContext=WARN
1og4j.1ogger.org.apache.shiro.cache.ehcache.EhCache=WARN

• shiro.ini

  ini文件说明

1. [mian] : 定义全局变量
   • 内置securityManger对象
   • 操作内置对象时，在[main]里面写东西

[main] 
securityManger.属性=值
# --
user=com.qd.user
securityManger.对象属性=$user

2. [users] : 定义用户名与密码

[users]
# 定义用户名为qd666
qd666 = 123456
# 定义用户名为qd666 同时具有admin、role1的角色
qd666 = 123456, admin，role1

3. [roles] : 定义角色

[roles]
role1=权限名1，权限名2
admin=权限名3，权限名4
# --- 用户表的查询，添加权限
role1=user:query,user:add

4. [urls] : 定义哪些内置urls生效.在web应用时使用

[urls]
# url地址=内置filter或自定义filter
# 访问时出现/login的url必须要去认支持authc对应的filter
/login=authc
# 任意的url都不需要进行认证等功能
/**=anon
# 所有的内容都必须保证用户已经登录
/**=user
# url abc访问时必须保证用户具有role1和role2的角色
/abc=roles["role1,role2"]

Realm结构

二、功能实现

配置实现认证

1. 身份验证

   在shiro 中，用户需要提供principals(身份）和credentials(证明）给shiro，从而应用能验证用户身份:

2. principals

   身份，即主体的标识属性，可以是任何东西，如用户名、邮箱等，唯一即可。一个主体可以有多个principals，但只有一个Primary principals，一般是用户名/密码/手机号。

3. credentials

   证明/凭正，即只有主体知道的安全值，如密码/数字证书等最常见的principals和credentials组合就是用户名/密码了。

认证流程

@Slf4j
public class Certification {
    //创建安全管理器工厂
    Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
    //使用工厂创建安全管理器
    SecurityManager securityManager = factory.getInstance();
    //把当前的安全管理器绑定到当前的线程
    SecurityUtils.setSecurityManager(securityManager);
    //获取当前的用户对象
    Subject currentUser = SecurityUtils.getSubject();

    //通过当前对象拿到Session
   // Session session = currentUser.getSession();
   // session.setAttribute("someKey","aValue");
   // String value = (String) session.getAttribute("someKey");

   // 判断用户是否认证通过
    if(!currentUser.isAuthenticated()) {
     		//封装用户名与密码
        AuthenticationToken token = new UsernamePasswordToken("lonestarr", "vespa");
        //设置记住我
        token.setRememberMe(true);
        try {
            //进行认证
            currentUser.login(token);  //执行了登录
        } catch (LockedAccountException lae) {   //用户锁定
            log.error(token.getPrincipal() + " is locked");
        } catch (AuthenticationException e) {
            log.error("用户名或密码不正确");
        }
    }
}

配置实现授权

授权，也叫访问控制，即在应用中控利谁能访问哪些资源―如访问页面/编辑数据/页面操作等)。在授权中需了解的几个关键对象:主体(Subject)、资源(Resource)、权限(Permission)角色(Role)。

对象	描述
主体	访问应用的用户
资源	某些页面、数据
权限	判断用户有无操作的权力
角色	权限的集合

授权流程

//接认证       
				//打印其识别主体
        log.info("User ["+currentUser.getPrincipal()+"] logged in successfully.");

        //角色判断 统一返回布尔值
        currentUser.hasRole("role1");
        List<String> list= Arrays.asList("role1","role2");
        //判断当前用户是否拥有list集合中的所有角色
        currentUser.hasAllRoles(list);
//--------------------------------------------------------
        //权限判断
        currentUser.isPermitted("user:query");
        //判断是否拥有全部的权限
        currentUser.isPermitted("user:query","user:add");
//--------------------------------------------------------
        //注销
        currentUser.logout();
        //结束
        System.exit(0);

认证与授权中主要的方法

 //获取当前的用户对象
        Subject currentUser = SecurityUtils.getSubject();
 //通过当前对象拿到Session
        Session session = currentUser.getSession();
//判断用户是否被认证
		currentUser.isAuthenticated()
//得到认证
        currentUser.getPrincipal()
//判断是否有此角色
        currentUser.hasRole("schwartz")
//判断是否有此权限
        currentUser.isPermitted("lightsaber:wield")
//注销
        currentUser.logout();

注意： Shiro默认使用自带的IniRealm,IniRealm从ini配置文件中读取用户的信息,但是开发中我们需要从数据库中获取数据，所以我们需要自定义Realm！

自定义Realm实现认证

需继承的接口

接口	描述
CachingRealm	负责缓存处理
AuthentictionRealm	负责认证
AuthorizingRealm	负责授权

通常自定义的realm继承AuthonizingRealm

• shiro配置类 固定步骤

@Configuration
public class ShiroConfig {
    //1.Realm 资源  自定义userRealm对象
    @Bean
    public Realm userRealm() { return new UserRealm(); }
    //2.securityManager 执行流程控制
    @Bean("securityManager")
    public DefaultWebSecurityManager getDefaultWebSecurityManager(UserRealm userRealm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        //关联Realm对象
        securityManager.setRealm(userRealm);
        return securityManager;
    }
    //3.ShiroFilterFactoryBean 请求过滤器
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("securityManager") DefaultWebSecurityManager defaultWebSecurityManager) {
        ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
        //设置安全管理器
        bean.setSecurityManager(defaultWebSecurityManager);
      //添加过滤器 设置默认请求等操作
        return bean;
    }
}

​ 在ShiroConfig 添加过滤器

map中的key值是ant路径
**   代表多级路径
*    代表单极路径
?    代表一个字符
# -----value是默认过滤器-------------
anon  ： 无需认证就可以访问
authc ： 必须认证了才能访问
user  ： 必须拥有 记住我 功能才能用
perms[] ： 拥有对某个资源的权限才能访问
role  ： 拥有某个角色权限才能访问

• *Realm类 继承AuthorizingRealm

public class UserRealm extends AuthorizingRealm {
    //授权方法
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("执行了授权方法");
     //....
        return null;
    }
  
    //认证方法
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        System.out.println("执行了认证方法");
      //......
        return null;
    }
}

自定义Realm实现授权

1. 对某些页面上的属性/组件进行授权

可以使用session解决  
在登录时将currentUser.getPricipal()放入session中
将currentUser.getPricipal()来自于MyRealm中doGetAuthenticationinfo认证方法返回的SimpleAuthenticationInfo对象的第一个属性。前台获取session判断即可

2. 控制后台资源路径的访问权限

• 先访问需要授权的页面

//硬编码方式，代码冗余  
		@RequestMapping("/xxx")
    @ResponseBody
    public String unauthorized() {
        Subject subject = SecurityUtils.getSubject();
        if (subject.isPermitted("vip1")) {
            return "ok";
        } else {
            return "未经授权无法访问此页面";
        }
    }

//-----方法2
//设置未授权的请求(页面)  这种方式需要添加大量的过滤器配置
bean.setUnauthorizedUrl("/xxx");

//-----方法3
//注解  如下
//硬编码方式，代码冗余  
    @RequiresPermissions("vip1")
		@RequestMapping("/xxx")
    @ResponseBody
    public String unauthorized() {
       return "ok";
    }

注解	描述
@RequiresAuthentication	需要完成用户登录
@RequiresGuest	未登录用户可以访问，登录用就不能访问。
@RequiresPermissions	需要有对应资源权限
@RequiresRoles	需要有对应的角色
@RequiresUser	需要完成用户登录并且完成了记住我功能。

tips : 当没有权限访问时，就会抛出500异常 AuthorizationException 统一处理

模拟登录

登录请求 建议定义全局异常处理

 @RequestMapping("/login")
    public String login(String username, String password) {
        //获取当前的认证
        Subject subject = SecurityUtils.getSubject();
        //封装用户的登录数据
        UsernamePasswordToken token = new UsernamePasswordToken(username, password);
        //执行登录方法 固定代码  若无异常就成功
        try {
            subject.login(token);
            return "index";
        } catch (AuthenticationException e) { //用户名不存在
            model.addAttribute("msg", "用户名或者密码错误");
            return "login";
        } 

userRealm

//@Configuration
public class UserRealm extends AuthorizingRealm {

     //授权方法
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("执行了授权方法");
        //获取当前用户
        Subject subject = SecurityUtils.getSubject();
        User currentUser = (User) subject.getPrincipal();
        //定义info,封装这个对象所有的角色和权限
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //判断登录者是否为超级管理员 权限为所有
        if ("超级管理员标志".equals(currentUser.getPermId())){  
            //1.获取角色与权限列表
            //2.绑定需要角色与权限
            info.addRole("");
            info.addStringPermission("");
        }else {
            //管理员
            info.addRole("admin");
            info.addStringPermission("*.*");
        }
        return info;
    }

    //认证方法
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        System.out.println("执行了认证方法");
        //获取当前用户
        UsernamePasswordToken userToken = (UsernamePasswordToken) token;
        //查询真实数据库
       // User user = userService.queryUserByName(userToken.getUsername());
        //若查询结果为空，会抛出异常
        if (user == null) {
            return null;
        }
        //密码认证，shiro帮我们自动匹配 ，之后就完成认证
        return new SimpleAuthenticationInfo(user, user.getUserPwd(), "");  //资源，密码
    }
}

        //设置安全管理器
        bean.setSecurityManager(defaultWebSecurityManager);
        Map<String, String> filterMap = new LinkedHashMap<>();
        //添加过滤器
        filterMap.put("/user/addUser", "perms[user:add]");
        filterMap.put("/user/*", "authc");
        bean.setFilterChainDefinitionMap(filterMap);
        //设置登录的请求(页面) 否则会报错
        bean.setLoginUrl("/login");
        //设置未授权的请求(页面)
        bean.setUnauthorizedUrl("/xxx");
        return bean;

tips： 越详细的规则放入前面哦！

退出登录

 //----方法1----请求
  Subject subject = SecurityUtils.getSubject();
  subject.logout();

//----方法2----过滤器
 filterMap.put("/user/logout", "logout");

相关文章： Shiro 整合 SpringBoot

三、其他功能

密码加密

shiro会获得一个credentialsMatcher对象，来对密码进行比对。想要用MD5方式进行加密:Md5CredentialsMatcher已经过期，要使用``HashedCredentialsMatcher`并设定算法名。

1. 在``securityManager`设置CredentialsMatcher

HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
//设置加密算法
matcher.setHashAlgorithmName("MD5");
//设置加密次数
matcher.setHashIterations(2);
userRealm.setCredentialsMatcher(matcher);

2. 加盐 改变构造方法

 return new SimpleAuthenticationInfo(user, ByteSource.Util.bytes(user.getUserPwd()), ByteSource.Util.bytes("12345"),"");  

3. 匹配

public class PasswordEncoder {
    public static String encoder(String password) {
        SimpleHash simpleHash = new SimpleHash("MD5", ByteSource.Util.bytes(password), ByteSource.Util.bytes("12345"), 2);
        return simpleHash.toString();
    }
}

多Realm认证

举个栗子：在登录微信时，我们可以选择使用手机号、也可以选择微信号进行登录，那么这种时怎么实现的呢？

• 在user表与实体中加入手机号、账号字段

• 新建MobileRealm

@Configuration
public class MobileRealm extends AuthenticatingRealm {

    @Autowired
    UserService userService;
    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        System.out.println("执行了认证方法");
        //获取当前用户
        UsernamePasswordToken userToken = (UsernamePasswordToken) token;
        //查询真实数据库
        User user = userService.queryUserByName(userToken.getUsername());
        //若查询结果为空，会抛出异常
        if (user == null) {
            return null;
        }
        //密码认证，shiro帮我们自动匹配 ，之后就完成认证
        return new SimpleAuthenticationInfo(user, user.getUserPwd(),"");  
    }
}

• 设置securityManager

//关联对象
securityManager.setRealms(Arrays.asList(userRealm,mobileRealm));

此时已经可以实现通过手机号也能登录账号 在多Realml的认证策略中，AuthenticationStrategy接口有三个实现类，了解

Remember me

• 一般前端会在页面提供记住我选项
• 实现

 if (subject.isAuthenticated() && subject.isRemembered()) {
      subject.login(token);
      token.setRememberMe(true);
 }   

• 记住我功能默认对应了``user` 过滤器

• 设置securityManager

CookieRememberMeManager rememberMeManager = new CookieRememberMeManager();
SimpleCookie simpleCookie = new SimpleCookie("rememberMe");
//防止xss读取cookie
simpleCookie.setHttpOnly(true);
//记住我cookie生效时间30天 ,单位秒
simpleCookie.setMaxAge(2592000);
rememberMeManager.setCookie(simpleCookie);
	securityManager.setRememberMeManager(rememberMeManager);

在微服务与分布式中 涉及到cookie共享问题 等等等头大...

认证缓存

我们每次登录时可以先从缓存中获取，如果没有在从数据库中查询，提高性能

• 在securityManager开启缓存

//缓存
AbstractCacheManager cacheManager = new MemoryConstrainedCacheManager();
securityManager.setCacheManager(cacheManager);

记住我，会话管理以及认证缓存，都可以通过扩展对应的manager接口的方式，实现自己的灵活扩展，比如将信息共享到redis。

结合Thylemeaf

1. 导入依赖

        <!--导入shiro与Thymeleaf整合包-->
        <dependency>
            <groupId>com.github.theborakompanioni</groupId>
            <artifactId>thymeleaf-extras-shiro</artifactId>
            <version>2.0.0</version>
        </dependency>

2. 配置ShiroConfig

    //整合ShiroDialect:用来整合shiro与thymeleaf
    @Bean
    public ShiroDialect getShiroDialect() {
        return new ShiroDialect();
    }

3. 具体使用 ： shiro springsecurity thymeleaf的标签使用和命名空间
4. 注解讲解：注解使用

四、整合JWT

至此，终于到了真正想写的地方，在实际的开发中，接口设计通常要考虑到安全与权限设计，JWT的token机制也不会占用服务器内存、利用JWT也能实现单点登录等等功能。下面简单整合两者的使用吧

JSON Web Token（JWT）是一个非常轻巧的规范。这个规范允许我们使用 JWT 在用户和服务器之间传递安全可靠的信息。我们利用一定的编码生成 Token，并在 Token 中加入一些非敏感信息，将其传递。

当用户登陆成功将颁发给用户一个token，token由jwt制作。往后token过期之前，用户访问的凭借都是token。如果token过期或者被篡改，则要求用户重新登陆。在token有效时，用户访问需要权限的接口都要经过shiro的两个核心注解RequiresRoles以及RequiresPermissions的验证。

1. 导入依赖

        <!--配置shiro -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.7.1</version>
        </dependency>
        <!--配置JWT-->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.4.0</version>
        </dependency>

2. JWTUtil
   生成token与校验token 指定 token 过期时间 EXPIRE_TIME 和签名密钥 SECRET

public class JwtUtil {
    //密钥
    private static final String SECRET = "!Q464rwr(&*)6%$#^%&JNJ46da";

    /**
     * 生成token
     * @param map:要加密的信息
     * @return 令牌
     */
    public static String sign(Map<String, String> map) {
        //设置过期时间 默认3天
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.DATE, 3);
        JWTCreator.Builder builder = JWT.create();
        //payload
        map.forEach((k, v) -> {
            builder.withClaim(k, v);
        });
        //指定令牌过期时间与加密
        String token = builder.withExpiresAt(instance.getTime())
                .sign(Algorithm.HMAC256(SECRET));
        return token;
    }

    /**
     * 验证token合法性/获取token全部信息
     * @param token
     * @return verify
     */
    public static DecodedJWT verify(String token) {
        return JWT.require(Algorithm.HMAC256(SECRET)).build().verify(token);
    }

    /**
     * 获取token单个信息
     * @param token
     * @param s:key
     * @return value
     */
    public static String getInfo(String token, String s) {
        DecodedJWT verify = verify(token);
        return verify.getClaim(s).asString();
    }
}

3. JWTFilter
   在上面，我们使用的是 shiro 默认的权限拦截 Filter，而因为 JWT 的整合，我们需要自定义自己的过滤器 JWTFilter

public class JWTFilter extends BasicHttpAuthenticationFilter {
    private Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     * 如果带有 token，则对 token 进行检查，否则直接通过
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws UnauthorizedException {
        //判断请求的请求头是否带上 "Token"
        if (isLoginAttempt(request, response)) {
            //如果存在，则进入 executeLogin 方法执行登入，检查 token 是否正确
            try {
                executeLogin(request, response);
                return true;
            } catch (Exception e) {
                System.out.println("token 错误");
                //token 错误   非法访问
                throw new RuntimeException("Unauthorized access!");
               // responseError(response, e.getMessage());
            }
        }
        //如果请求头不存在 Token，则可能是执行登陆操作或者是游客状态访问，无需检查 token，直接返回 true
        return true;
    }

    /**
     * 判断用户是否想要登入。
     * 检测 header 里面是否包含 Token 字段
     */
    @Override
    protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
        HttpServletRequest req = (HttpServletRequest) request;
        String token = req.getHeader("Authorization");
        return token != null;
    }

    /**
     * 执行登陆操作
     */
    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader("Authorization");
        JWTToken jwtToken = new JWTToken(token);
        // 提交给realm进行登入，如果错误他会抛出异常并被捕获
        getSubject(request, response).login(jwtToken);
        // 如果没有抛出异常则代表登入成功，返回true
        return true;
    }

    /**
     * 对跨域提供支持
     */
    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
        httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
        // 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态
        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }

    /**
     * 将非法请求跳转到 /unauthorized/**
     */
    private void responseError(ServletResponse response, String message) {
        try {
            HttpServletResponse httpServletResponse = (HttpServletResponse) response;
            //设置编码，否则中文字符在重定向时会变为空字符串
            message = URLEncoder.encode(message, "UTF-8");
            httpServletResponse.sendRedirect("/unauthorized/" + message);
        } catch (IOException e) {
            logger.error(e.getMessage());
        }
    }
}

4. JWTToken
   实现 AuthenticationToken 重写两个方法

public class JWTToken implements AuthenticationToken {
    private String token;

    public JWTToken(String token) {
        this.token = token;
    }

    @Override
    public Object getPrincipal() {
        return token;
    }

    @Override
    public Object getCredentials() {
        return token;
    }
}

5. ShiroConfig
   设置好自定义的Filter，让请求通过过滤器

@Configuration
public class ShiroConfig {
    /**
     * 先走 filter ，然后 filter 如果检测到请求头存在 token，则用 token 去 login，走 Realm 去验证
     */
    @Bean
    public ShiroFilterFactoryBean factory(SecurityManager securityManager) {
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        // 添加自己的过滤器并且取名为jwt
        Map<String, Filter> filterMap = new LinkedHashMap<>();
        //设置我们自定义的JWT过滤器
        filterMap.put("jwt", new JWTFilter());
        factoryBean.setFilters(filterMap);
        factoryBean.setSecurityManager(securityManager);
        // 设置无权限时跳转的 url;
        factoryBean.setUnauthorizedUrl("/unauthorized/无权限");
        Map<String, String> filterRuleMap = new HashMap<>();
        // 所有请求通过我们自己的JWT Filter
        filterRuleMap.put("/**", "jwt");
        // 访问 /unauthorized/** 不通过JWTFilter
        filterRuleMap.put("/unauthorized/**", "anon");
        factoryBean.setFilterChainDefinitionMap(filterRuleMap);
        return factoryBean;
    }

    /**
     * 注入 securityManager
     */
    @Bean
    public SecurityManager securityManager(MyRealm myRealm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        // 设置自定义 realm.
        securityManager.setRealm(myRealm);
        //关闭shiro自带的session，详情见文档
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        securityManager.setSubjectDAO(subjectDAO);
        return securityManager;
    }

    /**
     * 添加注解支持
     */
    @Bean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        // 强制使用cglib，防止重复代理和可能引起代理出错的问题
        // https://zhuanlan.zhihu.com/p/29161098
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        return defaultAdvisorAutoProxyCreator;
    }

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }

    @Bean
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }
}

6. Realm类
   自定义我们的Realm 实现认证与授权

@Component
public class MyRealm extends AuthorizingRealm {
    private final UserMapper userMapper;
    
    @Autowired
    public CustomRealm(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    /**
     * 必须重写此方法，不然会报错
     */
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JWTToken;
    }

    /**
     * 默认使用此方法进行用户名正确与否验证，错误抛出异常即可。
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("————身份认证方法————");
        String token = (String) authenticationToken.getCredentials();
        // 解密获得username，用于和数据库进行对比
        String username = JWTUtil.getInfo(token,"username");
        if (username == null) {
            throw new AuthenticationException("token认证失败！");
        }
        User user = userMapper.queryUserByName(username);
        if (user.getPassWord() == null) {
            throw new AuthenticationException("该用户不存在！");
        }
        return new SimpleAuthenticationInfo(token, token, "MyRealm");
    }

    /**
     * 只有当需要检测用户权限的时候才会调用此方法，例如checkRole,checkPermission之类的
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        System.out.println("————权限认证————");
        String token= principals.toString();
        String username = JWTUtil.getInfo(token,"username");
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //获得该用户角色
        User user = userMapper.queryUserByName(username);
        //每个角色拥有默认的权限
        int perm = user.getPerm();
        //每个用户可以设置新的权限
        //  String permission = userMapper.getPermission(username);
        Set<String> roleSet = new HashSet<>();
        Set<String> permissionSet = new HashSet<>();
        //需要将 role, permission 封装到 Set 作为 info.setRoles(), info.setStringPermissions() 的参数
        roleSet.add(perm + "");
        //   permissionSet.add(rolePermission);
        //  permissionSet.add(permission);
        //设置该用户拥有的角色和权限
        info.setRoles(roleSet);
        info.setStringPermissions(permissionSet);
        return info;
    }
}

7. Controller

    @PostMapping("/login")
    public ResultMap login(@RequestParam("username") String account,
                           @RequestParam("password") String password) {
        User user = userMapper.queryUserByName(account);
        if (user == null || !user.getPassWord().equals(password)) {
            throw new RuntimeException("用户名或密码错误");
        }
        Map<String, String> map = new HashMap<>();
        map.put("username", user.getAccount());
        return R.ok(JwtUtil.sign(map), "登录成功");
    }


    /**
     * 拥有 1、2、3 角色的用户可以访问下面的页面
     */
    @GetMapping("/getMessage")
    @RequiresRoles(logical = Logical.OR, value = {"1", "2", "3"})
    public R getMessage() {
       return R.ok("", "成功获得信息");
    }

运行结果：

不带token访问的情况下：

加上的情况：

---

The End~~