写在前面

喜欢的朋友可以关注下专栏：Java架构技术进阶。里面有大量batj面试题集锦，还有各种技术分享，如有好文章也欢迎投稿哦。

image.png

JWT(JSON WEB TOKEN)是基于RFC 7519标准定义的一种可以安全传输的小巧和自包含的JSON对象。由于数据是使用数字签名的，所以是可信任的和安全的。JWT可以使用HMAC算法对secret进行加密或者使用RSA的公钥私钥对来进行签名。

JWT通常由头部(Header)，负载(Payload)，签名(Signature)三个部分组成，中间以.号分隔，其格式为Header.Payload.Signature

Header：声明令牌的类型和使用的算法

   alg：签名的算法

   typ：token的类型，比如JWT

Payload：也称为JWT Claims，包含用户的一些信息

   系统保留的声明（Reserved claims）：

          iss (issuer)：签发人

          exp (expiration time)：过期时间

          sub (subject)：主题

          aud (audience)：受众用户

          nbf (Not Before)：在此之前不可用

          iat (Issued At)：签发时间

          jti (JWT ID)：JWT唯一标识，能用于防止JWT重复使用



   公共的声明(public)：

          见 http://www.iana.org/assignments/jwt/jwt.xhtml



   私有的声明(private claims)：

          根据业务需要自己定义的数据

Signature：签名

   签名格式：

          HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)

JWT的特点：

  JWT默认是不加密的，不能把用户敏感类信息放在Payload部分。

  JWT 不仅可以用于认证，也可以用于交换信息。

  JWT的最大缺点是服务器不保存会话状态，所以在使用期间不可能取消令牌或更改令牌的权限。

  JWT本身包含认证信息，为了减少盗用，JWT的有效期不宜设置太长。

  为了减少盗用和窃取，JWT不建议使用HTTP协议来传输代码，而是使用加密的HTTPS协议进行传输。



  首次生成token比较慢，比较耗CPU，在高并发的情况下需要考虑CPU占用问题。

  生成的token比较长，可能需要考虑流量问题。

认证原理：

 客户端向服务器申请授权，服务器认证以后，生成一个token字符串并返回给客户端，此后客户端在请求
 受保护的资源时携带这个token，服务端进行验证再从这个token中解析出用户的身份信息。

JWT的使用方式：

  一种做法是放在HTTP请求的头信息Authorization字段里面，格式如下：

         Authorization: <token>

         需要将服务器设置为接受来自所有域的请求，用Access-Control-Allow-Origin: *

  另一种做法是，跨域的时候，JWT就放在POST请求的数据体里面。

对JWT实现token续签的做法：

   1、额外生成一个refreshToken用于获取新token，refreshToken需存储于服务端，其过期时间比JWT的过期时间要稍长。

   2、用户携带refreshToken参数请求token刷新接口，服务端在判断refreshToken未过期后，取出关联的用户信息和当前token。

   3、使用当前用户信息重新生成token，并将旧的token置于黑名单中，返回新的token。

创建用于登录认证的工程auth-service：

1、 创建pom.xml文件

Xml代码

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
  <modelVersion>4.0.0</modelVersion>  
  <groupId>com.seasy.springcloud</groupId>  
  <artifactId>auth-service</artifactId>  
  <version>1.0.0</version>  
  <packaging>jar</packaging>  
    
  <parent>  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-parent</artifactId>  
    <version>2.0.8.RELEASE</version>  
    <relativePath/>  
  </parent>  
  
  <properties>  
    <java.version>1.8</java.version>  
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>  
  </properties>  
    
  <dependencies>  
    <dependency>    
        <groupId>org.springframework.boot</groupId>    
        <artifactId>spring-boot-starter-web</artifactId>  
    </dependency>  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-actuator</artifactId>  
    </dependency>  
      
    <!-- spring cloud -->  
    <dependency>  
        <groupId>org.springframework.cloud</groupId>  
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>  
    </dependency>  
      
    <!-- redis -->  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-data-redis</artifactId>  
    </dependency>  
    <dependency>  
        <groupId>org.apache.commons</groupId>  
        <artifactId>commons-pool2</artifactId>  
    </dependency>  
      
    <!-- jwt -->  
    <dependency>  
        <groupId>com.auth0</groupId>  
        <artifactId>java-jwt</artifactId>  
        <version>3.7.0</version>  
    </dependency>  
  </dependencies>  
    
  <dependencyManagement>  
    <dependencies>  
        <dependency>  
            <groupId>org.springframework.cloud</groupId>  
            <artifactId>spring-cloud-dependencies</artifactId>  
            <version>Finchley.RELEASE</version>  
            <type>pom</type>  
            <scope>import</scope>  
        </dependency>  
    </dependencies>  
  </dependencyManagement>  
