Spring Boot2 集成 Shiro 实现用户权限管理

深碍√TFBOYSˉ_ 2022-11-16 15:16 170阅读 0赞

# 前言 #

目前只要做WEB管理系统，从单个系统的权限管理以及到多个系统统一权限管理，用户权限管理是必须实现的功能，目前比较常见的权限架构有shiro和spring security，两个都比较优秀。

# 一 常见权限架构 #

## 1.1 Shiro ##

Apache Shiro是Java的一个安全框架。目前，使用Apache Shiro的人越来越多，因为它相当简单，对比Spring Security，可能没有Spring Security做的功能强大，但是在实际工作时可能并不需要那么复杂的东西，所以使用小而简单的Shiro就足够了。对于它俩到底哪个好，这个不必纠结，能更简单的解决项目问题就好了。

## 1.2 Spring Security ##

Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。它是一个轻量级的安全框架，它确保基于Spring的应用程序提供身份验证和授权支持。它与Spring MVC有很好地集成，并配备了流行的安全算法实现捆绑在一起。安全主要包括两个操作“认证”与“验证”（有时候也会叫做权限控制）。“认证”是为用户建立一个其声明的角色的过程，这个角色可以一个用户、一个设备或者一个系统。“验证”指的是一个用户在你的应用中能够执行某个操作。在到达授权判断之前，角色已经在身份认证过程中建立了。

1.3 Shiro和Spring Security比较  
（1）Shiro比Spring更容易使用，实现和最重要的理解  
（2）Spring Security更加知名的唯一原因是因为品牌名称  
（3）“Spring”以简单而闻名，但讽刺的是很多人发现安装Spring Security很难  
（4）Spring Security却有更好的社区支持  
（5）Apache Shiro在Spring Security处理密码学方面有一个额外的模块  
（6）Spring-security 对spring 结合较好，如果项目用的springmvc ，使用起来很方便。但是如果项目中没有用到spring，那就不要考虑它了。  
（7）Shiro 功能强大、且 简单、灵活。是Apache 下的项目比较可靠，且不跟任何的框架或者容器绑定，可以独立运行

# 二 Shiro简介 #

## 2.1 概念 ##

Apache Shiro 是 Java 的一个安全框架。目前，使用 Apache Shiro 的人越来越多，因为它相当简单，对比 Spring Security，可能没有 Spring Security 做的功能强大，但是在实际工作时可能并不需要那么复杂的东西，所以使用小而简单的 Shiro 就足够了。对于它俩到底哪个好，这个不必纠结，能更简单的解决项目问题就好了。

本教程只介绍基本的 Shiro 使用，不会过多分析源码等，重在使用。

Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在 JavaSE 环境，也可以用在 JavaEE 环境。Shiro 可以帮助我们完成：认证、授权、加密、会话管理、与 Web 集成、缓存等。这不就是我们想要的嘛，而且 Shiro 的 API 也是非常简单；其基本功能点如下图所示：

![d7b0049af94725974d055f14c2e1d910.png][]

**Authentication**：身份认证 / 登录，验证用户是不是拥有相应的身份；

**Authorization**：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；

**Session ****Management**：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通 JavaSE 环境的，也可以是如 Web 环境的；

**Cryptography**：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；

**Web Support**：Web 支持，可以非常容易的集成到 Web 环境；

**Caching**：缓存，比如用户登录后，其用户信息、拥有的角色 / 权限不必每次去查，这样可以提高效率；

**Concurrency**：shiro 支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；

**Testing**：提供测试支持；

**Run As**：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；

**Remember Me**：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了。

**记住一点，Shiro 不会去维护用户、维护权限；这些需要我们自己去设计 / 提供；然后通过相应的接口注入给 Shiro 即可。**

接下来我们分别从外部和内部来看看 Shiro 的架构，对于一个好的框架，从外部来看应该具有非常简单易于使用的 API，且 API 契约明确；从内部来看的话，其应该有一个可扩展的架构，即非常容易插入用户自定义实现，因为任何框架都不能满足所有需求。

