[Java知识库] springboot2集成shiro认证鉴权（中篇）

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> springboot2集成shiro认证鉴权（中篇） -> 正文阅读

[Java知识库]springboot2集成shiro认证鉴权（中篇）

在上一篇中，搭建了项目的基础结构，这一篇中，将简述一下shiro的集成过程。

中篇-session模式

1、添加依赖

在pom.xml中添加如下shiro依赖

<properties>
    <shiro.version>1.7.1</shiro.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-spring-boot-starter</artifactId>
        <version>${shiro.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-ehcache</artifactId>
        <version>${shiro.version}</version>
    </dependency>
</dependencies>

这里面主要是shiro的依赖，同时添加了ehcache的缓存支持，除此之外，还添加了spring cache支持，这个在后面做缓存时会用到，先提前添加进去。

2、缓存配置

（1）ehcache配置文件

在resources资源目录下新建ehcache.xml配置文件，文件内容如下。在文件中，定义了两个缓存用于shiro认证和鉴权的缓存，并设置了相应的过期时间和持久化策略。

<!-- ehcache配置 -->
<ehcache
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
        updateCheck="false">
    <!--缓存路径，用户目录下的base_ehcache目录-->
    <!--    <diskStore path="user.home/base_ehcache"/>-->
    <diskStore path="base_ehcache"/>

    <defaultCache maxElementsInMemory="10000"
                  eternal="false"
                  timeToIdleSeconds="600"
                  timeToLiveSeconds="600"
                  overflowToDisk="true"
                  maxElementsOnDisk="1000000"
                  diskPersistent="false"
                  diskExpiryThreadIntervalSeconds="120"
                  memoryStoreEvictionPolicy="LRU"/>

    <!--
    name：缓存文件名，同样的可以配置多个缓存
    maxElementsInMemory：内存中最多存储
    eternal：外部存储
    overflowToDisk：超出缓存到磁盘
    diskPersistent：磁盘持久化
    timeToLiveSeconds：缓存时间
    diskExpiryThreadIntervalSeconds：磁盘过期时间
    -->

    <!-- shiro 认证缓存 -->
    <cache name="shiro-authentication-cache"
           maxElementsInMemory="20000"
           eternal="false"
           overflowToDisk="true"
           diskPersistent="false"
           timeToLiveSeconds="1800"
           diskExpiryThreadIntervalSeconds="7200"/>

    <!-- shiro 授权缓存 -->
    <cache name="shiro-authorization-cache"
           maxElementsInMemory="20000"
           eternal="false"
           overflowToDisk="true"
           diskPersistent="false"
           timeToLiveSeconds="1800"
           diskExpiryThreadIntervalSeconds="7200"/>
</ehcache>

（2）缓存配置类

在com.ygr.config包下新建配置类CacheConfig，内容如下。注意其中的factoryBean.setShared(true)，这一行尤为重要，因为在当前使用的版本中，ehcache有一个条件，一个jvm中只允许有一个ehcache实例，所以这里需要设置为共享模式，否则后面shiro配置缓存管理器的时候，会冲突报错。@EnableCaching注解则是开启spring cache的支持，便于使用@Cacheable等注解进行缓存操作。

@EnableCaching
@Configuration
public class CacheConfig {

    @Bean
    public EhCacheManagerFactoryBean ehCacheManagerFactoryBean() {
        EhCacheManagerFactoryBean factoryBean = new EhCacheManagerFactoryBean();
        factoryBean.setConfigLocation(new ClassPathResource("ehcache.xml"));
        factoryBean.setShared(true);
        factoryBean.setCacheManagerName("cacheManager");
        return factoryBean;
    }
}

3、Realm配置

shiro有三大核心组件，分别是Subject、SecurityManager以及Realm，在web应用中，Subject可理解为当前用户，SecurityManager则是安全管理器，管理shiro中的组件，Realm则是为SecurityManager提供认证授权信息。

shiro已经提供了不少的Realm，如JdbcRealm、SimpleAccountRealm等，但在实际使用中，还是自己定义一个比较方便。通常，一个Realm对应一种认证方式，如果需要支持多种认证方式，那就定义多个Realm即可。在本篇中，使用的是用户名密码的方式进行认证。

新建LoginRealm，代码如下

@Slf4j
@Component
public class LoginRealm extends AuthorizingRealm {

    private final UserPrincipalService userPrincipalService;

    public LoginRealm(UserPrincipalService userPrincipalService, CacheManager cacheManager) {
        this.userPrincipalService = userPrincipalService;
        this.setCachingEnabled(true);
        this.setCacheManager(cacheManager);
        this.setAuthenticationCachingEnabled(true);
        this.setAuthorizationCachingEnabled(true);
        this.setAuthenticationCacheName("shiro-authentication-cache");
        this.setAuthorizationCacheName("shiro-authorization-cache");

        // 密码比对器 SHA-256
        HashedCredentialsMatcher hashMatcher = new HashedCredentialsMatcher();
        hashMatcher.setHashAlgorithmName(Sha256Hash.ALGORITHM_NAME);
        hashMatcher.setStoredCredentialsHexEncoded(false);
        hashMatcher.setHashIterations(1024);
        this.setCredentialsMatcher(hashMatcher);
    }

    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof UsernamePasswordToken;
    }

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        UserPrincipalEntity entity = (UserPrincipalEntity) principals.getPrimaryPrincipal();
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        info.setRoles(entity.getRoles());
        info.setStringPermissions(entity.getPermissions());
        return info;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) token;
        String username = usernamePasswordToken.getUsername();
        if (username == null) {
            return null;
        }
        UserPrincipalEntity userPrincipal = userPrincipalService.getUserPrincipal(username);
        if (userPrincipal == null) {
            return null;
        }
        return new SimpleAuthenticationInfo(userPrincipal, userPrincipal.getPassword(),
                new ShiroByteSource(AuthConstant.SECRET_SALT), getName());
    }
    
    @Override
    protected Object getAuthenticationCacheKey(PrincipalCollection principals) {
        UserPrincipalEntity userPrincipal = (UserPrincipalEntity) principals.getPrimaryPrincipal();
        return userPrincipal.getUsername();
    }

    /**
     * SimpleByteSource未实现Serializable接口，在缓存序列化时会报错，所以使用子类代替
     */
    public static class ShiroByteSource extends SimpleByteSource implements Serializable {
        /**
         * 父类没有无参构造器，这里加一个
         */
        public ShiroByteSource() {
            super(new byte[]{});
        }

        public ShiroByteSource(byte[] bytes) {
            super(bytes);
        }

        public ShiroByteSource(char[] chars) {
            super(chars);
        }

        public ShiroByteSource(String string) {
            super(string);
        }

        public ShiroByteSource(ByteSource source) {
            super(source);
        }

        public ShiroByteSource(File file) {
            super(file);
        }

        public ShiroByteSource(InputStream stream) {
            super(stream);
        }
    }
}

