Java JWT认证详解

1. JWT简介

JSON Web Token（JWT），是一种开放的标准（RFC 7519）。

JWT可以在通信双方之间安全地传递用户身份信息，同时因为它是开放的标准，所以可以被任何一种编程语言进行支持。

JWT有三个部分组成：Header（头部）、Payload（负载）和Signature（签名）。

header.payload.signature

其中Header声明类型和签名算法，Payload声明所包含的信息，Signature用于验证JWT的合法性。

2. JWT认证流程

JWT认证流程大概分为以下几步：

1.用户提供账号密码进行登录

2.服务端验证用户提供的账号密码是否正确

3.如果账号密码正确，服务端生成一个JWT并返回给客户端

4.客户端收到JWT之后在以后的请求中带上JWT

5.服务端对JWT进行验证，如果合法则允许请求，否则返回错误信息

3. 使用Java JWT

1. 添加依赖

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

2. JWT的创建与解析

JWT的创建有点类似于数字签名，处理过程大致分为三个步骤：

1.生成一个签名密钥

2.使用签名密钥生成JWT

3.在需要验证JWT的时候，解析JWT，并使用相同的签名密钥进行验证。

下面是一个简单的范例：

package com.example.jwt;

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

import javax.crypto.SecretKey;

public class JwtUtil {
    private static final String KEY = "jwtsecrethhhhhhhhhhhhhhhhhhhhhhhhhhhhhh";

    public static String createJwtToken(String id, String subject, String issuer, long ttlMillis) {
        SecretKey key = Keys.hmacShaKeyFor(KEY.getBytes());

        long nowMillis = System.currentTimeMillis();
        long expMillis = nowMillis + ttlMillis;

        return Jwts.builder()
                .setId(id)
                .setSubject(subject)
                .setIssuer(issuer)
                .setExpiration(new Date(expMillis))
                .signWith(key, SignatureAlgorithm.HS256)
                .compact();
    }

    public static Claims parseJwtToken(String jwt) {
        SecretKey key = Keys.hmacShaKeyFor(KEY.getBytes());

        return Jwts.parser()
                .setSigningKey(key)
                .parseClaimsJws(jwt)
                .getBody();
    }
}

其中createJwtToken方法用于创建JWT，parseJwtToken方法用于解析JWT。

注意在createJwtToken方法中必须指定JWT的有效期，否则默认为永久有效。

3. JWT的验证

当客户端传递了JWT以后，服务端需要对JWT进行验证，下面是一个简单的范例：

package com.example.jwt;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.ExpiredJwtException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
public class JwtTokenValidator {
    private static final Logger logger = LoggerFactory.getLogger(JwtTokenValidator.class);

    public boolean validate(String jwt) {
        try {
            Claims claims = JwtUtil.parseJwtToken(jwt);

            // TODO: 可以在这里进行权限校验

            return true;
        } catch (ExpiredJwtException e) {
            logger.error("Token已过期：{}", jwt);
        } catch (Exception e) {
            logger.error("Token验证失败：{}", jwt, e);
        }

        return false;
    }
}

其中validate方法用于验证JWT是否有效。在此处，我们只是简单判断JWT是否过期，若过期则返回错误信息，如果需要进行更复杂的校验，可以在TODO处进行实现。

4. Spring Security集成

Spring Security是一个非常流行的安全框架，可以与JWT非常好的集成。

1. 添加依赖

<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-jwt</artifactId>
    <version>1.1.0.RELEASE</version>
</dependency>

2. 配置JWT

在Spring Security的配置文件中添加JWT相关的配置：

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;

    @Autowired
    private JwtAuthenticationProvider jwtAuthenticationProvider;

    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter;

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.cors().and().csrf().disable()

                .authorizeRequests()
                .antMatchers(HttpMethod.OPTIONS, "/**").permitAll()

                .antMatchers("/login").permitAll()

                .anyRequest().authenticated()

                .and()
                .exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint)

                .and()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);

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

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.authenticationProvider(jwtAuthenticationProvider);
    }

    @Bean
    public JwtAuthenticationFilter jwtAuthenticationTokenFilter() throws Exception {
        return new JwtAuthenticationFilter();
    }

    @Bean
    public JwtAuthenticationProvider jwtAuthenticationProvider() {
        return new JwtAuthenticationProvider();
    }

    @Bean
    public JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint() {
        return new JwtAuthenticationEntryPoint();
    }
}

其中配置了几个重要的组件：

1.JwtAuthenticationEntryPoint：当用户的JWT无效时的异常处理入口；

2.JwtAuthenticationProvider：JWT的验证器；

3.JwtAuthenticationFilter：过滤器，用于在请求头中获取JWT并进行验证。

3. JWT认证

在Spring Security的UserDetailsService实现类中进行JWT的认证，下面是一个简单的范例：

package com.example.jwt.service;

import com.example.jwt.bean.JwtUser;
import com.example.jwt.dao.UserRepository;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.security.Keys;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

import javax.crypto.SecretKey;
import javax.servlet.http.HttpServletRequest;
import java.util.Date;
import java.util.Optional;

@Service
public class JwtUserDetailsService implements UserDetailsService {
    private static final String KEY = "jwtsecrethhhhhhhhhhhhhhhhhhhhhhhhhhhhhh";

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private HttpServletRequest httpServletRequest;

    private static final Long EXPIRATION_TIME = 60L * 60L * 1000L;

    @Override
    public UserDetails loadUserByUsername(String username) {
        Optional<User> optionalUser = userRepository.findByUsername(username);

        if (optionalUser.isPresent()) {
            User user = optionalUser.get();

            return new JwtUser(user.getId(), user.getUsername(), user.getPassword());
        }

        return null;
    }

    public String createJwtToken(Authentication authentication) {
        SecretKey key = Keys.hmacShaKeyFor(KEY.getBytes());

        String username = authentication.getName();

        long nowMillis = System.currentTimeMillis();
        long expMillis = nowMillis + EXPIRATION_TIME;

        return Jwts.builder()
                .setSubject(username)
                .setIssuer(httpServletRequest.getRequestURL().toString())
                .setIssuedAt(new Date(nowMillis))
                .setExpiration(new Date(expMillis))
                .signWith(key, SignatureAlgorithm.HS256)
                .compact();
    }

    public Authentication getAuthentication(String jwt) {
        Claims claims = Jwts.parser()
                .setSigningKey(KEY.getBytes())
                .parseClaimsJws(jwt)
                .getBody();

        String username = claims.getSubject();

        UserDetails userDetails = loadUserByUsername(username);

        return new UsernamePasswordAuthenticationToken(userDetails, "", userDetails.getAuthorities());
    }
}

其中loadUserByUsername方法用于从数据库中查询用户信息，createJwtToken方法用于创建JWT，getAuthentication方法用于根据JWT获取用户信息，如果JWT无效返回null。

4. 总结

JWT是一个非常方便的用户身份认证方式，它可以与各种编程语言非常好地进行集成，同时也可以与Spring Security等框架完美地进行结合。希望本文的介绍能够对大家有所帮助。