1.1 Spring security集成JWT实现token认证Demo

最新推荐文章于 2024-05-04 03:06:18 发布
最新推荐文章于 2024-05-04 03:06:18 发布
阅读量1.8k 收藏 26
点赞数 5
分类专栏： Spring Boot 文章标签： Spring Security 后端 登陆认证
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44296707/article/details/99633435
版权

简介

什么是JWT

Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).定义了一种简洁的，自包含的方法用于通信双方之间以JSON对象的形式安全的传递信息。因为数字签名的存在，这些信息是可信的，JWT可以使用HMAC算法或者是RSA的公私秘钥对进行签名。JWT官网： https://jwt.io/

JWT的构成

一个JWT由三个部分组成：header，payload，signature。分别保存了不同的信息。
头信息指定了JWT使用的签名算法
header={alg=HS512}
消息体用来承载要传递的数据，它的一个属性对被称为claim，这样的标准成为claims标准，同样是将其用Base64Url编码
在这里插入图片描述
部分是将前两个部分的json拼接中间加一点，再将这个拼接后的字符串用alg中的算法处理
在这里插入图片描述

JWT的请求流程

  1. 用户使用账号和面发出post请求；
  2. 服务器使用私钥创建一个jwt；
  3. 服务器返回这个jwt给浏览器；
  4. 浏览器将该jwt串在请求头中像服务器发送请求；
  5. 服务器验证该jwt；
  6. 返回响应的资源给浏览器。

下面开始代码讲解

首先是依赖的引入：

这里对于数据库的处理我用的是Mybatis，用Jpa的小伙伴相应的地方做一些改变即可

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.41</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.mobile</groupId>
            <artifactId>spring-mobile-device</artifactId>
            <version>1.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-core</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
    </dependencies>

自定义一个实现UserDetails接口的user类

@Data
public class JwtUser implements UserDetails {

    private String stuId;

    private String password;

    public JwtUser(String stuId, String password) {
        this.stuId = stuId;
        this.password = password;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return stuId;
    }

