SpringBoot + SpringSecurity+JWT整合（微服务适用）

最新推荐文章于 2024-04-20 11:00:00 发布
最新推荐文章于 2024-04-20 11:00:00 发布
阅读量1.1k 收藏 6
点赞数 3
文章标签： java spring boot jwt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42372860/article/details/120497844
版权

SpringSecurity基于表单的登录认证流程如下图：

大致过程是在UsernamePasswordAuthenticationFilter将username和password封装成UsernamePasswordAuthenticationToken，之后会在AuthenticationProvider（接口，需要自己实现）的authenticate方法中拿到且校验（一般是查数据库，对比账号密码），而校验成功则返回Authentication接口对象（一般情况是直接返回UsernamePasswordAuthenticationToken，该对象会默认记录在session以及SecurityContextHolder的SecurityContext中）随后走认证成功流程（一般会实现AuthenticationSuccessHandler接口），否则就抛异常走认证失败流程（一般会实现AuthenticationFailureHandler接口）。

以上是普通单体项目的认证过程，那么整合JWT或者说微服务则会有以下问题：

  1.  在哪里生成JWT？
  2. 如何解释前端传来的JWT字符串获取到用户信息？
  3. 认证成功后如何去除Session信息？（JWT是无状态的，不需要服务器端保存）JWT的详情参考

对于第一个问题，很好解决，在AuthenticationProvider认证成功后不返回UsernamePasswordAuthenticationToken，返回自定义的JwtAuthenticationToken，然后在自定义的LoginSuccessHandler返回给前端即可，代码如下：

//JWT中荷载存储内容的实体类
@Data
public class UserDetails {
    private String userId;
    private String username;
    private String portrait;
}
//用来生成和解释Token字符串，这里采用了单例模式，相当于JwtUtils
public class UserTokenManager {
    private final String SECRET = "happy-king";
    private static volatile UserTokenManager userTokenManager;

    private UserTokenManager() {
    }

    public static UserTokenManager getInstance() {
        if (userTokenManager == null) {
            synchronized (UserTokenManager.class) {
                if (userTokenManager == null) {
                    userTokenManager = new UserTokenManager();
                }
            }
        }
        return userTokenManager;
    }

    @SuppressWarnings("unchecked")
    public String generateToken(UserDetails userDetails, long timeout) {
        long currentTimeMillis = System.currentTimeMillis();
        return JWT.create()
                .withJWTId(UUID.randomUUID().toString())
                .withIssuedAt(new Date(currentTimeMillis))
                .withClaim("user_id", userDetails.getUserId())
                .withClaim("username", userDetails.getUsername())
                .withClaim("portrait", userDetails.getPortrait())
                .withExpiresAt(new Date(currentTimeMillis + timeout))
                .sign(Algorithm.HMAC256(SECRET));
    }

    public String generateToken(UserDetails userDetails) {
        return generateToken(userDetails, 1000 * 24 * 60 * 60L);
    }

    public UserDetails parseToken(String token) {
        try {
            DecodedJWT decodedJWT =         JWT.require(Algorithm.HMAC256(SECRET)).build().verify(token);
            Date issuedAt = decodedJWT.getIssuedAt();
            if (issuedAt.before(new Date())) {
                String userId = decodedJWT.getClaim("user_id").asString();
                String username = decodedJWT.getClaim("username").asString();
                String portrait = decodedJWT.getClaim("portrait").asString();
                UserDetails userDetails = new UserDetails();
                userDetails.setUsername(username);
                userDetails.setUserId(userId);
                userDetails.setPortrait(portrait);
                return userDetails;
            } else {
                return null;
            }
        } catch (Exception e) {
            return null;
        }
    }
}
//自定义的Authentication类
public class JwtAuthenticationToken  extends AbstractAuthenticationToken {
    private final UserDetails userDetails;
    private final UserTokenManager userTokenManager = UserTokenManager.getInstance();

    public JwtAuthenticationToken(UserDetails userDetails,
            Collection<? extends GrantedAuthority> authorities) {
        super(authorities);
        this.userDetails = userDetails;
    }

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

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

