SpringSecurity整合JWT实现访问控制

置顶 已于 2023-10-13 21:27:02 修改
阅读量1.5k 收藏 5
点赞数 1
分类专栏： java # SpringBoot spring 文章标签： java spring boot
于 2022-07-12 17:10:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43626356/article/details/125743433
版权
java 同时被 3 个专栏收录
68 篇文章 0 订阅
订阅专栏
SpringBoot
21 篇文章 0 订阅
订阅专栏
spring
15 篇文章 0 订阅
订阅专栏

Spring Security + JWT实现访问控制

前置知识点

整体流程

  1. 用户向服务器发送用户名、密码以及验证码用于登陆系统。
  2. 如果用户用户名、密码以及验证码校验正确的话，服务端会返回已经签名的 Token，也就是 JWT。
  3. 用户以后每次向后端发请求都在 Header 中带上这个 JWT 。
  4. 服务端检查 JWT 并从中获取用户相关信息。

如下图所示：
在这里插入图片描述

JWT （JSON Web Token）简单介绍

本文主要利用JWT实现登录授权，一旦登录之后，就返回给前端一个Token，利用Token进行信息交互。

Token由三部分组成：Header、Payload、Signature。

  • Header：通常由两部分组成：
    • typ（Type）：令牌类型，也就是 JWT。
    • alg（Algorithm） ：签名算法，比如 HS256。
  • Payload：Payload 也是 JSON 格式数据，其中包含了 Claims(声明，包含 JWT 的相关信息)。一般不存放隐私信息。
  • Signature：Signature 部分是对前两部分的签名，作用是防止 JWT（主要是 payload） 被篡改。

Spring Security 简单流程介绍

翻看源码可知，Spring Security通过职责链模式，通过各类XXXFilter对请求进行了拦截。实际操作时经常需要实现XXXFilter来自定义的登录以及访问控制。在这里插入图片描述

具体实现（仅展示关键实现类）

测试接口

/**
 * @author qyl
 * @program HelloController.java
 * @Description Test for diff auths
 * @createTime 2022-07-12 10:24
 */
@RestController
@RequestMapping("/test")
public class TestController {
    @ApiOperation(value = "hello")
    @PostMapping("hello")
    @PreAuthorize("hasAuthority('hello')")
    public R hello() {
        return R.ok().data("hello", "hello");
    }

    @ApiOperation(value = "manage")
    @PostMapping("manage")
    @PreAuthorize("hasAuthority('manage')")
    public R manage() {
        return R.ok().data("manage", "manage");
    }
}

自定义访问过滤器：

/**
 * <p>
 * 访问过滤器
 * 首先获取header中的token 判断是否已经登录；
 * 1.没登陆 抛异常
 * 2.登录过了 就将授权信息一起放入安全上下文中
 * </p>
 *
 * @author qyl
 * @since 2022-7-09
 */
public class TokenAuthenticationFilter extends BasicAuthenticationFilter {
    private TokenManager tokenManager;
    private RedisTemplate redisTemplate;

    public TokenAuthenticationFilter(AuthenticationManager authManager, TokenManager tokenManager,RedisTemplate redisTemplate) {
        super(authManager);
        this.tokenManager = tokenManager;
        this.redisTemplate = redisTemplate;
    }
	
    @Override
    protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain chain)
            throws IOException, ServletException {

        UsernamePasswordAuthenticationToken authentication = null;
        authentication = getAuthentication(req);

        if (authentication != null) {
            SecurityContextHolder.getContext().setAuthentication(authentication);
        } else {
            ResponseUtil.out(res, R.error());
        }
        chain.doFilter(req, res);
    }

    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
        // token置于header里
        String token = request.getHeader("token");
        if (token != null && !"".equals(token.trim())) {
            String userName = tokenManager.getUserFromToken(token);

            List<String> permissionValueList = (List<String>) redisTemplate.opsForValue().get(userName);
            Collection<GrantedAuthority> authorities = new ArrayList<>();
            for(String permissionValue : permissionValueList) {
                if(StringUtils.isEmpty(permissionValue)) continue;
                SimpleGrantedAuthority authority = new SimpleGrantedAuthority(permissionValue);
                authorities.add(authority);
            }

            if (!StringUtils.isEmpty(userName)) {
                return new UsernamePasswordAuthenticationToken(userName, token, authorities);
            }
            return null;
        }
        return null;
    }
}