    @Override
    public String getUsername() {
        return null;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

自定义一个实现UserDetailService的实现类，实现自定义用户验证

其中对于数据库的访问每个人都不同，所以并没有给出代码，需要有一个通过用户输入的用户名来查询用户信息的方法getUserByUserId(userId).

@Service
@Slf4j
public class JwtUserDetailServiceImpl implements UserDetailsService {

    @Autowired
    private UserService userService;

    @Override
    public UserDetails loadUserByUsername(String stuId) throws UsernameNotFoundException {
        User user = userService.getUserByUserId(stuId);
        if(user == null) {
            log.info("用户不存在");
            throw new UsernameNotFoundException(String.format("用户名为 %s 的用户不存在！", stuId));
        } else {
            return  new JwtUser(stuId, user.getPassword());
        }
    }
}

Token的工具类

这里可以直接复制粘贴过去

@Component
public class JwtTokenUtil {
    
    //秘钥
    private String secret = "myscret";
    //过期时间
    private long expiration = 1296000L;

    static final String CLAIM_KEY_USERNAME = "sub";
    static final String CLAIM_KEY_AUDIENCE = "audience";
    static final String CLAIM_KEY_CREATED = "created";

    private static final String AUDIENCE_UNKNOWN = "unknown";
    private static final String AUDIENCE_WEB = "web";
    private static final String AUDIENCE_MOBILE = "mobile";
    private static final String AUDIENCE_TABLET = "tablet";

    public String getUsernameFromToken(String token) {
        String username;
        try {
            final Claims claims = getClaimsFromToken(token);
            username = claims.getSubject();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }

    public Date getCreatedDateFromToken(String token) {
        Date created;
        try {
            final Claims claims = getClaimsFromToken(token);
            created = new Date((Long) claims.get(CLAIM_KEY_CREATED));
        } catch (Exception e) {
            created = null;
        }
        return created;
    }

    public Date getExpirationDateFromToken(String token) {
        Date expiration;
        try {
            final Claims claims = getClaimsFromToken(token);
            //得到token的有效期
            expiration = claims.getExpiration();
        } catch (Exception e) {
            expiration = null;
        }
        return expiration;
    }

    public String getAudienceFromToken(String token) {
        String audience;
        try {
            final Claims claims = getClaimsFromToken(token);
            audience = (String) claims.get(CLAIM_KEY_AUDIENCE);
        } catch (Exception e) {
            audience = null;
        }
        return audience;
    }

    private Claims getClaimsFromToken(String token) {
        Claims claims;
        try {
            claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            claims = null;
        }
        return claims;
    }

    //设置过期时间
    private Date generateExpirationDate() {
        return new Date(System.currentTimeMillis() + expiration * 1000);
//        return new Date(30 * 24 * 60);
    }

    private Boolean isTokenExpired(String token) {
        final Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }

    private Boolean isCreatedBeforeLastPasswordReset(Date created, Date lastPasswordReset) {
        return (lastPasswordReset != null && created.before(lastPasswordReset));
    }

    private String generateAudience(Device device) {
        String audience = AUDIENCE_UNKNOWN;
        if (device.isNormal()) {
            audience = AUDIENCE_WEB;
        } else if (device.isTablet()) {
            audience = AUDIENCE_TABLET;
        } else if (device.isMobile()) {
            audience = AUDIENCE_MOBILE;
        }
        return audience;
    }

    private Boolean ignoreTokenExpiration(String token) {
        String audience = getAudienceFromToken(token);
        return (AUDIENCE_TABLET.equals(audience) || AUDIENCE_MOBILE.equals(audience));
    }

    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
        claims.put(CLAIM_KEY_CREATED, new Date());
        return generateToken(claims);
    }

    String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(generateExpirationDate())
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    public Boolean canTokenBeRefreshed(String token, Date lastPasswordReset) {
        final Date created = getCreatedDateFromToken(token);
        return !isCreatedBeforeLastPasswordReset(created, lastPasswordReset)
                && (!isTokenExpired(token) || ignoreTokenExpiration(token));
    }

    public String refreshToken(String token) {
        String refreshedToken;
        try {
            final Claims claims = getClaimsFromToken(token);
            claims.put(CLAIM_KEY_CREATED, new Date());
            refreshedToken = generateToken(claims);
        } catch (Exception e) {
            refreshedToken = null;
        }
        return refreshedToken;
    }

    //TODO,验证当前的token是否有效
    public Boolean validateToken(String token, UserDetails userDetails) {
        JwtUser user = (JwtUser) userDetails;
        final String username = getUsernameFromToken(token);
        final Date created = getCreatedDateFromToken(token);
        return (username.equals(user.getUsername())&& !isTokenExpired(token));
    }

}

自定义一个拦截器类，用于拦截未进行身份认证的情况

@Component
@Slf4j
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint, Serializable {

    private static final long serialVersionUID = -8970718410437077606L;

    @Override
    public void commence(HttpServletRequest httpServletRequest,
                         HttpServletResponse httpServletResponse,
                         AuthenticationException e) throws IOException, ServletException {
        httpServletResponse.setHeader("Access_Control_Allow_Origin","*");
        httpServletResponse.setCharacterEncoding("UTF-8");
        httpServletResponse.setContentType("text/html; charset=utf-8");
        ResultVO result = ResultVOUtil.error(ResultEnum.AUTHENTICATION_ERROR);
        log.info("需要身份认证:{}" ,result);
        httpServletResponse.getWriter().append(JSON.toJSONString(result));
    }
}

自定义JwtAuthenticationTokenFilter拦截器，用于进行自定义用户身份验证

@Slf4j
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    private String tokenHeader = "Authorization";

    @Override
    protected void doFilterInternal(HttpServletRequest httpServletRequest,
                                    HttpServletResponse httpServletResponse,
                                    FilterChain filterChain) throws ServletException, IOException {
        if (httpServletRequest.getMethod().equals("OPTIONS")) {
            //TODO，这里是解决前后端对接时的跨域问题
            log.info("浏览器的请求预处理");
            httpServletResponse.setHeader("Access-Control-Allow-Origin", "*");
            httpServletResponse.setHeader("Access-Control-Allow-Methods", "POST,GET,OPTIONS,DELETE");
            httpServletResponse.setHeader("Access-Control-Max-Age", "3600");
            httpServletResponse.setHeader("Access-Control-Allow-Headers", "Origin,X-Requested-With,Content-Type,Accept,Authorization,token,Cookie");
            return;
        } else {
            String requestUrl = httpServletRequest.getRequestURI();
            log.info("requestURL: {}", requestUrl);
            String authToken = httpServletRequest.getHeader(this.tokenHeader);

            String stuId = jwtTokenUtil.getUsernameFromToken(authToken);

            log.info("checking authentication for user " + stuId);

            //当token中的username不为空时进行验证token是否是有效的token
            if (stuId != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                //token中username不为空，并且Context中的认证为空，进行token验证
                //TODO,从数据库得到带有密码的完整user信息
                UserDetails userDetails = this.userDetailsService.loadUserByUsername(stuId);
                log.info("加载userDetails:{}", userDetails.getUsername());
                if (jwtTokenUtil.validateToken(authToken, userDetails)) {
                    /**
                     * UsernamePasswordAuthenticationToken继承AbstractAuthenticationToken实现Authentication
                     * 所以当在页面中输入用户名和密码之后首先会进入到UsernamePasswordAuthenticationToken验证(Authentication)，
                     * 然后生成的Authentication会被交由AuthenticationManager来进行管理
                     * 而AuthenticationManager管理一系列的AuthenticationProvider，
                     * 而每一个Provider都会通UserDetailsService和UserDetail来返回一个
                     * 以UsernamePasswordAuthenticationToken实现的带用户名和密码以及权限的Authentication
                     */
                    UsernamePasswordAuthenticationToken authentication =
                            new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(httpServletRequest));
                    log.info("authenticated user " + stuId + ", setting security context");
                    //将authentication放入SecurityContextHolder中
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }
            }
            filterChain.doFilter(httpServletRequest, httpServletResponse);

        }
    }
}

