spring security 整合 jwt

最新推荐文章于 2024-08-22 15:10:51 发布
最新推荐文章于 2024-08-22 15:10:51 发布
阅读量943 收藏 2
点赞数
分类专栏： JWT
原文链接：https://www.jianshu.com/p/57e50b2b1144
版权

一、概念
JWT：JSON Web Token，一个基于JSON的令牌标准，令牌中可以含有有意义的信息

二、会话管理 之 Token原理

1、用户登录时，服务器端 加密 用户ID 和 过期时间 组成的字符串，得到token，发放给客户端
2、客户端每次发送请求都带上token
3、服务器端 解密token 或者 验证token，从而得到用户ID 和 会话过期时间

token生成方案：
token = user_id|expiry_date|HMAC(user_id|expiry_date, key)
token = AES(user_id|expiry_date, key)
token = RSA(user_id|expiry_date, private key)

HMAC（Hash-based Message Authentication Code）：基于哈希算法的消息认证机制，相当于有密钥参与的单向加密算法
HS256：即哈希算法为SHA-256 的 HMAC

Session 与 Token方案对比
1、单点登录系统中，采用Token方案，原始会话信息只在平台管理，应用向平台查询会话信息并单独保留，应用之间无需共享会话信息，从而跨域更容易
2、分布式系统中，采用Token方案，应用可以不存储会话信息（也就无需共享会话信息），只要验证token即可得到用户ID 和 过期时间，从而获取权限信息

三、Token 格式

格式：header.payload.signature
示例：eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJFVEgiLCJleHAiOjE1ODE5NTAzMjgsImlhdCI6MTU4MTk0MzEyOH0.as9ypxng9aeRDG2fGWNnZOLz9Mc86suO_0ZgSKI9LTvKC9w0q1vVYUTg4zqToXX34fFU3cWJz3VKLUHx4SyGzw
header 为 {"typ":"JWT","alg":"HS256"} 转 Base64，指明 类型 和 生成(验证)算法
payload 也是 JSON字符串 转 Base64，payload中的字段分为标准字段（声明claim） 和 自定义字段
payload中的标准字段：

 

iss: jwt签发者
sub: jwt所面向的用户
aud: 接收jwt的一方
exp: jwt的过期时间，这个过期时间必须要大于签发时间
nbf: jwt的起始生效时间
iat: jwt的签发时间
jti: jwt的唯一标识

signature 即 对 header + payload 进行签名得到

四、spring security 整合 jwt JAR包依赖

1、pom.xm

 

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

2、application.yml

 

jwt:
  secret: secret             # 用于生成token的密钥
  expiration: 7200000   # token有效期
  token: Authorization   # http header里token 所在的字段名

3、SecurityConfig.java 配置 Spring Security

 

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)  // 有这个注解， @PreAuthorize 才能有效
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;

    @Autowired
    JwtAuthorizationTokenFilter authenticationTokenFilter;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.addFilterBefore(new JwtLoginFilter(authenticationManager()),
             UsernamePasswordAuthenticationFilter.class)//自定义过滤器，处理app端登录返回token,使用token处理权限，web端使用session处理权限问题
.addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class) // 添加token过滤器
                .exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint)  // 凭证无效时的处理
                .and()
                .authorizeRequests()
                .antMatchers("/login").permitAll()
                .antMatchers(HttpMethod.OPTIONS, "/**").anonymous()  // 允许匿名访问
                .anyRequest().authenticated()
                .and()
                .csrf().disable()
                // 不使用session，此策略 使得 每次请求都要自行处理权限问题（往SecurityContextHolder.context中添加和查询Authentication）
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }
}

4、JwtAuthenticationEntryPoint.java 处理凭证无效的情况

 

@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException)
            throws IOException {
        response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "凭证无效");
    }
}

6.app端登录，生成token

package com.qijubian.web.infrastructures.filter;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qijubian.web.domains.models.LonginUser;
import com.qijubian.web.infrastructures.commons.JwtTokenUtil;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
import org.springframework.stereotype.Component;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName JwtLoginFilter
 * @Description //TODO
 * @Author tangyinjian
 * @Date 2020/11/10 8:50
 * @Version 1.0
 **/
@Component
public class JwtLoginFilter extends AbstractAuthenticationProcessingFilter {

    private static Logger logger = LoggerFactory.getLogger(JwtLoginFilter.class);

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    public JwtLoginFilter(AuthenticationManager authenticationManager) {
        super(new AntPathRequestMatcher("/doLogin", "POST"));
        setAuthenticationManager(authenticationManager);
    }