自定义登录过滤器：

/**
 * <p>
 * 登录过滤器，继承UsernamePasswordAuthenticationFilter，
 * 通过对Post发送的/login请求进行拦截，对用户名密码进行登录校验
 * </p>
 *
 * @author qyl
 * @since 2022-7-09
 */
public class TokenLoginFilter extends UsernamePasswordAuthenticationFilter {

    private AuthenticationManager authenticationManager;
    private TokenManager tokenManager;
    private RedisTemplate redisTemplate;

    public TokenLoginFilter(AuthenticationManager authenticationManager, TokenManager tokenManager, RedisTemplate redisTemplate) {
        this.authenticationManager = authenticationManager;
        this.tokenManager = tokenManager;
        this.redisTemplate = redisTemplate;
        this.setPostOnly(false);
        this.setRequiresAuthenticationRequestMatcher(new AntPathRequestMatcher("/login","POST"));
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse res)
            throws AuthenticationException {
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);
        return authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword(), new ArrayList<>()));
    }

    /**
     * 登录成功将用户信息放入redis中： 
     *    username 作为 key
     *    permissionValueList 作为 value
     * 之后将token返回以便在访问控制时从redis中取出权限，实现访问控制
     * 
     * @param req
     * @param res
     * @param chain
     * @param auth
     * @throws IOException
     * @throws ServletException
     */
    @Override
    protected void successfulAuthentication(HttpServletRequest req, HttpServletResponse res, FilterChain chain,
                                            Authentication auth) throws IOException, ServletException {
        SecurityUser user = (SecurityUser) auth.getPrincipal();
        String token = tokenManager.createToken(user.getCurrentUserInfo().getUsername());
        redisTemplate.opsForValue().set(user.getCurrentUserInfo().getUsername(), user.getPermissionValueList());
        ResponseUtil.out(res, R.ok().data("token", token));
    }

    /**
     * 登录失败
     * @param request
     * @param response
     * @param e
     * @throws IOException
     * @throws ServletException
     */
    @Override
    protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response,
                                              AuthenticationException e) throws IOException, ServletException {
        ResponseUtil.out(response, R.error());
    }
}

自定义登录过程中账号密码查询方式（不写就不好从数据库获取账号密码）

/**
 * <p>
 * 自定义userDetailsService - 认证用户详情
 * </p>
 */