首先，我们从外部来看 Shiro 吧，即从应用程序角度的来观察如何使用 Shiro 完成工作。如下图：

![99a4881ab06133290c1606e1948964ab.png][]

可以看到：应用代码直接交互的对象是 Subject，也就是说 Shiro 的对外 API 核心就是 Subject；其每个 API 的含义：

**Subject**：主体，代表了当前 “用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是 Subject，如网络爬虫，机器人等；即一个抽象概念；所有 Subject 都绑定到 SecurityManager，与 Subject 的所有交互都会委托给 SecurityManager；可以把 Subject 认为是一个门面；SecurityManager 才是实际的执行者；

**SecurityManager**：安全管理器；即所有与安全有关的操作都会与 SecurityManager 交互；且它管理着所有 Subject；可以看出它是 Shiro 的核心，它负责与后边介绍的其他组件进行交互，如果学习过 SpringMVC，你可以把它看成 DispatcherServlet 前端控制器；

**Realm**：域，Shiro 从从 Realm 获取安全数据（如用户、角色、权限），就是说 SecurityManager 要验证用户身份，那么它需要从 Realm 获取相应的用户进行比较以确定用户身份是否合法；也需要从 Realm 得到用户相应的角色 / 权限进行验证用户是否能进行操作；可以把 Realm 看成 DataSource，即安全数据源。

也就是说对于我们而言，最简单的一个 Shiro 应用：

*  应用代码通过 Subject 来进行认证和授权，而 Subject 又委托给 SecurityManager；
 *  我们需要给 Shiro 的 SecurityManager 注入 Realm，从而让 SecurityManager 能得到合法的用户及其权限进行判断。

**从以上也可以看出，Shiro 不提供维护用户 / 权限，而是通过 Realm 让开发人员自己注入。**

接下来我们来从 Shiro 内部来看下 Shiro 的架构，如下图所示：

![b677930168e1f85c849b3344ea6263cc.png][]

**Subject**：主体，可以看到主体可以是任何可以与应用交互的 “用户”；

**SecurityManager**：相当于 SpringMVC 中的 DispatcherServlet 或者 Struts2 中的 FilterDispatcher；是 Shiro 的心脏；所有具体的交互都通过 SecurityManager 进行控制；它管理着所有 Subject、且负责进行认证和授权、及会话、缓存的管理。

**Authenticator**：认证器，负责主体认证的，这是一个扩展点，如果用户觉得 Shiro 默认的不好，可以自定义实现；其需要认证策略（Authentication Strategy），即什么情况下算用户认证通过了；

**Authrizer**：授权器，或者访问控制器，用来决定主体是否有权限进行相应的操作；即控制着用户能访问应用中的哪些功能；

**Realm**：可以有 1 个或多个 Realm，可以认为是安全实体数据源，即用于获取安全实体的；可以是 JDBC 实现，也可以是 LDAP 实现，或者内存实现等等；由用户提供；注意：Shiro 不知道你的用户 / 权限存储在哪及以何种格式存储；所以我们一般在应用中都需要实现自己的 Realm；

**SessionManager**：如果写过 Servlet 就应该知道 Session 的概念，Session 呢需要有人去管理它的生命周期，这个组件就是 SessionManager；而 Shiro 并不仅仅可以用在 Web 环境，也可以用在如普通的 JavaSE 环境、EJB 等环境；所以呢，Shiro 就抽象了一个自己的 Session 来管理主体与应用之间交互的数据；这样的话，比如我们在 Web 环境用，刚开始是一台 Web 服务器；接着又上了台 EJB 服务器；这时想把两台服务器的会话数据放到一个地方，这个时候就可以实现自己的分布式会话（如把数据放到 Memcached 服务器）；

**SessionDAO**：DAO 大家都用过，数据访问对象，用于会话的 CRUD，比如我们想把 Session 保存到数据库，那么可以实现自己的 SessionDAO，通过如 JDBC 写到数据库；比如想把 Session 放到 Memcached 中，可以实现自己的 Memcached SessionDAO；另外 SessionDAO 中可以使用 Cache 进行缓存，以提高性能；

