SpringSecurity - 整合JWT使用 Token 认证授权

已于 2022-03-12 11:09:08 修改
阅读量6.7k 收藏 25
点赞数 4
分类专栏： 微服务 文章标签： java 开发语言 后端
于 2022-01-09 20:32:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43692950/article/details/122396221
版权

一、SpringSecurity

前面讲解了SpringSecurity的动态认证和动态权限角色，我们都知道在现在大多都是微服务前后端分离的模式开发，前面讲的还是基于Session的，本篇我们整合JWT实现使用Token认证授权。

上篇文章地址：https://blog.csdn.net/qq_43692950/article/details/122394611

在开始前需要了解JWT，如果不了解，可以先看下下面这篇我的博客：

https://blog.csdn.net/qq_43692950/article/details/107443397

二、SpringSecurity 整合JWT使用 Token 认证授权

本篇文章还是接着上篇文章进行讲解，数据库还是使用上两篇文章中创建的数据库：
在这里插入图片描述
由于我们要使用JWT生成Token和存储一些信息，所以先引入JWT的依赖：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.6.0</version>
</dependency>

编写JwtTool工具：

@Data
@Component
public class JwtTool {
    private String key = "com.bxc";
    private long overtime = 1000 * 60 * 60;

    public String CreateToken(String userid, String username, List<String> roles) {
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        JwtBuilder builder = Jwts.builder()
                .setId(userid)
                .setSubject(username)
                .setIssuedAt(now)
                .signWith(SignatureAlgorithm.HS256, key)
                .claim("roles", roles);
        if (overtime > 0) {
            builder.setExpiration(new Date(nowMillis + overtime));
        }
        return builder.compact();
    }