</project>  

2、JWT工具类

Java代码

public class JWTUtil {  
    public static final String SECRET_KEY = "123456"; //秘钥  
    public static final long TOKEN_EXPIRE_TIME = 5 * 60 * 1000; //token过期时间  
    public static final long REFRESH_TOKEN_EXPIRE_TIME = 10 * 60 * 1000; //refreshToken过期时间  
    private static final String ISSUER = "issuer"; //签发人  
  
    /** 
     * 生成签名 
     */  
    public static String generateToken(String username){  
        Date now = new Date();  
        Algorithm algorithm = Algorithm.HMAC256(SECRET_KEY); //算法  
          
        String token = JWT.create()  
            .withIssuer(ISSUER) //签发人  
            .withIssuedAt(now) //签发时间  
            .withExpiresAt(new Date(now.getTime() + TOKEN_EXPIRE_TIME)) //过期时间  
            .withClaim("username", username) //保存身份标识  
            .sign(algorithm);  
        return token;  
    }  
      
    /** 
     * 验证token 
     */  
    public static boolean verify(String token){  
        try {  
            Algorithm algorithm = Algorithm.HMAC256(SECRET_KEY); //算法  
            JWTVerifier verifier = JWT.require(algorithm)  
                    .withIssuer(ISSUER)  
                    .build();  
            verifier.verify(token);  
            return true;  
        } catch (Exception ex){  
            ex.printStackTrace();  
        }  
        return false;  
    }  
      
    /** 
     * 从token获取username 
     */  
    public static String getUsername(String token){  
        try{  
            return JWT.decode(token).getClaim("username").asString();  
        }catch(Exception ex){  
            ex.printStackTrace();  
        }  
        return "";  
    }  
}  

3、LoginController类

Java代码

@RestController  
public class LoginController {  
    @Autowired  
    StringRedisTemplate redisTemplate;  
      
    /** 
     * 登录认证 
     * @param username 用户名 
     * @param password 密码 
     */  
    @GetMapping("/login")  
    public AuthResult login(@RequestParam String username, @RequestParam String password) {  
        if("admin".equals(username) && "admin".equals(password)){  
            //生成token  
            String token = JWTUtil.generateToken(username);  
              
            //生成refreshToken  
            String refreshToken = StringUtil.getUUIDString();  
              
            //数据放入redis  
            redisTemplate.opsForHash().put(refreshToken, "token", token);  
            redisTemplate.opsForHash().put(refreshToken, "username", username);  
              
            //设置token的过期时间  
            redisTemplate.expire(refreshToken, JWTUtil.REFRESH_TOKEN_EXPIRE_TIME, TimeUnit.MILLISECONDS);  
              
            return new AuthResult(0, "success", token, refreshToken);  
        }else{  
            return new AuthResult(1001, "username or password error");  
        }  
    }  
      
    /** 
     * 刷新token 
     */  
    @GetMapping("/refreshToken")  
    public AuthResult refreshToken(@RequestParam String refreshToken) {  
        String username = (String)redisTemplate.opsForHash().get(refreshToken, "username");  
        if(StringUtil.isEmpty(username)){  
            return new AuthResult(1003, "refreshToken error");  
        }  
  
        //生成新的token  
        String newToken = JWTUtil.generateToken(username);  
        redisTemplate.opsForHash().put(refreshToken, "token", newToken);  
        return new AuthResult(0, "success", newToken, refreshToken);  
    }  
  
    @GetMapping("/")  
    public String index() {  
        return "auth-service: " + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));  
    }  
}  

4、application配置信息

Java代码

spring.application.name=auth-service  
server.port=4040  
  
