[Java知识库]shiro之前后端分离（基于jwt的token安全认证）

前后端分离项目与传统的一体式项目有所不同，用户安全认证的方式不太一样，前后端分离项目不能像一体式项目那样使用session认证，所以一般使用token认证，具体原理很简单，客户端每次请求服务器的时候都会带上token密钥，服务器识别认证token后，即可识别身份并响应数据。废话不多说，直接上代码。
主要代码：
一、JwtUtil
Jwt即java web token，是比较成熟的token方案，JwtUtil里面有生成token的方法、校验token是否有效是否过期的方法、以及通过token获取解析值的方法，这里我们可以设置token的有效时间。

@Component
public class JwtUtil {



    /**
     * JWT认证过期时间 EXPIRE_TIME 分钟
     */
    private static final long EXPIRE_TIME = 30*1000;

    /**
     * 校验token是否正确
     *
     * @param token  密钥
     * @param secret 用户的密码
     * @return 是否正确
     */
    public static boolean verify(String token, String username, String secret) {
        try {
            //根据密码生成JWT效验器
            Algorithm algorithm = Algorithm.HMAC256(secret);
            JWTVerifier verifier = JWT.require(algorithm)
                    .withClaim("username", username)
                    .build();
            //效验TOKEN
            DecodedJWT jwt = verifier.verify(token);
            System.out.println("登录认证成功!");
            return true;
        } catch (Exception exception) {
            System.out.println("JwtUtil登录认证失败!");
            return false;
        }
    }

    /**
     * 获得token中的信息无需secret解密也能获得
     *
     * @return token中包含的用户名
     */
    public static String getUsername(String token) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim("username").asString();
        } catch (JWTDecodeException e) {
            return null;
        }
    }

    /**
     * 生成token签名EXPIRE_TIME 分钟后过期
     *
     * @param username 用户名(电话号码)
     * @param secret   用户的密码
     * @return 加密的token
     */
    public static String sign(String username, String secret) {
        long nowTime = System.currentTimeMillis();
        Date date = new Date(nowTime + EXPIRE_TIME);


        Algorithm algorithm = Algorithm.HMAC256(secret);
        // 附带username信息
        return JWT.create()
                .withClaim("username", username)
                .withClaim("currentTimeMillis", String.valueOf(nowTime))
                .withExpiresAt(date)
                .sign(algorithm);
    }

    public static String getClaim(String token, String claim) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim(claim).asString();
        } catch (JWTDecodeException e) {
            return null;
        }
    }
}

二、shiroConfig
shiroConfig基本变动不大，需要注意以下几点：1.需要设置关闭shiro自带的session；2.需要设置我们自己的身份认证过滤器MyFilter类（后面会介绍），关于MyFilter类也是前后端分离使用token认证的核心，不在使用shiro自带的authc过滤器（传统项目session校验使用的就是authc过滤器）了；3.realm不要设置缓存，传统一体式项目我们使用的用户名和密码校验，因为一个用户的用户名和密码不会经常改变，所以我们可以设置缓存，改变密码后需要更新缓存，而前后端分离项目使用的是经常改变的token，所以认证不能设置缓存，而权限可以单独设置@cache缓存，在后面代码UserServiceImpl中有所体现。

@Configuration
public class shiroConfig {
    //创建shirofilter,负责拦截所有请求
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        Map<String, Filter> filters = new HashMap<>();
        filters.put("auth", new MyFilter());
        shiroFilterFactoryBean.setFilters(filters);
        //配置系统受限资源
        //配置系统公共资源
        Map<String,String> map  = new HashMap<>();
        //顺序无关
        map.put("/user/login","anon");
        map.put("/**","auth");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);

        return shiroFilterFactoryBean;
    }

    //创建shiro安全管理器
    @Bean
    public DefaultWebSecurityManager getDefaultWebSecurityManager(Realm realm){
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();

        //关闭shiro自带的session
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        defaultWebSecurityManager.setSubjectDAO(subjectDAO);
        //配置realm
        defaultWebSecurityManager.setRealm(realm);
        return defaultWebSecurityManager;
    }

    //创建自定义realm
    @Bean
    public Realm getRealm(){
        CustomerRealm customerRealm = new CustomerRealm();
        //设置缓存管理器
        customerRealm.setCachingEnabled(false);
        customerRealm.setAuthenticationCachingEnabled(true);
        customerRealm.setAuthenticationCacheName("AuthenticationCache");
        customerRealm.setAuthorizationCachingEnabled(true);
        customerRealm.setAuthorizationCacheName("AuthorizationCache");

        return customerRealm;
    }

}

三、编写自己的token来继承UsernamePasswordToken
由于我们使用shiro认证的时候已经不在是使用username和password，而是通过Jwt用username和password来生成的token进行认证，所以我们需要自己来写UsernamePasswordToken，以便subject.login(token)

public class JwtToken extends UsernamePasswordToken {
    private String token;

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

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

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

四、MyFilter
我们编写自己的Filter需要继承BasicHttpAuthenticationFilter(shiro的身份认证过滤器)，我们需要重写executeLogin和isAccessAllowed，在executeLogin中，通过ServletRequest直接获取token，生成JwtToken,来进行getSubject(request, response).login(jwtToken)操作，实际上就是subject.login(token),最终会调用自定义realm中的doGetAuthenticationInfo方法。
我们在Filter中如果认证失败，可以直接设置返回需要的内容response.getWriter().print(…);

@Component
public class MyFilter extends BasicHttpAuthenticationFilter {


    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader("Token");
        JwtToken jwtToken = new JwtToken(token);
        // 提交给realm进行登入，如果错误他会抛出异常并被捕获
        try {
            getSubject(request, response).login(jwtToken);
            // 如果没有抛出异常则代表登入成功，返回true
            return true;
        } catch (AuthenticationException e) {
            response.setCharacterEncoding("utf-8");
            response.getWriter().print("error");
            return false;
        }

    }



