【实践篇】教你玩转JWT认证---从一个优惠券聊起

引言

最近面试过程中，无意中跟候选人聊到了JWT相关的东西，也就联想到我自己关于JWT落地过的那些项目。
关于JWT，可以说是分布式系统下的一个利器，我在我的很多项目实践中，认证系统的第一选择都是JWT。它的优势会让你欲罢不能，就像你领优惠券一样。
大家回忆一下一个场景，如果你和你的女朋友想吃某江家的烤鱼了，你会怎么做呢？
传统的时代，我想场景是这样的：我们走进一家某江家餐厅，会被服务员引导一个桌子，然后我们开始点餐，服务原会记录我们点餐信息，然后在送到后厨去。这个过程中，那个餐桌就相当于session，而我们的点餐信息回记录到这个session之中，然后送到后厨。这个是一个典型的基于session的认证过程。但我们也发现了它的弊端，就是基于session的这种认证，对服务器强依赖，而且信息都是存储在服务器之上，灵活性和扩展性大大降低。
而互联网时代，大众点评、美团、饿了么给了我们另一个选择，我们可能第一时间会在这些平台上搜索江边城外的优惠券，这个优惠券中可能会描述着两人实惠套餐明细。这张优惠券就是我们的 JWT，我们可以在任何一家有参与优惠活动的餐厅使用这张优惠券，而不必被限制在同一家餐厅。同时这张优惠券中直接记录了我们的点餐明细，等我们到了餐厅，只需要将优惠券二维码告知服务员，服务员就会给我们端上我们想要的食物。
好了，以上只是一个小例子，其实只是想说明一下JWT相较于传统的基于session的认证框架的优势。
JWT 的优势在于它可以跨域、跨服务器使用，而 Session 则只能在本域名下使用。而且，JWT 不需要在服务端保存用户的信息，只需要在客户端保存即可，这减轻了服务端的负担。 这一点在分布式架构下优势还是很明显的。
什么是JWT

说了这么多，如何定义JWT呢？
JWT（JSON Web Token）是一种用于在网络应用中进行身份验证的开放标准（RFC7519）。它可以安全地在用户和服务器之间传输信息，因为它使用数字签名来验证数据的完整性和真实性。
JWT包含三个部分：头部、载荷和签名。头部包含算法和类型信息，载荷包含用户的信息，签名用于验证数据的完整性和真实性。
额外说一下poload，也就是负荷部分，这块是jwt的核心模块，它内部包括一些声明（claims）。声明由三个类型组成：
Registered Claims：这是预定义的声明名称，主要包括以下几种：

• iss：Token 发行者
  
• sub：Token 主题
  
• aud：Token的受众
  
• exp：Token 过期时间
  
• iat：Token发行时间
  
• jti：Token唯一标识符
  

Public Claims：公共声明是自己定义的声明名称，以避免冲突。
Private Claims：私有声明与公共声明类似，不同之处在于它是用于在双方之间共享信息的。
当用户登录时，服务器将生成一个JWT，并将其作为响应返回给客户端。客户端将在后续的请求中发送此JWT。服务器将使用相同的密钥验证JWT的签名，并从载荷中获取用户信息。如果签名验证通过并且用户信息有效，则服务器将允许请求继续进行。
JWT优点

JWT优点如果我们系统的总结一下， 如下：

• 跨语言和平台：JWT是基于JSON标准的，因此可以在不同的编程语言和平台之间进行交换和使用。无状态：由于JWT包含所有必要的信息，服务器不需要在每个请求中存储任何会话数据，因此可以轻松地进行负载均衡。
  
• 安全性：JWT使用数字签名来验证数据的完整性和真实性，因此可以防止数据被篡改或伪造。
  
• 可扩展性：JWT可以包含任何用户信息，因此可以轻松地扩展到其他应用程序中。
  
• 一个基于JWT认证的方案
  

