shiro与jwt前后端分离项目集成

已于 2022-10-10 20:20:07 修改
阅读量742 收藏 7
点赞数 1
分类专栏： shiro jwt 文章标签： java shiro jwt springboot
于 2022-10-10 20:09:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16525829/article/details/127250363
版权
shiro 同时被 2 个专栏收录
1 篇文章 0 订阅
订阅专栏
jwt
1 篇文章 0 订阅
订阅专栏

前置准备

导入依赖

shiro依赖

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

jwt依赖

        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.13.0</version>
        </dependency>

lombok依赖

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
            <scope>provided</scope>
        </dependency>

redis依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

配置redis

本项目中将token临时存储到redis中，需要在application.yml文件中配置redis中，并添加redisconfig配置类

server:
  port: 8080
spring:
  redis:
    #Redis服务器连接端口
    port: 6379
    #Redis服务器地址
    host: 
    #Redis数据库索引（默认为0）
    database: 0
    #密码
    password: 
    #连接超时时间（毫秒）
    connect-timeout: 1800000
    lettuce:
      pool:
        #连接池最大连接数（使用负值表示没有限制）
        max-active: 20
        #最大阻塞等待时间(负数表示没限制)
        max-wait: -1
        #连接池中的最大空闲连接
        max-idle: 5
        #连接池中的最小空闲连接
        min-idle: 0

package com.zq.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
//key序列化方式
        template.setKeySerializer(redisSerializer);
//value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
//value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
//解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
// 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

认证流程图

请添加图片描述

集成流程

编写token生成及校验工具类

package com.zq.utils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.TokenExpiredException;

import java.util.Date;

public class TokenUtil {
	//密钥改成自己的
    private static final String SIGN="123456";
    public static String createToken(Integer userId,String username,long expireTime){
        long currentTimeMillis = System.currentTimeMillis();
        return JWT.create().
                withSubject("user")
                .withAudience(String.valueOf(userId))//将user id保存到token里面,作为载荷
                .withClaim("account",username)
                .withClaim("createTime",new Date())
                .withIssuedAt(new Date(currentTimeMillis))
                .withExpiresAt(new Date(currentTimeMillis+ expireTime))
                .sign(Algorithm.HMAC256(SIGN));//以SIGN作为token的秘钥
    }

    public static StatusEnum verifyToken(String token){
        try {
            JWT.require(Algorithm.HMAC256(SIGN)).build().verify(token);
            return StatusEnum.SUCCESS;
        }catch (TokenExpiredException e){//token过期
            return StatusEnum.EXPIRED;
        }catch (Exception e){//其他异常,校验失败
            return StatusEnum.FAILED;
        }
    }

    public static Integer getUserIdByToken(String token){
        return Integer.valueOf(JWT.decode(token).getAudience().get(0));
    }

    public static String getAccountByToken(String token){
        return JWT.decode(token).getClaim("account").asString();
    }
}

编写token状态枚举类

package com.zq.utils;

public enum StatusEnum{
    SUCCESS,
    EXPIRED,
    FAILED;
}

编写接口统一返回类

package com.zq.vo;

import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
import lombok.experimental.Accessors;

@Data
@Accessors(chain = true)
public class ResultVo<T>{
    private Integer code;
    private String msg;
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private T data;
    public static <T> ResultVo<T> success(String msg){
        ResultVo<T> resultVo= new ResultVo<>();
        resultVo.setCode(ResultEnum.SUCCESS.getCode())
                .setMsg(msg);
        return resultVo;
    }
    public static <T> ResultVo<T> success(String msg,T data){
        ResultVo<T> resultVo= new ResultVo<>();
        resultVo.setCode(ResultEnum.SUCCESS.getCode())
                .setMsg(msg)
                .setData(data);
        return resultVo;
    }
    public static <T> ResultVo<T> fail(String msg){
        ResultVo<T> resultVo= new ResultVo<>();
        resultVo.setCode(ResultEnum.FAIL.getCode())
                .setMsg(msg);
        return resultVo;
    }

