商务合作

spring如何使用jwt

worktile 其他 158

回复

共3条回复 我来回复
  • 不及物动词的头像
    不及物动词
    这个人很懒，什么都没有留下～
    评论

    Spring framework是一个非常流行的Java开发框架，而JWT（JSON Web Token）是一种用于进行跨域身份验证的令牌。在Spring中使用JWT可以通过以下步骤实现：

    步骤1：添加相关依赖
    首先，需要在项目的pom.xml文件中添加相关的依赖。可以使用以下依赖：

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

    步骤2：创建JWT工具类
    接下来，需要创建一个JWT工具类，用于生成和解析JWT令牌。可以在该类中定义一些方法，比如签名生成器、令牌生成器、令牌解析器等。可以参考以下示例代码：

    import io.jsonwebtoken.*;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class JWTUtil {
    private static final long EXPIRATION_TIME = 864_000_000; // 10 days
    private static final String SECRET = "your-secret-key";

    public static String generateToken(String username) {
        Map<String, Object> claims = new HashMap<>();
        claims.put("sub", username);
        claims.put("iat", new Date());

        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
                .signWith(SignatureAlgorithm.HS512, SECRET)
                .compact();
    }

    public static String getUsernameFromToken(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(SECRET)
                .parseClaimsJws(token)
                .getBody();

        return (String) claims.get("sub");
    }

    public static boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(SECRET).parseClaimsJws(token);
            return true;
        } catch (SignatureException e) {
            // Invalid JWT signature
        } catch (MalformedJwtException e) {
            // Invalid JWT token
        } catch (ExpiredJwtException e) {
            // Expired JWT token
        } catch (UnsupportedJwtException e) {
            // Unsupported JWT token
        } catch (IllegalArgumentException e) {
            // JWT claims string is empty
        }
        return false;
    }
}

    步骤3：配置Spring Security
    在Spring Security的配置文件中，需要添加相应的过滤器来验证JWT令牌。可以使用以下代码作为参考：

    @Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .authorizeRequests()
                .antMatchers("/api/login").permitAll()
                .anyRequest().authenticated()
                .and()
                .addFilterBefore(new JWTAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
    }
}

    步骤4：创建JWT身份验证过滤器
    JWT身份验证过滤器负责从请求头中提取JWT令牌，并对其进行验证。可以参考以下示例代码：

    public class JWTAuthenticationFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        String header = request.getHeader("Authorization");

        if (header == null || !header.startsWith("Bearer ")) {
            chain.doFilter(request, response);
            return;
        }

        String token = header.replace("Bearer ", "");
        if (JWTUtil.validateToken(token)) {
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(JWTUtil.getUsernameFromToken(token), null, new ArrayList<>());
            SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        }

        chain.doFilter(request, response);
    }
}

    通过以上步骤，就可以在Spring中使用JWT进行身份验证了。可以在登录成功后，生成JWT令牌并返回给客户端。客户端在后续的请求中需要将该令牌添加到请求头的Authorization字段中，以进行身份验证。在服务器端，可以使用JWTAuthenticationFilter来对JWT令牌进行验证和解析，确保请求的合法性。

    1年前 0条评论
  • fiy的头像
    fiy
    Worktile&PingCode市场小伙伴
    评论

    Spring框架是一个非常流行的Java开发框架，它简化了Web应用程序的开发，而JWT（JSON Web Token）是一种用于身份验证和授权的开放标准。

    在Spring中使用JWT，我们需要执行以下步骤：

    1. 添加依赖：
      首先，在项目的Maven或Gradle配置文件中添加相应的JWT依赖项。例如，在Maven中，我们可以使用以下依赖项：
    <dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>
    1. 创建JWT Token：
      为了创建JWT Token，我们需要定义一个密钥用于签名和加密，以及一些声明信息，例如用户ID、角色等。使用JWT库提供的Builder模式，我们可以构建一个JWT Token。示例代码如下：
    import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

String jwtToken = Jwts.builder()
        .setSubject(userId)
        .claim("roles", roles)
        .setIssuedAt(new Date())
        .setExpiration(new Date(System.currentTimeMillis() + tokenExpirationTime))
        .signWith(SignatureAlgorithm.HS512, secretKey)
        .compact();
    1. 验证JWT Token：
      前端发送的每个请求都应该携带JWT Token。在后端接收到请求时，我们需要验证Token的合法性。我们可以定义一个Spring拦截器或过滤器来处理此过程。示例代码如下：
    import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureException;

try {
    Claims claims = Jwts.parser()
            .setSigningKey(secretKey)
            .parseClaimsJws(token)
            .getBody();
    // 验证通过，可以进行进一步处理
} catch (SignatureException e) {
    // Token验证失败
}
    1. 解析JWT Token：
      在验证JWT Token之后，我们可以从Token中解析出所需的信息。示例代码如下：
    import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;