我将举一个我实际业务落地的一个例子。
我的业务场景中一般都会有一个业务网关，该网关的核心功能就是鉴权和上线文转换。用户请求会将JWT字符串存与header之中，然后到网关后进行JWT解析，解析后的上下文信息，会转变成明文K-V的方式在此存于header之中，供系统内部各个微服务之间互相调用时提供明文上下文信息。具体时序图如下：

基于Spring security的JWT实践

JWT原理很简单，当然，你可以完全自己实现JWT的全流程，但是，实际中，我们一般不需要这么干，因为有很多成熟和好用的轮子提供给我们，而且封装性和安全性也远比自己匆忙的封装一个简单的JWT来的高。
如果是基于学习JWT，我是建议大家自己手写一个demo的，但是如果重实践的角度触发，我们完全可以使用Spring Security提供的JWT组件，来高效快速的实现一个稳定性和安全性都非常高的JWT认证框架。
以下是我基于我的业务实际情况，根据保密性要求，简化了的JWT实践代码。也算是抛砖引玉，希望可以给大家在业务场景中运用JWT做一个参考。
maven依赖

首先，我们需要添加以下依赖到pom.xml文件中：

1. <dependency>
2. <groupId>org.springframework.boot</groupId>
3. spring-boot-starter-security</artifactId>
4. </dependency>
5. <dependency>
6. <groupId>io.jsonwebtoken</groupId>
7. jjwt</artifactId>
8. <version>0.9.1</version>
9. </dependency>

复制代码

JWT工具类封装

然后，我们可以创建一个JwtTokenUtil类来生成和验证JWT令牌：

1. import io.jsonwebtoken.Claims;
2. import io.jsonwebtoken.Jwts;
3. import io.jsonwebtoken.SignatureAlgorithm;
4. import org.springframework.beans.factory.annotation.Value;
5. import org.springframework.security.core.userdetails.UserDetails;
6. import org.springframework.stereotype.Component;
7. import java.util.Date;
8. import java.util.HashMap;
9. import java.util.Map;
10. import java.util.function.Function;
12. @Component
13. public class JwtTokenUtil {
14.     private static final long JWT_TOKEN_VALIDITY = 5 * 60 * 60;
15.     @Value("${jwt.secret}")
16.     private String secret;
18.     public String generateToken(UserDetails userDetails) {
19.         Map<String, Object> claims = newHashMap <>();
20.         return createToken(claims, userDetails.getUsername());
21.     }
22.     private String createToken(Map<String, Object> claims, String subject) {
23.         Date now = new Date();
24.         Date expiration = new Date(now.getTime() + JWT_TOKEN_VALIDITY * 1000);
25.         return Jwts.builder()
26.                 .setClaims(claims)
27.                 .setSubject(subject)
28.                 .setIssuedAt(now)
29.                 .setExpiration(expiration)
30.                 .signWith(SignatureAlgorithm.HS256, secret)
31.                 .compact();
32.     }
33.     public boolean validateToken(String token, UserDetails userDetails) {
34.         final String username = extractUsername(token);
35.         return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
36.     }
37.     private boolean isTokenExpired(String token) {
38.         return extractExpiration(token).before(new Date());
39.     }
40.     public String extractUsername(String token) {
41.         return extractClaim(token, Claims::getSubject);
42.     }
43.     public Date extractExpiration(String token) {
44.         return extractClaim(token, Claims::getExpiration);
45.     }
46.     private <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
47.         final Claims claims = extractAllClaims(token);
48.         return claimsResolver.apply(claims);
49.     }
50.     private Claims extractAllClaims(String token) {
51.         return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
52.     }
53. }

复制代码

在这个实现中，我们使用了jjwt库来创建和解析JWT令牌。我们定义了以下方法：

• generateToken：生成JWT令牌。
  
• createToken：创建JWT令牌。
  
• validateToken：验证JWT令牌是否有效。
  
• isTokenExpired：检查JWT令牌是否过期。
  
• extractUsername：从JWT令牌中提取用户名。
  
• extractExpiration：从JWT令牌中提取过期时间。
  
• extractClaim：从JWT令牌中提取指定的声明。
  
