小程序（二）shiro+jwt登录认证

---

一、Shiro和JWT技术

Shiro是Java领域非常知名的认证（ Authentication ）与授权
（ Authorization ）框架，用以替代JavaEE中的JAAS功能。相
较于其他认证与授权框架，Shiro设计的非常简单，所以广受好
评。任意JavaWeb项目都可以使用Shiro框架，而Spring Security
必须要使用在Spring项目中。所以Shiro的适用性更加广泛。像什
么 JFinal 和 Nutz 非Spring框架都可以使用Shiro，而不能使用Spring Security框架。

---

1、Shiro简介

什么是认证？
认证就是要核验用户的身份，比如说通过用户名和密码来检验用户的身份。说简单一些，认证就
是登陆。登陆之后Shiro要记录用户成功登陆的凭证。

什么是授权？
授权是比认证更加精细度的划分用户的行为。比如说一个教务管理系统中，学生登陆之后只能查
看信息，不能修改信息。而班主任就可以修改学生的信息。这就是利用授权来限定不同身份用户
的行为。

Shiro靠什么做认证与授权？
Shiro可以利用 HttpSession 或者 Redis 存储用户的登陆凭证，以及角色或者身份信息。然后利
用过滤器（Filter），对每个Http请求过滤，检查请求对应的 HttpSession 或者 Redis 中的认证
与授权信息。如果用户没有登陆，或者权限不够，那么Shiro会向客户端返回错误信息。
也就是说，我们写用户登陆模块的时候，用户登陆成功之后，要调用Shiro保存登陆凭证。然后查
询用户的角色和权限，让Shiro存储起来。将来不管哪个方法需要登陆访问，或者拥有特定的角色
跟权限才能访问，我们在方法前设置注解即可，非常简单。

2、JWT简介

JWT（Json Web Token）, 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标
准。JWT一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服
务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用
于认证，也可被加密。

JWT可以用在单点登录的系统中：
传统的 JavaWeb 项目，利用 HttpSession 保存用户的登陆凭证。如果后端系统采用了负载均衡
设计，当用户在A节点成功登陆，那么登陆凭证保存在A节点的 HttpSession 中。如果用户下一
个请求被负载均衡到了B节点，因为B节点上面没有用户的登陆凭证，所以需要用户重新登录，
这个体验太糟糕了。

如果用户的登陆凭证经过加密（ Token ）保存在客户端，客户端每次提交请求的时候，把
Token 上传给后端服务器节点。即便后端项目使用了负载均衡，每个后端节点接收到客户端上传
的Token之后，经过检测，是有效的 Token ，于是就断定用户已经成功登陆，接下来就可以提供
后端服务了。

JWT兼容更多的客户端：
传统的 HttpSession 依靠浏览器的 Cookie 存放 SessionId ，所以要求客户端必须是浏览器。现
在的JavaWeb系统，客户端可以是浏览器、APP、小程序，以及物联网设备。为了让这些设备都
能访问到JavaWeb项目，就必须要引入JWT技术。JWT的 Token 是纯字符串，至于客户端怎么
保存，没有具体要求。只要客户端发起请求的时候，附带上 Token 即可。所以像物联网设备，我
们可以用 SQLite 存储 Token 数据

二、创建JWT工具类

JWT的 Token 要经过加密才能返回给客户端，包括客户端上传的 Token ，后端项目需要验证核
实。于是我们需要一个JWT工具类，用来 加密Token 和 验证Token 的有效性。

1、导入依赖库

        <dependency>
            <groupId>com.auth0groupId>
            <artifactId>java-jwtartifactId>
            <version>3.3.0version>
        dependency>
        
        <dependency>
            <groupId>org.apache.shirogroupId>
            <artifactId>shiro-spring-boot-starterartifactId>
            <version>1.5.3version>
        dependency>
        
        <dependency>
            <groupId>cn.hutoolgroupId>
            <artifactId>hutool-allartifactId>
            <version>5.0.7version>
        dependency>

        
        <dependency>
            <groupId>com.google.zxinggroupId>
            <artifactId>coreartifactId>
            <version>3.4.0version>
        dependency>
        <dependency>
            <groupId>com.google.zxinggroupId>
            <artifactId>javaseartifactId>
            <version>3.4.0version>
        dependency>

2、定义密钥和过期时间

我建议大家把密钥和过期时间定义到SpringBoot配置文件中，然后再值注入到JavaBean中，这样
维护起来比较方便。

WeChatMiNi:
  jwt:
    #密钥
    secret: buba123456
    #令牌期时间
    expire: 7
    #令牌缓存时间（天）
    cache-expire: 10

