Shiro+Spring Boot+jwt

最新推荐文章于 2023-04-24 09:24:35 发布
最新推荐文章于 2023-04-24 09:24:35 发布
阅读量2.2k 收藏 4
点赞数 2
分类专栏： Spring 文章标签： spring boot spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53946134/article/details/126245064
版权

目录

前言

一、shiro是什么？

二、使用步骤

1.引入依赖

2.代码讲解

源代码

前言

Shiro+SpringBoot+jwt集成小的Dome+源代码，源代码在最后

提示：以下是本篇文章正文内容，下面案例可供参考

一、shiro是什么？

Apache Shiro 是Java 的一个安全框架。Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE 环境，也可以用在JavaEE 环境。Shiro 可以帮助我们完成：认证、授权、加密、会话管理、与Web 集成、缓存等。

 为什么用shiro？java领域中spring security(原名Acegi)也是一个开源的权限管理框架，但是spring security依赖spring运行，而shiro就相对独立，最主要是因为shiro使用简单、灵活，所以现在越来越多的用户选择shiro。

二、使用步骤

1.引入依赖

代码如下（示例）： 

        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.4.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2.代码讲解

ShiroConfig

package com.hnchances.demo.shiro;

import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.mgt.DefaultSubjectDAO;
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.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;

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

@Configuration
public class ShiroConfig {

    @Bean(name = "userRealm")
    public UserRealm userRealm(){
        return new UserRealm();
    }
    @Bean("securityManager")
    public DefaultWebSecurityManager getManager(@Qualifier("userRealm") UserRealm realm) {
        DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
        // 使用自己的realm
        manager.setRealm(realm);
//        /*
//         * 关闭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.setSubjectDAO(subjectDAO);

        return manager;
    }

    @Bean("shiroFilter")
    public ShiroFilterFactoryBean factory(@Qualifier("securityManager") DefaultWebSecurityManager securityManager) {
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();

        // 添加自己的过滤器并且取名为jwt
        Map<String, Filter> filterMap = new HashMap<>();
        filterMap.put("jwt", new JWTFilter());
        factoryBean.setFilters(filterMap);

        factoryBean.setSecurityManager(securityManager);
        /*
         * anon:无需认证就可以访问
         * authc:必须认证了才能访问
         * user:必须拥有 记住我 功能才能用
         * role：拥有某个角色权限才嫩访问
         */
        Map<String, String> filterRuleMap = new HashMap<>();
//        filterRuleMap.put("/**", "jwt");
        // 访问401和404页面不通过我们的Filter
        filterRuleMap.put("/system/user/login", "anon");
        filterRuleMap.put("/user/imgCode", "anon");
        //开放API文档接口
        filterRuleMap.put("/swagger-ui.html", "anon");
        filterRuleMap.put("/webjars/**","anon");
        filterRuleMap.put("/swagger-resources/**","anon");
        filterRuleMap.put("/v2/**","anon");
        filterRuleMap.put("/static/**","anon");
        filterRuleMap.put("/user/add","perms[user:add]");
        filterRuleMap.put("/user/update","perms[user:update]");
        filterRuleMap.put("/user/del","perms[user:del]");
        filterRuleMap.put("/user/userinfo","perms[user:userinfo]");
        filterRuleMap.put("/grades/updateOrAdd","perms[user:updateOrAdd]");


        //sql监控
        factoryBean.setFilterChainDefinitionMap(filterRuleMap);
        factoryBean.setLoginUrl("/login");
        return factoryBean;
    }

    /**
     * 下面的代码是添加注解支持
     */
    @Bean
    @DependsOn("lifecycleBeanPostProcessor")
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        // 强制使用cglib，防止重复代理和可能引起代理出错的问题
        // https://zhuanlan.zhihu.com/p/29161098
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        return defaultAdvisorAutoProxyCreator;
    }

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

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

UserRealm

package com.hnchances.demo.shiro;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.hnchances.demo.entity.User;
import com.hnchances.demo.service.UserService;
import com.hnchances.demo.util.JWTUtils;
import lombok.SneakyThrows;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
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.Service;