**CacheManager**：缓存控制器，来管理如用户、角色、权限等的缓存的；因为这些数据基本上很少去改变，放到缓存中后可以提高访问的性能

**Cryptography**：密码模块，Shiro 提供了一些常见的加密组件用于如密码加密 / 解密的。

到此 Shiro 架构及其组件就认识完了，接下来挨着学习 Shiro 的组件吧。

## 2.2 核心组件 ##

### 2.2.1 Subject ###

Subject：即“当前操作用发户”。但是，在Shiro中，Subject这一概念并不仅仅指人，也可以是第三方进程、后台帐户（Daemon Account）或其他类似事物。它仅仅意味着“当前跟软件交互的东西”。但考虑到大多数目的和用途，你可以把它认为是Shiro的“用户”概念。Subject代表了当前用户的安全操作，SecurityManager则管理所有用户的安全操作。

### 2.2.2 SecurityManager ###

SecurityManager：它是Shiro框架的核心，典型的Facade模式，Shiro通过SecurityManager来管理内部组件实例，并通过它来提供安全管理的各种服务。

### 2.2.2 Realm ###

Realm充当了Shiro与应用安全数据间的“桥梁”或者“连接器”。也就是说，当对用户执行认证（登录）和授权（访问控制）验证时，Shiro会从应用配置的Realm中查找用户及其权限信息。  
  从这个意义上讲，Realm实质上是一个安全相关的DAO：它封装了数据源的连接细节，并在需要时将相关数据提供给Shiro。当配置Shiro时，你必须至少指定一个Realm，用于认证和（或）授权。配置多个Realm是可以的，但是至少需要一个。  
  Shiro内置了可以连接大量安全数据源（又名目录）的Realm，如LDAP、关系数据库（JDBC）、类似INI的文本配置资源以及属性文件等。如果缺省的Realm不能满足需求，你还可以插入代表自定义数据源的自己的Realm实现。

## 2.3. Shiro 特点 ##

（1）易于理解的 Java Security API；  
（2）简单的身份认证（登录），支持多种数据源（LDAP，JDBC，Kerberos，ActiveDirectory 等）；  
（3）对角色的简单的签权（访问控制），支持细粒度的签权；  
（4）支持一级缓存，以提升应用程序的性能；  
（5）内置的基于 POJO 企业会话管理，适用于 Web 以及非 Web 的环境；  
（6）异构客户端会话访问；  
（7）非常简单的加密 API；  
（8）不跟任何的框架或者容器捆绑，可以独立运行。

# 三 Spring Boot2 实现 #

创建Spring Boot2项目，项目名称：spring-boot2-shiro-upms，版本：2.3.0

## 3.1 pom.xml ##

<dependency>
                <groupId>org.apache.shiro</groupId>
                <artifactId>shiro-spring</artifactId>
                <version>1.4.0</version>
            </dependency>

## 3.2 ShiroConfig 配置 ##