    public static <T> ResultVo<T> error(String msg) {
        ResultVo<T> resultVo = new ResultVo<>();
        resultVo.setCode(ResultEnum.ERROR.getCode())
                .setMsg(msg);
        return resultVo;
    }

    public static <T> ResultVo<T> invalid(String msg) {
        ResultVo<T> resultVo = new ResultVo<>();
        resultVo.setCode(ResultEnum.INVALID.getCode())
                .setMsg(msg);
        return resultVo;
    }
}

enum ResultEnum {
    SUCCESS(200),
    INVALID(300),
    FAIL(400),
    ERROR(500);
    private Integer code;

    ResultEnum(Integer code) {
        this.code=code;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }
}

自定义Realm

package com.zq.realms;

import com.zq.pojo.JwtToken;
import com.zq.service.impl.UserService;
import com.zq.utils.StatusEnum;
import com.zq.utils.TokenUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
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.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

//自定义realm
@Slf4j
@Component
public class CustomerRealm extends AuthorizingRealm {
    @Autowired
    private UserService userService;
    //授权访问
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        log.info("doGetAuthorizationInfo");
        SimpleAuthorizationInfo info=new SimpleAuthorizationInfo();
        //获得当前subject
        Subject subject= SecurityUtils.getSubject();
        //获得当前的principal,也就是认证完后我们放入的信息

        String username=(String) subject.getPrincipal();
        //添加权限
        info.addStringPermissions(userService.getPermissions(username));
        //添加角色
        info.addRole(userService.getRoles(username));

        return info;
    }

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        log.info("doGetAuthenticationInfo");
        String token=(String)authenticationToken.getCredentials();
        if(token==null){
            throw new AuthenticationException("token无效");
        }
        StatusEnum statusEnum = TokenUtil.verifyToken(token);
        if(statusEnum.equals(StatusEnum.EXPIRED)){
            throw new AuthenticationException("token过期");
        }
        if(statusEnum.equals(StatusEnum.FAILED)){
            throw new AuthenticationException("token无效");
        }
        String username= TokenUtil.getAccountByToken(token);
        log.info("登录用户为:{}",username);

        //交给AuthenticatingRealm使用CredentialsMatcher进行密码匹配，不配置的话则使用默认的SimpleCredentialsMatcher
        //用户名,凭证,realm name
        return new SimpleAuthenticationInfo(username,token,this.getName());
    }

    /*
     * 多重写一个support
     * 标识这个Realm是专门用来验证JwtToken，不负责验证其他的token（UsernamePasswordToken）
     * 必须重写此方法，不然Shiro会报错
     */
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JwtToken;
    }

}

自定义UsernamePasswordToken

package com.zq.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import org.apache.shiro.authc.AuthenticationToken;

@Data
@AllArgsConstructor
public class JwtToken implements AuthenticationToken {
    private String token;
    @Override
    public Object getPrincipal() {
        return token;
    }

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

自定义密码(token)匹配器

package com.zq.config;

import com.zq.utils.TokenUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;


@Slf4j
@Component
public class CustomHashedCredentialsMatcher extends HashedCredentialsMatcher {

    @Autowired
    private RedisTemplate redisTemplate;

    //自定义你的Token校验逻辑，比如与存储在Redis中的Token做对比
    @Override
    public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {
        log.info("doCredentialsMatch");
        String tokenStr = (String) token.getCredentials();
        Integer id = TokenUtil.getUserIdByToken(tokenStr);
        String redisToken = (String)redisTemplate.opsForValue().get("user:token:"+id);
        if(!tokenStr.equals(redisToken))
            throw new AuthenticationException("非法token");
        return true;
    }
}

编写Shiro配置类

package com.zq.config;

import com.zq.realms.CustomerRealm;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.mgt.DefaultSubjectDAO;
import org.apache.shiro.realm.Realm;
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.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.servlet.Filter;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 用来整合shiro框架相关的配置类
 */
@Configuration
public class ShiroConfig {
    @Autowired
    private CustomerRealm customerRealm;
    //创建shiroFilter,负责拦截所有请求
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean=new ShiroFilterFactoryBean();