    @Override
    public Authentication attemptAuthentication(
        HttpServletRequest request,
        HttpServletResponse response
    ) throws AuthenticationException{
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        //规定时间内登录次数限制
        UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(username,password);
        logger.info("用户(登录名)：{} 正在进行登录验证。。。密码：{}", username);
        //提交给自定义的provider组件进行身份验证和授权
        Authentication authentication = getAuthenticationManager().authenticate(authRequest);
        return authentication;
    }

    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
//        Collection<? extends GrantedAuthority> authorities = authResult.getAuthorities();
//        StringBuffer sb = new StringBuffer();
//        for (GrantedAuthority authority : authorities) {
//            sb.append(authority.getAuthority()).append(",");
//        }
        LonginUser user = (LonginUser) authResult.getPrincipal();
        String jwt = jwtTokenUtil.generateToken(user.getUsername());  // 生成 Token，返回给客户端
//        String jwt = Jwts.builder()
//            .claim("authorities", userName)
//            .setSubject(authResult.getName())
//            .setExpiration(new Date(System.currentTimeMillis() + 60 * 60 * 1000))//设置过期时间
//            .signWith(SignatureAlgorithm.HS512, "root@123")//设置加密方式，以及key
//            .compact();
        //设置登录成功后返回的信息
        Map<String,String> map = new HashMap<>();
        user.setPassword(null);
        user.setSecondaryPassword(null);
        user.setAuthorities(null);
        map.put("token",jwt);
        map.put("userInfo",new ObjectMapper().writeValueAsString(user));
        map.put("success","true");
        map.put("msg","登录成功");
        response.setContentType("application/json;charset=utf-8");
        PrintWriter writer = response.getWriter();
        writer.write(new ObjectMapper().writeValueAsString(map));
        writer.flush();
        writer.close();
    }

    @Override
    protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {
        Map<String,String> map = new HashMap<>();
        map.put("success","false");
        map.put("msg","登录失败,"+failed.getMessage());
        response.setContentType("application/json;charset=utf-8");
        PrintWriter writer = response.getWriter();
        writer.write(new ObjectMapper().writeValueAsString(map));
        writer.flush();
        writer.close();
    }

}

5、JwtAuthorizationTokenFilter.java 验证token，获取权限，将权限存入上下文

 

@Component
public class JwtAuthorizationTokenFilter extends OncePerRequestFilter {
    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Value("${jwt.token}")
    private String tokenHeader;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
        final String requestHeader = request.getHeader(this.tokenHeader);  // 从header 中获取token
        String username = null;
        String authToken = null;
        if (requestHeader != null && requestHeader.startsWith("Bearer ")) {  // token 以 Bearer 为前缀，表示 Bearer Token ，区别于MAC Token
            authToken = requestHeader.substring(7);
            try {
                username = jwtTokenUtil.getUsernameFromToken(authToken);  // 从token中解析出 username
            } catch (ExpiredJwtException e) {
            }
        }

        // 验证token
        if (username != null && jwtTokenUtil.validateToken(authToken, username)) {
            UserDetails userDetails = this.loadUserByUsername(username);  // 查询UserDetails
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
            SecurityContextHolder.getContext().setAuthentication(authentication);  // 在上下文中记录UserDetails
        }
        chain.doFilter(request, response);
    }

    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        List<GrantedAuthority> authorityList = new ArrayList<>();
        /* 此处查询数据库得到角色权限列表，这里可以用Redis缓存以增加查询速度 */
        authorityList.add(new SimpleGrantedAuthority("ROLE_USER"));  // 角色 需要以 ROLE_ 开头
        return new org.springframework.security.core.userdetails.User(username,  "", true, true,
                true, true, authorityList);
    }
}

6、JwtTokenUtil.java JWT工具类

 

@Component
public class JwtTokenUtil implements Serializable {

    @Value("${jwt.secret}")
    private String secret;

    @Value("${jwt.expiration}")
    private Long expiration;

    @Value("${jwt.token}")
    private String tokenHeader;

    private Clock clock = DefaultClock.INSTANCE;