Claims claims = Jwts.parser()
        .setSigningKey(secretKey)
        .parseClaimsJws(token)
        .getBody();
String userId = claims.getSubject();
List<String> roles = (List<String>) claims.get("roles");
    1. 设置过期时间和刷新Token：
      为了增加安全性，我们可以设置Token的过期时间，并在Token过期之后提供刷新Token的机制，以便用户持续使用应用程序。示例代码如下：
    import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.JwtException;
import io.jsonwebtoken.Jwts;

try {
    Claims claims = Jwts.parser()
            .setSigningKey(secretKey)
            .parseClaimsJws(token)
            .getBody();
    // 验证通过，可以进行进一步处理
} catch (ExpiredJwtException e) {
    // Token已过期，可以刷新Token
} catch (JwtException e) {
    // 其他JWT异常处理
}

    通过上述步骤，我们可以在Spring应用程序中轻松地集成JWT。使用JWT进行身份验证和授权可以提供一种安全可靠的方式来保护我们的应用程序。

    1年前 0条评论
  • worktile的头像
    worktile
    Worktile官方账号
    评论

    Spring是一个开源的Java开发框架，集成了许多功能模块，可以帮助开发者快速构建Java应用程序。JWT（JSON Web Token）是一种用于身份验证的开放标准，用于在客户端和服务器之间传递安全的、加密的认证信息。

    在Spring中使用JWT可以实现基于令牌的身份验证和授权机制。下面介绍在Spring中如何使用JWT进行身份验证。

    1. 添加依赖
      首先需要在Spring项目中添加相关依赖。可以使用Maven或者Gradle进行依赖管理。

    对于Maven，在pom.xml文件中添加以下依赖：

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

    对于Gradle，在build.gradle文件中添加以下依赖：

    compile 'io.jsonwebtoken:jjwt:0.9.1'
    1. 创建JWT工具类
      接下来需要创建一个JWT工具类，用于生成和解析JWT。
    import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;

public class JwtUtils {
    private static final String SECRET_KEY = "your_secret_key";
    private static final long EXPIRATION_TIME = 86400000; // 24 hours

    public static String generateToken(String username) {
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + EXPIRATION_TIME);

        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(now)
                .setExpiration(expiryDate)
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .compact();
    }

    public static String getUsernameFromToken(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody();

        return claims.getSubject();
    }

    public static boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}

    上述代码中，generateToken方法用于生成JWT，getUsernameFromToken方法用于从JWT中获取用户名，validateToken方法用于验证JWT的有效性。

    1. 添加身份验证过滤器
      然后需要创建一个身份验证过滤器，用于检查请求中的JWT，并使用JWT工具类验证其有效性。
    import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
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 javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class JwtAuthenticationFilter extends AbstractAuthenticationProcessingFilter {
    private AuthenticationManager authenticationManager;

    public JwtAuthenticationFilter(AuthenticationManager authenticationManager) {
        super(new AntPathRequestMatcher("/api/login", "POST"));
        this.authenticationManager = authenticationManager;
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException, IOException, ServletException {
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        return authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(username, password)
        );
    }

    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
        String username = ((UserDetails) authResult.getPrincipal()).getUsername();
        String token = JwtUtils.generateToken(username);

        response.setHeader("Authorization", "Bearer " + token);
        chain.doFilter(request, response);
    }
}

    上述代码中，JwtAuthenticationFilter继承自AbstractAuthenticationProcessingFilter，用于处理登录请求，并验证用户名和密码。验证成功后，使用JWT工具类生成JWT，并将其添加到响应头中。

    1. 添加安全配置
      最后需要在安全配置中添加上述的身份验证过滤器。
    @Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .csrf().disable()
                .authorizeRequests()
                .antMatchers("/api/login").permitAll()
                .anyRequest().authenticated()
                .and()
                .addFilter(new JwtAuthenticationFilter(authenticationManager()));
    }
}

    上述代码中，configure方法配置了HTTP请求的安全规则，指定了哪些请求需要进行身份验证。同时添加了JwtAuthenticationFilter过滤器。

    使用JWT进行身份验证的流程就是这样的。在客户端进行登录请求时，需要提供用户名和密码，服务器验证成功后，生成JWT并返回给客户端。客户端在后续请求中通过在请求头中添加JWT来进行身份验证。服务器验证JWT的有效性后，允许请求访问受限资源。

    需要注意的是，上述代码只是一个简单的示例，实际使用中可能需要根据具体的需求进行更多的定制。

    1年前 0条评论
注册PingCode 在线客服
站长微信
站长微信
电话联系

400-800-1024

工作日9:30-21:00在线

分享本页
返回顶部
                                                                                                                           PingCode智能化研发管理工具，25人以下免费使用。