WebSecurityConfig配置类

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {


    @Autowired
    private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    public void configureAuthentication(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception {
        authenticationManagerBuilder
                .userDetailsService(this.userDetailsService)
                .passwordEncoder(passwordEncoder());
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public JwtAuthenticationTokenFilter authenticationTokenFilterBean() throws Exception {
        return new JwtAuthenticationTokenFilter();
    }

    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        httpSecurity
                //token的验证方式不需要开启csrf的防护
                .csrf().disable()
                .exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint)
                .and()
                //设置无状态的连接,即不创建session
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
                .authorizeRequests()
//                .antMatchers(HttpMethod.OPTIONS, "/**").permitAll()
//                当前的url允许进行匿名访问,即不需要身份认证
                .antMatchers(
                        "/",
                        "/*.html",
                        "/favicon.ico",
                        "/**/*.html",
                        "/**/*.css",
                        "/**/*.js"
                ).permitAll()
                //配置swagger界面的匿名访问
                .antMatchers("/swagger-ui.html").permitAll()
                .antMatchers("/swagger-resources/**").permitAll()
                .antMatchers("/images/**").permitAll()
                .antMatchers("/webjars/**").permitAll()
                .antMatchers("/v2/api-docs").permitAll()
                .antMatchers("/configuration/ui").permitAll()
                .antMatchers("/configuration/security").permitAll()
                .antMatchers("/login").permitAll()
                //配置允许匿名访问的路径
                .anyRequest().authenticated();

        //配置自己的验证过滤器
        httpSecurity
                .addFilterBefore(authenticationTokenFilterBean(), UsernamePasswordAuthenticationFilter.class);

        // disable page caching
        httpSecurity.headers().cacheControl();
    }
}

最后就是service的逻辑层

@Service
@Slf4j
public class UserServiceImpl implements UserService{

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private JwtUserDetailServiceImpl jwtUserDetailService;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Override
    public User getUserByUserId(String userId) {
        return userMapper.getUserByUserId(userId);
    }

    @Override
    public Map login(String username, String password) {
        User user = userMapper.getUserByUserId(username);
        if (user == null) {
            Map map = new HashMap();
            map.put("code",0);
            map.put("message","用户不存在.");
            return map;
        }
        UserDetails userDetails = jwtUserDetailService.loadUserByUsername(username);
        if (!(new BCryptPasswordEncoder().matches(password, userDetails.getPassword()))) {
            Map map = new HashMap();
            map.put("code",1);
            map.put("message","密码错误..");
            return map;
        }
        //TODO，将username和password被获得后封装到UsernamePasswordAuthenticationToken
        Authentication token = new UsernamePasswordAuthenticationToken(username, password, userDetails.getAuthorities());
        //TODO，token被传递给AuthenticationManager进行验证
        Authentication authentication = authenticationManager.authenticate(token);
        //将生成的authentication放入容器中，生成安全的上下文
        log.info("验证成功.");
        SecurityContextHolder.getContext().setAuthentication(authentication);

        //生成token
        final String realToken = jwtTokenUtil.generateToken(userDetails);

        Map map = new HashMap();
        map.put("message", "token生成成功.");
        map.put("token", realToken);

        return map;
}
}

