SpringBoot+jwt+shiro实现登录验证及接口权限校验

已于 2022-11-17 15:22:44 修改
阅读量7.7k 收藏 8
点赞数 1
分类专栏： java学习 文章标签： spring boot java 后端 maven
于 2022-11-10 11:12:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhang_199911/article/details/127783869
版权

SpringBoot+jwt+shiro+token实现对接口权限校验

最近在一个项目上实现登录模块，就想到了权限验证功能，了解了Spring Security和Shiro之后，决定使用Shiro来实现简单的鉴权功能，Spring Security相比Shiro功能更加强大，相应的，学习成本也更高。

1.Shiro介绍

Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。
三个核心组件：Subject, SecurityManager 和 Realms

三大核心组件关系：
在这里插入图片描述

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

SecurityManager：安全管理器，即所有与安全有关的操作都会与SecurityManager进行交互，是Shiro框架的核心，管理所有的Subject，类似于Spring MVC的前端控制器DispatcherServlet；

Realm域：Shiro从Realm中获取安全数据（比如用户、角色、权限），SecurityManager要验证用户身份，需要从Realm中获取相应的用户进行比较确定用户是否合法；验证用户角色/权限也需要从Realm获得相应数据进行比较，类似于DataSource，安全数据源；它封装了数据源的连接细节，并在需要时将相关数据提供给Shiro.

Realm域的认证和授权

认证（authentication）
在程序中认证要做的事情主要是搞明白访问者是谁，他有没有在我们系统中注册过？他是不是我们系统中的用户？如果是，那么这个用户有没有被我们加入黑名单！这是认证要做的事情。举个例子：进一个旅游景区首先要买票吧，要是你手里没有票在检票口会被检票大叔/大妈直接拦住，不让你进去，如果你手里有票，大叔还会看一眼你票是不是今天买的，有没有过期啊……如果你有票并且一切正常，那么你进可以进去了。这就是一个认证的过程！

授权（authorization）
授权的作用主要是验证你有没有访问某项资源的权利！我们都知道在MySQL数据库中，root用户可以随便增删改查各个库的数据，但是普通用户可能就只有查看到权利，而没有删除和修改的权利。在程序中也一样，有一个很常见的需求：用户A可以访问和并修改一个页面，对于用户B可能就只有访问这个页面的权利，而不能修改！

需要注意的是：Shiro本身不提供维护用户、权限，而是通过Realm让开发人员自己注入到SecurityManager，从而让SecurityManager能得到合法的用户以及权限进行判断；

2.JWT介绍

JWT(JSON Web Token)，由请求头、请求体和签名3部分组成，它主要用来生成token，进行认证。

3.实现认证和授权的整体思路

客户端访问服务端，服务端对请求进行认证，主要包括用户名和密码是否正确，如果认证成功会给客户端颁发一个凭证token，后面客户端再访问服务端的时候都要携带这个token，如果不携带或者token被篡改，都会认证失败！如果token认证成功，客户端访问资源，那么此时服务端还会去认证该用户是否有访问此资源的权利！如果此用户没有访问这个资源的权利，同样会访问失败！

4.前置准备

4.1 数据库设计

权限的认证和校验采用RBAC模型，总共有5张表，分别为user、user_role、role、role_permission和permission，
其中user_role和role_permission为中间表，user表和role表示一对多的关系，
role表和permission表也是一对多的关系。

4.2Maven依赖

        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.5.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version> 1.5.3</version>
        </dependency>
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.18.1</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

5.代码实现

5.1工具类

JWT基础工具，用于提供token生成和解密底层功能

import io.jsonwebtoken.*;

import java.util.Date;

public class JwtUtils {
    /**
     * 实例（单例）
     */
    private volatile static JwtUtils instance;

    /**
     * 发行者
     */
    private String subObject = "发行者名称";

    /**
     * 过期时间，默认7天
     */
    private long expired = 1000 * 60 * 60 * 24 * 7;

    /**
     * jwt构造
     */
    private static JwtBuilder jwtBuilder;

    /**
     * 密钥
     */
    private String secret = "你的密钥";// 密钥

    private JwtUtils(){}