简单解释一下，UserPrincipalService是自定义的一个接口，用于获取用户信息，包括用户名、密码、角色、权限等数据，接口定义及实现见后面的代码。构造器中除了UserPrincipalService之外，还注入了CacheManager，此CacheManager是shiro的，不是spring cache的，在此Realm中开启了全局缓存，并设置认证缓存与授权缓存名称；同时，设置了密码比对器，与上一篇的UaUserInfoService示例代码的加密方法对应。至于ShiroByteSource这个类纯粹是为了弥补SimpleByteSource未实现序列化接口导致无法缓存的问题，除非缓存失效，否则这个问题会一直存在。

另外，重写了getAuthenticationCacheKey方法，因为登录时使用的AuthenticationToken是UsernamePasswordToken，登录后将认证信息缓存的时候，调用的是如下的方法来获取缓存的key，而UsernamePasswordToken的getPrincipal()返回的是用户名

protected Object getAuthenticationCacheKey(AuthenticationToken token) {
	return token != null ? token.getPrincipal() : null;
}

但是在退出要清除认证信息缓存的时候，调用的是如下的方法来获取key，其中调用的getAvailablePrincipal方法返回的是principal对象，与登录时的key对应不上，会导致退出了，但认证缓存还在的问题，下次登录时依然会查缓存，而不是查数据库，这就导致了缓存与数据库的一致性问题。

protected Object getAuthenticationCacheKey(PrincipalCollection principals) {
    return getAvailablePrincipal(principals);
}

最重要的还是doGetAuthorizationInfo以及doGetAuthenticationInfo方法，二者分别返回授权信息以及认证信息，代码很简单，不过多解释，至于获取认证信息时使用的userPrincipalService.getUserPrincipal(username)，看后续的代码即可。除此之外，重写了supports方法，此方法指明了当前Realm支持的认证token类型，官方更建议使用setAuthenticationTokenClass来进行设置，只不过这里只有一种认证方式，所以直接指定只支持用户名密码认证即可。