    public String generateJWT(){
        return userTokenManager.generateToken(userDetails);
    }
}
//登录认证主要逻辑类
public class AuthenticationProvider implements org.springframework.security.authentication.AuthenticationProvider {
    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        UsernamePasswordAuthenticationToken token = (UsernamePasswordAuthenticationToken) authentication;
        //获取账号密码
        String username = (String) token.getPrincipal();
        String password = (String) token.getCredentials();
        //省略了查数据库以及对比流程

        UserDetails userDetails = new UserDetails();
        userDetails.setUsername(username);
        userDetails.setUserId(UUID.randomUUID().toString());
        //在微服务中，角色和权限信息要保存在Redis中
        SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority("ROLE_xx");
         JwtAuthenticationToken jwtAuthenticationToken = new JwtAuthenticationToken(userDetails, Collections.singleton(simpleGrantedAuthority));
        //必须设置为认证成功
        jwtAuthenticationToken.setAuthenticated(true);
        return jwtAuthenticationToken;
    }

    @Override
    public boolean supports(Class<?> authentication) {
        return authentication == JwtAuthenticationToken.class || authentication == UsernamePasswordAuthenticationToken.class;
    }
}
//然后登录成功直接写token响应到前端即可
public class LoginSuccessHandler implements AuthenticationSuccessHandler {
    private final ObjectMapper objectMapper;
    public LoginSuccessHandler(ObjectMapper objectMapper){
        this.objectMapper = objectMapper;
    }

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        JwtAuthenticationToken jwtAuthenticationToken = (JwtAuthenticationToken) authentication;
        response.setContentType("application/json;charset=utf-8");
        HashMap<String, Object> map = new HashMap<>();
        map.put("token", jwtAuthenticationToken.generateJWT());
        String result = objectMapper.writeValueAsString(map);
        response.getWriter().write(result);
    }
}

需要注意必须执行以下代码：

JwtAuthenticationToken jwtAuthenticationToken = new JwtAuthenticationToken(userDetails, Collections.singleton(simpleGrantedAuthority));
jwtAuthenticationToken.setAuthenticated(true);

因为除了认证接口外，其他所有需要授权（）的接口都会被AbstractSecurityInterceptor拦截，里面有一个authenticateIfRequired方法，如果没有调用

jwtAuthenticationToken.setAuthenticated(true);则会重新进行用户认证。源码如下：

private Authentication authenticateIfRequired() {
		Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
		if (authentication.isAuthenticated() && !this.alwaysReauthenticate) {
			if (this.logger.isTraceEnabled()) {
				this.logger.trace(LogMessage.format("Did not re-authenticate %s before authorizing", authentication));
			}
			return authentication;
		}
		authentication = this.authenticationManager.authenticate(authentication);
		// Don't authenticated.setAuthentication(true) because each provider does that
		if (this.logger.isDebugEnabled()) {
			this.logger.debug(LogMessage.format("Re-authenticated %s before authorizing", authentication));
		}
		SecurityContextHolder.getContext().setAuthentication(authentication);
		return authentication;
	}

第二个问题则需要用到SpringSecurity中的拦截器，我们需要自定义一个JwtFilter，并且将其加入到UsernamePasswordAuthenticationFilter之后，代码如下：

public final class JwtFilter  extends GenericFilterBean {
    private final static String BEARER = "bearer";

    private final UserTokenManager userTokenManager = UserTokenManager.getInstance();

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        doFilter((HttpServletRequest) request, (HttpServletResponse) response, chain);
    }

    /**
*以下抛出的异常你可以改为写出JSON响应
**/
    private void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication != null) {
            chain.doFilter(request, response);
            return;
        }
        String bearer = request.getHeader(BEARER);
        if (bearer == null || bearer.isEmpty()){
            bearer = request.getParameter(BEARER);
        }
        if (bearer == null || bearer.isEmpty()){
            //没有登录
            throw new AuthenticationCredentialsNotFoundException("没有用户凭证");
        }else{
            UserDetails userDetails = userTokenManager.parseToken(bearer);
            if (userDetails == null){
                throw new CredentialsExpiredException("用户凭证失效");
            }
            //微服务项目角色权限信息需要重Redis中获取，这里只是模拟
            SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority("ROLE_xx");
            JwtAuthenticationToken jwtAuthenticationToken = new JwtAuthenticationToken(userDetails, Collections.singleton(simpleGrantedAuthority));
            jwtAuthenticationToken.setAuthenticated(true);
            //注意要将解释出来的JwtAuthenticationToken信息保存到SecurityContext中
            SecurityContextHolder
                    .getContext()
                    .setAuthentication(jwtAuthenticationToken);
        }
        chain.doFilter(request, response);
    }
}