    /**
     * 获取实例
     * @return
     */
    public static JwtUtils getInstance(){
        if (instance == null){
            synchronized (JwtUtils.class){
                if (instance == null){
                    instance = new JwtUtils();
                }
            }
        }
        jwtBuilder = Jwts.builder();
        return instance;
    }

    /**
     * 荷载信息(通常是一个User信息，还包括一些其他的元数据)
     * @param key
     * @param val
     * @return
     */
    public JwtUtils setClaim(String key,Object val){
        jwtBuilder.claim(key,val);
        return this;
    }

    /**
     * 生成 jwt token
     * @return
     */
    public String generateToken(){
        String token = jwtBuilder
                .setSubject(subObject) // 发行者
                //.claim("id","121") // 参数
//                .setIssuedAt(new Date()) // 发行时间
                .setExpiration(new Date(System.currentTimeMillis() + expired))
                .signWith(SignatureAlgorithm.HS256,secret) // 签名类型 与 密钥
                .compressWith(CompressionCodecs.DEFLATE)// 对载荷进行压缩
                .compact(); // 压缩一下
        return token;
    }

    /**
     * 解析 token
     * @param token
     * @return
     */
    public Claims check(String token){
        try{
            final Claims claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
            return claims;
        }catch (Exception e){}
        return null;
    }

    public String getSubObject() {
        return subObject;
    }

    /**
     * 设置发行者
     * @param subObject
     * @return
     */
    public JwtUtils setSubObject(String subObject) {
        this.subObject = subObject;
        return this;
    }

    public long getExpired() {
        return expired;
    }

    /**
     * 设置过期时间
     * @param expired
     * @return
     */
    public JwtUtils setExpired(long expired) {
        this.expired = expired;
        return this;
    }

    public String getSecret() {
        return secret;
    }

    /**
     * 设置密钥
     * @param secret
     * @return
     */
    public JwtUtils setSecret(String secret) {
        this.secret = secret;
        return this;
    }
}

Token业务工具类，用于根据自己业务需要来生成相应token，包括写入redis等，此处我们业务上是用户手机号唯一（根据业务可以替换为用户id等）

@Component
public class TokenUtil {

   @Resource
   RedisTemplate<String,Object> redisTemplate;

    public static final String TOKEN = "login_user.token:";
    private static final String PHONE = "login_user.phone:";

    /**
     * jwt生成token
     * */
    public  String makeToken(String telephone){
        JwtUtils jwt = JwtUtils.getInstance();
        return jwt.setClaim(PHONE, telephone).generateToken();
    }

    /**
     * 生成token，存入redis中，设置七天失效时间
     * */
    public  String makeTokenInRedis(UserInfoDTO userInfoDTO){
        final String telephone = userInfoDTO.getTelephone();
        String token = makeToken(telephone);
        Map<String,Object> map = new HashMap<>();
        map.put("信息","用户信息");
        ...用户其他信息省略，根据业务需要自行添加
        String s = JSON.toJSONString(map);
//        RedisTemplate<Object,Object> redisTemplate = new RedisTemplate<>();
        
//redis具体存储逻辑可以自行调整  
redisTemplate.opsForValue().set(TOKEN+telephone,s,7,TimeUnit.DAYS);
        return token;
    }

    /**
     * 解析token
     * */
    public  JSONObject tokenAnalysis(String token){
        JwtUtils jwt = JwtUtils.getInstance();
        Claims check = jwt.check(token);
        if (check==null){
            return null;
        }
        String msg = (String)redisTemplate.boundValueOps(TOKEN+check.get(PHONE)).get();
        if (msg==null){
            return null;
        }
        return JSONObject.parseObject(msg);

    }

}

shiro token信息封装

@AllArgsConstructor
public class JwtToken implements AuthenticationToken {

    private String token;

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

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

5.2 业务层

实体（已简化，可以根据需要将Role和Permission展开）

import lombok.Data;

import java.util.List;

/**
 * 简化版，如果后续需要，将role和permission分别建立实体。
 */
@Data
public class UserRole {

    //用户id
    Long userId;

    //角色名称集合
    List<String> roles;

    //权限名称集合
    List<String> permissions;
}

Service层(接口已省略，只贴实现类)

@Service
public class UserRoleImpl implements UserRoleService {
    @Resource
    UserRoleMapper userRoleMapper;