如果自定义鉴权规则，重写对应的isPermitted方法即可。

UserPrincipalEntity定义了用户主要信息，包括用户id、用户名、密码、登录时间、以及对应的角色编号和权限标识，代码如下。

@Accessors(chain = true)
@Data
public class UserPrincipalEntity implements Serializable {
    /**
     * 用户id
     */
    private Long id;
    /**
     * 用户名
     */
    private String username;
    /**
     * 加密后的密码
     */
    @JsonIgnore
    private String password;
    /**
     * 登录时间
     */
    private Date loginTime;
    /**
     * 角色
     */
    private Set<String> roles;
    /**
     * 权限
     */
    private Set<String> permissions;
}

public interface UserPrincipalService {
    UserPrincipalEntity getUserPrincipal(String username);
}

@RequiredArgsConstructor
@Service
public class UserPrincipalServiceImpl implements UserPrincipalService {

    private final UaUserInfoService userInfoService;
    private final UaUserRoleRelationService userRoleRelationService;
    private final UaRoleInfoService roleInfoService;
    private final UaRoleAuthorityRelationService roleAuthorityRelationService;
    private final UaAuthorityInfoService authorityInfoService;

    @Override
    public UserPrincipalEntity getUserPrincipal(String username) {
        UaUserInfo userInfo = userInfoService.getOne(new QueryWrapper<UaUserInfo>().lambda().eq(UaUserInfo::getName, username));
        if (userInfo == null) {
            return null;
        }
        UserPrincipalEntity userPrincipal = new UserPrincipalEntity();
        userPrincipal.setId(userInfo.getId())
                .setUsername(userInfo.getName())
                .setPassword(userInfo.getPassword())
                .setRoles(new HashSet<>())
                .setPermissions(new HashSet<>())
                .setLoginTime(new Date());
        Set<Long> roleIds = userRoleRelationService.list(new QueryWrapper<UaUserRoleRelation>().lambda().eq(UaUserRoleRelation::getUserId, userInfo.getId()))
                .stream().map(UaUserRoleRelation::getRoleId)
                .collect(Collectors.toSet());
        if (CollectionUtil.isEmpty(roleIds)) {
            return userPrincipal;
        }
        List<UaRoleInfo> roleInfos = roleInfoService.listByIds(roleIds);
        List<UaRoleAuthorityRelation> roleAuthorityRelations = roleAuthorityRelationService.list(new QueryWrapper<UaRoleAuthorityRelation>()
                .lambda().in(UaRoleAuthorityRelation::getRoleId, roleIds));
        Set<Long> authorityIds = roleAuthorityRelations.stream().map(UaRoleAuthorityRelation::getAuthorityId)
                .collect(Collectors.toSet());
        List<UaAuthorityInfo> authorityInfos;
        if (CollectionUtil.isEmpty(authorityIds)) {
            authorityInfos = new ArrayList<>();
        } else {
            authorityInfos = authorityInfoService.listByIds(authorityIds);
        }

        Set<String> roles = new HashSet<>();
        Set<String> permissions = new HashSet<>();
        for (UaRoleInfo role : roleInfos) {
            roles.add(role.getCode());
            Set<Long> ids = roleAuthorityRelations.stream()
                    .filter(item -> role.getId().equals(item.getRoleId()))
                    .map(UaRoleAuthorityRelation::getAuthorityId)
                    .collect(Collectors.toSet());
            Set<String> perms = authorityInfos.stream()
                    .filter(item -> ids.contains(item.getId()))
                    .map(UaAuthorityInfo::getUri)
                    .collect(Collectors.toSet());
            permissions.addAll(perms);
        }
        userPrincipal.setRoles(roles).setPermissions(permissions);
        return userPrincipal;
    }
}

Realm已经配置，接下来就是让它生效了。

4、shiro核心配置

先把代码贴出来，在一一解释

@Configuration
public class ShiroConfig {

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