至此单体项目整合SpringSecurit 和JWT登录已经完成，用户登录成功后，SecurityContextPersistenceFilter中的SecurityContextRepository（默认实现是HttpSessionSecurityContextRepository）会将JwtAuthenticationToken写到session中。但是因为JWT用于分布式系统或者微服务的，所以我们不能用Session来管理，只需要修改默认的HttpSessionSecurityContextRepository为NullSecurityContextRepository并关闭session管理即可。

代码如下：

 @Override
    protected void configure(HttpSecurity http) throws Exception {
            //移除默认登录页面
        http.removeConfigurer(DefaultLoginPageConfigurer.class);
        //关闭csrf
        http.csrf().disable()
//关闭请求缓存
                .requestCache().disable()
//关闭session管理
                .sessionManagement().disable()
//修改SecurityContextRepository
.securityContext().securityContextRepository(new NullSecurityContextRepository()).and()
                .addFilterAfter(new JwtFilter(), UsernamePasswordAuthenticationFilter.class)
                
                .authorizeRequests().anyRequest().permitAll().and()
                .formLogin()
                .loginPage("/login")
                .failureHandler(new LoginFailureHandler(objectMapper))
                .successHandler(new LoginSuccessHandler(objectMapper))
                .permitAll()
                .and()
                .httpBasic();
    }

 至此，整合工作已经完毕，下面提供了代码下载地址，以上流程和WebSecurityConfigurerAdapter的实现配置用于用户微服务，然后在不同的服务下定义不同的WebSecurityConfigurerAdapter然后设置formLogin().disable()即可

示例代码下载

 

 

 

 