    /**
     * 执行登录认证
     *
     * @param request
     * @param response
     * @param mappedValue
     * @return
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        try {
            return executeLogin(request, response);
            // return true;有一篇博客这里直接返回true是不正确的,在这里我特别指出一下
        } catch (Exception e) {
            System.out.println("JwtFilter过滤认证失败!");
            return false;
        }
    }


    /**
     * 对跨域提供支持
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @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);
    }
}

五、CustomerRealm
自定义Realm，doGetAuthenticationInfo中，核心是我们先通过token获取username，通过username再查询数据库来获取password，最后调用JwtUtil.verify(token, username, user.getPassword()方法，来判断token是否匹配是否过期

public class CustomerRealm extends AuthorizingRealm {

    @Autowired
    @Lazy
    private UserService userService;


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

    //授权

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {

        //shiro中Principal存储的是字符串
 //       String primaryPrincipal = (String) principalCollection.getPrimaryPrincipal();
//       User user = userService.getUserByPrincipal(primaryPrincipal);

        //也可以直接存储user对象，以便在程序中直接获取使用，但是AuthenticationInfo在存储的时候也需要做响应的处理
        String username = JwtUtil.getUsername(principalCollection.toString());
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        List<String> pers = userService.getPers();
        for (String per : pers) {
            authorizationInfo.addStringPermission(per);
        }
        return authorizationInfo;
    }

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        String token = (String) authenticationToken.getPrincipal();
        // 解密获得username，用于和数据库进行对比
        String username = null;
        try {
            //这里工具类没有处理空指针等异常这里处理一下(这里处理科学一些)
            username = JwtUtil.getUsername(token);
        } catch (Exception e) {
            throw new AuthenticationException("heard的token拼写错误或者值为空");
        }
        if (username == null) {
            System.out.println("token无效(空''或者null都不行!)");
            throw new AuthenticationException("token无效");
        }
        User user = userService.getUserByUsername(username);
        if (user == null) {
            System.out.println("用户不存在!)");
            throw new AuthenticationException("用户不存在!");
        }
        if (!JwtUtil.verify(token, username, user.getPassword())) {
            System.out.println("用户名或密码错误(token无效或者与登录者不匹配)!");
            throw new AuthenticationException("用户名或密码错误(token无效或者与登录者不匹配)!");
        }
        return new SimpleAuthenticationInfo(token,token,this.getName());
    }
}

六、UserServiceImpl
由于我们的realm不能设置认证缓存，所以我们可以单独的设置获取权限的缓存

@Service("userService")
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;


    @Override
    public User getUserByUsername(String username) {
        return userMapper.getUserByUsername(username);
    }

   //获取权限，这里我为了简单测试，没有写参数
    @Override
    @Cacheable(value = "cache")
    public List<String> getPers() {
        System.out.println("请求了。。。。。。。。。。。。。");
        return userMapper.getPers();
    }
}

七、UserController
"/login"方法为公开方法，客户端登录后服务器返回token响应，其他方法为测试方法，都会被自定义Filter拦截进行认证。

@Controller
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;
    @RequestMapping("/login")
    @ResponseBody
    public String login(User user, HttpServletResponse response) throws Exception {
        String tokenStr = JwtUtil.sign(user.getUsername(), user.getPassword());
        JwtToken token = new JwtToken(tokenStr);
        Subject subject = SecurityUtils.getSubject();
        try {
            subject.login(token);
            System.out.println("认证成功");
            HttpServletResponse httpServletResponse = (HttpServletResponse) response;
            httpServletResponse.setHeader("token", tokenStr);
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("认证失败");
        }
        return "success";
    }

    @RequestMapping("/test")
    @ResponseBody
    @RequiresPermissions("user:add:*")
    public String test() {
        return "success";
    }
}

后续改进：
一、安全性问题
这里我们使用了token进行登录认证，由于每次客户端请求服务器的时候都需要带上token，所以存在一定的风险被窃取，这样黑客极有可能拿着token来窃取服务器数据或者攻击，所以为了安全，token的过期时间往往设置的比较短，但是这样也带来一个问题，就是用户每过一段时间就需要重新登录认证，显然这样是不够友好的。
解决办法：服务器在生成token的时候也会生成一个refresh-token，并把refresh-token保存在redis中，并把这两个token都发送给客户端，客户端将token和refresh-token保存的浏览器内存里，在请求数据的时候只带上token，服务器检测token有效后还比对 Token 中的时间戳与缓存中的 RefreshToken 时间戳是否一致，一致后才能请求到数据。当发现token过期的时候，客户端会使用refresh-token来向服务器请求刷新token，服务器会生成新的token和refresh-token，刷新redis中的refresh-token，并把两个新的token发送给客户端，这样一来，refresh-token只在第一次和刷新token的时候才会进行传输，就降低了被窃取的风险，黑客即便是拿到了token，但如果没有拿到refresh-token，短时间内的数据丢失和破坏也是在有限范围。同时通过设置refresh-token，还会带来另一个好处，就是我们可以通过控制服务器redis中的refresh-token来间接控制jwt的token认证。、

二、用户登出的问题
当我们使用refresh-token的时候，我们可以通过控制redis中的refresh-token来控制用户是否登出（通过删除refresh-token来实现），如果我们一些简单的项目没有使用refresh-token怎么办呢？
解决办法：我们可以设置token的黑名单，比如登出的时候把token添加到黑名单中，并在我们自定义的Filter中的进行检测请求token是否在黑名单中，如果在黑名单中，就报错，提示登录失败。