3、创建JWT工具类

package com.buba.wechatmini.common.utils;

/**
 * @author qlx
 */


import com.buba.wechatmini.exception.WechatminiException;
import cn.hutool.core.date.DateField;
import cn.hutool.core.date.DateUtil;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.io.UnsupportedEncodingException;
import java.util.Date;

@Component
@Slf4j
public class JwtUtil {
    //密钥
    @Value("${WeChatMiNi.jwt.secret}")
    private String secret;
    //过期时间（天）
    @Value("${WeChatMiNi.jwt.expire}")
    private int expire;

    public String createToken(int userId) throws UnsupportedEncodingException {
//         @param date 基准日期
//         @param dateField 偏移的粒度大小（小时、天、月等）{@link DateField}
//         @param offset 偏移量，正数为向后偏移，负数为向前偏移
//         @return 偏移后的日期
        Date date = DateUtil.offset(new Date(), DateField.DAY_OF_YEAR,expire).toJdkDate();
        Algorithm algorithm = Algorithm.HMAC256(secret); //创建加密算法对象
        JWTCreator.Builder builder = JWT.create();
        String token = builder.withClaim("userId",userId).withExpiresAt(date).sign(algorithm);
        return token;
    }
    public int getUserId(String token) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim("userId").asInt();
        } catch (Exception e) {
            throw new WechatminiException("令牌无效");
        }
    }

    public void verifierToken(String token) throws UnsupportedEncodingException {
        Algorithm algorithm = Algorithm.HMAC256(secret); //创建加密算法对象
        JWTVerifier verifier = JWT.require(algorithm).build();
        verifier.verify(token);
    }
}

三、把令牌封装成认证对象

二中，我们通过JwtUtil类可以生成 Token ，这个 Token 我们是要返回给客户端的。接下来
我们要把 JWT 和 Shiro框架 对接起来，这样 Shiro框架 就会拦截所有的Http请求，然后验证请求
提交的 Token 是否有效。

客户端提交的Token不能直接交给Shiro框架，需要先封装成 AuthenticationToken 类型的对象，
所以我们我们需要先创建 AuthenticationToken 的实现类。
在com.buba.wechatmini.config.shiro 中创建 OAuth2Token 类。

package com.buba.wechatmini.config.shiro;

import org.apache.shiro.authc.AuthenticationToken;

/**
 * @author qlx
 */
public class OAuth2Token implements AuthenticationToken {

     private String token;

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

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

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

四、创建OAuth2Realm类

OAuth2Realm 类是 AuthorizingRealm 的实现类，我们要在这个实现类中定义认证和授权的方
法。

因为认证与授权模块设计到用户模块和权限模块，现在我们还没有真正的开发业务模块，所
以我们这里先暂时注释掉实现认证去授权方法。
在 com.buba.wechatmini.config.shiro 中创建 OAuth2Realm 类。

package com.buba.wechatmini.config.shiro;

import com.buba.wechatmini.common.utils.JwtUtil;
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author qlx
 */
@Component
public class OAuth2Realm extends AuthorizingRealm {

     @Autowired
     private JwtUtil jwtUtil;

     @Override
     public boolean supports(AuthenticationToken token) {
         return token instanceof OAuth2Token;
     }
     /**
     * 授权(验证权限时调用)
     * Shiro每次验证权限之前，都要执行授权方法，把用户具有的权限封装成权限对象，然后放行请
求。接下来Web方法的 @RequiresPermissions 注解，会从权限对象中提取权限数据，跟要求的
权限作比较。如果用户具有该Web方法要求的权限，那么Web方法就会正常执行。反之则返回异
常消息。
     */
     @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection collection) {
         SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
         TbUser user = (TbUser) collection.getPrimaryPrincipal();
         int userId = user.getId();
        //用户权限列表
        Set<String> permsSet = userService.searchUserPermissions(userId);
        //用户角色列表
        Set<String> rolesSet = userService.searchUserRoles(userId);
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        info.setStringPermissions(permsSet);
        info.addRoles(rolesSet );
        return info;
    }
     /**
     * 认证(登录时调用)
     */
     @Override
     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws
             AuthenticationException {
            //String accessToken = (String) token.getPrincipal();
           // int userId = jwtUtil.getUserId(accessToken);
            //查询用户信息
           //TbUser user = userService.searchById(userId);
           //if(user==null){
          //      throw new LockedAccountException("账号已被锁定,请联系管理员");
           //}
           SimpleAuthenticationInfo info=new SimpleAuthenticationInfo(user, accessToken,
getName());
          return info;
     }

}