@Service
public class UserRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;

    /**
     * 大坑！，必须重写此方法，不然Shiro会报错
     */

    @Override
    public boolean supports(AuthenticationToken token) {
        // TODO Auto-generated method stub
        return token instanceof JWTToken;
    }

    /**
     * 授权
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        authorizationInfo.addStringPermission("user:add");
        User activeUser = (User) SecurityUtils.getSubject().getPrincipal();
        authorizationInfo.addStringPermission(activeUser.getIdentity()+"");
//
//        if(activeUser.getUser().getType()==0){
//            authorizationInfo.addStringPermission("*:*");
//        }else {
//            List<String> permissions = new ArrayList<>(activeUser.getPermissions());
//            List<Role> roleList = activeUser.getRoles();
//            //授权角色
//            if (!CollectionUtils.isEmpty(roleList)) {
//                for (Role role : roleList) {
//                    authorizationInfo.addRole(role.getRoleName());
//                }
//            }
//            //授权权限
//            if (!CollectionUtils.isEmpty(permissions)) {
//                for (String  permission : permissions) {
//                    if (permission != null && !"".equals(permission)) {
//                        authorizationInfo.addStringPermission(permission);
//                    }
//                }
//            }
//        }
        return authorizationInfo;
    }

    /**
     * 认证
     */
    @SneakyThrows
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
        String token = (String) auth.getCredentials();
        // 解密获得username，用于和数据库进行对比
        String username = JWTUtils.getUsername(token);

        if (username == null) {
            throw new AuthenticationException(" token错误，请重新登入！");
        }
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.eq("userName",username);
        User userBean = userService.getOne(queryWrapper);

        if (userBean == null) {
            throw new AccountException("账号不存在!");
        }
        if(JWTUtils.isExpire(token)){
            throw new AuthenticationException(" token过期，请重新登入！");
        }

        if (! JWTUtils.verify(token, username, userBean.getPassWord())) {
            throw new CredentialsException("密码错误!");
        }



//        //如果验证通过，获取用户的角色
//        List<Role> roles= userService.findRolesById(userBean.getId());
//        //查询用户的所有菜单(包括了菜单和按钮)
//        List<Menu> menus=userService.findMenuByRoles(roles);
//
//        Set<String> urls=new HashSet<>();
//        Set<String> perms=new HashSet<>();
//        if(!CollectionUtils.isEmpty(menus)){
//            for (Menu menu : menus) {
//                String url = menu.getUrl();
//                String per = menu.getPerms();
//                if(menu.getType()==0&& !StringUtils.isEmpty(url)){
//                    urls.add(menu.getUrl());
//                }
//                if(menu.getType()==1&&!StringUtils.isEmpty(per)){
//                    perms.add(menu.getPerms());
//                }
//            }
//        }
//        //过滤出url,和用户的权限
//        ActiveUser activeUser = new ActiveUser();
//        activeUser.setRoles(roles);
//        activeUser.setUser(userBean);
//        activeUser.setMenus(menus);
//        activeUser.setUrls(urls);
//        activeUser.setPermissions(perms);
        return new SimpleAuthenticationInfo(userBean, token, getName());
    }
}

 jwtUtil

package com.hnchances.demo.util;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.io.UnsupportedEncodingException;
import java.util.Date;

public class JWTUtils {
    /**
     * 过期时间6小时
     */
    private static final long EXPIRE_TIME = 6*60*60*1000;

    /**
     * 校验token是否正确
     * @param token 密钥
     * @param secret 用户的密码
     * @return 是否正确
     */
    public static boolean verify(String token, String username, String secret) {
        try {
            Algorithm algorithm = Algorithm.HMAC256(secret);
            JWTVerifier verifier = JWT.require(algorithm)
                    .withClaim("username", username)
                    .build();
            DecodedJWT jwt = verifier.verify(token);
            return true;
        } catch (Exception exception) {
            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;
        }
    }

