1. PingCode智库首页
  2. 百科

后端java如何使用jwt

Edit1 • • 百科

后端java如何使用jwt

后端Java如何使用JWT

在后端Java中使用JWT（JSON Web Token）进行身份验证和授权的核心要点是生成JWT、验证JWT、解析JWT、保护API端点。本文将详细讲解如何实现这些步骤，并提供相关代码示例。

一、生成JWT

在后端Java中生成JWT的第一步是创建JWT令牌。JWT包含三个部分：头部（Header）、负载（Payload）和签名（Signature）。头部包含令牌的元信息，负载包含用户信息和声明，签名用于验证令牌的完整性。

1、头部和负载的创建

在头部部分，我们通常会指定令牌的类型和签名算法。最常见的签名算法是HMAC SHA256。负载部分则包含用户的身份信息和其他声明，如过期时间（exp）。

import io.jsonwebtoken.Jwts;


import io.jsonwebtoken.SignatureAlgorithm;


import java.util.Date;


public class JwtUtil {


    private static final String SECRET_KEY = "mySecretKey";


    public static String generateToken(String username) {


        return Jwts.builder()


                .setSubject(username)


                .setIssuedAt(new Date())


                .setExpiration(new Date(System.currentTimeMillis() + 3600000))  // 1 hour expiration


                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)


                .compact();


    }


}

在这个例子中，JWT令牌包含了用户名、发行时间和过期时间，并使用HMAC SHA256算法进行签名。

2、签名和生成令牌

生成令牌的关键是使用signWith方法进行签名，确保令牌的完整性和防篡改。在实际应用中，SECRET_KEY应存储在安全的地方，如环境变量或配置文件中。

二、验证JWT

验证JWT是确保令牌的真实性和有效性的过程。在验证过程中，后端服务会使用与生成JWT时相同的签名密钥。

1、提取和解析令牌

首先，我们需要从请求头中提取JWT令牌。通常，JWT令牌会放在HTTP请求的Authorization头中，以Bearer开头。

import io.jsonwebtoken.Claims;


import io.jsonwebtoken.Jws;


import io.jsonwebtoken.Jwts;


import io.jsonwebtoken.SignatureException;


public class JwtUtil {


    private static final String SECRET_KEY = "mySecretKey";


    public static Claims validateToken(String token) {


        try {


            Jws<Claims> claimsJws = Jwts.parser()


                    .setSigningKey(SECRET_KEY)


                    .parseClaimsJws(token);


            return claimsJws.getBody();


        } catch (SignatureException e) {


            throw new RuntimeException("Invalid JWT token");


        }


    }


}

在这个例子中，validateToken方法会解析令牌并返回声明部分（Claims）。如果签名不匹配，方法会抛出异常。

2、验证声明和有效期

验证声明和有效期是验证JWT的重要部分。我们需要确保令牌未过期且包含期望的声明。

import io.jsonwebtoken.Claims;


public class JwtUtil {


    private static final String SECRET_KEY = "mySecretKey";


    public static Claims validateToken(String token) {


        try {


            Jws<Claims> claimsJws = Jwts.parser()


                    .setSigningKey(SECRET_KEY)


                    .parseClaimsJws(token);


            Claims claims = claimsJws.getBody();


            if (claims.getExpiration().before(new Date())) {


                throw new RuntimeException("JWT token has expired");


            }


            return claims;


        } catch (SignatureException e) {


            throw new RuntimeException("Invalid JWT token");


        }


    }


}

在这个例子中，我们添加了对过期时间的验证。如果令牌已过期，方法会抛出异常。

三、解析JWT

解析JWT的过程与验证类似。解析JWT是从令牌中提取用户信息和其他声明，以便在后端服务中使用。

1、解析用户信息

解析用户信息是JWT最常见的用途之一。我们可以从声明部分中提取用户名或其他用户信息。

import io.jsonwebtoken.Claims;


public class JwtUtil {


    private static final String SECRET_KEY = "mySecretKey";


    public static String getUsernameFromToken(String token) {


        Claims claims = validateToken(token);


        return claims.getSubject();


    }


}

在这个例子中，getUsernameFromToken方法会从令牌中提取用户名。我们可以使用这个用户名在数据库中查询用户信息。

2、解析其他声明

除了用户名，我们还可以解析其他声明，如用户角色或权限。

import io.jsonwebtoken.Claims;


public class JwtUtil {


    private static final String SECRET_KEY = "mySecretKey";


    public static String getUsernameFromToken(String token) {


        Claims claims = validateToken(token);


        return claims.getSubject();


    }


    public static List<String> getRolesFromToken(String token) {


        Claims claims = validateToken(token);


        return claims.get("roles", List.class);


    }


}

在这个例子中，getRolesFromToken方法会从令牌中提取用户角色。我们可以使用这些角色信息进行权限控制。

四、保护API端点

在后端服务中保护API端点是JWT的另一个重要用途。我们可以使用JWT进行身份验证和授权，确保只有合法用户可以访问受保护的资源。

1、使用过滤器保护端点