    @Override
    public UserRole getUserRole(UserInfoDTO userInfoDTO) {
        final Long userInfoDTOId = userInfoDTO.getId();
        final List<String> userRolesById = userRoleMapper.findUserRolesById(userInfoDTOId);
        final List<String> userPermissionsById = userRoleMapper.findUserPermissionsById(userInfoDTOId);
        UserRole userRole = new UserRole();
        userRole.setUserId(userInfoDTOId);
        userRole.setRoles(userRolesById);
        userRole.setPermissions(userPermissionsById);
        return userRole;
    }
}

DAO层(此处我的两个方法分别是根据用户id查询该用户的所有角色，以及根据用户id查询该用户的所有权限)

@Mapper
public interface UserRoleMapper {
    //id与userid相同
    List<String> findUserRolesById(@Param("id")Long id);

    List<String>  findUserPermissionsById(@Param("id")Long id);
}

5.3 shiro相关

shiro配置

@Configuration
@Slf4j
public class ShiroConfig {
    /**
     * 注册shiro的Filter，拦截请求
     */

    @Bean("securityManager")
    public SecurityManager securityManager(UserRealm userRealm) {
        /*
         * 关闭shiro自带的session，详情见文档
         * http://shiro.apache.org/session-management.html#SessionManagement-StatelessApplications%28Sessionless%29
         */
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        //设置manager
        DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
        manager.setRealm(userRealm);
        return manager;
    }

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

    /**
     * @return org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor
     * @Description 开启shiro aop注解支持.使用代理方式;所以需要开启代码支持;
     * @Param [securityManager]
     **/
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }


    @Bean("shiroFilter")
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean filter = new ShiroFilterFactoryBean();
        filter.setSecurityManager(securityManager);

        //加入自定义的filter
        // setLoginUrl 如果不设置值，默认会自动寻找Web工程根目录下的"/login.jsp"页面 或 "/login" 映射
        //前后端分离项目中该链接应该为后端接口的访问url，通过该接口返回需要登录的状态码，由前端跳转至登录页面
        //shiroFilter.setLoginUrl("/user/login");
        // 设置无权限时跳转的 url;
        //shiroFilter.setUnauthorizedUrl("/user/test");
        // 添加自己的过滤器并且取名为jwt
        Map<String, Filter> filterMap = filter.getFilters();

        filterMap.put("jwt", new jwtFilter());
        filter.setFilters(filterMap);

        //定义相关路径
        filter.setLoginUrl("/login");
        filter.setUnauthorizedUrl("/noAuthorize");

        // 设置拦截器
        //定义拦截路径,记得将静态资源也排除过滤
        /*进行权限的控制,必须使用LinkHashMap,shrio要按照顺序进行设置*/
        Map<String, String> authMap = new LinkedHashMap<>();

        //anon:无参，开放权限，可以理解为匿名用户或游客
        authMap.put("/user/login", "anon");
        authMap.put("/user/register", "anon");

        //其余接口一律拦截
        //主要这行代码必须放在所有权限设置的最后，不然会导致所有 url 都被拦截
        //authc:无参，需要认证
        authMap.put("/**", "jwt");

        filter.setFilterChainDefinitionMap(authMap);

        //配置完成
        log.info("shiro factory 创建成功");
        return filter;
    }

    @Bean("jwtFilter")
    public JwtFilter jwtFilter() {
        return new JwtFilter();
    }

    /**
     * SpringShiroFilter首先注册到spring容器
     * 然后被包装成FilterRegistrationBean
     * 最后通过FilterRegistrationBean注册到servlet容器
     * @return
     */
    @Bean
    @SuppressWarnings("all")
    public FilterRegistrationBean delegatingFilterProxy(){
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        DelegatingFilterProxy proxy = new DelegatingFilterProxy();
        proxy.setTargetFilterLifecycle(true);
        proxy.setTargetBeanName("shiroFilter");
        filterRegistrationBean.setFilter(proxy);
        return filterRegistrationBean;
    }
    @Bean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        // 强制使用cglib，防止重复代理和可能引起代理出错的问题
        // https://zhuanlan.zhihu.com/p/29161098
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        return defaultAdvisorAutoProxyCreator;
    }
}

Realm