披星戴月123
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
SpringBoot+SpringSecurity+Jwt权限认证---认证
python6_quanzhan的博客
12-10 504
1. 整体逻辑 1. SpringSecurity认证的逻辑规则 启动项目时，SpringBoot自动检索所有带@Configuration的注解，所以就将我们的WebSecurityConfig给加载了，这个config中，我们需要在configure(AuthenticationManagerBuilder auth)方法中注册一个继承自UserDetailsService的接口，这个接口中只有一个方法，那就是使用username获取到数据库中用户信息并返回成UserDetail实体。这个方法需要.
SpringBoot整合SpringSecurity、JWT
weixin_39585914的博客
11-10 1327
文章目录 前言 一、pom.xml添加Maven依赖 二、类实现 1.类配置 2.JWT工具 3.application.yaml配置 三、控制层 四、服务层 五、数据库 六、Postman测试 前言 学习笔记 一、pom.xml添加Maven依赖 <!--SpringSecurity依赖配置--> <dependency> <groupId>org.spring...
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证
08-26
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证，可根据注解的格式不同，做到角色权限控制，角色加资源权限控制等，粒度比较细化。 @PreAuthorize("hasAnyRole('ADMIN','USER')")：具有admin或user角色的用户可以访问。 @PreAuthorize("hasRole('ADMIN') and hasRole('USER')"):具有admin和user角色的用户可以访问 文章地址：https://blog.csdn.net/fuu123f/article/details/108233463
详细！SpringBoot整合SpringSecurity实现JWT认证
MarkerHub的博客
01-02 1115
小Hub领读：最近做了个security项目，参考了一下这个例子，还可以作者：智慧zhuhuixhttps://blog.csdn.net/jpgzhu/article/details/...
Spring Boot 3 + JWT + Security 联手打造安全帝国：一篇文章让你掌握未来！
最新发布
wangluoanquan111的博客
04-20 720
已经成为java后台权限校验的第一选择.今天就通过读代码的方式带大家深入了解一下Security,本文主要是基于开源项目[spring-security)来讲解Spring Security + JWT(Json Web Token).实现用户鉴权,以及权限校验.所有代码基于jdk17+构建.现在让我们开始吧!BCryptMaven从时代发展的角度看，网络安全的知识是学不完的，而且以后要学的会更多，同学们要摆正心态，既然选择入门网络安全，就不能仅仅只是入门程度而已，能力越强机会才越多。
SpringBoot整合SpringSecurity+JWT
qq_43975645的博客
07-18 641
注意：SIGNATURE是生成token的公钥，当外部token进来时需要公钥解密。
SpringBoot中使用SpringSecurity+JWT
qq_42757083的博客
04-05 634
一、JWT 前提知识 1.1. 对称加密，非对称加密，加盐。 1.2. 报文鉴别，数字签名，身份认证等数据安全。 1.3. jwt介绍 JWT的作用 2.1. 就是把签证解密之后与头部和载荷对应，从而确认身份。 二、SpringSecurity 前提知识 1.1. 了解是什么，知道自定义登陆等 三、实践 添加依赖 <!-- springSecurity依赖：安全框架--> <dependency>
详解SpringBoot+SpringSecurity+jwt整合及初体验
08-25
主要介绍了详解SpringBoot+SpringSecurity+jwt整合及初体验，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Springboot+SpringSecurity+JWT实现用户登录和权限认证示例
08-19
主要介绍了Springboot+SpringSecurity+JWT实现用户登录和权限认证示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
springBoot + SpringSecurity + JWT（适用微服务）
09-26
springBoot + SpringSecurity + JWT（适用微服务）
springboot+security+mybatis+redis+jwt，鉴权框架搭建
06-22
本项目集成了springboot+security+mybatis+redis+jwt用于学习security鉴权功能，其中有集成了redis，mybatis，jasypt，jwt，thymeleaf，knife4j，mybatis-plus 项目搭建已经比较成熟，能够直接进行使用，通过代码...
微服务项目构建认证中心（SpringSecurity+JWT）
何故的博客
01-09 1118
前言，毕设项目中，由于只考虑web端的，没考虑客户端，所以没有用oauth2（其实也是因为没掌握，尴尬） 一、项目准备 父项目，建立统一管理，pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:
SpringBoot整合SpringSecurity实现JWT认证
热门推荐
我的博客
03-30 3万+
前言 微服务架构，前后端分离目前已成为互联网项目开发的业界标准，其核心思想就是前端（APP、小程序、H5页面等）通过调用后端的API接口，提交及返回JSON数据进行交互。 在前后端分离项目中，首先要解决的就是登录及授权的问题。微服务架构下，传统的session认证限制了应用的扩展能力，无状态的JWT认证方法应运而生，该认证机制特别适用于分布式站点的单点登录（SSO）场景 目录 该文会通过创建...
SpringBoot整合Spring Security + JWT
LIUUUU
04-15 1559
版本 SpringBoot:2.2.5.RELEASE jjwt:0.9.0 Jdk:1.8 Maven:3.5.2 Idea:2019.3 依赖 项目pom.xml文件中引入Spring Security和Jwt的依赖坐标 <dependency> <groupId>org.springframework.boot</groupId> &l...
spring boot + spring security + Jwt
qq_36722687的博客
06-30 348
spring boot + spring security + Jwt主要依赖标题新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 主要依赖 <dependency> <grou
SpringBoot和SpringSecurity整合一下JWT
qq_1641486826的博客
12-03 824
上一篇写了SpringBoot整合SpringSecurity实现了登录认证和授权，但是SpringSecurity是把用户信息存储在session中的。对服务器有一定的压力，所以目前JWT这种服务无状态的校验方式比较流行 我接着上篇的代码改进，将JWT融合进去 首先导入JWT的maven坐标，我使用的是jjwt <properties> <java.version>1.8</java.version> <jjwt.versio
Spring boot 整合 spring Secrity 整合 JWT验证
m0_63884706的博客
05-13 176
创建 spring boot 项目 并 引入springSecrity所需依赖 <!--SpringSecurity启动器--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> 创建一个 Controlle...
SpringBoot整合Spring Security + JWT实现用户认证
leveretz的博客
07-13 1570
SpringBoot整合Spring Security + JWT实现用户认证
springboot集成springsecurity + jwt的使用
hjh15827475896的博客
06-07 1619
当项目中要用到用户的认证及权限的时候我们一般会使用 springSecurity来解决。
SpringBoot+SpringSecurity+JWT
09-19
在SpringBoot和SpringSecurity的结合中，可以使用JWT来实现认证和授权的功能。 为了在SpringBoot中使用SpringSecurity和JWT，你需要进行以下几个步骤： 1. 引入相关依赖：在项目的pom.xml文件中添加SpringSecurity...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值