在Spring Boot中，我们可以使用过滤器（Filter）保护API端点。过滤器会在每个请求到达控制器之前执行，检查请求头中的JWT令牌。

import org.springframework.web.filter.OncePerRequestFilter;


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 OncePerRequestFilter {


    private static final String AUTHORIZATION_HEADER = "Authorization";


    private static final String BEARER_PREFIX = "Bearer ";


    @Override


    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)


            throws ServletException, IOException {


        String header = request.getHeader(AUTHORIZATION_HEADER);


        if (header != null && header.startsWith(BEARER_PREFIX)) {


            String token = header.substring(BEARER_PREFIX.length());


            try {


                Claims claims = JwtUtil.validateToken(token);


                // 添加用户信息到请求中，以便后续使用


                request.setAttribute("claims", claims);


            } catch (RuntimeException e) {


                response.sendError(HttpServletResponse.SC_UNAUTHORIZED, e.getMessage());


                return;


            }


        }


        filterChain.doFilter(request, response);


    }


}

在这个例子中，JwtAuthenticationFilter会检查请求头中的JWT令牌。如果令牌有效，会将用户信息添加到请求中。

2、配置过滤器

接下来，我们需要在Spring Boot应用中配置过滤器。

import org.springframework.context.annotation.Bean;


import org.springframework.context.annotation.Configuration;


import org.springframework.security.config.annotation.web.builders.HttpSecurity;


import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;


import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;


import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;


@Configuration


@EnableWebSecurity


public class SecurityConfig extends WebSecurityConfigurerAdapter {


    @Bean


    public JwtAuthenticationFilter jwtAuthenticationFilter() {


        return new JwtAuthenticationFilter();


    }


    @Override


    protected void configure(HttpSecurity http) throws Exception {


        http.csrf().disable()


                .authorizeRequests()


                .antMatchers("/public/").permitAll()


                .anyRequest().authenticated()


                .and()


                .addFilterBefore(jwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);


    }


}

在这个例子中，我们禁用了CSRF保护，并配置了JWT过滤器。所有以/public/开头的请求将被允许匿名访问，其他请求需要进行JWT身份验证。

3、使用用户信息

在控制器中，我们可以使用从JWT解析出的用户信息。

import org.springframework.web.bind.annotation.GetMapping;


import org.springframework.web.bind.annotation.RequestAttribute;


import org.springframework.web.bind.annotation.RequestMapping;


import org.springframework.web.bind.annotation.RestController;


import io.jsonwebtoken.Claims;


@RestController


@RequestMapping("/api")


public class ApiController {


    @GetMapping("/user")


    public String getUserInfo(@RequestAttribute Claims claims) {


        return "Hello, " + claims.getSubject();


    }


}

在这个例子中，getUserInfo方法会从请求属性中提取用户信息并返回。

总结

使用JWT进行身份验证和授权的过程包括生成JWT、验证JWT、解析JWT、保护API端点。在Java后端中，我们可以使用io.jsonwebtoken库来处理JWT令牌。生成JWT时，我们需要创建头部和负载，并使用签名算法进行签名。验证JWT时，我们需要解析令牌并验证签名和声明。解析JWT时，我们可以从令牌中提取用户信息和其他声明。在保护API端点时，我们可以使用过滤器进行身份验证，并在控制器中使用用户信息。

通过以上步骤，我们可以在Java后端应用中安全、有效地使用JWT进行身份验证和授权。

相关问答FAQs：

1. JWT是什么？后端Java如何使用JWT？

JWT（JSON Web Token）是一种用于身份验证和授权的开放标准。它由三部分组成：头部、载荷和签名。在后端Java中，可以使用Java的JWT库来生成和验证JWT。

2. 如何生成JWT并在后端Java中使用？

要生成JWT，首先需要创建一个包含身份信息和其他有用信息的JSON对象。然后，使用Java的JWT库将其加密并生成一个JWT字符串。在后端Java中，可以使用以下代码示例：

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

public class JwtUtil {
    private static final String SECRET_KEY = "your_secret_key";

    public static String generateToken(String subject) {
        return Jwts.builder()
                .setSubject(subject)
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .compact();
    }

    public static Claims parseToken(String token) {
        return Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody();
    }
}

使用上述代码，您可以通过调用generateToken方法生成JWT，并通过调用parseToken方法解析JWT字符串并获取其中的声明。

3. 如何在后端Java中验证JWT？

要验证JWT，在后端Java中，您可以使用JWT库提供的方法来解析JWT并验证其签名和有效性。以下是一个示例代码：

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

public class JwtUtil {
    private static final String SECRET_KEY = "your_secret_key";

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

使用上述代码，您可以通过调用validateToken方法来验证JWT的有效性。如果JWT有效，则返回true；否则，返回false。

原创文章，作者：Edit1，如若转载，请注明出处：https://docs.pingcode.com/baike/306609

赞 (0)
Edit1Edit1
上一篇 2024年8月15日 下午2:50
下一篇 2024年8月15日 下午2:50
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部