/**
 * Shiro从从Realm获取安全数据（如用户、角色、权限）
 * ，就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应
 * 的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；
 * 可以把Realm看成DataSource，即安全数据源。Realm主要有两个方法：
 * doGetAuthorizationInfo(获取授权信息)
 * doGetAuthenticationInfo(获取身份验证相关信息)：
 * @Version 1.0
 **/
@Configuration
@Slf4j
public class UserRealm extends AuthorizingRealm {

    @Resource
    UserRoleService userRoleService;

    @Resource
    TokenUtil tokenUtil;

	//根据token解析body得到的用户部分信息来富化该用户全部信息，如果之前token是根据用户全量信息生成的，可以省略
    @Resource
    UserMapper userMapper;

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

    /**
     * 授权(验证权限时调用)
     * 这个方法就会从数据库中读取我们所需要的信息，最后封装成SimpleAuthorizationInfo返回去
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        UserInfo userInfo = UserCache.getCurrentUser();
        UserInfoDTO userInfoDTO = new UserInfoDTO();
        BeanUtils.copyProperties(userInfo,userInfoDTO);

        //添加角色及权限
        UserRole userRole = this.userRoleService.getUserRole(userInfoDTO);
        userRole.getRoles().forEach(authorizationInfo::addRole);
        userRole.getPermissions().forEach(authorizationInfo::addStringPermission);

        return authorizationInfo;
    }

    /**
     * 认证(登录时调用)
     */
    @SneakyThrows
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken)  {
        final String token = (String) authenticationToken.getCredentials();

        log.info("正在对token进行登录验证...");
        JSONObject object = tokenUtil.tokenAnalysis(token);
        if (Objects.isNull(object)){
            log.error("token为{}的用户token错误",token);
            throw new Exception("token错误...");
        }
        String telephone = object.getString("telephone");
        UserInfo userInfo = this.userMapper.getUserInfoByTelephone(telephone);

        if (Objects.isNull(userInfo)){
            log.error("token为{}的用户信息不存在",token);
            throw new UnknownAccountException("用户信息不存在...");
        }

         //缓存添加当前用户信息(这个就是个ThreadLocal存储登录用户信息)
         UserCache.addCurrentUser(userInfo);

        return new SimpleAuthenticationInfo(token,token,"UserRealm");
    }
}

JwtFilter

@Slf4j
public class JwtFilter extends BasicHttpAuthenticationFilter {

    @Override
    protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
        HttpServletRequest req = (HttpServletRequest) request;
        String authorization = req.getHeader("Authorization");
        return authorization != null;
    }

    /**
     * 这里我们详细说明下为什么最终返回的都是true，即允许访问
     * 例如我们提供一个地址 GET /article
     * 登入用户和游客看到的内容是不同的
     * 如果在这里返回了false，请求会被直接拦截，用户看不到任何东西
     * 所以我们在这里返回true，Controller中可以通过 subject.isAuthenticated() 来判断用户是否登入
     * 如果有些资源只有登入用户才能访问，我们只需要在方法上面加上 @RequiresAuthentication 注解即可
     * 但是这样做有一个缺点，就是不能够对GET,POST等请求进行分别过滤鉴权(因为我们重写了官方的方法)，但实际上对应用影响不大
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        log.info("JwtFilter-->>>执行登录认证:init()");
        //如果请求头不存在token,则可能是执行登陆操作或是游客状态访问,直接返回true
        if (!isLoginAttempt(request, response)) {
            return true;
        }
        //如果存在,则进入executeLogin方法执行登入,检查token 是否正确
        try {
            executeLogin(request, response);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            throw new AuthenticationException("Token失效请重新登录!");
        }
    }

    /**
     * 重写AuthenticatingFilter的executeLogin方法丶执行登陆操作
     */
    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        log.info("JwtFilter-->>>executeLogin-Method:init()");
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader("Authorization");//Access-Token
        JwtToken jwtToken = new JwtToken(token);
        //UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(UserCache.getCurrentUser().getTelephone(),UserCache.getCurrentUser().getPassword());
        // 提交给realm进行登入,如果错误他会抛出异常并被捕获, 反之则代表登入成功,返回true
        getSubject(request, response).login(jwtToken);
        return true;
    }


    /**
     * 对跨域提供支持
     */
    @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);
    }

}

