Java implementa la generación de tokens y la función de verificación de inicio de sesión

1. Las ventajas del token en comparación con la cookie
1. Admite el acceso entre dominios, coloca el token en el encabezado de la solicitud y la cookie no admite el acceso entre dominios;

2. Sin estado, el servidor no necesita almacenar el token, solo necesita verificar que la información del token sea correcta, y la sesión debe almacenarse en el servidor, generalmente a través del ID de sesión en la cookie para encontrar la sesión correspondiente en el servidor;

3. No es necesario vincularse a un esquema de autenticación especial (nombre de usuario tradicional e inicio de sesión con contraseña), solo es necesario generar el token de acuerdo con nuestra configuración esperada;

4. Es más adecuado para terminales móviles (Android, iOS, applets, etc.). Las plataformas nativas como esta no admiten cookies. Por ejemplo, los applets WeChat, cada solicitud es una sesión. Por supuesto, podemos buscarlo manualmente cada vez. Agregue cookies, consulte a otro blogger para obtener más detalles;

5. Evite los ataques de falsificación entre sitios CSRF, o porque no se basan en cookies;

En segundo lugar, la autenticación de token basada en
JWT implementa JWT: JSON Web Token, de hecho, el token es una cadena de tres partes: encabezado, carga útil, firma

1. Introducir dependencias

<dependency> 
      <groupId> com.auth0 </groupId> 
      <artifactId> java-jwt </artifactId> 
      <version> 3.8.2 </version> 
    </dependency>

　　

2. Establecer la clave y el tiempo de vida

// Establecer el tiempo de caducidad 
    private static final long EXPIRE_DATE = 30 * 60 * 100000; 
    // token key 
    private static final String TOKEN_SECRET = "ZCEQIUBFKSJBFJH2020BQWE";

　　

3. Implemente el método de firma

Token de cadena público estático (nombre de usuario de cadena, contraseña de cadena) { 

        String token = ""; 
        intente { 
            // 
            Fecha fecha = nueva Fecha (System.currentTimeMillis () + EXPIRE_DATE); 
            // Clave secreta y algoritmo de cifrado 
            Algoritmo algoritmo = Algoritmo .HMAC256 (TOKEN_SECRET); 
            // Establecer información del encabezado 
            Map <String, Object> header = new HashMap <> (); 
            header.put ("typ", "JWT"); 
            header.put ("alg", "HS256 "); 
            // Llevar información de nombre de usuario y contraseña, generar 
            token de firma = JWT.create () 
                    .withHeader (encabezado) 
                    .withClaim (" nombre de usuario ", nombre de usuario)
                    .withClaim ("contraseña", contraseña) .withExpiresAt (fecha) 
                    .sign (algoritmo); 
        } catch (Excepción e) { 
            e.printStackTrace (); 
            volver nulo; 
        } 
        ficha de retorno; 
    }

　　

4. Verificar el token

público booleano estático verificar (String token) { 
        / ** 
         * @desc 验证 token ， 通过 返回 true 
         * @create 2019/1/18/018 9:39 
         * @params [token] 需要 校验 的 串
         ** / 
        try { 
            Algoritmo algoritmo = Algoritmo.HMAC256 (TOKEN_SECRET); 
            JWTVerifier verifier = JWT.require (algoritmo) .build (); 
            DecodedJWT jwt = verifier.verify (token); 
            volver verdadero; 
        } catch (Excepción e) { 
            e.printStackTrace (); 
            falso retorno; 
        } 
    }

　　

5. Prueba

1), use el token generado para verificar directamente, el éxito

public static void main (String [] args) { 
       String username = "zhangsan"; 
        Cadena contraseña = "123"; 
        Cadena token = token (nombre de usuario, contraseña); 
        System.out.println (token); 
        booleano b = verificar (token); 
        System.out.println (b); 
    }

　　

3. Complete el código de la herramienta Token

paquete xxx.utils; // su paquete 

import com.auth0.jwt.JWT; 
import com.auth0.jwt.JWTVerifier; 
import com.auth0.jwt.algorithms.Algorithm; 
import com.auth0.jwt.interfaces.DecodedJWT; 

import java.util.Date; 
import java.util.HashMap; 
import java.util.Map; 
/ ** 
 * @desc usa token para verificar si el usuario ha iniciado sesión 
 * @author zm 
 ** / 
public class TokenUtils { 
    // Establecer el tiempo de caducidad 
    privado static final long EXPIRE_DATE = 30 * 60 * 100000; 
    // token secret 
    private static final String TOKEN_SECRET = "ZCfasfhuaUUHufguGuwu2020BQWE"; 

    token de String estático público (String token, String password) { 

        String token = ""; 
        try {
            // Hora de 
            vencimiento Fecha fecha = nueva Fecha (System.currentTimeMillis () + EXPIRE_DATE); 
            // 
            Algoritmo algoritmo = Algorithm.HMAC256 (TOKEN_SECRET); 
            // Establecer información del encabezado 
            Mapa <Cadena, Objeto> encabezado = nuevo HashMap <> (); 
            header.put ("typ", "JWT"); 
            header.put ("alg", "HS256"); 
            // llevar nombre de usuario, información de contraseña, generar 
            token de firma = JWT.create () 
                    .withHeader (encabezado) 
                    .withClaim ("nombre de usuario", nombre de usuario) 
                    .withClaim ("contraseña", contraseña) .withExpiresAt (fecha) 
                    .sign (algoritmo);
        } catch (Excepción e) {
            e.printStackTrace ();  
    public static void main (String [] args) {
            volver nulo;
        } 
        ficha de retorno; 
    } 

    verificación booleana estática pública (token de cadena) { 
        / ** 
         * @desc 验证 token ， 通过 返回 true 
         * @params [token] 需要 校验 的 串
         ** / 
        try { 
            Algorithm algoritm = Algorithm.HMAC256 (TOKEN_SECRET); 
            JWTVerifier verifier = JWT.require (algoritmo) .build (); 
            DecodedJWT jwt = verifier.verify (token); 
            volver verdadero; 
        } catch (Excepción e) { 
            e.printStackTrace (); 
            falso retorno; 
        } 
    }
       String username = "zhangsan"; 
        Cadena contraseña = "123"; 
        Cadena token = token (nombre de usuario, contraseña); 
        System.out.println (token); 
        boolean b = verificar ( "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJwYXNzd22yZCI6IjEyMyIsImV4cCI6MTU3ODE5NzQxMywidXNlcm5hbWUiOiJ6aGFuZ3NhbiJ9.IyTZT0tISQQZhGhsNuaqHGV8LD7idjUYjn3MGbulmJg"); 
        System.out.println (b); 
    } 
}