    @Bean
    @DependsOn({"lifecycleBeanPostProcessor"})
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator proxyCreator = new DefaultAdvisorAutoProxyCreator();
        /*
         * setUsePrefix(false)用于解决一个奇怪的bug。在引入spring aop的情况下。
         * 在@Controller注解的类的方法中加入@RequiresRole注解，会导致该方法无法映射请求，导致返回404。 加入这项配置能解决这个bug
         */
        proxyCreator.setProxyTargetClass(true);
        proxyCreator.setUsePrefix(false);
        return proxyCreator;
    }

    @Bean
    public EhCacheManager shiroCacheManager() {
        EhCacheManager ehCacheManager = new EhCacheManager();
        CacheManager cacheManager = CacheManager.create();
        ehCacheManager.setCacheManager(cacheManager);
        return ehCacheManager;
    }

    @Bean
    public DefaultWebSecurityManager securityManager(List<Realm> realms) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealms(realms);
        securityManager.setCacheManager(shiroCacheManager());
        return securityManager;
    }

    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        factoryBean.setSecurityManager(securityManager);

        Map<String, Filter> filterMap = new LinkedHashMap<>();
        factoryBean.setFilters(filterMap);
        factoryBean.setFilterChainDefinitionMap(getFilterChainDefinitionMap());
        return factoryBean;
    }

    private Map<String, String> getFilterChainDefinitionMap() {
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        filterChainDefinitionMap.put("/auth/login", "anon");
        filterChainDefinitionMap.put("/auth/registry", "anon");
        filterChainDefinitionMap.put("/auth/logout", "authc");
        filterChainDefinitionMap.put("/doc.html", "anon");
        filterChainDefinitionMap.put("/webjars/**", "anon");
        filterChainDefinitionMap.put("/favicon.ico", "anon");
        filterChainDefinitionMap.put("/swagger**", "anon");
        filterChainDefinitionMap.put("/v2/api-docs/**", "anon");
        filterChainDefinitionMap.put("/v3/api-docs/**", "anon");
        filterChainDefinitionMap.put("/error", "anon");
        filterChainDefinitionMap.put("/**", "anon");
        return filterChainDefinitionMap;
    }
}

首先是LifecycleBeanPostProcessor，注册这个Bean的目的在于将shiro的生命周期交给spring进行管理，无需用户手动干预。

DefaultAdvisorAutoProxyCreator主要是解决一个bug，如代码中注释所述，当controller接口上加了shiro的权限注解时，接口映射会有问题，报404，这个Bean就是用于解决此问题。

EhCacheManager中主要注意CacheManager.create()，通过查看此方法的源码可以发现，此方法使用了双重检查的单例模式来确保jvm中只有一个实例，这一点在上面的缓存配置那里有提及。在这里，如果不用CacheManager.create()而是ehCacheManager.setCacheManagerConfigFile("classpath:ehcache.xml")则最终会导致ehcache实例不唯一而启动失败。

DefaultWebSecurityManager是SecurityManager的一个实现，在这里，注入了Realm集合，实际上就一个LoginRealm，同时设置了缓存管理器用来保存认证与鉴权信息。

ShiroFilterFactoryBean用来注册过滤器，getFilterChainDefinitionMap()方法返回的是默认的过滤规则，对于一些固定死的请求，可以在这里进行设置，filterChainDefinitionMap的键是请求路径，值则是对应的过滤器名称，这里使用的都是shiro默认过滤器的简写。shiro提供的默认过滤器如下

配置缩写	对应的过滤器	功能
anon	AnonymousFilter	指定url可以匿名访问
authc	FormAuthenticationFilter	指定url需要form表单登录，默认会从请求中获取`username`、`password`,`rememberMe`等参数并尝试登录，如果登录不了就会跳转到loginUrl配置的路径。我们也可以用这个过滤器做默认的登录逻辑，但是一般都是我们自己在控制器写登录逻辑的，自己写的话出错返回的信息都可以定制嘛。
authcBasic	BasicHttpAuthenticationFilter	指定url需要basic登录
logout	LogoutFilter	登出过滤器，配置指定url就可以实现退出功能，非常方便
noSessionCreation	NoSessionCreationFilter	禁止创建会话
perms	PermissionsAuthorizationFilter	需要指定权限才能访问
port	PortFilter	需要指定端口才能访问
rest	HttpMethodPermissionFilter	将http请求方法转化成相应的动词来构造一个权限字符串，这个感觉意义不大，有兴趣自己看源码的注释
roles	RolesAuthorizationFilter	需要指定角色才能访问
ssl	SslFilter	需要https请求才能访问
user	UserFilter	需要已登录或“记住我”的用户才能访问