        //给filter设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);

        //自定义过滤器，JwtFilter,使用LinkedHashMap保证Filter的有序性
        Map<String, Filter> filterMap=new LinkedHashMap<>();
        filterMap.put("jwt",new JwtFilter());
        shiroFilterFactoryBean.setFilters(filterMap);


        //配置系统公共资源
        Map<String,String> map=new LinkedHashMap<>();
        map.put("/test/hello","anon");
        map.put("/test/login","anon");

        //配置需要经过jwt过滤器校验的资源
        map.put("/**","jwt");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;
    }

    //创建安全管理器,管理Realm数据源
    @Bean
    public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("myRealm") Realm realm){
        DefaultWebSecurityManager defaultWebSecurityManager=new DefaultWebSecurityManager();

        //给安全管理器设置
        defaultWebSecurityManager.setRealm(realm);
        //关闭ShiroSession，实现Shiro无状态
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        defaultWebSecurityManager.setSubjectDAO(subjectDAO);

        return defaultWebSecurityManager;
    }

    //创建自定义Realm
    @Bean("myRealm")
    public Realm getRealm(CustomHashedCredentialsMatcher customHashedCredentialsMatcher){
        //配置自定义密码匹配器
        customerRealm.setCredentialsMatcher(customHashedCredentialsMatcher);
        return customerRealm;
    }

    //开启Shiro注解支持

    /**
     * 如果userPrefix和proxyTargetClass都为false会导致 aop和shiro权限注解不兼容 资源报错404
     * 因此两个属性至少需要其中一个属性为true才可以
     * 这个Bean的作用是使得@RequiresRoles和@RequiresPermissions注解生效
     * @return
     */
    @Bean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator =
                new DefaultAdvisorAutoProxyCreator();
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        return defaultAdvisorAutoProxyCreator;
    }

    /**
     * 开启aop注解支持
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager); // 这里需要注入 SecurityManger 安全管理器
        return authorizationAttributeSourceAdvisor;
    }
}

编写JWT过滤器

package com.zq.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.zq.pojo.JwtToken;
import com.zq.vo.ResultVo;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.RequestMethod;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

@Slf4j
public class JwtFilter extends BasicHttpAuthenticationFilter {

    /**
     * 过滤器拦截请求的入口方法
     * 是否允许访问，如果带有 token，则对 token 进行检查，否则直接拒绝
     * 如果返回true,就流转到下一个链式调用
     * 如果返回false，就会流转到onAccessDenied方法
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        log.info("isAccessAllowed");
        if (isLoginAttempt(request, response)) {//请求头包含Token
            try { //如果存在，则进入 executeLogin 方法，检查 token 是否正确
                executeLogin(request, response);
                return true;
            }catch (AuthenticationException e){
                handlerLoginException(response,e);
            } catch (Exception e) {
                handlerLoginException(response,new AuthenticationException("error"));
            }
        }else {
            handlerLoginException(response,new AuthenticationException("token无效"));
        }
        //如果请求头不存在 Token，直接返回 false
        return false;
    }

    //拒绝访问的请求
    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        return false;
    }

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

    /**
     * Shiro认证操作
     * executeLogin实际上就是先调用createToken来获取token，这里我们重写了这个方法，就不会自动去调用createToken来获取token
     * 然后调用getSubject方法来获取当前用户再调用login方法来实现登录
     * 这也解释了我们为什么要自定义jwtToken，因为我们不再使用Shiro默认的UsernamePasswordToken了。
     * */
    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception{
        log.info("executeLogin");
        HttpServletRequest req = (HttpServletRequest) request;
        String token = req.getHeader("Authorization");
        JwtToken jwt = new JwtToken(token);
        getSubject(request, response).login(jwt);
        return true;
    }

    /**
     * 在JwtFilter处理逻辑之前，进行跨域处理
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        log.info("preHandle");
        HttpServletRequest req= (HttpServletRequest) request;
        HttpServletResponse res= (HttpServletResponse) response;
        res.setHeader("Access-control-Allow-Origin",req.getHeader("Origin"));
        res.setHeader("Access-control-Allow-Methods","GET,POST,OPTIONS,PUT,DELETE");
        res.setHeader("Access-control-Allow-Headers",req.getHeader("Access-Control-Request-Headers"));
        // 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态
        if (req.getMethod().equals(RequestMethod.OPTIONS.name())) {
            res.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }
    
    /**
     * 在token校验无效之后返回json信息，这里使用jackson配合原生servlet写法，直接抛出的异常会被jwt过滤器捕获并自己处理，使用全局异常处理无效
     * @param response
     * @param e
     */
    private void handlerLoginException(ServletResponse response,AuthenticationException e){
        response.setContentType("application/json;charset=utf-8");
        try(PrintWriter writer = response.getWriter()){
            ResultVo<Object> resultVo=ResultVo.invalid(e.getMessage());
            ObjectMapper objectMapper=new ObjectMapper();
            writer.print(objectMapper.writeValueAsString(resultVo));
        }catch (IOException ignored){
        }
    }
}