eureka.instance.hostname=${spring.cloud.client.ip-address}  
eureka.instance.instance-id=${spring.cloud.client.ip-address}:${server.port}  
eureka.instance.prefer-ip-address=true  
  
eureka.client.service-url.defaultZone=http://root:123456@${eureka.instance.hostname}:7001/eureka/  
  
#redis  
spring.redis.database=0  
spring.redis.timeout=3000ms  
spring.redis.lettuce.pool.max-active=100  
spring.redis.lettuce.pool.max-wait=-1ms  
spring.redis.lettuce.pool.min-idle=0  
spring.redis.lettuce.pool.max-idle=8  
  
#standalone  
spring.redis.host=192.168.134.134  
spring.redis.port=7001  
  
#sentinel  
#spring.redis.sentinel.master=mymaster  
#spring.redis.sentinel.nodes=192.168.134.134:26379,192.168.134.134:26380 

5、启动类

Java代码

@SpringBootApplication  
@EnableEurekaClient  
public class Main{  
    public static void main(String[] args){  
        SpringApplication.run(Main.class, args);  
    }  
}  

改造SpringCloud Gateway工程

1、在pom.xml文件添加依赖

Xml代码

<!-- redis -->  
<dependency>  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-data-redis</artifactId>  
</dependency>  
<dependency>  
    <groupId>org.apache.commons</groupId>  
    <artifactId>commons-pool2</artifactId>  
</dependency>  
  
<!-- jwt -->  
<dependency>  
    <groupId>com.auth0</groupId>  
    <artifactId>java-jwt</artifactId>  
    <version>3.7.0</version>  
</dependency>  

2、创建全局过滤器JWTAuthFilter

Java代码

@Component  
public class JWTAuthFilter implements GlobalFilter, Ordered{  
    @Override  
    public int getOrder() {  
        return -100;  
    }  
      
    @Override  
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {  
        String url = exchange.getRequest().getURI().getPath();  
          
        //忽略以下url请求  
        if(url.indexOf("/auth-service/") >= 0){  
            return chain.filter(exchange);  
        }  
          
        //从请求头中取得token  
        String token = exchange.getRequest().getHeaders().getFirst("Authorization");  
        if(StringUtil.isEmpty(token)){  
            ServerHttpResponse response = exchange.getResponse();  
            response.setStatusCode(HttpStatus.OK);  
            response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");  
              
            Response res = new Response(401, "401 unauthorized");  
            byte[] responseByte = JSONObject.fromObject(res).toString().getBytes(StandardCharsets.UTF_8);  
              
            DataBuffer buffer = response.bufferFactory().wrap(responseByte);  
            return response.writeWith(Flux.just(buffer));  
        }  
          
        //请求中的token是否在redis中存在  
        boolean verifyResult = JWTUtil.verify(token);  
        if(!verifyResult){  
            ServerHttpResponse response = exchange.getResponse();  
            response.setStatusCode(HttpStatus.OK);  
            response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");  
  
            Response res = new Response(1004, "invalid token");  
            byte[] responseByte = JSONObject.fromObject(res).toString().getBytes(StandardCharsets.UTF_8);  
              
            DataBuffer buffer = response.bufferFactory().wrap(responseByte);  
            return response.writeWith(Flux.just(buffer));  
        }  
          
        return chain.filter(exchange);  
    }  
}  

3、关键的application配置信息

Java代码

spring:  
  application:  
    name: service-gateway  
  cloud:  
    gateway:  
      discovery:  
        locator:  
          enabled: true  
          lowerCaseServiceId: true  
      routes:  
        #认证服务路由  
        - id: auth-service  
          predicates:  
            - Path=/auth-service/**  
          uri: lb://auth-service  
          filters:  
            - StripPrefix=1  

最后针对上面的高频常问面试题我还总结出了适合于1－5年以上开发经验的java程序员面试涉及到的绝大部分面试题及答案做成了文档和学习笔记文件以及架构视频资料免费分享给大家（包括Dubbo、Redis、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术资料），希望能帮助到您面试前的复习且找到一个好的工作，也节省大家在网上搜索资料的时间来学习，也可以关注我一下以后会有更多干货分享。免费获取方式：加入Java进阶之路：878249276。