添加权限验证注解
我们创建Web方法的时候，如果希望只有满足相关权限的用户才能调用这个Web方法，我们只需
要给Web方法添加上 @RequiresPermissions 注解即可

 @PostMapping("/addUser")
 @ApiOperation("添加用户")
 @RequiresPermissions(value = {"ROOT", "USER:ADD"}, logical = Logical.OR)
 public Result addUser() {
 return Result .ok("用户添加成功");
 }

五、设计刷新令牌

1、为什么要刷新Token的过期时间？

我们在定义JwtUtil工具类的时候，生成的 Token 都有过期时间。那么问题来了，假设 Token 过
期时间为15天，用户在第14天的时候，还可以免登录正常访问系统。但是到了第15天，用户的
Token过期，于是用户需要重新登录系统。
HttpSession 的过期时间比较优雅，默认为15分钟。如果用户连续使用系统，只要间隔时间不超
过15分钟，系统就不会销毁 HttpSession 对象。JWT的令牌过期时间能不能做成 HttpSession
那样超时时间，只要用户间隔操作时间不超过15天，系统就不需要用户重新登录系统。实现这种
效果的方案有两种： 双Token 和 Token缓存 ，这里重点讲一下 Token 缓存方案。

Token缓存方案是把 Token 缓存到Redis，然后设置Redis里面缓存的 Token 过期时间为正常
Token 的1倍,然后根据情况刷新 Token 的过期时间。
Token失效，缓存也不存在的情况
当第15天，用户的 Token 失效以后，我们让Shiro程序到Redis查看是否存在缓存的 Token ，如
果这个 Token 不存在于Redis里面，就说明用户的操作间隔了15天，需要重新登录。
Token失效，但是缓存还存在的情况
如果Redis中存在缓存的 Token ，说明当前 Token 失效后，间隔时间还没有超过15天，不应该让
用户重新登录。所以要生成新的 Token 返回给客户端，并且把这个 Token 缓存到Redis里面，这
种操作成为刷新 Token 过期时间。

2、客户端如何更新令牌？

在我们的方案中，服务端刷新 Token 过期时间，其实就是生成一个新的 Token 给客户端。那么
客户端怎么知道这次响应带回来的Token是更新过的呢？这个问题很容易解决。

只要用户成功登陆系统，当后端服务器更新 Token 的时候，就在响应中添加 Token 。客户端那
边判断每次Ajax响应里面是否包含 Token ，如果包含，就把 Token 保存起来就可以了。

3、如何在响应中添加令牌？

我们定义 OAuth2Filter 类拦截所有的HTTP请求，一方面它会把请求中的 Token 字符串提取出
来，封装成对象交给Shiro框架；另一方面，它会检查 Token 的有效性。如果 Token 过期，那么
会生成新的 Token ，分别存储在 ThreadLocalToken 和 Redis 中。
之所以要把 新令牌 保存到 ThreadLocalToken 里面，是因为要向 AOP切面类 传递这个 新令牌 。
虽然 OAuth2Filter 中有 doFilterInternal() 方法，我们可以得到响应并且写入 新令牌 。但是
这个做非常麻烦，首先我们要通过IO流读取响应中的数据，然后还要把数据解析成JSON对象，
最后再放入这个新令牌。如果我们定义了 AOP切面类 ，拦截所有Web方法返回的 R对象 ，然后
在 R对象 里面添加 新令牌 ，这多简单啊。但是 OAuth2Filter 和 AOP 切面类之间没有调用关
系，所以我们很难把 新令牌 传给 AOP切面类 。
这里我想到了 ThreadLocal ，只要是同一个线程，往 ThreadLocal 里面写入数据和读取数据是
完全相同的。在Web项目中，从 OAuth2Filter 到 AOP切面类 ，都是由同一个线程来执行的，中
途不会更换线程。所以我们可以放心的把新令牌保存都在 ThreadLocal 里面， AOP切面类 可以成
功的取出新令牌，然后往 R对象 里面添加新令牌即可。
ThreadLocalToken 是我自定义的类，里面包含了 ThreadLocal 类型的变量，可以用来保存线程
安全的数据，而且避免了使用线程锁.

六、创建ThreadLocalToken类

在 com.buba.wechatmini.config.shiro 中创建 ThreadLocalToken类。

package com.buba.wechatmini.config.shiro;

/**
 * @author qlx
 */
 @Component
public class ThreadLocalToken {
    private ThreadLocal local=new ThreadLocal();
     
    public void setToken(String token){
         local.set(token);
    }
    
    public String getToken(){
         return (String) local.get();
    }
    
    public void clear(){
         local.remove();
    }
}

七、创建OAuth2Filter类