• extractAllClaims：从JWT令牌中提取所有声明。
  

UserDetailsService类定义

接下来，我们可以创建一个自定义的UserDetailsService，用于验证用户登录信息：

1. import org.springframework.beans.factory.annotation.Autowired;
2. import org.springframework.security.core.userdetails.User;
3. import org.springframework.security.core.userdetails.UserDetails;
4. import org.springframework.security.core.userdetails.UserDetailsService;
5. import org.springframework.security.core.userdetails.UsernameNotFoundException;
6. import org.springframework.stereotype.Service;
8. @Service
9. public class JwtUserDetailsService implements UserDetailsService {
10.     @Autowired
11.     private UserRepository userRepository;
12.     @Override
13.     public UserDetails loadUserByUsername(String username)
14.             throws UsernameNotFoundException {
15.         UserEntity user = userRepository.findByUsername(username);
16.         if (user == null) {
17.             throw new UsernameNotFoundException("User not found with username: " + username);
18.         }
19.         return new User(user.getUsername(), user.getPassword(),
20.                 new ArrayList<>());
21.     }
22. }

复制代码

在这个实现中，我们使用了UserRepository来检索用户信息。我们实现了UserDetailsService接口，并覆盖了loadUserByUsername方法，以便验证用户登录信息。
JwtAuthenticationFilter定义

接下来，我们可以创建一个JwtAuthenticationFilter类，用于拦截登录请求并生成JWT令牌：

1. import com.fasterxml.jackson.databind.ObjectMapper;
2. import org.springframework.security.authentication.AuthenticationManager;
3. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
4. import org.springframework.security.core.Authentication;
5. import org.springframework.security.core.AuthenticationException;
6. import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
8. import javax.servlet.FilterChain;
9. import javax.servlet.ServletException;
10. import javax.servlet.http.HttpServletRequest;
11. import javax.servlet.http.HttpServletResponse;
12. import java.io.IOException;
13. import java.util.Collections;
14. import java.util.Date;
16. public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
17.     private final AuthenticationManager authenticationManager;
18.     private final JwtTokenUtil jwtTokenUtil;
20.     public JwtAuthenticationFilter(AuthenticationManager authenticationManager, JwtTokenUtil jwtTokenUtil) {
21.         this.authenticationManager = authenticationManager;
22.         this.jwtTokenUtil = jwtTokenUtil;
23.     }
25.     @Override
26.     public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
27.         try {
28.             LoginRequest loginRequest = new ObjectMapper().readValue(request.getInputStr eam(), LoginRequest.class);
29.             return authenticationManager.authenticate(
30.                     new UsernamePasswordAuthenticationToken(loginRequest.getUsername(), loginRequest.getPassword(), Collections.emptyList())
31.             );
32.         } catch (IOException e) {
33.             throw new RuntimeException(e);
34.         }
35.     }
37.     @Override
38.     protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult)throwsIOException,ServletException {
39.         UserDetails userDetails = (UserDetails) authResult.getPrincipal();
40.         String token = jwtTokenUtil.generateToken(userDetails);
41.         response.addHeader("Authorization", "Bearer " + token);
42.     }
44.     private static class LoginRequest {
45.         private String username;
46.         private String password;
48.         public String getUsername() {
49.             return username;
50.         }
52.         public void setUsername(String username) {
53.             this.username = username;
54.         }
56.         public String getPassword() {
57.             return password;
58.         }
60.         public void setPassword(String password) {
61.             this.password = password;
62.         }
63.     }
64. }

复制代码

在这个实现中，我们继承了
UsernamePasswordAuthenticationFilter类，并覆盖了attemptAuthentication和successfulAuthentication方法，以便在登录成功时生成JWT令牌并将其添加到HTTP响应头中。
Spring Security配置类

最后，我们可以创建一个Spring Security配置类，以便配置验证和授权规则：

