JWT单点登录

JWT的介绍：

JWT也就是JSON Web Token（JWT），是目前最流行的跨域身份验证解决方案。

JWT的组成：

一个JWT实际上就是一个字符串，它由三部分组成：头部(Header)、载荷(Payload)与签名(signature).

1， Header

{“typ”:“JWT”,“alg”:“HS256”}

这个json中的typ属性，用来标识整个token字符串是一个JWT字符串；它的alg属性，用来说明这个JWT签发的时候所使用的签名和摘要算法

typ跟alg属性的全称其实是type跟algorithm，分别是类型跟算法的意思。之所以都用三个字母来表示，也是基于JWT最终字串大小的考虑，

同时也是跟JWT这个名称保持一致，这样就都是三个字符了…typ跟alg是JWT中标准中规定的属性名称

2， Payload(负荷)

{“sub”:“123”,“name”:“Tom”,“admin”:true}

payload用来承载要传递的数据，它的json结构实际上是对JWT要传递的数据的一组声明，这些声明被JWT标准称为claims，

它的一个“属性值对”其实就是一个claim(要求)，

每一个claim的都代表特定的含义和作用。

3 signature

签名是把header和payload对应的json结构进行base64url编码之后得到的两个串用英文句点号拼接起来，然后根据header里面alg指定的签名算法生成出来的。

算法不同，签名结果不同。以alg: HS256为例来说明前面的签名如何来得到。

按照前面alg可用值的说明，HS256其实包含的是两种算法：HMAC算法和SHA256算法，前者用于生成摘要，后者用于对摘要进行数字签名。这两个算法也可以用HMACSHA256来统称 。

JWT的验证过程

JWT验证的方法其实很简单，只要把header做base64url解码，就能知道JWT用的什么算法做的签名，然后用这个算法，再次用同样的逻辑对header和payload做一次签名，

并比较这个签名是否与JWT本身包含的第三个部分的串是否完全相同，只要不同，就可以认为这个JWT是一个被篡改过的串，自然就属于验证失败了。

接收方生成签名的时候必须使用跟JWT发送方相同的密钥

JWT结合springboot项目：

1. pom.xml添加如下依赖：

    <!-- https://mvnrepository.com/artifact/com.auth0/java-jwt -->
    <dependency>
    	<groupId>com.auth0</groupId>
    	<artifactId>java-jwt</artifactId>
    	<version>3.8.1</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt -->
    <dependency>
    	<groupId>io.jsonwebtoken</groupId>
    	<artifactId>jjwt</artifactId>
    	<version>0.9.1</version>
    </dependency>
   

2. test单元测试加密

    @Test
    public void testCase1(){
    	JwtBuilder builder = Jwts.builder();
    	JwtBuilder jwtBuilder = builder.setSubject("yangjingwen")
    		.signWith(SignatureAlgorithm.HS256, "qianfeng")
    		.claim("role", "admin")
    		.setExpiration(new Date(System.currentTimeMillis() + 60000))
    		.setIssuedAt(new Date());
    	String compact = jwtBuilder.compact();
    	System.out.println(compact);
    }
   

3. test单元测试解密

    @Test
    public void testCase2(){
    	String 	token="eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ5YW5namluZ3dlbiIsInJvbGUiOiJhZG1pbiIsI	mV4cCI6MTU2MzI2ODUzNywiaWF0IjoxNTYzMjY4NDc3fQ.mHrESLyGONzlAXwOmRa	U3gkVwFZ_pNqBUl7WcM2vviE";
    	String key="qianfeng";
    	Claims body = Jwts.parser().setSigningKey(key)
    			.parseClaimsJws(token).getBody();
    	String subject = body.getSubject();
    	Date issuedAt = body.getIssuedAt();
    	Date expiration = body.getExpiration();
    }
   

JWT基本使用

生成token的逻辑：登录成功之后，采用jwt生成token。

//登录成功之后，需要生成token
String token = Jwts.builder().setSubject(userDTO.getUsername()) //主题，可以放用户的详细信息
    .setIssuedAt(new Date()) //token创建时间
    .setExpiration(new Date(System.currentTimeMillis() + 60000)) //token过期时间
    .setId(memeber.getMemeberId()) //用户ID
    .setClaims(hashMap) //配置角色信息
    .signWith(SignatureAlgorithm.HS256, "qianfeng") //加密方式和加密密码
    .compact();

Token校验

try {
    JwtParser parser = Jwts.parser();
    parser.setSigningKey("qianfeng");
    Jws<Claims> claimsJws = parser.parseClaimsJws(token);
    Claims body = claimsJws.getBody();
    String username = body.getSubject();
    Object role = body.get("role");
    return true;
} catch (ExpiredJwtException e) {
	e.printStackTrace();
} catch (UnsupportedJwtException e) {
    e.printStackTrace();
} catch (MalformedJwtException e) {
	e.printStackTrace();
} catch (SignatureException e) {
	e.printStackTrace();
} catch (IllegalArgumentException e) {
    e.printStackTrace();
}

Springboot如何开启拦截器

package com.qianfeng.interceptor;

import io.jsonwebtoken.*;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 登录拦截
 */
@Component
public class LoginInterceptor implements HandlerInterceptor {

  	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    String token = request.getParameter("token");

    try {
        JwtParser parser = Jwts.parser();
        parser.setSigningKey("qianfeng");
        Jws<Claims> claimsJws = parser.parseClaimsJws(token);
        Claims body = claimsJws.getBody();
        String username = body.getSubject();
        Object role = body.get("role");

        return true;
    } catch (ExpiredJwtException e) {
        e.printStackTrace();
    } catch (UnsupportedJwtException e) {
        e.printStackTrace();
    } catch (MalformedJwtException e) {
        e.printStackTrace();
    } catch (SignatureException e) {
        e.printStackTrace();
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    }


    return false;
  }

 	 @Override
   public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

   @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse 	response, Object handler, Exception ex) throws Exception {

    }
}

添拦截器

package com.qianfeng.configuration;

import com.qianfeng.interceptor.LoginInterceptor;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

@Configuration
public class AppConfiguration implements WebMvcConfigurer {

	@Resource
    private LoginInterceptor loginInterceptor;

	@Bean
	@LoadBalanced
	public RestTemplate provideRestTemplate(){
    	return new RestTemplate();
	}

 	/**
 	* 添加拦截器
 	* @param registry
	 */
	@Override
	public void addInterceptors(InterceptorRegistry registry) {

    	registry.addInterceptor(loginInterceptor).addPathPatterns("/**");

    }
}