package com.modules.common.config;
    
    import com.modules.common.utils.SHA256Util;
    import com.modules.shiro.ShiroRealm;
    import com.modules.shiro.ShiroSessionIdGenerator;
    import com.modules.shiro.ShiroSessionManager;
    import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
    import org.apache.shiro.cache.MemoryConstrainedCacheManager;
    import org.apache.shiro.mgt.SecurityManager;
    import org.apache.shiro.session.mgt.SessionManager;
    import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
    import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
    import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
    import org.apache.shiro.web.servlet.SimpleCookie;
    import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.util.LinkedHashMap;
    import java.util.Map;
    
    /**
     * @Auther: lc
     * @Date: 2020/3/19 10:49
     * @Description: Shiro配置类
     */
    @Configuration
    public class ShiroConfig {
    
        @Value("${spring.shiro.cache-key}")
        private String CACHE_KEY;
        @Value("${spring.shiro.session-key}")
        private String SESSION_KEY;
        @Value("${spring.shiro.redis.expire}")
        private int EXPIRE;
    
        /**
         * 开启Shiro-aop注解支持
         *
         * @Attention 使用代理方式所以需要开启代码支持
         * @Author lc
         */
        @Bean
        public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
            AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
            authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
            return authorizationAttributeSourceAdvisor;
        }
    
        /**
         * Shiro基础配置
         *
         * @Author lc
         */
        @Bean
        public ShiroFilterFactoryBean shiroFilterFactory(SecurityManager securityManager) {
            ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
            shiroFilterFactoryBean.setSecurityManager(securityManager);
            Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
            // 注意过滤器配置顺序不能颠倒
            // 配置过滤:不会被拦截的链接
            filterChainDefinitionMap.put("/statics/**", "anon");
            filterChainDefinitionMap.put("/js/**", "anon");
            filterChainDefinitionMap.put("/doc.html", "anon");
            filterChainDefinitionMap.put("/swagger-ui.html", "anon");
            filterChainDefinitionMap.put("/swagger-resources/**", "anon");
            filterChainDefinitionMap.put("/image/**", "anon");
            filterChainDefinitionMap.put("/v2/api-docs", "anon");
            filterChainDefinitionMap.put("/webjars/**", "anon");
    //        filterChainDefinitionMap.put("/home/**", "anon");
            filterChainDefinitionMap.put("/user/**", "anon");
            //加权限
    //        filterChainDefinitionMap.put("/**", "authc");
            //不加权限
            filterChainDefinitionMap.put("/**", "anon");
            // 配置shiro默认登录界面地址，前后端分离中登录界面跳转应由前端路由控制，后台仅返回json数据
            shiroFilterFactoryBean.setLoginUrl("/user/loginUnauth");
    //        shiroFilterFactoryBean.setLoginUrl(JSON.toJSONString(Result.unauth()));
            shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
            return shiroFilterFactoryBean;
        }
    
        /**
         * 安全管理器
         *
         * @Author lc
         */
        @Bean
        public SecurityManager securityManager() {
            DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
            // 自定义Ssession管理
            securityManager.setSessionManager(sessionManager());
            // 自定义Cache实现
    //        securityManager.setCacheManager(cacheManager());
            // 自定义Realm验证
            securityManager.setRealm(shiroRealm());
            return securityManager;
        }
    
        /**
         * 身份验证器
         *
         * @Author lc
         */
        @Bean
        public ShiroRealm shiroRealm() {
            ShiroRealm shiroRealm = new ShiroRealm();
            shiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());
            // 相关认证缓存到cache中
            shiroRealm.setCacheManager(new MemoryConstrainedCacheManager());
            return shiroRealm;
        }
    
        /**
         * 凭证匹配器
         * 将密码校验交给Shiro的SimpleAuthenticationInfo进行处理,在这里做匹配配置
         *
         * @Author lc
         */
        @Bean
        public HashedCredentialsMatcher hashedCredentialsMatcher() {
            HashedCredentialsMatcher shaCredentialsMatcher = new HashedCredentialsMatcher();
            // 散列算法:这里使用SHA256算法;
            shaCredentialsMatcher.setHashAlgorithmName(SHA256Util.HASH_ALGORITHM_NAME);
            // 散列的次数，比如散列两次，相当于 md5(md5(""));
            shaCredentialsMatcher.setHashIterations(SHA256Util.HASH_ITERATIONS);
            return shaCredentialsMatcher;
        }
    
        /**
         * 配置Session管理器
         *
         * @Author lc
         */
        @Bean
        public SessionManager sessionManager() {
            ShiroSessionManager shiroSessionManager = new ShiroSessionManager();
            //设置session过期时间
            shiroSessionManager.setGlobalSessionTimeout(EXPIRE);
            // 去掉shiro登录时url里的JSESSIONID
            shiroSessionManager.setSessionIdUrlRewritingEnabled(false);
            return shiroSessionManager;
    
        }
    
    
        /**
         * SessionID生成器
         *
         * @Author lc
         */
        @Bean
        public ShiroSessionIdGenerator sessionIdGenerator() {
            return new ShiroSessionIdGenerator();
        }
    
        /**
         * 配置保存sessionId的cookie
         * 注意：这里的cookie 不是上面的记住我 cookie 记住我需要一个cookie session管理 也需要自己的cookie
         * 默认为: JSESSIONID 问题: 与SERVLET容器名冲突,重新定义为 token
         */
        @Bean
        public SimpleCookie sessionIdCookie() {
            //这个参数是cookie的名称，设置sessionId的名称为 token
            SimpleCookie simpleCookie = new SimpleCookie("token");
            //setcookie的httponly属性如果设为true的话，会增加对xss防护的安全系数。它有以下特点：
            //setcookie()的第七个参数
            //设为true后，只能通过http访问，javascript无法访问
            //防止xss读取cookie
            simpleCookie.setHttpOnly(true);
            simpleCookie.setPath("/");
            //maxAge=-1表示浏览器关闭时失效此Cookie
            simpleCookie.setMaxAge(-1);
            return simpleCookie;
        }
    }