OK，大功告成
直接测一下

6.使用测试

@ControllerMapping("test")
public class TestController {

    @PostMapping("test2")
    @RequiresRoles(value = {"admin","user"},logical = Logical.OR)
    public String test2(@RequestBody JSONObject object){
        int a = 1+1;
        return "SUCCESS";
    }
}

上面注解中的角色名称是数据库自定义的

注解使用说明： RequiresRoles–>RequiresPermissions–>RequiresAuthentication–>RequiresUser–>RequiresGuest
Note:如果有个多个注解的话，前面的通过了会继续检查后面的，若不通过则直接返回

在这里插入图片描述

面向秃头编程
关注
专栏目录
Springboot整合shiro:实现用户登录和权限验证
猪大肠的博客
08-25 6731
Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。当然类型大家也可以使用spring security；因为我平时开发的项目都是中小型的，所以使用shiro对于业务来说已经够用了，那么下面是我整理的整合记录； 一、什么是Shiro 这里大家需要先认识一下它的三个重要的组件； 1.1、Subject 即当前的操作用户，就是当前登录的用户； 1.2、SecurityManager 该组件是用来管理所有的操作用户的安全操作 1.3、Realm 该组件需要我们自定义，主
SpringBoot：切面AOP实现权限校验：实例演示与注解全解
程序员麦冬的博客（公众号同名）
11-03 1609
1 理解AOP 1.1 什么是AOP AOP（Aspect Oriented Programming），面向切面思想，是Spring的三大核心思想之一（两外两个：IOC-控制反转、DI-依赖注入）。 那么AOP为何那么重要呢？在我们的程序中，经常存在一些系统性的需求，比如权限校验、日志记录、统计等，这些代码会散落穿插在各个业务逻辑中，非常冗余且不利于维护。例如下面这个示意图： 有多少业务操作，就要写多少重复的校验和日志记录代码，这显然是无法接受的。当然，用面向对象的思想，我们可以把这些重复的代码抽离出来，
基于JWT 和 Shiro 做接口权限认证
最新发布
ewii12567的博客
07-24 1172
自定义的权限认证和身份认证逻辑。方法是权限认证。方法是身份认证时就是交给这个自定义类处理。@Service@Autowired// /**// * 大坑！，必须重写此方法，不然Shiro会报错// */// }// /**// * 只有当需要检测用户权限的时候才会调用此方法，例如checkRole,checkPermission之类的// */@Override/*** 默认使用此方法进行用户名正确与否验证，错误抛出异常即可。
springboot集成shiro+jwt详解+完整实例
Timmer的博客
05-26 7483
目录 简介 目的 需要的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...
Springboot整合Shiro+JWT
weixin_43424751的博客
04-18 531
在前后端分离的项目中我们通常会采用jwttoken的方式来作为跨域身份验证解决方案。 引入依赖 <dependency> <groupId>org.crazycake</groupId> <artifactId>shiro-redis-spring-boot-starter</artifactId> <version>3.2.1</version> </dependency> <!
Springboot通过注解＋切面实现接口权限校验
修行者Java的博客
03-19 927
先获取到注解@HasPermission 的内容，从redis中拿到当前用户的所有权限，如果当前用户不是超级管理员并且权限中不包含要请求的接口权限，就返回未授权。用户在登录时会查询数据库将所有权限存入redis，如果对该用户做权限修改时，同步修改redis，这样每次请求接口时，都能从redis中拿到最新的权限。1.首先创建注解 @HasPermission ，跟普通注解创建方式基本一致。另外，还有一种权限校验的方式，可以参考若依的开源，类似这种。2.创建一个切面，用来请求接口时做前置校验。
springboot整合shiro实现登录验证
c1225992531的博客
08-02 8353
springboot整合shiro实现登录验证 今天第一次接触springboot，本来是要学习springboot和shiro整合的，但是由于springboot结构还不太了解，所以先来了解一下springboot。 springboot可以快速创建一个机遇spring的项目，而且让这个项目跑起来只需要很少的配置就可以了，主要有以下核心功能： 1.独立运行的spring项目：springboo...
Springboot + shiro +jwt 实现登录和权限控制
weixin_43803888的博客
09-16 1424
Springboot + shiro +jwt 项目 Maven依赖 Springboot采用的是2.2.0 下面是jwt 和shiro的依赖 <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.2.0</version>
SpringBoot集成Shiro、Jwt和Redis
10-24
在SpringBoot中结合Shiro使用Jwt，可以在用户登录成功后生成一个Jwt Token，然后将其返回给客户端。客户端每次请求时带上Token，服务器端验证Token的有效性，以此实现无状态的身份认证。 **Redis** 是一个高性能的...
SpringBoot整合JWT + Shiro
weixin_43920711的博客
10-28 7217
一、什么是Shiro Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。 三个核心组件：Subject, SecurityManager 和 Realms 三大核心组件： Subject：主体 主体，代表了当前的“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是主体，如第三方进程、网络爬虫、机器人等，Subject是一个抽象概念，所有的Subject都绑定到Securi
SpringBoot集成shiro+redis+jwt实现无状态授权验证
热门推荐
liangshitian的博客
01-03 3万+
前言 1.放弃Cookie,Session,使用JWT进行鉴权，完全实现无状态鉴权。 2.JWT密钥支持过期时间；jwt作为创建验证token工具，并选择一种验证方式与算法。 3.使用redis做缓存处理，缓存token等等登录信息，以实现单点登录与超时登录功能。 4.密码加密(采用AES-128 + Base64的方式)。 5.根据RefreshToken自动刷新AccessToken...
springboot拦截器实现拦截器 权限校验，登录demo
11-14
不知道为啥不能设置0。这个是demo，有时间博主吧git整理下 链接发出来
SpringBoot+Shiro+Jwt实现登录认证——最干的干货
守夜人爱吃兔子的博客
08-04 1561
1. 概述 1.1 SpringBoot 这个就没什么好说的了，能看到这个教程的，估计都是可以说精通了SpringBoot的使用 1.2 Shiro 一个安全框架，但不只是一个安全框架。它能实现多种多样的功能。并不只是局限在web层。在国内的市场份额占比高于SpringSecurity，是使用最多的安全框架 可以实现用户的认证和授权。比SpringSecurity要简单的多。 1.3 Jwt 我的理解就是可以进行客户端与服务端之间验证的一种技术，取代了之前使用Session来验证的不安全性
第九篇：SpringBoot整合Shiro+Jwt
药岩
04-10 458
Shiro安全认证框架 Shiro 概述 Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架，使用shiro就可以非常快速的完成认证、授权等功能的开发，降低系统成本。 Shiro 认证流程 具体流程分析如下: 首先调用Subject.login(token)进行登录，其会自动委托给S...
Shiro登录验证
weixin_45834569的博客
01-16 1533
1.首先需要导入Shiro依赖包 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>1.3.2</version> </dependency> 2.定义自己的Reaml 需要继承AuthenticatingRealm 重写doGetAuthenticationInf
shiro-登录验证
segegefe的博客
08-24 1433
从上可以看出，具体的登录账号和密码从request中取出来，并创建了token对象，调用subject的login方法，login方法实现大致流程是用token去realm中取AuthenticationInfo对象，AuthenticationInfo对象存放的是正确的登录账号和密码，并和token中数据进行匹配，然后根据匹配情况返回相应的结果。shiro实现登录验证，可以用它自身的方法来实现，也可以自定义方法来实现登录验证，了解了shiro的登录逻辑，实现自定义的验证逻辑就很简单。
Shiro - 登陆验证
Yanliang
02-12 350
本文将利用springboot集成shiro进行用户的登陆验证功能的开发实现。 springboot集成shiro需要引入以下依赖 &amp;lt;!-- shiro-spring --&amp;gt; &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.apache.shiro&amp;lt;/groupId&amp;gt; &amp;lt;artifa
SpringBoot实现权限验证
weixin_52721608的博客
08-28 830
SpringBoot实现权限验证
SpringBoot+JWT：实现Token登录权限认证详解
"本文详细介绍了如何使用SpringBoot结合JWT（JSON Web Token）实现用户登录权限认证。文中通过具体的示例代码，展示了JWT的登陆认证流程、JWT的构成以及其优势，并给出了项目的依赖配置。" 在现代Web应用中，安全性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值