全局异常处理

package com.zq.exception;

import com.zq.vo.ResultVo;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.AuthorizationException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;


@Slf4j
@RestControllerAdvice
public class GlobalException {

    @ExceptionHandler(value = {AuthorizationException.class})
    public ResultVo<Object> handleAuthorizationException(Exception e){
        return ResultVo.fail("权限不足");
    }

}

编写service

这里代码没从数据库查，写死的测试数据，自己改动一下就行

package com.zq.service.impl;

import com.zq.po.UserPO;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class UserService {
    public UserPO queryUserByName(String username){
        if ("admin".equals(username))
            return new UserPO(1,username);
        return null;
    }
    public String getRoles(String username){
        return "user";
    }
    public List<String> getPermissions(String username){
        List<String> perms = new ArrayList<>();
        perms.add("user:add");
        perms.add("user:upate");
        return perms;
    }
}

对应的User实体类

package com.zq.po;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;


@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserPO {
    private Integer id;
    private String username;
}

编写Controller测试类

package com.zq.controller;

import com.zq.po.UserPO;
import com.zq.service.impl.UserService;
import com.zq.utils.TokenUtil;

import com.zq.vo.ResultVo;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresAuthentication;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Slf4j
@RestController
@RequestMapping("test")
public class TestController {

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private UserService userService;

    @GetMapping("hello")
    public ResultVo<Object> hello(){
        return ResultVo.success("Hello");
    }

    @GetMapping("world")
    public ResultVo<Object> world(){
        return ResultVo.success("world");
    }

    @PostMapping("login")
    public ResultVo<Object> login(String username,String password){
        //TODO
        UserPO userPO = userService.queryUserByName(username);
        if(userPO==null)
            return ResultVo.fail("用户不存在");
        String token = TokenUtil.createToken(userPO.getId(), username, 2L * 60 * 60 * 1000);
        redisTemplate.opsForValue().set("user:token:"+userPO.getId(),token,2*60, TimeUnit.MINUTES);
        Map<String,String> map=new HashMap<>();
        map.put("token",token);
        return ResultVo.success("登录成功",map);
    }
    @GetMapping("user")
    @RequiresRoles("user")
    public ResultVo<Object> user(){
        return ResultVo.success("访问uer成功");
    }

    @GetMapping("add")
    @RequiresPermissions("user:add")
    public ResultVo<Object> add(){
        return ResultVo.success("访问add成功");
    }

    @GetMapping("delete")
    @RequiresPermissions("user:delete")
    public ResultVo<Object> delete(){
        return ResultVo.success("访问delete成功");
    }

    @GetMapping("insert")
    @RequiresRoles("admin")
    public ResultVo<Object> insert(){
        System.out.println(SecurityUtils.getSubject().hasRole("admin"));
        return ResultVo.success("访问insert成功");
    }