    public boolean VerityToken(String token) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(key)
                    .parseClaimsJws(token)
                    .getBody();
            if (claims != null) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    public String getUserid(String token) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(key)
                    .parseClaimsJws(token)
                    .getBody();
            if (claims != null) {
                return claims.getId();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public String getUserName(String token) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(key)
                    .parseClaimsJws(token)
                    .getBody();
            if (claims != null) {
                return claims.getSubject();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public List<String> getUserRoles(String token) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(key)
                    .parseClaimsJws(token)
                    .getBody();
            if (claims != null) {
                return (List<String>) claims.get("roles");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public String getClaims(String token, String param) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(key)
                    .parseClaimsJws(token)
                    .getBody();
            if (claims != null) {
                return claims.get(param).toString();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

使用CreateToken就可以生成下面这种字符串：

eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiI4Iiwic3ViIjoiYWRtaW4iLCJpYXQiOjE2NDE3Mjg5NzgsInJvbGVzIjpbIlJPTEVfYWRtaW4iXSwiZXhwIjoxNjQxNzMyNTc4fQ.qI_pXiwm2IzZNRdyKvTRuSj0JxiPHepPOXg_u6AAE88

我们就使用类似上面这串做我们的Token。

既然使用Token了，肯定大多都是采用前后端分离架构，一般都是采用JSON进行交互的，但细心的会发现，前面的登录都是一个form表单的形式，所以第一步我们先把登录换成JSON的形式。

下面就需要重写自己的登录过滤器，需要实现UsernamePasswordAuthenticationFilter接口，其中attemptAuthentication(HttpServletRequest request, HttpServletResponse response) 表示获取用户用户名密码的入口，我们可以在这里自定义接受用户名密码，比如以json形式接受，然后再传递给Security，然后Security下面就会去调用UserDetailsService做用户名和密码的正确性验证，如果用户名密码正确那就是登录成功，就会触发该实现下的successfulAuthentication方法，否则就是unsuccessfulAuthentication方法，我们可以在相应的方法中编写相应的提示返回给客户端：

public class LoginAuthenticationFilter extends UsernamePasswordAuthenticationFilter {

    private JwtTool jwtTool;

    public LoginAuthenticationFilter(AuthenticationManager authenticationManager, JwtTool jwtTool) {
        this.setAuthenticationManager(authenticationManager);
        this.jwtTool = jwtTool;
//        this.setPostOnly(false);
//        this.setRequiresAuthenticationRequestMatcher(new AntPathRequestMatcher("/login","POST"));
    }


    @SneakyThrows
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        response.setContentType("text/json;charset=utf-8");
        if (request.getContentType().equals(MediaType.APPLICATION_JSON_UTF8_VALUE) || request.getContentType().equals(MediaType.APPLICATION_JSON_VALUE)) {
            BufferedReader br = null;
            try {
                br = new BufferedReader(new InputStreamReader(request.getInputStream(), "utf-8"));
                String line = null;
                StringBuilder sb = new StringBuilder();
                while ((line = br.readLine()) != null) {
                    sb.append(line);
                }
                JSONObject json = JSONObject.parseObject(sb.toString());
                System.out.println(json.toString());

                String username = json.getString("username");
                String password = json.getString("password");

                UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(username, password);
                this.setDetails(request, authRequest);
                return this.getAuthenticationManager().authenticate(authRequest);
            } catch (IOException e) {
                e.printStackTrace();
                response.getWriter().write(JSON.toJSONString(ResponseTemplate.builder().code(400).message("参数错误！").build()));
            }
        } else {
            return super.attemptAuthentication(request, response);
        }
        response.getWriter().write(JSON.toJSONString(ResponseTemplate.builder().code(400).message("参数错误！").build()));
        return null;
    }

    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response,
                                            FilterChain chain, Authentication authentication) throws IOException, ServletException {
        UserEntity user = (UserEntity) authentication.getPrincipal();
        String username = user.getUsername();
        List<GrantedAuthority> authorities = (List<GrantedAuthority>) user.getAuthorities();
        List<String> roles = authorities.stream().map(GrantedAuthority::getAuthority).collect(Collectors.toList());
        String token = jwtTool.CreateToken(String.valueOf(user.getId()), username, roles);
        response.setContentType("text/json;charset=utf-8");
        Map<String, Object> map = new HashMap<>();
        map.put("username", username);
        map.put("role", roles);
        map.put("token", token);
        response.getWriter().write(JSON.toJSONString(ResponseTemplate.builder().data(map).build()));

    }

    @Override
    protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
        response.setContentType("text/json;charset=utf-8");

        if (e instanceof UsernameNotFoundException || e instanceof BadCredentialsException) {
            response.getWriter().write(JSON.toJSONString(ResponseTemplate.builder().code(400).message("用户名或密码错误！").build()));
        } else if (e instanceof DisabledException) {
            response.getWriter().write(JSON.toJSONString(ResponseTemplate.builder().code(400).message("账户被禁用，请联系管理员！").build()));
        } else {
            response.getWriter().write(JSON.toJSONString(ResponseTemplate.builder().code(400).message("用户名或密码错误！").build()));

        }
    }

}

登录成功后，我们使用Jwt生成了一串Token并返还给用户，以后的所有请求都需要携带该Token，但Security 默认的是从Session中获取用户信息，显然也不符合我们的要求，所以下面我们要重写自己的Token过滤器。

需要实现BasicAuthenticationFilter接口，我们只需在doFilterInternal中做自己的逻辑即可，如果全部OK就放行该过滤器即可：

@Slf4j
public class JWTAuthenticationFilter extends BasicAuthenticationFilter {

    private JwtTool jwtTool;

    public JWTAuthenticationFilter(AuthenticationManager authenticationManager, JwtTool jwtTool) {
        super(authenticationManager);
        this.jwtTool = jwtTool;
    }

    public JWTAuthenticationFilter(AuthenticationManager authenticationManager, AuthenticationEntryPoint authenticationEntryPoint) {
        super(authenticationManager, authenticationEntryPoint);
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        response.setContentType("text/json;charset=utf-8");
        String token = request.getHeader("token");

        if (StringUtils.isEmpty(token)){
            response.getWriter().write(JSON.toJSONString(ResponseTemplate.builder().code(401).message("登录失效！").build()));
            return;
        }

        boolean isold = jwtTool.VerityToken(token);

        if (!isold) {
            response.getWriter().write(JSON.toJSONString(ResponseTemplate.builder().code(401).message("登录失效！").build()));
            return;
        }

        String username = jwtTool.getUserName(token);

        if (StringUtils.isEmpty(username)) {
            response.getWriter().write(JSON.toJSONString(ResponseTemplate.builder().code(401).message("登录失效！").build()));
            return;
        }

        List<String> roles = jwtTool.getUserRoles(token);
        if (roles.isEmpty()) {
            response.getWriter().write(JSON.toJSONString(ResponseTemplate.builder().code(403).message("权限不足！").build()));
            return;
        }
        List<GrantedAuthority> authorities = roles.stream().map(r -> new SimpleGrantedAuthority(r)).collect(Collectors.toList());
        UserEntity principal = new UserEntity();
        principal.setUsername(username);
        try {
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(principal, null, authorities);
            SecurityContextHolder.getContext().setAuthentication(authentication);
            String userid = jwtTool.getUserid(token);
            request.setAttribute("userid", userid);
            request.setAttribute("username", username);
//            request.setAttribute("role", role);
            chain.doFilter(request, response);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().write(JSON.toJSONString(ResponseTemplate.builder().code(401).message("登录失效！").build()));
        }
    }
}

上面我们重写了接受用户名密码，和校验Token的过滤器，显然已经符合我们前后端分离架构，但是还有一个就是无权限的返回，在上两篇就可以看出，无权限是返回的403错误，显然也不符合，应该要修改为JSON的返回。

我们可以实现AccessDeniedHandler这个接口，来做无权限自定义的返回：

@Component
public class AuthenticationAccessDeniedHandler implements AccessDeniedHandler {

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException)
            throws IOException, ServletException {
        response.setContentType("text/json;charset=utf-8");
        response.getWriter().write(JSON.toJSONString(ResponseTemplate.builder().code(403).message("权限不足！").build()));
    }

}

最后修改WebSecurityConfig，将上面的过滤器添加到Security 中，替换到默认的过滤器：

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