## 3.3 域对象配置 ##

package com.modules.shiro;
    
    import com.modules.common.enmus.PublicEnum;
    import com.modules.system.entity.SysUser;
    import com.modules.system.service.SysMenuService;
    import com.modules.system.service.SysRoleService;
    import com.modules.system.service.SysUserService;
    import org.apache.shiro.authc.*;
    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.apache.shiro.util.ByteSource;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import java.util.HashSet;
    import java.util.Set;
    
    /**
     * @Auther: lc
     * @Date: 2020/3/19 10:37
     * @Description: Shiro权限匹配和账号密码匹配
     */
    public class ShiroRealm extends AuthorizingRealm {
    
        @Autowired
        private SysUserService userService;
    
        @Autowired
        private SysRoleService sysRoleService;
    
        @Autowired
        private SysMenuService sysMenuService;
    
        /**
         * 授权权限
         * 用户进行权限验证时候Shiro会去缓存中找,如果查不到数据,会执行这个方法去查权限,并放入缓存中
         *
         * @Author lc
         */
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
            SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
            SysUser user = (SysUser) principalCollection.getPrimaryPrincipal();
            //获取用户ID
            long userId = user.getUserId();
            //这里可以进行授权和处理
            Set<String> rolesSet = new HashSet<>();
            Set<String> permsSet = new HashSet<>();
            // 查询角色
            rolesSet = sysRoleService.selectRoleKeys(userId);
            // 查询权限
            permsSet = sysMenuService.selectPermsByUserId(userId);
            // 放入角色
            authorizationInfo.setRoles(rolesSet);
            // 放入菜单
            authorizationInfo.setStringPermissions(permsSet);
            return authorizationInfo;
        }
    
        /**
         * 身份认证
         *
         * @Author lc
         */
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
            //获取用户的输入的账号.
            String username = (String) authenticationToken.getPrincipal();
            //通过username从数据库中查找 User对象，如果找到进行验证
            //实际项目中,这里可以根据实际情况做缓存,如果不做,Shiro自己也是有时间间隔机制,2分钟内不会重复执行该方法
            SysUser user = userService.selectUserByLoginName(username);
            //判断账号是否存在
            if (user == null) {
                throw new AuthenticationException();
            }
            //判断账号是否停用
            if (user.getStatus() == null || PublicEnum.DISABLE.getCode().equals(user.getStatus())) {
                throw new LockedAccountException();
            }
            //进行验证
            SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
                    user,                                  //用户名
                    user.getPassword(),                    //密码
                    ByteSource.Util.bytes(user.getSalt()), //设置盐值
                    getName()
            );
            return authenticationInfo;
        }
    }

## 3.4 SHA256Util 加密工具类 ##

package com.modules.common.utils;
    
    import org.apache.shiro.crypto.hash.SimpleHash;
    
    /**
     * @Auther: lc
     * @Date: 2020/3/19 10:28
     * @Description: Sha-256加密工具
     */
    public class SHA256Util {
    
        /**
         * 私有构造器
         **/
        private SHA256Util() {
        }
    
        ;
        /**
         * 加密算法
         **/
        public final static String HASH_ALGORITHM_NAME = "SHA-256";
        /**
         * 循环次数
         **/
        public final static int HASH_ITERATIONS = 15;
    
        /**
         * 执行加密-采用SHA256加密
         **/
        public static String sha256(String password, String salt) {
            return new SimpleHash(HASH_ALGORITHM_NAME, password, salt, HASH_ITERATIONS).toString();
        }
    
        public static void main(String[] args) {
            System.out.println(sha256("admin123", "111"));
        }
    
    
    }