    @GetMapping("in")
    @RequiresAuthentication
    public ResultVo<Object> in(){
        return ResultVo.success("访问in成功");
    }
}

测试

调用公共接口

公共接口是不经过JWT过滤器校验的接口

hello接口

在这里插入图片描述
控制台无输出

login接口

在这里插入图片描述
在这里插入图片描述

访问受限接口

使用有效token

在这里插入图片描述

在这里插入图片描述

使用无效token

在这里插入图片描述

不携带token

在这里插入图片描述

携带token访问需要角色的接口

角色不满足

这里是写死的只有user角色
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

角色满足

在这里插入图片描述
在这里插入图片描述

使用token访问权限接口

权限不满足

在这里插入图片描述
在这里插入图片描述

权限满足

在这里插入图片描述
在这里插入图片描述

控制台打印情况

这里给出部分在调试阶段控制台的打印情况

[19:36:05.741] INFO  com.zq.config.JwtFilter 90 preHandle - preHandle
[19:36:05.741] INFO  com.zq.config.JwtFilter 30 isAccessAllowed - isAccessAllowed
[19:36:05.742] INFO  com.zq.config.JwtFilter 59 isLoginAttempt - isLoginAttempt
[19:36:05.742] INFO  com.zq.config.JwtFilter 73 executeLogin - executeLogin
[19:36:05.742] INFO  com.zq.realms.CustomerRealm 48 doGetAuthenticationInfo - doGetAuthenticationInfo
[19:36:05.761] INFO  com.zq.realms.CustomerRealm 61 doGetAuthenticationInfo - 登录用户为:admin
[19:36:05.762] INFO  com.zq.config.CustomHashedCredentialsMatcher 24 doCredentialsMatch - doCredentialsMatch

[19:36:24.170] INFO  com.zq.config.JwtFilter 90 preHandle - preHandle
[19:36:24.170] INFO  com.zq.config.JwtFilter 30 isAccessAllowed - isAccessAllowed
[19:36:24.171] INFO  com.zq.config.JwtFilter 59 isLoginAttempt - isLoginAttempt
[19:36:24.171] INFO  com.zq.config.JwtFilter 73 executeLogin - executeLogin
[19:36:24.171] INFO  com.zq.realms.CustomerRealm 48 doGetAuthenticationInfo - doGetAuthenticationInfo
[19:36:24.173] INFO  com.zq.realms.CustomerRealm 61 doGetAuthenticationInfo - 登录用户为:admin
[19:36:24.173] INFO  com.zq.config.CustomHashedCredentialsMatcher 24 doCredentialsMatch - doCredentialsMatch

[19:37:40.395] INFO  com.zq.config.JwtFilter 90 preHandle - preHandle
[19:37:40.396] INFO  com.zq.config.JwtFilter 30 isAccessAllowed - isAccessAllowed
[19:37:40.396] INFO  com.zq.config.JwtFilter 59 isLoginAttempt - isLoginAttempt
[19:37:40.396] INFO  com.zq.config.JwtFilter 73 executeLogin - executeLogin
[19:37:40.396] INFO  com.zq.realms.CustomerRealm 48 doGetAuthenticationInfo - doGetAuthenticationInfo

[19:38:14.030] INFO  com.zq.config.JwtFilter 90 preHandle - preHandle
[19:38:14.031] INFO  com.zq.config.JwtFilter 30 isAccessAllowed - isAccessAllowed
[19:38:14.031] INFO  com.zq.config.JwtFilter 59 isLoginAttempt - isLoginAttempt

[19:40:35.457] INFO  com.zq.config.JwtFilter 90 preHandle - preHandle
[19:40:35.458] INFO  com.zq.config.JwtFilter 30 isAccessAllowed - isAccessAllowed
[19:40:35.458] INFO  com.zq.config.JwtFilter 59 isLoginAttempt - isLoginAttempt