    /**
     * 生成签名,2min后过期
     * @param username 用户名
     * @param secret 用户的密码
     * @return 加密的token
     */
    public static String sign(String username, String secret) {
        try {
            Date date = new Date(System.currentTimeMillis()+EXPIRE_TIME);
            Algorithm algorithm = Algorithm.HMAC256(secret);
            // 附带username信息
            return JWT.create()
                    .withClaim("username", username)
                    .withExpiresAt(date)
                    .sign(algorithm);
        } catch (UnsupportedEncodingException e) {
            return null;
        }
    }

    /**
     * 判断过期
     * @param token
     * @return
     */
    public static boolean isExpire(String token){
        DecodedJWT jwt = JWT.decode(token);
        return System.currentTimeMillis()>jwt.getExpiresAt().getTime();
    }
    }

 UserController

 @ApiOperation(value = "用户登录")
    @PostMapping("/login")
    public R login(String username,String password){
        Subject subject = SecurityUtils.getSubject();
        String token = JWTUtils.sign(username, password);
        JWTToken jwtToken = new JWTToken(token);
        try{
            subject.login(jwtToken);
            return R.success("登录成功");
        }catch (UnknownAccountException e){
            return R.success("用户名错误");
        }
        catch (IncorrectCredentialsException e){
            return R.success("密码错误");
        }

    }

源代码

源代码demo

StudentManagementSystemdemo: java岗位测试