## 3.5 ShiroUtils工具类 ##

package com.modules.common.utils;
    
    import com.modules.system.entity.SysUser;
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.session.Session;
    
    /**
     * @Auther: lc
     * @Date: 2020/3/19 10:32
     * @Description: Shiro工具类
     */
    public class ShiroUtils {
    
        /**
         * 私有构造器
         **/
        private ShiroUtils() {
        }
    
        /**
         * 获取当前用户Session
         *
         * @Return user 用户信息
         */
        public static Session getSession() {
            return SecurityUtils.getSubject().getSession();
        }
    
        /**
         * 用户登出
         *
         * @Author lc
         */
        public static void logout() {
            SecurityUtils.getSubject().logout();
        }
    
        /**
         * 获取当前用户信息
         *
         * @Author lc
         * @Return user 用户信息
         */
        public static SysUser getUserInfo() {
            return (SysUser) SecurityUtils.getSubject().getPrincipal();
        }
    }

## 3.6 自定义权限异常提示 ##

package com.modules.shiro;
    
    import com.modules.common.web.Result;
    import org.apache.shiro.authz.AuthorizationException;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    /**
     * @Auther: lc
     * @Date: 2020/3/19 10:27
     * @Description: 自定义异常
     */
    @ControllerAdvice
    public class MyShiroException {
    
        /**
         * 处理Shiro权限拦截异常
         * 如果返回JSON数据格式请加上 @ResponseBody注解
         *
         * @Author lc
         * @Return Map<Object> 返回结果集
         */
        @ResponseBody
        @ExceptionHandler(value = AuthorizationException.class)
        public Result defaultErrorHandler() {
            return Result.unauth();
        }
    }

## 3.7 login登录 ##

package com.modules.system.controller;
    
    import com.modules.common.utils.IpUtils;
    import com.modules.common.utils.ShiroUtils;
    import com.modules.common.web.BaseController;
    import com.modules.common.web.Result;
    import com.modules.system.entity.SysUser;
    import com.modules.system.service.SysUserService;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    import io.swagger.annotations.ApiParam;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.authc.*;
    import org.apache.shiro.subject.Subject;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.*;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.Date;
    
    /**
     * 登录管理
     *
     * @author lc
     */
    @Api(tags = "登录管理")
    @Slf4j
    @CrossOrigin
    @RestController
    @RequestMapping("/user")
    public class LoginController extends BaseController {
    
        @Autowired
        private SysUserService userService;
    
        /**
         * 登录
         *
         * @return
         */
        @ApiOperation(value = "用户登录", notes = "用户登录")
        @GetMapping(value = "/login")
        public Result login(HttpServletRequest request,
                            @ApiParam(name = "loginName", value = "登录账号") @RequestParam(value = "loginName") String loginName,
                            @ApiParam(name = "password", value = "密码") @RequestParam(value = "password") String password) {
            SysUser user = new SysUser();
            Subject subject = SecurityUtils.getSubject();
            UsernamePasswordToken token = new UsernamePasswordToken(loginName, password);
            try {
                subject.login(token);
                user = ShiroUtils.getUserInfo();
                user.setToken(ShiroUtils.getSession().getId().toString());
            } catch (UnknownAccountException un) {
                log.error("UnknownAccountException=====>未知账户");
                return error("未知账户");
            } catch (IncorrectCredentialsException ic) {
                log.error("IncorrectCredentialsException=====>密码不正确");
                return error("密码不正确");
            } catch (LockedAccountException lo) {
                log.error("LockedAccountException=====>账户已停用");
                return error("账户已停用");
            } catch (ExcessiveAttemptsException ex) {
                log.error("ExcessiveAttemptsException=====>用户名或密码错误次数过多");
                return error("用户名或密码错误次数过多");
            } catch (AuthenticationException au) {
                log.error("AuthenticationException=====>账号或者密码错误");
                return error("账号或者密码错误");
            } finally {
                try {
                    user.setLoginDate(new Date());
                    user.setLoginIp(IpUtils.getIpAddr(request));
                    userService.updateByPrimaryKeySelective(user);
                } catch (Exception e) {
                    log.error("IOException=====>更新账户登录信息异常！", e.getMessage());
                }
            }
            return success("登录成功", user);
        }
    
        /**
         * @Description: 退出登录
         * @author lc
         */
        @ApiOperation(value = "退出登录", notes = "退出登录")
        @GetMapping(value = "/logout")
        public Result logout() {
            ShiroUtils.logout();
            return success("退出成功");
        }
    
        /**
         * @Description: 未登陆，返回无权限提示
         * @author lc
         */
        @ApiOperation(value = "无权限", notes = "无权限")
        @GetMapping(value = "/loginUnauth")
        public Result loginUnauth() {
            return unauth();
        }
    }