    @Autowired
    UserService userService;

    @Autowired
    CustomAccessDecisionManager customAccessDecisionManager;

    @Autowired
    CustomFilterInvocationSecurityMetadataSource customFilterInvocationSecurityMetadataSource;

    @Autowired
    AuthenticationAccessDeniedHandler authenticationAccessDeniedHandler;

    @Autowired
    JwtTool jwtTool;

    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userService).passwordEncoder(password());
    }

    @Bean
    PasswordEncoder password() {
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() {
                    @Override
                    public <O extends FilterSecurityInterceptor> O postProcess(O o) {
                        o.setSecurityMetadataSource(customFilterInvocationSecurityMetadataSource);
                        o.setAccessDecisionManager(customAccessDecisionManager);
                        return o;
                    }
                })
                .antMatchers("/**").fullyAuthenticated()
                .and()
                .formLogin()
                .loginProcessingUrl("/login")
                .permitAll()
                .and()
                .exceptionHandling()
                .accessDeniedHandler(authenticationAccessDeniedHandler)
                .and()
                .addFilter(new JWTAuthenticationFilter(authenticationManager(), jwtTool))
                .addFilter(new LoginAuthenticationFilter(authenticationManager(),jwtTool))
                .csrf().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }

    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/register/**");
    }

    @Bean
    RoleHierarchy roleHierarchy() {
        RoleHierarchyImpl roleHierarchy = new RoleHierarchyImpl();
        String hierarchy = "ROLE_admin > ROLE_user > ROLE_common";
        roleHierarchy.setHierarchy(hierarchy);
        return roleHierarchy;
    }
}

相比于上一次的修改，这里就是通过addFilter的方式添加我们的过滤器。

下面就可以启动项目，访问http://localhost:8080/admin/test测试接口：
在这里插入图片描述
直接就是返回登录失效了，下面我们使用PostMan登录：http://localhost:8080/login
在这里插入图片描述

可以看到这里我把权限也返回出来进行测试，表示该用户只能访问admin/**,下面我们使用Token访问http://localhost:8080/admin/test
在这里插入图片描述
如果访问common/**:
在这里插入图片描述
到这里就实现了使用Jwt Token的认证授权了。

在这里插入图片描述
喜欢的小伙伴可以关注我的个人微信公众号，获取更多学习资料！

小毕超
关注
专栏目录
【第八篇】SpringSecurity基于JWT实现Token
筱白爱学习！的博客
06-14 673
SpringBoot项目中基于SpringSecurity作为认证授权框架的情况下如何整合JWT来实现Token的处理
Springboot整合Spring security+Oauth2+JWT搭建认证服务器，网关，微服务之间权限认证及授权
04-22
Springboot整合Spring security+Oauth2+JWT搭建认证服务器，网关，微服务之间权限认证及授权
SpringSecurity之JWT实现token认证和授权.zip
08-09
在Web应用开发中，安全一直是非常重要的一个方面。Spring Security基于Spring 框架，提供了一套Web应用安全性的完整解决方案。
Spring Boot整合Spring Security+JWT+OAuth 2.0 实现认证鉴权登录（框架介绍）
最新发布
weixin_49999835的博客
08-30 1364
该模式针对客户端而言，对用户是透明的，不需要用户参与，非用户层面授权。客户端向授权服务器发送自己的的 client_id 和client_secrect 请求 access_token ，用户中心仅校验客户端应用身份。客户端通过授权后可以获得授权范围内所有用户的信息，对客户端应用需要极高的信任。
SpringSecurity+Jwt实现token权限验证
weixin_43671737的博客
07-02 2357
1，首先先贴一下项目结构更容易梳理思路，文章较长请细心阅读。 2.创建User用户和UserPermissons用户权限实体类，在生成token时会需要用户的账号密码和权限。还需要几个工具类，现在一步步为大家展示。 yml配置文件 # 端口 server: port: 8080 # 数据库连接配置 spring: datasource: driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3
Spring Security + JWT 实现基于Token的安全验证
热门推荐
huanghuitan的博客
05-16 2万+
Spring Security + JWT 实现基于token的安全验证 准备工作 使用Maven搭建SpringMVC项目，并加入Spring Security的实现 参考: Spring SecurityJWT官网 JWT简介 参考：JWT简介 JWT的结构 JWT包含了使用 . 分隔的三部分： 1.Header 头部，
3.Spring Security实现JWT token验证，GrantedAuthority接口，权限注解（@prePostEnabled、@Secured、@jsr250E）
相互学习 共同进步
04-24 3702
Component@Autowired/*** hasPermission鉴权方法* 这里仅仅判断PreAuthorize注解中的权限表达式* 实际中可以根据业务需求设计数据库通过targetUrl和permission做更复杂鉴权* 当然targetUrl不一定是URL可以是数据Id还可以是管理员标识等,这里根据需求自行设计* @Param authentication 用户身份(在使用hasPermission表达式时Authentication参数默认会自动带上)
Spring-Security & JWT 实现 token
天行健，君子以自强不息；地势坤，君子以厚德载物。
07-23 2367
一、JWT//www.ruanyifeng.com/blog/2018/07/json_web_token-tutorial.html二、项目环境搭建2.1 引入依赖pom.xml<dependencies> <dependency> <groupId>javax.xml.bind</gro...
SpringBoot-JWT-Token:JWT令牌，Spring-Security
03-22
本篇文章将深入探讨如何在Spring Boot应用中结合Spring Security实现JWT令牌的认证和授权。 首先，JWT令牌是一种轻量级的身份验证标准，它允许信息在多个服务之间安全地传输，而无需在服务器上存储会话信息。JWT...
spring-security-jwt-demo.zip
11-19
《Spring Security与JWT整合实战详解》 在现代Web应用程序中，安全性和用户认证是至关重要的。Spring Security作为Java领域中最受欢迎的安全框架，为开发者提供了强大的安全解决方案。而JSON Web Token（JWT）则是...
spring security token认证_认证与授权，SpringSecurity与Token实现登录认证
weixin_39876592的博客
12-02 2105
简介Web 应用的安全性包括用户认证（Authentication）和用户授权（Authorization）两个部分。认证用户认证指的是验证某个用户是否为系统中的合法主体，也就是说用户能否访问该系统。用户认证一般要求用户提供用户名和密码。系统通过校验用户名和密码来完成认证过程。认证成功后将生成一个Token返回前端，供后续操作的验证。授权用户授权指的是验证某个用户是否有权限执行某个操作。在一个系统...
SpringSecurity Jwt Token 自动刷新的实现
08-19
主要介绍了SpringSecurity Jwt Token 自动刷新的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
【第十一篇】SpringSecurity基于JWT实现Token的处理
yqqの博客
03-18 783
在SpringSecurity中的认证是通过UsernamePasswordAuthenticationFilter来处理的，现在我们要通过JWT来处理，那么我们就需要重写其中几个处理的方法然后就是当客户端提交请求，我们需要拦截请求检查header头中是否携带了对应的Token信息，并检查是否合法。/*** 校验Token是否合法的Filter//如果携带错误的token，则给用户提示请登录！resultMap . put("msg" , "请登录！");} else {
SpringBoot 整合Spring Security（二）JWT Token认证 及认证思路分析
Lyndon的专栏
08-04 1322
单点登录相关
Spring Security的项目中集成JWT Token令牌安全访问后台API
BASK2312的博客
12-29 1163
首先，让我们来补一下jwt的知识。jwt token的全称叫，主要用于在各方之间以JSON 对象方式安全地传输信息。此信息是数字签名的，可以验证和信任，JWT 可以使用密钥（使用HMAC算法）或使用RSA或ECDSA的公钥/私钥对进行签名。虽然 JWT 可以加密以在各方之间提供保密性，但我们将专注于签名令牌。签名的令牌可以验证其中包含的声明的完整性，而加密的令牌会向其他方隐藏这些声明。当使用公钥/私钥对对令牌进行签名时，只有持有私钥的一方才可以签署。
spring boot中常用的安全框架 Security框架 利用Security框架实现用户登录验证token和用户授权（接口权限控制）
Json的知识梦工厂
07-23 5133
org.springframework.security.crypto.password.PasswordEncoder 接口。
Spring Security + JWT 实现基于token的登录验证
weixin_41037842的博客
04-11 2875
一、JWT JWT：json web token，是目前最流行的一个跨域认证解决方案：客户端发起用户登录请求，服务器端接收并认证成功后，生成一个 JSON 对象，然后将其返回给客户端。 基于spring security实现登录认证 基础配置 /** * @Description 安全配置 * @Date * */ @Configuration @EnableWebSecurity @EnableGlobalMethodSecurity(prePostEnabled = true) public
SpringSecurity整合JWT
胡峻峥的博客
01-19 1110
一、前言 　　最近负责支付宝小程序后端项目设计，这里主要分享一下用户会话、接口鉴权的设计。参考过微信小程序后端的设计，会话需要依靠redis。相关的开发人员和我说依靠Redis并不是很靠谱，redis在业务高峰期不稳定，容易出现问题，总会出现用户会话丢失、超时的问题。之前听过JWT相关的设计，决定尝试一下。 二、什么是JWT 　　JSON Web Token（JWT）是一个开放标准（RFC ...
SpringSecurity——整合JWT
qq_41297145的博客
12-30 2475
在第4步中，通过增加JwtFilter过滤器来验证身份，允许前端通过携带正确且未过期的JwtToken进行身份验证，验证时需要同样需要通过LoadUserByUsername方法获取UserDetails对象（Principal对象），然后创建一个UsernamePasswordAuthenticationToken对象给SecurityContextHolder验证，如果和步骤2中写入的authentication一致，即验证成功，正确获取到用户权限。自定义JwtFilter拦截器，
spring-security-jwt 版本对照表
09-18
spring-security-jwt 是一个基于 Spring Security 的 JSON Web Token（JWT）集成库。它将 JWT 的认证和授权过程与 Spring Security 进行了深度集成，方便开发人员使用 JWT 进行身份验证和权限控制。 以下是 spring-security-jwt 的版本对照表： - 版本1.0.0：最初发布的版本，提供了基本的 JWT 支持，包括 JWT 的生成、解析和校验。 - 版本1.1.0：在1.0.0版本的基础上进行了一些改进，增加了对 JWT 的加密和解密功能，提供了更加安全的身份验证和授权机制。 - 版本1.2.0：引入了一些新的特性，包括对 JWT 的刷新和延长过期时间的支持，使得 JWT 的使用更加灵活和方便。 - 版本2.0.0：在1.x 版本的基础上进行了重构，提供了更加简洁和易用的 API 接口，优化了性能和稳定性。 - 版本2.1.0：在2.0.0版本的基础上增加了对 OAuth2 的支持，使得开发人员可以更方便地集成第三方身份验证和授权服务。 以上是针对 spring-security-jwt 的一些常见版本，每个版本都有不同的功能和改进。开发人员可以根据自己的需求选择合适的版本，并且可以从官方文档中获取更详细的版本说明和用法示例。
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小毕超

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值