    public String generateToken(String subject) {
        Map<String, Object> claims = new HashMap<>();
        Date createdDate = clock.now();
        Date expirationDate = calculateExpirationDate(createdDate);

        return Jwts.builder()
                .setClaims(claims)
                .setSubject(subject)
                .setIssuedAt(createdDate)
                .setExpiration(expirationDate)
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    private Date calculateExpirationDate(Date createdDate) {
        return new Date(createdDate.getTime() + expiration);
    }

    public Boolean validateToken(String token, String username) {
        final String tokenUsername = getUsernameFromToken(token);
        return (tokenUsername.equals(username) && !isTokenExpired(token)
        );
    }

    public String getUsernameFromToken(String token) {
        return getClaimFromToken(token, Claims::getSubject);
    }

    public <T> T getClaimFromToken(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = getAllClaimsFromToken(token);
        return claimsResolver.apply(claims);
    }

    private Claims getAllClaimsFromToken(String token) {
        return Jwts.parser()
                .setSigningKey(secret)
                .parseClaimsJws(token)
                .getBody();
    }

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

    public Date getExpirationDateFromToken(String token) {
        return getClaimFromToken(token, Claims::getExpiration);
    }

}

 

 

 

tyjlearning
关注
专栏目录
Spring Security整合Jwt
qq614452400的博客
09-04 394
spring-cloud-starter-oauth2里整合了jwt包 编写JwtTokenStoreConfig 类 @Configuration public class JwtTokenStoreConfig { @Bean public TokenStore jwtTokenStore(){ return new JwtTokenStore(jwtAccessTokenConverter()); } //转换token字符串 @Bean
SpringSecurity+JWT快速入门
胡云峰的博客
01-02 5402
SpringSecurity+JWT快速入门
【深入浅出 Spring Security（十三）】使用 JWT 进行前后端分离认证（附源码）
qq_63691275的博客
07-07 4186
使用JWT进行前后端分离认证实现，其后端主要实现其实就是分为俩步（在已经封装好JWT生成和验证工具类的基础上），第一步就是登录认证成功后如何将生成的 jwt 响应给前端？——在AuthenticationSuccessHandler中进行实现；第二步就是前端携带该 jwt 向服务器端发送请求后，如何去认证该请求？——去重写BasicAuthenticationFilter中的doFilterInternal方法，在此方法中进行认证即可...
spring Security + jwt使用
wenlai123456的博客
08-22 1433
spring Security + jwt
Spring Security 超详细整合 JWT，能否拿下看你自己！
08-31 9239
文章目录1.JWT 入门1.1 JWT 概念1.2 JWT 应用场景1.3 为何选择 JWT基于 Session 的传统认证基于 JWT 的认证1.4 JWT 的结构标头（Header）载荷（Payload）签名（Signature）1.5 RBAC (Role-Based Access Control)1.6 JWT 基本使用添加依赖生成 Token解析 Token2.Security 整合 JWT2.1 单独抽离 Security 模块添加相关依赖JWT 工具类JWT 相关配置JWT 登录授权过滤器自定
JWT详细解析
m0_65224643的博客
07-30 4483
Json web token (JWT)，是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准((RFC7519)。该token被设计为的，特别。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。
前后端分离认证实践指南：Spring Security和JWT详解
七一
04-09 2979
简介 Spring Security 是针对Spring项目的安全框架，也是Spring Boot底层安全模块默认的技术选型，他可 以实现强大的Web安全控制，对于安全控制，我们仅需要引入 spring-boot-starter-security 模块，进行少量的配置，即可实现强大的安全管理！ Spring Security的两个主要目标是 “认证” 和 “授权”（访问控制）。 认证: 验证当前访问系统的是不是本系统用户，并且要确认具体是哪个用户。 授权：也就是用户是否有权限进行某个操作 快速入门
SpringSecurity整合Jwt过程图解
08-25
"SpringSecurity整合Jwt过程图解" 在本文中，我们将详细介绍SpringSecurity整合Jwt的过程图解。Jwt（Json Web Token）是一种基于Token的身份验证机制，广泛应用于Web应用程序的身份验证和授权中。SpringSecurity是...
详解SpringBoot+SpringSecurity+jwt整合及初体验
08-25
SpringBoot+SpringSecurity+jwt整合详解 SpringBoot是当前最流行的Java框架之一，它提供了便捷的方式来构建基于Web的应用程序。然而，在构建Web应用程序时，安全性是不可忽视的重要方面。因此，本文将详细介绍如何...
SpringSecurity 整合 JWT.docx
06-27
为了在Spring Security中整合JWT，首先需要引入JWT的相关库，如jjwt。然后，可以创建JWT的生成和解析方法。以下是一个简单的示例： ```java import io.jsonwebtoken.Jwts; import java.util.Date; public class ...
SpringSecurity整合JWT.docx
06-27
【Spring Security 整合 JWT】 在现代Web应用中，安全认证和授权是至关重要的环节。传统的有状态登录机制，依赖于服务器端的Session和客户端的Cookie来维持用户状态，但这种方式存在一些问题，如服务器存储压力大，...
springSecurity中jwt机制及应用详解(1)
2401_83329402的博客
05-03 768
现在正是金三银四的春招高潮，前阵子小编一直在搭建自己的网站，并整理了全套的**【一线互联网大厂Java核心面试题库+解析】：包括Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等**《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！
SpringSecurity如何使用JWT认证?
bangiao的博客
06-06 965
JWT全名叫JSON Web Token, 是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。jwt总体结构还是比较简单的, 我们需要注意的点在于jwt的缺点:jwt 比较容易暴露, 由于存放在客户端, 所以我们需要提供 https 协议进行保护, 同时 jwt 的过期时间不宜过长。
springsecurity整合完成认证服务
wang01_01的博客
05-09 482
这样就可以根据我们数据库查询的accountvo来设置，这样springsecurity就根据后面的方法来获取值，判断你的账号是否可用之类的。咱这个认证服务就是颁发token的，所有咱们放行所有springsecurity的认证。authenticationManager.authenticate（） 传入我们的用户名密码，然后springsecurity就会帮我们往下进行验证。然后我们再看这个方法的返回。上面调用的方法最终就会找到这个loadUserByUsername()方法。
jwt+token验证
qq_51127361的博客
09-19 2128
导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId
第12讲实现JWT认证异常处理器
m0_68935893的博客
02-22 235
新建JwtAuthenticationEntryPoint。
认证授权失败处理以及统一异常处理
afjja的博客
08-20 2419
​ 实际我们在开发过程中可能需要做很多的判断校验，如果出现了非法情况我们是期望响应对应的提示的。但是如果我们每次都自己手动去处理就会非常麻烦。我们可以选择直接抛出异常的方式，然后对异常进行统一处理。把异常中的信息封装成ResponseResult响应给前端。我们的项目在认证出错或者权限不足的时候响应回来的Json是Security的异常处理结果。但是这个响应的格式肯定是不符合我们项目的接口规范的。所以需要自定义异常处理。统一异常处理（全局异常处理器）：所有的异常都会交给这个全局异常去处理。
整合SpringSecurity和JWT实现登录认证和授权
Java升级之路的博客
09-07 4850
文章目录前言一、SpringSecurity是什么？二、JWT是什么？1. JWT的组成2. JWT实现认证和授权的原理三、整合步骤1. 引入相关依赖2. yml配置中加入jwt配置信息3. 添加JWT token的工具类4. 添加SpringSecurity的配置类5. 添加自定义结果处理类5.1 添加CustomAccessDeniedHandler5.2 添加CustomAuthenticationEntryPoint6. 添加JwtUser类7. 添加过滤器JwtAuthenticationTok
关于accessDeniedHandler与authenticationEntryPoint 全局异常处理问题
u014226080的博客
11-17 2255
会在全局异常捕获前捕获异常；会在全局异常之后捕获。
SpringSecurity整合JWT
最新发布
09-16
Spring Security是一个强大的企业级安全框架，它支持多种身份验证机制。集成JSON Web Tokens (JWT) 使得应用能够采用安全、轻量级的方式处理用户认证。JWT是一种开放的标准（RFC 7519），用于作为访问令牌在网络间传递。 以下是使用Spring Security整合JWT的基本步骤： 1. 添加依赖：在你的项目中添加Spring Security JWT的依赖，如`spring-security-oauth2-jwt`。 ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> </dependency> ``` 2. 配置JWT处理器：创建一个自定义的JWTTokenProvider，处理token的生成和验证。 ```java @Configuration @EnableWebSecurity public class JwtConfig { @Bean public JwtTokenProvider jwtTokenProvider() { return new JwtTokenProvider(); } //... } ``` 3. 创建JWT过滤器：配置一个JWT过滤器，对HTTP请求进行身份验证检查，并根据JWT内容获取用户信息。 4. 定义JWT安全拦截器：使用`@PreAuthorize`注解标记需要验证JWT的Controller或方法。 ```java @GetMapping("/api/protected") @PreAuthorize("hasRole('USER')") public String protectedEndpoint() { //... } ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值