[19:40:47.404] INFO  com.zq.config.JwtFilter 90 preHandle - preHandle
[19:40:47.404] INFO  com.zq.config.JwtFilter 30 isAccessAllowed - isAccessAllowed
[19:40:47.404] INFO  com.zq.config.JwtFilter 59 isLoginAttempt - isLoginAttempt

[19:40:51.141] INFO  com.zq.config.JwtFilter 90 preHandle - preHandle
[19:40:51.141] INFO  com.zq.config.JwtFilter 30 isAccessAllowed - isAccessAllowed
[19:40:51.141] INFO  com.zq.config.JwtFilter 59 isLoginAttempt - isLoginAttempt
[19:40:51.141] INFO  com.zq.config.JwtFilter 73 executeLogin - executeLogin
[19:40:51.142] INFO  com.zq.realms.CustomerRealm 48 doGetAuthenticationInfo - doGetAuthenticationInfo
[19:40:51.143] INFO  com.zq.realms.CustomerRealm 61 doGetAuthenticationInfo - 登录用户为:admin
[19:40:51.143] INFO  com.zq.config.CustomHashedCredentialsMatcher 24 doCredentialsMatch - doCredentialsMatch
[19:40:51.273] INFO  com.zq.realms.CustomerRealm 30 doGetAuthorizationInfo - doGetAuthorizationInfo

[19:44:13.431] INFO  com.zq.config.JwtFilter 90 preHandle - preHandle
[19:44:13.431] INFO  com.zq.config.JwtFilter 30 isAccessAllowed - isAccessAllowed
[19:44:13.432] INFO  com.zq.config.JwtFilter 59 isLoginAttempt - isLoginAttempt
[19:44:13.432] INFO  com.zq.config.JwtFilter 73 executeLogin - executeLogin
[19:44:13.432] INFO  com.zq.realms.CustomerRealm 48 doGetAuthenticationInfo - doGetAuthenticationInfo
[19:44:13.433] INFO  com.zq.realms.CustomerRealm 61 doGetAuthenticationInfo - 登录用户为:admin
[19:44:13.433] INFO  com.zq.config.CustomHashedCredentialsMatcher 24 doCredentialsMatch - doCredentialsMatch
[19:44:13.474] INFO  com.zq.realms.CustomerRealm 30 doGetAuthorizationInfo - doGetAuthorizationInfo

[19:45:12.566] INFO  com.zq.config.JwtFilter 90 preHandle - preHandle
[19:45:12.566] INFO  com.zq.config.JwtFilter 30 isAccessAllowed - isAccessAllowed
[19:45:12.566] INFO  com.zq.config.JwtFilter 59 isLoginAttempt - isLoginAttempt
[19:45:12.566] INFO  com.zq.config.JwtFilter 73 executeLogin - executeLogin
[19:45:12.566] INFO  com.zq.realms.CustomerRealm 48 doGetAuthenticationInfo - doGetAuthenticationInfo
[19:45:12.567] INFO  com.zq.realms.CustomerRealm 61 doGetAuthenticationInfo - 登录用户为:admin
[19:45:12.568] INFO  com.zq.config.CustomHashedCredentialsMatcher 24 doCredentialsMatch - doCredentialsMatch
[19:45:12.616] INFO  com.zq.realms.CustomerRealm 30 doGetAuthorizationInfo - doGetAuthorizationInfo

[19:45:59.999] INFO  com.zq.config.JwtFilter 90 preHandle - preHandle
[19:45:59.999] INFO  com.zq.config.JwtFilter 30 isAccessAllowed - isAccessAllowed
[19:45:59.999] INFO  com.zq.config.JwtFilter 59 isLoginAttempt - isLoginAttempt
[19:45:59.999] INFO  com.zq.config.JwtFilter 73 executeLogin - executeLogin
[19:45:59.999] INFO  com.zq.realms.CustomerRealm 48 doGetAuthenticationInfo - doGetAuthenticationInfo
[19:46:00.000] INFO  com.zq.realms.CustomerRealm 61 doGetAuthenticationInfo - 登录用户为:admin
[19:46:00.001] INFO  com.zq.config.CustomHashedCredentialsMatcher 24 doCredentialsMatch - doCredentialsMatch
[19:46:00.047] INFO  com.zq.realms.CustomerRealm 30 doGetAuthorizationInfo - doGetAuthorizationInfo