一般来说，上述的过滤器结合shiro的权限注解已经足够使用了，而如果需要自定义过滤器，可参考如下的示例代码（注：只是示例，并未用到）

首先，定义一个过滤器

public class CustomAuthFilter extends AuthenticatingFilter {

    @Override
    protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) throws Exception {
        // 从请求头中获取对应的认证信息，此方法会在后面执行executeLogin时由父类调用
        // if (认证信息不为空) {
        //     return AuthenticationToken实例;
        // }
        return null;
    }


    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        // 放过预检请求
        return ((HttpServletRequest) request).getMethod().equals(RequestMethod.OPTIONS.name()) || super.isPermissive(mappedValue);
    }


    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        // isAccessAllowed返回false，会进入此方法
        // 从请求头中获取对应的认证信息
        // if (认证信息不为空) {
        //     // 进行登录认证
        //     return executeLogin(request, response);
        // }
        // 否则当做匿名用户放行，毕竟有些接口是不登录也可以访问的，具体能否访问就看过滤规则以及接口上的权限注解了
        return true;
    }

    @Override
    protected boolean onLoginFailure(AuthenticationToken token, AuthenticationException e, ServletRequest request, ServletResponse response) {
        // executeLogin登录失败则返回错误信息
        writeResult(ApiResult.error(HttpStatus.UNAUTHORIZED, e.getMessage()));
        return false;
    }

    private <T> void writeResult(ApiResult<T> result) {
        HttpServletResponse response = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getResponse();
        assert response != null;
        response.setCharacterEncoding("UTF-8");
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
        response.setHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS, "true");
        // 后台统一返回数据的状态码都是200(系统层面请求成功), 实际业务的状态码根据 ApiResult 进行判断
        response.setStatus(HttpStatus.OK.value());
        PrintWriter writer = null;
        try {
            writer = response.getWriter();
            writer.print(JSONUtil.toJsonStr(result));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

然后注册过滤器，在上面的配置类中，修改最后两个方法如下

@Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        factoryBean.setSecurityManager(securityManager);

        Map<String, Filter> filterMap = new LinkedHashMap<>();
        // 注册自定义过滤器
        filterMap.put("customAuthFilter", new CustomAuthFilter());
        factoryBean.setFilters(filterMap);
        factoryBean.setFilterChainDefinitionMap(getFilterChainDefinitionMap());
        return factoryBean;
    }

    private Map<String, String> getFilterChainDefinitionMap() {
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        filterChainDefinitionMap.put("/auth/login", "anon");
        filterChainDefinitionMap.put("/auth/registry", "anon");
        filterChainDefinitionMap.put("/auth/logout", "anon");
        filterChainDefinitionMap.put("/doc.html", "anon");
        filterChainDefinitionMap.put("/webjars/**", "anon");
        filterChainDefinitionMap.put("/favicon.ico", "anon");
        filterChainDefinitionMap.put("/swagger**", "anon");
        filterChainDefinitionMap.put("/v2/api-docs/**", "anon");
        filterChainDefinitionMap.put("/v3/api-docs/**", "anon");
        filterChainDefinitionMap.put("/error", "anon");
        // 除上面定义的请求外，其余请求默认都会经过customAuthFilter过滤器
        // 注：这里的customAuthFilter名称要与上面注册的一致
        filterChainDefinitionMap.put("/**", "customAuthFilter");
        return filterChainDefinitionMap;
    }

至此，过滤器就OK了。不过我并未用到，上述仅仅是一个示例。接下来，对需要进行权限校验的接口，添加相应的注解，如列表查询用户的接口上添加@RequiresPermissions("list:ua-user-info")注解，则用户必须要拥有list:ua-user-info权限才可以访问。

相应的注解还有以下几个

注解	功能
@RequiresGuest	只有游客可以访问
@RequiresAuthentication	需要登录才能访问
@RequiresUser	已登录的用户或“记住我”的用户能访问
@RequiresRoles	已登录的用户需具有指定的角色才能访问
@RequiresPermissions	已登录的用户需具有指定的权限才能访问

接下来就是登录退出功能的实现了。

5、登录退出

登录退出在shiro非常简单，登录只需要SecurityUtils.getSubject().login(token)即可，其中的token是AuthenticationToken实现类实例，不同类型的AuthenticationToken实例对应不同的Realm，退出则SecurityUtils.getSubject().logout()即可。而如果是在过滤器中进行认证，则参考上面的过滤器示例中executeLogin方法。