注意事项：因为在 OAuth2Filter 类中要读写 ThreadLocal 中的数据，所以 OAuth2Filter 类必 须要设置成多例的，否则 ThreadLocal 将无法使用。 在配置文件中，添加JWT需要用到的密钥、过期时间和缓存过期时间。

WeChatMiNi:
  jwt:
    #密钥
    secret: buba123456
    #令牌期时间
    expire: 7
    #令牌缓存时间（天）
    cache-expire: 10

在包com.buba.wechatmini.config.shiro中创建 OAuth2Filter 类

package com.buba.wechatmini.config.shiro;

/**
 * @author qlx
 */

import cn.hutool.http.HttpStatus;
import com.alibaba.druid.util.StringUtils;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.buba.wechatmini.common.utils.JwtUtil;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.web.filter.authc.AuthenticatingFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMethod;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

@Component
@Scope("prototype")
public class OAuth2Filter extends AuthenticatingFilter {

    @Autowired
    private ThreadLocalToken threadLocalToken;

    @Value("${WeChatMiNi.jwt.cache-expire}")
    private int cacheExpire;

    @Autowired
    private JwtUtil jwtUtil;

    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * 拦截请求之后，用于把令牌字符串封装成令牌对象
     */
    @Override
    protected AuthenticationToken createToken(ServletRequest request,ServletResponse response) throws Exception {
        //获取请求token
        String token = getRequestToken((HttpServletRequest) request);
        if (StringUtils.isEmpty(token)) {
            return null;
        }
        return new OAuth2Token(token);
    }
    /**
     * 拦截请求，判断请求是否需要被Shiro处理
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request,ServletResponse response, Object mappedValue) {
        HttpServletRequest req = (HttpServletRequest) request;
        // Ajax提交application/json数据的时候，会先发出Options请求
        // 这里要放行Options请求，不需要Shiro处理
        if (req.getMethod().equals(RequestMethod.OPTIONS.name())) {
            return true;
        }
        // 除了Options请求之外，所有请求都要被Shiro处理
        return false;
    }
    /**
     * 该方法用于处理所有应该被Shiro处理的请求
     */
    @Override
    protected boolean onAccessDenied(ServletRequest request,
                                     ServletResponse response) throws Exception {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse resp = (HttpServletResponse) response;
        resp.setHeader("Content-Type", "text/html;charset=UTF-8");
        //允许跨域请求
        resp.setHeader("Access-Control-Allow-Credentials", "true");
        resp.setHeader("Access-Control-Allow-Origin", req.getHeader("Origin"));
        threadLocalToken.clear();
        //获取请求token，如果token不存在，直接返回401
        String token = getRequestToken((HttpServletRequest) request);
        if (StringUtils.isEmpty(token)) {
            resp.setStatus(HttpStatus.HTTP_UNAUTHORIZED);
            resp.getWriter().print("无令牌,请先登录");
            return false;
        }
        try {
            jwtUtil.verifierToken(token); //检查令牌是否过期
        } catch (TokenExpiredException e) {
            //客户端令牌过期，查询Redis中是否存在令牌，如果存在令牌就重新生成一个令牌给客户端
            if (redisTemplate.hasKey(token)) {
                redisTemplate.delete(token);//删除令牌
                int userId = jwtUtil.getUserId(token);
                token = jwtUtil.createToken(userId); //生成新的令牌
                //把新的令牌保存到Redis中
                redisTemplate.opsForValue().set(token, userId + "", cacheExpire,
                        TimeUnit.DAYS);
                //把新令牌绑定到线程
                threadLocalToken.setToken(token);
            } else {
                //如果Redis不存在令牌，让用户重新登录
                resp.setStatus(HttpStatus.HTTP_UNAUTHORIZED);
                resp.getWriter().print("令牌已经过期");
                return false;
            }
        } catch (JWTDecodeException e) {
            resp.setStatus(HttpStatus.HTTP_UNAUTHORIZED);
            resp.getWriter().print("无效的令牌");
            return false;
        }
        boolean bool = executeLogin(request, response);
        return bool;
    }
    @Override
    protected boolean onLoginFailure(AuthenticationToken token,
                                     AuthenticationException e, ServletRequest request, ServletResponse response) {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse resp = (HttpServletResponse) response;
        resp.setStatus(HttpStatus.HTTP_UNAUTHORIZED);
        resp.setContentType("application/json;charset=utf-8");
        resp.setHeader("Access-Control-Allow-Credentials", "true");
        resp.setHeader("Access-Control-Allow-Origin", req.getHeader("Origin"));
        try {
            resp.getWriter().print(e.getMessage());
        } catch (IOException exception) {
        }
        return false;
    }
    /**
     * 获取请求头里面的token
     */
    private String getRequestToken(HttpServletRequest httpRequest) {
        //从header中获取token
        String token = httpRequest.getHeader("token");
        //如果header中不存在token，则从参数中获取token
        if (StringUtils.isEmpty(token)) {
            token = httpRequest.getParameter("token");
        }
        return token;
    }
    @Override
    public void doFilterInternal(ServletRequest request,
                                 ServletResponse response, FilterChain chain) throws ServletException, IOException
    {
        super.doFilterInternal(request, response, chain);
    }

}