✘迟暮
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot整合JWT + Shiro
weixin_43920711的博客
10-28 7041
一、什么是Shiro Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。 三个核心组件：Subject, SecurityManager 和 Realms 三大核心组件： Subject：主体 主体，代表了当前的“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是主体，如第三方进程、网络爬虫、机器人等，Subject是一个抽象概念，所有的Subject都绑定到Securi
springboot集成shiro+jwt详解+完整实例
Timmer的博客
05-26 5674
目录 简介 目的 需要的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...
【Java专题_01】springboot+Shiro+Jwt整合方案
热门推荐
weixin_40736233的博客
04-02 1万+
【Java专题_01】springboot+Shiro+Jwt整合方案
SpringBoot+Shiro+JWT
weixin_37375983的博客
11-10 1003
SpringBoot+Shiro+JWT
SpringBoot+Shiro+JWT实现授权
帅帅气气的黑猫警长
09-03 1255
SpringBoot+JWT+Shiro实现前后端分离的授权
Spring boot整合shiro+jwt实现前后端分离
08-25
Spring Boot 整合 Shiro+JWT 实现前后端分离 Spring Boot 框架是一个流行的 Java 框架，用于构建 Web 应用程序。Shiro 是一个强大的安全框架，提供了身份验证、授权、会话管理、加密等功能。JWT（JSON Web Token）...
基于SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端商城系统源码
05-13
yshop基于当前流行技术组合的前后端分离商城系统： SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含分类、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、...
spring boot+shiro+mybatis+pagehelper+mapper+jwt,swagger2前后端分离restful框架
01-06
前后端分离之后台架构，供各位参考...Spring boot shiro权限管理 Ehcache缓存框架，可以改成redis Mybatis+PageHelper+通用mapper JWT前后端token验证 Swagger2 api生成工具 已经实现了用户、权限、组织等代码的实现
spring boot 整合JWT+shiro
10-09
spring boot整合JWT+shiro ，异常处理的分装，就是一个简单的整合demo.对初学者很有帮助.
springboot2.0+shiro+jwt+redis+swagger+layui+thymeleaf
11-02
基于spring boot 2.1.6、shiro、jwt、redis、swagger2、mybatis 、thymeleaf、layui 后台管理系统， 权限控制的方式为 RBAC。代码通熟易懂 、JWT（无状态token）过期自动刷新，数据全程 ajax 获取，封装 ajax 工具类...
SpringBoot整合Shiro+JWT
05-15
本Demo案例为SpringBoot整合Shiro + JWT实现用户认证，代码注释全都有以及sql文件都已经打包，下载之后刷新pom依赖即可直接运行。
springboot集成jwt和shiro实现前后端分离权限demo2
04-10
springboot集成jwt和shiro实现前后端分离权限demo2 添加realm中异常处理
SpringBoot+Shiro+JWT+Jedis+MybatisPlus+前后端分离+基于url通用权限管理系统
01-25
前后端分离（这里只展示后台），基于url拦截的通用权限管理系统，采用jwt+redis的机制取代传统session+cookie的认证授权方式，shiro框架，配置Jedis，以redis作缓存
SpringBoot+Shiro+JWT实现权限管理
segegefe的博客
04-08 2299
1.为什么使用JWT 1.简洁(Compact):可以通过URL，POST参数或者在HTTP header发送，因为数据量小，传输速度也很快。 2.自包含(Self-contained)：负载中包含了所有用户所需要的信息，避免了多次查询数据库。 3.安全(security): 与简单的JSON相比，XML和XML数字签名会引入复杂的安全漏洞。 2.认证原理 1.用户登陆之后，使用密码对账号进行签名生成并返回token并设置过期时间； 2.将token保存到本地，并且每次发送请求时都在header上携带tok
springboot+shiro+jwt
staticvoi的博客
12-14 882
JWT JSON Web Token（JWT）是一个非常轻巧的规范。这个规范允许我们使用 JWT 在用户和服务器之间传递安全可靠的信息。 我们利用一定的编码生成 Token，并在 Token 中加入一些非敏感信息，将其传递。 一个完整的 Token : eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJmcm9tX3VzZXIiOiJCIiwidGFyZ2V0X3VzZXIiOiJBIn0.rSWamyAYwuHCo7IFAgd1oRpSP7nzL7BF5t7ItqpKViM
SpringBoot+Shiro+Jwt实现登录认证
weixin_44740485的博客
05-08 1816
srpingboot这里就不再进行赘述，相信大家都非常的熟悉了 Shiro 一个安全框架，可以实现用户的认证和授权。比SpringSecurity要简单的多。 Jwt 我的理解就是可以进行客户端与服务端之间验证的一种技术，取代了之前使用 Session 来验证的不安全性 什么不适用 Session？ 原理是，登录之后客户端和服务端各自保存一个相应的 SessionId，每次客户端发起请求的时候就得携带这个 SessionId 来进行比对 1、Session 在用户请求量大的时候服务器开销太大了 2
Shiro+JWT+Spring Boot Restful简易教程
weixin_33834137的博客
10-26 932
序言 我也是半路出家的人，如果大家有什么好的意见或批评，请务必issue下。 项目地址：github.com/Smith-Cruis… 。 如果想要直接体验，直接clone项目，运行mvn spring-boot:run命令即可进行访问。网址规则自行看教程后面。 如果想了解Spring Security可以看 Spring Boot 2.0+Srping Security+Thymeleaf的简易...
Springboot整合Shiro+JWT实现认证授权
我的青春一去不复返
09-02 2204
Springboot整合Shiro+JWT实现用户登录认证和权限授权
Springboot+Shiro+Jwt实现简单的权限控制
Java技术攻略的博客
04-24 1605
因为需要实现一个设备管理系统的权限管理模块，在查阅很多博客以及其他网上资料之后，发现重复、无用的博客很多，因此写一篇文章来记录，以便后面复习。书写顺序。
shiro+springboot+jwt项目
最新发布
05-23
Shiro是一个Java安全框架，可以提供身份验证、授权、加密和会话管理等功能，Spring Boot是一个快速开发框架，可以帮助开发人员更快地构建和部署应用程序，JWT（JSON Web Token）是一种轻量级的身份验证和授权机制。将这三个框架结合起来，可以构建一个安全的Web应用程序。 以下是一个简单的Shiro+Spring Boot+JWT项目的实现步骤： 1.创建一个Spring Boot项目，并添加Shiro和JWT依赖项： ``` <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>1.7.1</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-api</artifactId> <version>0.10.7</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-impl</artifactId> <version>0.10.7</version> <scope>runtime</scope> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-jackson</artifactId> <version>0.10.7</version> <scope>runtime</scope> </dependency> ``` 2.创建一个Shiro配置类，配置Shiro的安全策略和过滤器链： ``` @Configuration public class ShiroConfig { @Bean public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) { ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean(); shiroFilterFactoryBean.setSecurityManager(securityManager); shiroFilterFactoryBean.setLoginUrl("/login"); shiroFilterFactoryBean.setUnauthorizedUrl("/unauthorized"); Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>(); filterChainDefinitionMap.put("/login", "anon"); filterChainDefinitionMap.put("/**", "jwt"); shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap); return shiroFilterFactoryBean; } @Bean public DefaultWebSecurityManager securityManager(Realm realm) { DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager(); securityManager.setRealm(realm); return securityManager; } @Bean public Realm realm() { return new UserRealm(); } @Bean public JwtFilter jwtFilter() { return new JwtFilter(); } } ``` 3.创建一个自定义Realm类，实现Shiro的认证和授权逻辑： ``` public class UserRealm extends AuthorizingRealm { @Autowired private UserService userService; @Override protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) { SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo(); User user = (User) principals.getPrimaryPrincipal(); authorizationInfo.addRole(user.getRole()); return authorizationInfo; } @Override protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException { String username = (String) token.getPrincipal(); User user = userService.findByUsername(username); if (user == null) { throw new UnknownAccountException(); } return new SimpleAuthenticationInfo(user, user.getPassword(), getName()); } } ``` 4.创建一个JwtFilter类，实现JWT的认证逻辑： ``` public class JwtFilter extends AuthenticatingFilter { @Autowired private UserService userService; @Override protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception { HttpServletRequest httpServletRequest = (HttpServletRequest) request; String token = httpServletRequest.getHeader("Authorization"); if (StringUtils.isEmpty(token)) { throw new UnauthorizedException(); } JwtToken jwtToken = new JwtToken(token); try { getSubject(request, response).login(jwtToken); } catch (AuthenticationException e) { throw new UnauthorizedException(); } return true; } @Override protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) { return false; } } ``` 5.创建一个JwtToken类，实现JWT的Token逻辑： ``` public class JwtToken implements AuthenticationToken { private String token; public JwtToken(String token) { this.token = token; } @Override public Object getPrincipal() { return JwtUtils.getSubject(token); } @Override public Object getCredentials() { return token; } } ``` 6.创建一个UserController类，实现用户登录和获取用户信息的逻辑： ``` @RestController public class UserController { @Autowired private UserService userService; @PostMapping("/login") public Result login(@RequestBody User user) { String token = userService.login(user); return Result.success(token); } @GetMapping("/user") public Result getUserInfo() { User user = (User) SecurityUtils.getSubject().getPrincipal(); return Result.success(user); } } ``` 7.创建一个UserService类，实现用户登录和生成JWT Token的逻辑： ``` @Service public class UserService { @Autowired private UserMapper userMapper; public User findByUsername(String username) { return userMapper.findByUsername(username); } public String login(User user) { User realUser = findByUsername(user.getUsername()); if (realUser == null || !realUser.getPassword().equals(user.getPassword())) { throw new UnauthorizedException(); } return JwtUtils.generateToken(realUser.getId(), realUser.getUsername(), realUser.getRole()); } } ``` 8.创建一个JwtUtils类，实现JWT的Token生成和解析逻辑： ``` public class JwtUtils { private static final String SECRET = "secret"; private static final long EXPIRATION_TIME = 86400000; // 24 hours public static String generateToken(String id, String username, String role) { Date now = new Date(); Date expirationDate = new Date(now.getTime() + EXPIRATION_TIME); return Jwts.builder() .setId(id) .setSubject(username) .claim("role", role) .setIssuedAt(now) .setExpiration(expirationDate) .signWith(SignatureAlgorithm.HS512, SECRET) .compact(); } public static String getSubject(String token) { return Jwts.parser() .setSigningKey(SECRET) .parseClaimsJws(token) .getBody() .getSubject(); } } ``` 这样，就可以使用Shiro+Spring Boot+JWT构建一个安全的Web应用程序了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值