新建类LoginController，代码如下

@Api(tags = "认证")
@RequiredArgsConstructor
@Validated
@RequestMapping("auth")
@RestController
public class LoginController {

    private final UaUserInfoService userInfoService;

    @ApiOperation("注册")
    @PostMapping("registry")
    public ApiResult<UaUserInfo> registry(@RequestBody @Valid LoginRegistryParam param) {
        long count = userInfoService.count(new QueryWrapper<UaUserInfo>().lambda().eq(UaUserInfo::getName, param.getUsername()));
        if (count > 0) {
            return ApiResult.error(HttpStatus.BAD_REQUEST, "用户已存在！");
        }
        String encryptPassword = userInfoService.encryptPassword(param.getPassword());
        UaUserInfo userInfo = new UaUserInfo()
                .setName(param.getUsername())
                .setPassword(encryptPassword);
        userInfoService.save(userInfo);
        return ApiResult.ok(userInfo);
    }

    @ApiOperation("登录")
    @PostMapping("login")
    public ApiResult<UserPrincipalEntity> login(@RequestBody @Valid LoginRegistryParam param) {
        UsernamePasswordToken token = new UsernamePasswordToken(param.getUsername(), param.getPassword());
        SecurityUtils.getSubject().login(token);
        UserPrincipalEntity userPrincipal = (UserPrincipalEntity) SecurityUtils.getSubject().getPrincipal();
        return ApiResult.ok(userPrincipal);
    }

    @ApiOperation("退出")
    @PostMapping("logout")
    public ApiResult<Void> logout() {
        SecurityUtils.getSubject().logout();
        return ApiResult.ok();
    }
}

其中，LoginRegistryParam的定义如下

@Data
public class LoginRegistryParam {

    @NotBlank
    private String username;

    @NotBlank
    private String password;
}

为了方便测试，我预先准备了一份脚本，创建了admin用户并绑定角色ADMIN，同时为ADMIN授予了所有接口的权限。脚本如下

truncate table ua_role_info;
insert into ua_role_info(code, name)
VALUES ('ADMIN', '系统管理员'),
       ('USER', '普通用户');


truncate table ua_authority_info;
insert into ua_authority_info(id, parent_id, name, uri, type)
VALUES (1, -1, '认证授权', 'ua', 1),
       (2, 1, '权限管理', 'ua-authority-info', 1),
       (3, 1, '角色管理', 'ua-role-info', 1),
       (4, 1, '用户管理', 'ua-user-info', 1);

insert into ua_authority_info(parent_id, name, uri, type, group_name)
VALUES (2, '列表查询', 'list:ua-authority-info', 2, 'ua-authority-info'),
       (2, '主键查询', 'detail:ua-authority-info', 2, 'ua-authority-info'),
       (2, '新增', 'save:ua-authority-info', 2, 'ua-authority-info'),
       (2, '更新', 'update:ua-authority-info', 2, 'ua-authority-info'),
       (2, '删除', 'delete:ua-authority-info', 2, 'ua-authority-info');

insert into ua_authority_info(parent_id, name, uri, type, group_name)
VALUES (3, '列表查询', 'list:ua-role-info', 2, 'ua-role-info'),
       (3, '主键查询', 'detail:ua-role-info', 2, 'ua-role-info'),
       (3, '新增', 'save:ua-role-info', 2, 'ua-role-info'),
       (3, '更新', 'update:ua-role-info', 2, 'ua-role-info'),
       (3, '删除', 'delete:ua-role-info', 2, 'ua-role-info');
insert into ua_authority_info(parent_id, name, uri, type, group_name)
VALUES (3, '列表查询', 'list:ua-role-authority-relation', 2, 'ua-role-authority-relation'),
       (3, '主键查询', 'detail:ua-role-authority-relation', 2, 'ua-role-authority-relation'),
       (3, '新增', 'save:ua-role-authority-relation', 2, 'ua-role-authority-relation'),
       (3, '更新', 'update:ua-role-authority-relation', 2, 'ua-role-authority-relation'),
       (3, '删除', 'delete:ua-role-authority-relation', 2, 'ua-role-authority-relation');