八、 创建ShiroConfig类

我们要创建的 ShiroConfig 类，是用来把 OAuth2Filter 和 OAuth2Realm 配置到Shiro框架，这
样我们辛苦搭建的Shiro+JWT才算生效。

package com.buba.wechatmini.config.shiro;

import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.mgt.SessionsSecurityManager;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.servlet.Filter;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @author qlx
 */
@Configuration
public class ShiroConfig {

    @Bean
    public SessionsSecurityManager securityManager(OAuth2Realm oAuth2Realm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(oAuth2Realm);
//        securityManager.setRememberMeManager(null);
        return securityManager;
    }

    @Bean("shiroFilter")
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager, OAuth2Filter
            oAuth2Filter) {
        ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
        shiroFilter.setSecurityManager(securityManager);
        //oauth过滤
        Map<String, Filter> filters = new HashMap<>();
        filters.put("oauth2", oAuth2Filter);
        shiroFilter.setFilters(filters);
        Map<String, String> filterMap = new LinkedHashMap<>();
        filterMap.put("/webjars/**", "anon");
        filterMap.put("/druid/**", "anon");
        filterMap.put("/app/**", "anon");
        filterMap.put("/sys/login", "anon");
        filterMap.put("/swagger/**", "anon");
        filterMap.put("/v2/api-docs", "anon");
        filterMap.put("/swagger-ui.html", "anon");
        filterMap.put("/swagger-resources/**", "anon");
        filterMap.put("/captcha.jpg", "anon");
        filterMap.put("/user/register", "anon");
        filterMap.put("/user/login", "anon");
        filterMap.put("/test/**", "anon");
        filterMap.put("/**", "oauth2");
        shiroFilter.setFilterChainDefinitionMap(filterMap);
        return shiroFilter;
    }
    @Bean("lifecycleBeanPostProcessor")
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

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

九、利用AOP，把更新的令牌返回给客户端

我们在写 OAuth2Filter 的时候，把更新后的令牌写到 ThreadLocalToken 里面的
ThreadLocal 。那么这个小节，我们要创建 AOP切面类 ，拦截所有Web方法的返回值，在返回
的 R对象 中添加更新后的令牌。
在 com.buba.wechatmini.config.shiro 中创建 TokenAspect 类。

package com.buba.wechatmini.config.shiro;


import com.buba.wechatmini.common.utils.Result;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
 * @author qlx
 */

@Aspect
@Component
public class TokenAspect {
    @Autowired
    private ThreadLocalToken threadLocalToken;

    @Pointcut("execution(public * com.buba.wechatmini.controller.*.*(..)))")
    public void aspect() {
    }

    @Around("aspect()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        Result r = (Result) point.proceed(); //方法执行结果
        String token = threadLocalToken.getToken();
        //如果ThreadLocal中存在Token，说明是更新的Token
        if (token != null) {
            r.put("token", token); //往响应中放置Token
            threadLocalToken.clear();
        }
        return r;
    }
}

十、精简返回给客户端的异常内容

这里我们要对返回的异常内容做一下精简
在 com.buba.wechatmini.config.shiro中，创建 ExceptionAdvice 类。

package com.buba.wechatmini.config.shiro;

/**
 * @author qlx
 */

import com.buba.wechatmini.exception.WechatminiException;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.UnauthorizedException;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@Slf4j
@RestControllerAdvice
public class ExceptionAdvice {
 @ResponseBody
 @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
 @ExceptionHandler(Exception.class)
 public String validExceptionHandler(Exception e) {
         log.error("执行异常",e);
         if (e instanceof MethodArgumentNotValidException) {
             MethodArgumentNotValidException exception = (MethodArgumentNotValidException)
                    e;
             //将错误信息返回给前台
             return exception.getBindingResult().getFieldError().getDefaultMessage();
             }
         else if(e instanceof WechatminiException){
             WechatminiException exception=(WechatminiException)e;
             return exception.getMessage();
             }
         else if(e instanceof UnauthorizedException){
             return "你不具有相关权限";
             }
         else {
             return "后端执行异常";
             }
         }
}