## 3.8 application.properties配置 ##

server.port=8087
    server.servlet.context-path=/upms
    #启用优雅关机
    server.shutdown=graceful
    #缓冲10秒
    spring.lifecycle.timeout-per-shutdown-phase=10s
    # mysql连接
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/upms?useUnicode=true&characterEncoding=UTF-8&userSSL=false&serverTimezone=GMT%2B8
    spring.datasource.username=root
    spring.datasource.password=111
    # druid web页面
    druid.login.enabled=false
    druid.login.username=druid
    druid.login.password=druid
    #druid连接池
    spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
    spring.datasource.initialSize=20
    spring.datasource.minIdle=30
    spring.datasource.maxActive=50
    spring.datasource.maxWait=60000
    spring.datasource.timeBetweenEvictionRunsMillis=60000
    spring.datasource.minEvictableIdleTimeMillis=300000
    spring.datasource.validationQuery=SELECT 'x'
    spring.datasource.testWhileIdle=true
    spring.datasource.testOnBorrow=true
    spring.datasource.testOnReturn=true
    spring.datasource.poolPreparedStatements=true
    spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
    spring.datasource.filters=stat
    spring.datasource.connectionProperties:druid.stat.slowSqlMillis=5000
    # MyBatis 配置
    mybatis.mapper-locations=classpath*:mapper/**/*Mapper.xml
    # mybatis-plus 配置
    mybatis-plus.mapper-locations=classpath*:mapper/**/*Mapper.xml
    mybatis.configuration.jdbc-type-for-null=null
    #配置分页插件pagehelper
    pagehelper.helperDialect=mysql
    pagehelper.reasonable=true
    pagehelper.supportMethodsArguments=true
    pagehelper.params.count=countSql
    #日志配置
    logging.level.com.modules.project.dao=debug
    logging.level.com.modules.system.dao=debug
    # 设置时间
    spring.jackson.time-zone=GMT+8
    # 全局格式化日期
    spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
    #权限登录token
    spring.shiro.cache-key=shiro:cache:
    spring.shiro.session-key=shiro:session:
    # session过期时间，30天：2592000,30分钟：1800
    spring.shiro.redis.expire=2592000

# 四 源码 #

码云地址：[https://gitee.com/lichao12/spring-boot2-shiro-upms][https_gitee.com_lichao12_spring-boot2-shiro-upms]

[d7b0049af94725974d055f14c2e1d910.png]: /images/20221022/a7737e67f3734024a925da2e53e30a3c.png
[99a4881ab06133290c1606e1948964ab.png]: /images/20221022/55ad973998784596b8d606105c97b4a5.png
[b677930168e1f85c849b3344ea6263cc.png]: /images/20221022/c9a771ff679441aead5337d003eb973a.png
[https_gitee.com_lichao12_spring-boot2-shiro-upms]: https://gitee.com/lichao12/spring-boot2-shiro-upms