1. import org.springframework.beans.factory.annotation.Autowired;
2. import org.springframework.context.annotation.Bean;
3. import org.springframework.context.annotation.Configuration;
4. import org.springframework.security.authentication.AuthenticationManager;
5. import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
6. import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
7. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
8. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
9. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
10. import org.springframework.security.config.http.SessionCreationPolicy;
11. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
12. import org.springframework.security.crypto.password.PasswordEncoder;
13. import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
15. @Configuration
16. @EnableWebSecurity
17. @EnableGlobalMethodSecurity(prePostEnabled = true)
18. public class SecurityConfig extends WebSecurityConfigurerAdapter {
19.     @Autowired
20.     private JwtUserDetailsService jwtUserDetailsService;
21.     @Autowired
22.     private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
23.     @Autowired
24.     private JwtTokenUtil jwtTokenUtil;
26.     @Override
27.     protected void configure(HttpSecurity http) throws Exception {
28.         http.csrf().disable()
29.                 .authorizeRequests().antMatchers("/authenticate").permitAll()
30.                 .anyRequest().authenticated().and()
31.                 .exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint).and()
32.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
33.         http.addFilterBefore(newJwtAuthenticationFilter(authenticationManager(), jwtTokenUtil), UsernamePasswordAuthenticationFilter.class);
34.     }
35.     @Override
36.     protected void configure(AuthenticationManagerBuilder auth) throws Exception {
37.         auth.userDetailsService(jwtUserDetailsService).passwordEncoder(passwordEncoder());
38.     }
39.     @Override
40.     @Bean
41.     public AuthenticationManager authenticationManagerBean() throws Exception {
42.         return super.authenticationManagerBean();
43.     }
44.     @Bean
45.     public PasswordEncoder passwordEncoder() {
46.         return new BCryptPasswordEncoder();
47.     }
48. }

复制代码

在这个实现中，我们使用JwtUserDetailsService来验证用户登录信息，并使用
JwtAuthenticationEntryPoint来处理验证错误。
我们还配置了JwtAuthenticationFilter来生成JWT令牌，并将其添加到HTTP响应头中。我们还定义了一个PasswordEncoderbean，用于加密用户密码。
调试接口验证

现在，我们可以向/authenticate端点发送POST请求，以验证用户登录信息并生成JWT令牌。例如：

1. bash
2. curl -X POST \
3.   http://localhost:8080/authenticate \
4.   -H 'Content-Type: application/json'\
5.   -d '{
6.     "username": "user",
7.     "password": "password"
8. }'

复制代码

如果登录信息验证成功，将返回一个带有JWT令牌的HTTP响应头。我们可以使用这个令牌来访问需要授权的端点。例如：

1. bash
2. curl -X GET \
3.   http://localhost:8080/hello \
4.   -H 'Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1c2VyIiwiaWF0IjoxNjI0MDM2NzA4LCJleHAiOjE2MjQwMzc1MDh9.9fZS7jPp0NzB0JyOo4y4jO4x3s3KjV7yW1nLzV7cO_c'

复制代码

在这个示例中，我们向/hello端点发送GET请求，并在HTTP头中添加JWT令牌。如果令牌有效并且用户有权访问该端点，则返回一个成功的HTTP响应。
总结

JWT是一种简单、安全和可扩展的身份验证机制，适用于各种应用程序和场景。它可以减少服务器的负担，提高应用程序的安全性，并且可以轻松地扩展到其他应用程序中。
但是JWT也有一定的缺点，比如他的payload模块并没有明确说明一定要加密传输，所以当你没有额外做一些安全性措施的情况下，jwt一旦被别人截获，很容易泄漏用户信息。所以，如果要增加JWT的在实际项目中的安全性，安全加固措施必不可少，包括加密方式，秘钥的保存，JWT的过期策略等等。
当然实际中的认证鉴权框架不止有JWT，JWT只是解决了用户上下文传输的问题。实际项目中经常是JWT结合其他认证系统一同使用，比如OAuth2.0。这里篇幅有限，就不展开。以后有机会再单独写一篇关于OAuth2.0认证架构的文章。

作者：京东物流 赵勇萍
内容来源：京东云开发者社区

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！