Controller层写登陆接口

@RestController
public class LogInController {

    @Autowired
    private UserService userService;

    /**
     * 登录接口
     */
    @PostMapping("/login")
    public Map login(String username, String password) {
        return userService.login(username, password);
    }
}

下面失去postman测试的结果:

![在这里插入图片描述](https://img-blog.csdnimg.cn/2019081515042150.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5NjcwNw==,size_16,color_FFFFFF,t_70在这里插入图片描述

Token返回给前端后，前端会将它加入到请求头里，每次访问后端url时都会解析token来判断是否有权限访问当前url。后续会继续更新权限访问的实现。

L1nZHongHUI
关注
  • 5
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Springboot+Spring-Security+JWT 实现用户登录和权限认证
congge
06-08 27万+
如今，互联网项目对于安全的要求越来越严格，这就是对后端开发提出了更多的要求，目前比较成熟的几种大家比较熟悉的模式，像RBAC 基于角色权限的验证，shiro框架专门用于处理权限方面的，另一个比较流行的后端框架是Spring-Security，该框架提供了一整套比较成熟，也很完整的机制用于处理各类场景下的可以基于权限，资源路径，以及授权方面的解决方案，部分模块支持定制化，而且在和oauth2.0进...
spring boot + spring security + Jwt
qq_36722687的博客
06-30 361
spring boot + spring security + Jwt主要依赖标题新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 主要依赖 <dependency> <grou
单点登录一：springboot项目使用redis、springSecurity、jwt实现单点登录的demo
qq_35515283的博客
05-22 2123
springboot项目使用redis、springSecurity、jwt实现单点登录，写一个最基础的demo。容易理解
springSecurity中jwt机制及应用详解
最新发布
2401_84092666的博客
05-04 701
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！这种格式是OAuth2附带token的一种规范格式至于什么是OAuth2，那是另一个话题了这样一来，服务器就能够收到这个令牌了，通过对令牌的验证，即可知道该令牌是否有效。它们的完整交互流程是非常简单清晰的：令牌的组成为了保证令牌的安全性，jwt令牌由三个部分组成，分别是：header：令牌头部，记录了整个令牌的类型和签名算法payload：令牌负荷，记录了保存的主体信息，比如你要保存的用户信息就可以放到这里s
简单高效快速整合SpringBoot+SpringSecurity+Jwt实现前后端分离权限框架
刘信晨
04-30 2497
一、效果、简叙 首先吐槽一下我以前看到(Security)的文章: 1、有标题没内容(标题很牛逼什么小白、新手都会的)； 2、只说核心的流程、处理要求，没有代码(大神你不懂的小白怎么操作，我们不会呀)； 3、有图有效果代码拉下来出错 留言不回复； 先给大家看一下效果吧 登录：验证权限: 二、代码编写 首先我先贴出我们Git地址: https://gitee.com/liurunyong/Spr...
spring security_spring-security-oauth2官方jwt-demo运行实例解析
weixin_39542850的博客
11-26 283
简述在开发过程中权限控制必不可少，如何选择一款优秀的权限架构是一份很头疼的事，而shiro和spring-security则是市面上比较优秀的两款权限开源框架，通过改造对应的定制化源码扩展出自己业务所需的架构。下面主要来运行一下官方spring-security-oauth2权限框架的测试demo,通过运行的效果来初步认识这款权限架构。1、下面是从官方下载[源码地址:https://github....
解析SpringSecurity+JWT认证流程实现
08-18
在SpringSecurity中，我们使用JWT认证方式来实现认证，通过生成一个JWT token来验证用户的身份。在认证流程中，我们首先需要生成一个JWT token，然后将其传递给客户端，客户端在每次请求时都需要带上这个token，以便...
springsecurity+oauth2+jwt实现单点登录demo
06-06
该资源是springsecurity+oauth2+jwt实现的单点登录demo，模式为授权码模式，实现自定义登录页面和自定义授权页面。应用数据存在内存中或者存在数据库中（附带数据库表结构），token存储分为数据库或者Redis。demo...
springboot+springSecurity+jwt实现的基于token的权限管理的一个demo
02-16
这个“springboot+springSecurity+jwt实现的基于token的权限管理的一个demo”旨在演示如何在Spring Boot应用中集成这些技术，以创建一个安全的、基于令牌的身份验证系统。 首先，Spring Boot是Java领域的一个快速...
Spring Security基于JWT实现SSO单点登录详解
08-25
在 sso-server 项目中，我们实现了认证服务器，使用 Spring Security 框架验证用户的身份，并生成 JWT Token。 在 sso-client 和 sso-client2 项目中，我们实现了资源服务器，使用 Spring Security 框架验证 JWT ...
基于springboot+springSecurity+jwt实现的基于token的权限管理+源代码+文档
04-09
本项目通过集成Spring Boot、Spring Security和JWT（JSON Web Tokens）技术，构建了一个基于token的权限管理系统。下面将详细阐述这些关键技术及其相互间的协同工作原理。 1. **Spring Boot**： Spring Boot是...
SpringBoot+SpringSecurity+JWT整合实现单点登录SSO史上最全详解
程序员闪充宝
01-05 4266
作者：波波烤鸭blog.csdn.net/qq_38526573/article/details/103409430一、什么是单点登陆单点登录（Single Sign On），简称为 S...
SpringSecurity+JWT实现登陆验证的思路（有一点点源码分析）
weixin_45654405的博客
04-04 1742
看了几个SpringSecurity+JWT的登陆demo，两个demo在一些细节实现上有一些不同，然后对于各个类和接口的关系比较模糊，就决定整理一下思路。 先简单的借用一下一位UP 三更草堂的图了解一下登陆大概的流程和用到的类，这个他讲的还比较清晰。 前后端分离项目登陆流程。 SpringSecurity工作流程（过滤器链） 登陆的后端实现：要实现登录验证主要需要实现上图过滤链的橙色方块部分的过滤器（UsernamePasswordAuthenticationFilter），这个过滤器的工作原理如下图
SpringSecurity+jwt权限管理demo
saienenen的博客
03-27 591
一，前言 我发现很多开源项目在权限安全这方面用的都是Spring-Security。所以这段时间学习了 Spring-Security ，做了一个权限管理demo巩固一下。之前有做过一个 shiro 的权限管理demo，前端就是借用那个项目的，只有一点地方改变。shiro 二，代码实践 1，POM 不止有这几个依赖，后面会提供源码 <dependency> <groupId>org.springframework.boot</grou
springboot3+jwt+security的整合使用搭建简易Demo
三两肉的博客
09-11 8611
springboot3+jwt+security的整合使用搭建简易Demo
SpringSecurity + JWT（前后端分离）
HGW的博客
09-30 5298
想必大四的小伙伴们陆陆续续开始写毕业设计了，对于网络安全框架SpringSecurity在网上的资源都是前后端不分离的，这里记录一下小伟的前后端分离版。
基于spring security实现vue2前后端分离的双token刷新机制（完整代码详解，含金量拉满！）
qq_60614034的博客
03-27 3581
网上许多博主，放张图片讲讲双token原理就发出来，没有含金量，还耽误大伙的时间。但是我不一样，我将会把代码的每一步骤都讲明白，并把详细代码放出来，让每一位看到的人都能跟着一步步自己搞，弄明白每一步的执行流程。要是觉得我跟那些博主一样，也是水文章，互相抄袭，请在评论区直接开骂。如果是第一次接触security请看这篇spring security单token前后端分离详细配置。
springsecurity Oauth2.0 + jwt 极简入门demo
asfasfasgjkl的博客
08-18 1480
springsecurity Oauth2.0 服务器和客户端 极简入门demo
spring security 实现自定义认证和登录（4）：使用token进行验证
qq_45691577的博客
03-06 3585
前面我们实现了给客户端下发token，虽然客户端拿到了token，但我们还没处理客户端下一次携带token请求时如何验证，我们想要实现拿得到token之后，只需要验证token，不需要用户再携带用户名和密码了。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值