Java架构笔记：用JWT对SpringCloud进行认证和鉴权

慕容千语

发布于 2019-06-11 23:35:29

2.2K0

发布于 2019-06-11 23:35:29

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

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2019.03.17 ，如有侵权请联系 cloudcommunity@tencent.com 删除

java