源码

https://gitee.com/codewarning/shiro_demo

菜的深沉
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot+Shiro+Jwt实现简单的权限控制
Java技术攻略的博客
04-24 1609
因为需要实现一个设备管理系统的权限管理模块，在查阅很多博客以及其他网上资料之后，发现重复、无用的博客很多，因此写一篇文章来记录，以便后面复习。书写顺序。
Spring boot整合shiro+jwt实现前后端分离
08-25
Spring Boot 整合 Shiro+JWT 实现前后端分离 Spring Boot 框架是一个流行的 Java 框架，用于构建 Web 应用程序。Shiro 是一个强大的安全框架，提供了身份验证、授权、会话管理、加密等功能。JWT（JSON Web Token）...
Shiro框架和JWT
市民景先生
07-11 2525
目录shiro简介1.认证2.授权3.shiro靠什么做认证与授权JWT简介创建JWTUtil工具类令牌封装成对象AuthenticationToken类AuthorizingRealm类刷新令牌的新机制 创建存储令牌的媒介类创建过滤器创建ShiroConfigshiro是java非常有名的认证与授权的框架，使用JavaEE中JAAS功能。设计简单，SpringSecurity必须使用spring项目中。核验用户身份，认证登录，登录后Shiro要记录用户成功登录的凭证比再认证更加精细度的划分用户的行为。比如
Shiro+Jwt总结
m0_51433562的博客
03-19 8805
Shiro和JWT整合实现用户的认证和授权
基于JWT 和 Shiro 做接口权限认证
最新发布
Karka_的博客
06-20 595
自定义的权限认证和身份认证逻辑。方法是权限认证。方法是身份认证时就是交给这个自定义类处理。@Service@Autowired// /**// * 大坑！，必须重写此方法，不然Shiro会报错// */// }// /**// * 只有当需要检测用户权限的时候才会调用此方法，例如checkRole,checkPermission之类的// */@Override/*** 默认使用此方法进行用户名正确与否验证，错误抛出异常即可。
【shiro】shiro整合JWT——1.需要创建的类
kevin的博客
06-02 929
shiro整合JWT系列，主要记录核心思路–如何在shiro+redis整合JWTToken。JwtToken （JWT实体类）JwtUtil （JWT工具类）JwtFilter （JWT拦截器）
Shiro整合JWT
m0_67391270的博客
03-28 1399
文章目录 基于token的身份验证 个人理解 jwt工具类 shiro部分修改 登录的修改: realm的修改: 自定义filter: 配置: 测试 总结 基于token的身份验证 JSON Web Token（JWT）是一个非常轻巧的规范。这个规范允许我们使用JWT在用户和服务器之间传递安全可靠的信息。 <!--JWT--> <dependency> <groupId>com.auth0</grou
springboot集成jwt和shiro实现前后端分离权限demo2
04-10
这个"springboot集成jwt和shiro实现前后端分离权限demo2"项目，旨在提供一个实际的案例，帮助开发者理解如何在Spring Boot应用中实现前后端分离的权限管理。通过学习和实践这个示例，你可以掌握JWT和Shiro的使用技巧...
springboot集成jwt和shiro实现前后端分离权限demo
04-04
本示例项目“springboot集成jwt和shiro实现前后端分离权限demo”旨在帮助初学者理解如何在Spring Boot环境下结合JWT（JSON Web Token）和Shiro进行权限管理，以实现安全的Web应用。下面将详细介绍相关的知识点。 **...
SpringBoot + Shiro实现前后端全分离接口安全框架
09-02
SpringBoot与Shiro的结合为开发者提供了一个高效、便捷的实现前后端全分离接口安全的框架。本文将深入探讨如何利用这两个强大的工具构建安全的Web服务。 首先，SpringBoot是Spring框架的一个轻量级版本，它简化了...
shiro-jwt-springboot：shiro合并jwt前进行分离权限认证示例
01-29
在本文中，我们将深入探讨如何将JWT（JSON Web Token）与Apache Shiro框架结合使用，以便在Spring Boot应用中实现安全的权限认证。这个项目"shiro-jwt-springboot"是一个实例，它展示了在整合JWT之前如何对权限认证...
【Java专题_01】springboot+Shiro+Jwt整合方案
热门推荐
weixin_40736233的博客
04-02 1万+
【Java专题_01】springboot+Shiro+Jwt整合方案
springboot集成shiro+jwt详解+完整实例
Timmer的博客
05-26 6282
目录 简介 目的 需要的jar 集成过程 1.配置shiro 2.创建自定义Realm 2.1 LoginRealm用于处理用户登录 2.2 JwtRealm用于在登录之后，用户的token是否正确以及给当前用户授权等 2.3OurModularRealmAuthenticator用于匹配的相应的Realm 2.4 DataAutoToken及实现类 2.5JwtFilter处理在shiro配置的自定义的Filter 2.6 controller层登录和其他接口 2.7 se...
Shiro整合JWT在SpringBoot中实现认证和权限鉴定
Katharsis_2021的博客
10-15 437
公司新项目需要一个基于SpringBoot的脚手架，需求是整合JWT和Shiro进行认证和权限鉴定。在搭建的过程中遇到了很多问题，为了不让经验流失在脑海中，就有了这篇文章的诞生。
Shiro+JWT超详解
qq_39159736的博客
05-07 1万+
首先我们来分别看看shiro和jwt的作用： shiro： jwt：JSON Web Token，是一种特殊的token，因此我们在来看看Token是干嘛的？ 一、Token token 是一串字符串，通常因为作为鉴权凭据，最常用的使用场景是 API 鉴权，用户凭证。 1. API 鉴权 那么 API 用户凭证一般有几种方式呢？我大概整理了如下： cookie + session：和平常 web 登陆一样的鉴权方式，很常见，不再赘...
springboot shiro jwt实现认证和授权
myli92的博客
03-16 2353
1.shiro，jwt，oauth2.0是什么？ Shiro：权限框架，可在C/S下运行。 shiro是一套权限管理框架，包括认证、授权等，在使用时直接写相应的接口（小而简单的Shiro就足够） jwt：是一个鉴权生成加密token的一个名称。 oauth2.0 :一种权限实现标准，是一种安全的授权框架，提供了一套详细的授权机制。用户或应用可以通过公开的或私有的设置，使用第三方认证和授权。 Shiro 有三大核心组件，即 Subject、SecurityManager 和 Realm。 2.依赖引
Shiro+JWT+Spring Boot Restful简易教程
weixin_33834137的博客
10-26 939
序言 我也是半路出家的人，如果大家有什么好的意见或批评，请务必issue下。 项目地址：github.com/Smith-Cruis… 。 如果想要直接体验，直接clone项目，运行mvn spring-boot:run命令即可进行访问。网址规则自行看教程后面。 如果想了解Spring Security可以看 Spring Boot 2.0+Srping Security+Thymeleaf的简易...
教你 Shiro + SpringBoot 整合 JWT
weixin_33849215的博客
04-30 1089
本篇文章将教大家在 shiro + springBoot 的基础上整合 JWT （JSON Web Token） 如果对 shiro 如何整合 springBoot 还不了解的可以先去看我的上一篇文章 《教你 Shiro 整合 SpringBoot，避开各种坑》 附上源码：github.com/HowieYuan/s… JWT JSON Web Token（JWT）是一个非常轻巧的规范。这个规...
shiro前后端分离
09-05
是的，"shiro前后端分离"是一种常见的应用架构模式。Shiro是一个用于身份验证、授权和会话管理的Java开源框架。在前后端分离的架构中，前端和后端分别独立开发，通过API进行通信。在这种模式下，Shiro通常被用于后端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值