insert into ua_authority_info(parent_id, name, uri, type, group_name)
VALUES (4, '列表查询', 'list:ua-user-info', 2, 'ua-user-info'),
       (4, '主键查询', 'detail:ua-user-info', 2, 'ua-user-info'),
       (4, '新增', 'save:ua-user-info', 2, 'ua-user-info'),
       (4, '更新', 'update:ua-user-info', 2, 'ua-user-info'),
       (4, '删除', 'delete:ua-user-info', 2, 'ua-user-info');
insert into ua_authority_info(parent_id, name, uri, type, group_name)
VALUES (4, '列表查询', 'list:ua-user-role-relation', 2, 'ua-user-role-relation'),
       (4, '主键查询', 'detail:ua-user-role-relation', 2, 'ua-user-role-relation'),
       (4, '新增', 'save:ua-user-role-relation', 2, 'ua-user-role-relation'),
       (4, '更新', 'update:ua-user-role-relation', 2, 'ua-user-role-relation'),
       (4, '删除', 'delete:ua-user-role-relation', 2, 'ua-user-role-relation');

truncate table ua_user_info;
insert into ua_user_info(id, name, password)
    VALUE (1, 'admin', 'i8TY37+scxcO3FrMuHVnDaULwDc11+ujgGXPRG5YBWs=');

truncate table ua_user_role_relation;
insert into ua_user_role_relation(user_id, role_id)
VALUES (1, 1);

truncate table ua_role_authority_relation;
insert into ua_role_authority_relation(role_id, authority_id)
select 1, id
from ua_authority_info;

启动项目，然后登录即可访问对应接口，如果是新注册用户或者是权限未被授予，则无法访问。

6、异常处理

异常处理，包括认证授权异常、参数校验异常以及如空指针异常等这类运行时异常。代码如下，其中，账号被锁、操作频繁暂时没有用到

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ApiResult<Void> handleValidationException(MethodArgumentNotValidException e) {
        BindingResult bindingResult = e.getBindingResult();
        StringBuilder msg = new StringBuilder();
        if (bindingResult instanceof BeanPropertyBindingResult) {
            for (ObjectError error : bindingResult.getAllErrors()) {
                if (error instanceof FieldError) {
                    msg.append(((FieldError) error).getField()).append(error.getDefaultMessage()).append("！");
                }
            }
        }
        return ApiResult.error(HttpStatus.BAD_REQUEST, msg.toString());
    }

    @ExceptionHandler(UnknownAccountException.class)
    public ApiResult<Void> handleUnknownAccountException(UnknownAccountException e) {
        log.error("UnknownAccountException: {}", e.getMessage());
        return ApiResult.error(HttpStatus.UNAUTHORIZED, "账户不存在！");
    }

    @ExceptionHandler(IncorrectCredentialsException.class)
    public ApiResult<Void> handleIncorrectCredentialsException(IncorrectCredentialsException e) {
        log.error("IncorrectCredentialsException: {}", e.getMessage());
        return ApiResult.error(HttpStatus.UNAUTHORIZED, "密码错误！");
    }

    @ExceptionHandler(LockedAccountException.class)
    public ApiResult<Void> handleLockedAccountException(LockedAccountException e) {
        log.error("LockedAccountException: {}", e.getMessage());
        return ApiResult.error(HttpStatus.FORBIDDEN, "账号被锁定！");
    }

    @ExceptionHandler(ExcessiveAttemptsException.class)
    public ApiResult<Void> handleExcessiveAttemptsException(ExcessiveAttemptsException e) {
        log.error("LockedAccountException: {}", e.getMessage());
        return ApiResult.error(HttpStatus.FORBIDDEN, "操作频繁，请稍后再试！");
    }

    @ExceptionHandler(UnauthenticatedException.class)
    public ApiResult<Void> handleUnauthenticatedException(UnauthenticatedException e) {
        log.error("UnauthenticatedException: {}", e.getMessage());
        return ApiResult.error(HttpStatus.UNAUTHORIZED, "认证失败！");
    }

    @ExceptionHandler(UnauthorizedException.class)
    public ApiResult<Void> handleUnauthorizedException(UnauthorizedException e) {
        log.error("UnauthorizedException: {}", e.getMessage());
        return ApiResult.error(HttpStatus.FORBIDDEN, "没有访问权限！");
    }

    @ExceptionHandler(Exception.class)
    public ApiResult<Void> handleOtherException(Exception e) {
        log.error("server error: ", e);
        return ApiResult.error(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage());
    }
}