@Service("userDetailsService")
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserService userService;

    @Autowired
    private PermissionService permissionService;

    /***
     * 根据账号获取用户信息
     * @param username:
     * @return: org.springframework.security.core.userdetails.UserDetails
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 从数据库中取出用户信息
        User user = userService.selectByUsername(username);

        // 判断用户是否存在
        if (null == user){
            throw new UsernameNotFoundException("用户名不存在！");
        }
        // 返回UserDetails实现类
        User curUser = new User();
        BeanUtils.copyProperties(user,curUser);

        List<String> authorities = permissionService.selectPermissionValueByUserId(user.getId());
        SecurityUser securityUser = new SecurityUser(curUser);
        securityUser.setPermissionValueList(authorities);
        return securityUser;
    }

Security 配置类

/**
 * <p>
 * Security配置类
 * </p>
 *
 * @author qyl
 * @since 2022-7-09
 */
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private UserDetailsService userDetailsService;
    private TokenManager tokenManager;
    private DefaultPasswordEncoder defaultPasswordEncoder;
    private RedisTemplate redisTemplate;

    @Autowired
    public SecurityConfig(UserDetailsService userDetailsService, DefaultPasswordEncoder defaultPasswordEncoder,
                          TokenManager tokenManager, RedisTemplate redisTemplate) {
        this.userDetailsService = userDetailsService;
        this.defaultPasswordEncoder = defaultPasswordEncoder;
        this.tokenManager = tokenManager;
        this.redisTemplate = redisTemplate;
    }

    /**
     * 配置设置
     *
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.exceptionHandling()			// 如果有异常 直接就抛出 不再跳转到登录页面
                .authenticationEntryPoint(new UnauthorizedEntryPoint())
                .and().csrf().disable()		//关闭csrf
                .authorizeRequests()		
                .anyRequest().authenticated()	// 对所有的请求都进行验证
                .and().addFilter(new TokenLoginFilter(authenticationManager(), tokenManager, redisTemplate))					// 增加两个过滤器 职责链模式
                .addFilter(new TokenAuthenticationFilter(authenticationManager(), tokenManager, redisTemplate)).httpBasic();
    }

    /**
     * 密码处理 这里通过注入的userDetailsService来实现Form传来的账号密码与数据库账号密码进行比对
     *
     * @param auth
     * @throws Exception
     */
    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(defaultPasswordEncoder);
    }

    /**
     * 配置哪些请求不拦截
     *
     * @param web
     * @throws Exception
     */
    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/swagger-ui.html", "/swagger-resources/**", "/webjars/**", "/v2/**", "/api/**");
    }
}

实际运行流程解析

访问控制流程解析

  1. 发送一个hello请求在这里插入图片描述
  2. 进入TokenAuthenticationFilter判断用户是否登录 如果存在token了（已经登录了），就把用户权限封装到UsernamePasswordAuthenticationToken中，把该UsernamePasswordAuthenticationToken放入安全信息上下文，以便后面存取。在这里插入图片描述
  3. 之后执行下一个Filter在这里插入图片描述
  4. 最后进入SecurityContextPersistenceFilter，即在所有的Filter执行完毕后，把安全信息保存起来，做个持久化在这里插入图片描述
  5. 当保存完安全信息之后就放行，开始请求TestController接口中的hello方法，并开始权限验证。在这里插入图片描述
    在这里插入图片描述
    整个过程就是这样，这里test用户没有manage权限，请求自然失败了。在这里插入图片描述在这里插入图片描述

登录流程解析

  1. 发送post请求
    在这里插入图片描述
  2. 进入TokenLoginFilter把信息传入ProviderManager中进行数据校验。在这里插入图片描述
    这里用到了上述我们自定义的UserDetailsService来查询信息。
    在这里插入图片描述
  3. 在比对成功之后就进入successfulAuthentication方法，实现自己的一些业务逻辑。
    在这里插入图片描述
  4. 再看redis已经将username和permissionList存进去了在这里插入图片描述

总结

JWT需要注意细节：

  1. 使用安全系数高的加密算法。
  2. 使用成熟的开源库，没必要造轮子。
  3. JWT 存放在 localStorage 中而不是 Cookie 中，避免 CSRF 风险。
  4. 一定不要将隐私信息存放在 Payload 当中。密钥一定保管好，一定不要泄露出去。
  5. JWT 安全的核心在于签名，签名安全的核心在密钥。
  6. Payload 要加入 exp （JWT 的过期时间），永久有效的 JWT 不合理。并且，JWT 的过期时间不易过长。

完整代码链接

github代码链接

邱可爱
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringSecurity整合Jwt过程图解
08-25
通过上述步骤，我们可以实现SpringSecurity整合Jwt的过程图解，从而实现更加安全、灵活的身份验证机制。 知识点： * SpringSecurity：是一个基于Java的安全框架，提供了强大的身份验证和授权机制。 * Jwt（Json ...
SpringBoot2.6整合SpringSecurity+JWT
01-11
**三、SpringBoot 2.6与Spring Security整合** 1. **添加依赖**：首先，在`pom.xml`文件中引入Spring Security和JWT的相关依赖，如`spring-security-oauth2-jose`和`jjwt`库。 2. **配置Spring Security**：创建一...
【深入浅出 Spring Security（十三）】使用 JWT 进行前后端分离认证（附源码）
qq_63691275的博客
07-07 3872
使用JWT进行前后端分离认证实现，其后端主要实现其实就是分为俩步（在已经封装好JWT生成和验证工具类的基础上），第一步就是登录认证成功后如何将生成的 jwt 响应给前端？——在AuthenticationSuccessHandler中进行实现；第二步就是前端携带该 jwt 向服务器端发送请求后，如何去认证该请求？——去重写BasicAuthenticationFilter中的doFilterInternal方法，在此方法中进行认证即可...
SpringBoot2.7.X整合SpringSecurity+JWT（入门级简单易懂）
zyyxiaoxiao的博客
04-12 4453
SpringBoot2.7.9整合SpringSecurity+JWT、入门级简单易懂
Spring Security 超详细整合 JWT
最新发布
2401_86138300的博客
07-02 314
Spring Security是一个功能强大并且高度可定制的Java安全框架，用于保护基于Spring的应用程序。JWT（JSON Web Tokens）是一种用于在网络应用环境间传递声明的一种紧凑的、URL安全的方式。将Spring Security与JWT整合可以为应用程序提供一个安全且高效的认证机制。整合Spring Security和JWT涉及到许多细节，上述步骤提供了一个大致的框架。确保你的开发环境中已经包含了Spring Boot和Spring Security的依赖。
Spring security 整合JWT 接口权限控制
欢迎阅读程序猿小张的博客~
08-06 743
Spring security 整合 JWT 接口权限控制
SpringSecurity整合jwt
qq_51705526的博客
05-02 7140
前言: 准备把权限管理写到自己的jee项目中, 索性想到了SpringSecurity框架, 就来学一下！ 认证 登录校验流程 token可以存在localstoryge springsecurity完整流程 就是一个过滤链 UsernamePasswordAuthenticationFilter：(认证)处理登录页面填写了用户名和密码之后的登录请求ExcpetionTranslationFilter：处理过滤器链中抛出的任何AccessDeniedException和AuthenticationEx
SpringSecurity整合JWT实现认证和授权
weixin_44909963的博客
04-28 5487
SpringSecurity整合JWT实现认证和授权 文章目录SpringSecurity整合JWT实现认证和授权前言一、SpringSecurity介绍和架构分析及使用流程二、使用步骤1.引入库2.读入数据总结 前言 本文主要讲解l通过整合SpringSecurity和JWT实现后台用户的登录和授权功能，使用到的技术有nacos,dubbo,SpringSecurity,redis. 一、SpringSecurity介绍和架构分析及使用流程 SpringSecurity是一个安全框架，支持自定义需求。
【Spring Security系列】Spring Security整合JWT：构建安全的Web应用
热门推荐
小威的博客
04-22 1万+
前面两个章节介绍过了Spring Security，这里就不再赘述了！！！JWT是一种轻量级的身份验证和授权机制，通过发送包含用户信息的加密令牌来实现身份验证。这个工具我们在前面的文章中也提起过。
Spring Security整合JWT实现权限认证和授权
weixin_45818966的博客
11-05 4168
关于spring security整合jwt实现前后端权限认证和授权管理
Spring Security + JWT 实现登录认证和权限控制
weixin_44320429的博客
05-06 1337
自定义类实现接口，用户发起登录请求后会执行方法来进行登录验证。该方法会返回一个类型的结果，该类的父类实现了接口，用来封装用户的认证信息。/*** 自定义登录验证逻辑*/@Component@Autowired@Override//登录请求中的账号//登录密码throw new UsernameNotFoundException("账号不存在！");//这里直接用了MD5加密，没用Security中的passwordEncoderif (!
Spring Security + JWT基础整合
weixin_45565886的博客
02-08 1413
Spring Security + JWT基础整合
springboot+springSecurity+jwt实现登录认证后令牌授权
09-12
在这个项目中，我们将探讨如何利用Spring Boot、Spring Security和JWT来实现登录认证后的令牌授权。 首先，让我们从Spring Boot开始。Spring Boot简化了Spring应用的初始搭建以及开发过程。通过提供默认配置，它极...
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证
08-26
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证，可根据注解的格式不同，做到角色权限控制，角色加资源权限控制等，粒度比较细化。 @PreAuthorize("hasAnyRole('ADMIN','USER')")：具有admin或...
SpringSecurity 整合 JWT.docx
06-27
为了在Spring Security中整合JWT，首先需要引入JWT的相关库，如jjwt。然后，可以创建JWT的生成和解析方法。以下是一个简单的示例： ```java import io.jsonwebtoken.Jwts; import java.util.Date; public class ...
java将数组拼接为字符串
weixin_43626356的博客
03-02 1万+
List<String> ids = ImmutableList.of("1", "2", "3"); //直接用String.join System.out.println(String.join(",", ids)); //使用 org.apache.commons.lang.StringUtils System.out.println(StringUtils.join(array, ",")); //使用 Google Guava 中的 com.google.common.base.
MyBatis查询数据返回null
weixin_43626356的博客
07-07 5264
mybatis返回null
java之CSV大批量数据入库
weixin_43626356的博客
07-27 2823
maven + springboot + juc 实现千万数据入库
SpringSecurity整合JWT：实现无状态登录
"这篇文档介绍了如何使用Spring Security整合JWT（JSON Web Token）以实现无状态登录，探讨了无状态登录的优缺点，并简要说明了JWT的基本原理和构成部分。" 正文: 在现代Web应用程序中，为了提高系统的可伸缩性和可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值