Java implémente la génération de jetons et la fonction de connexion de vérification

1. Les avantages du jeton par rapport au cookie
1. Prise en charge de l'accès inter-domaines, placez le jeton dans l'en-tête de la demande et le cookie ne prend pas en charge l'accès inter-domaines;

2. Sans état, le serveur n'a pas besoin de stocker le jeton, il suffit de vérifier que les informations sur le jeton sont correctes et la session doit être stockée sur le serveur, généralement via l'ID de session dans le cookie pour trouver la session correspondante sur le serveur;

3. Pas besoin de se lier à un schéma d'authentification spécial (nom d'utilisateur traditionnel et connexion par mot de passe), il suffit de générer le jeton conformément à nos paramètres attendus;

4. Plus adapté aux terminaux mobiles (Android, iOS, applets, etc.). Les plates-formes natives comme celle-ci ne prennent pas en charge les cookies. Par exemple, les applets WeChat, chaque demande est une session, bien sûr, nous pouvons y aller manuellement Ajoutez des cookies, veuillez consulter un autre blogueur pour plus de détails;

5. Évitez les attaques de contrefaçon entre sites CSRF, ou parce qu'elles ne reposent pas sur les cookies;

Deuxièmement, l'authentification par jeton basée sur
JWT implémente JWT: JSON Web Token, en fait, le jeton est une chaîne de trois parties: en-tête, charge utile, signature.

1. Introduire des dépendances

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

　　

2. Réglez la clé et le temps de vivre

// Définir le temps d'expiration 
    privé statique final long EXPIRE_DATE = 30 * 60 * 100000; 
    // clé de jeton 
    privé statique final String TOKEN_SECRET = "ZCEQIUBFKSJBFJH2020BQWE";

　　

3. Implémentez la méthode de signature

jeton de chaîne statique public (nom d'utilisateur de chaîne, mot de passe de chaîne) { 

        String token = ""; 
        essayez { 
            // 
            Date date = new Date (System.currentTimeMillis () + EXPIRE_DATE); 
            // Clé secrète et algorithme de chiffrement 
            Algorithme algorithme = Algorithm .HMAC256 (TOKEN_SECRET); 
            // Définir les informations d'en-tête 
            Map <String, Object> header = new HashMap <> (); 
            header.put ("typ", "JWT"); 
            header.put ("alg", "HS256 "); 
            // Porter les informations sur le nom d'utilisateur et le mot de passe, générer un 
            jeton de signature = JWT.create () 
                    .withHeader (en-tête) 
                    .withClaim (" username ", username)
                    .withClaim ("mot de passe", mot de passe) .withExpiresAt (date)
                    .sign (algorithme); 
        } catch (Exception e) { 
            e.printStackTrace (); 
            return null; 
        } 
        return token; 
    }

　　

4. Vérifiez le jeton

vérification statique publique booléenne (jeton de chaîne) { 
        / ** 
         * @desc 验证 jeton ， 通过 返回 vrai 
         * @create 2019/1/18/018 9:39 
         * @params [jeton] 需要 校验 的 串
         ** / 
        try { 
            Algorithme algorithme = Algorithm.HMAC256 (TOKEN_SECRET); 
            Vérificateur JWTVerifier = JWT.require (algorithme) .build (); 
            DecodedJWT jwt = verifier.verify (token); 
            return true; 
        } catch (Exception e) { 
            e.printStackTrace (); 
            retour faux; 
        } 
    }

　　

5. Test

1), utilisez le jeton généré pour vérifier directement le succès

public static void main (String [] args) { 
       String username = "zhangsan"; 
        Mot de passe de chaîne = "123"; 
        Jeton de chaîne = jeton (nom d'utilisateur, mot de passe); 
        System.out.println (jeton); 
        booléen b = vérifier (jeton); 
        System.out.println (b); 
    }

　　

3. Code d'outil Token complet

package xxx.utils; // votre package 

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 utilise un jeton pour vérifier si l'utilisateur est connecté 
 * @author zm 
 ** / 
public class TokenUtils { 
    // Définir le délai d'expiration 
    privé static final long EXPIRE_DATE = 30 * 60 * 100000; 
    // token key 
    private static final String TOKEN_SECRET = "ZCfasfhuaUUHufguGuwu2020BQWE"; 

    public static token String (String username, String password) { 

        String token = ""; 
        try {
            // Date d'expiration 
            Date date = nouvelle Date (System.currentTimeMillis () + EXPIRE_DATE); 
            // 
            Algorithm algorithm = Algorithm.HMAC256 (TOKEN_SECRET); 
            // Définir les informations d'en-tête 
            Map <String, Object> header = new HashMap <> (); 
            header.put ("typ", "JWT"); 
            header.put ("alg", "HS256"); 
            // transporter le nom d'utilisateur, les informations de mot de passe, générer le 
            jeton de signature = JWT.create () 
                    .withHeader (en-tête) 
                    .withClaim ("nom d'utilisateur", nom d'utilisateur) 
                    .withClaim ("mot de passe", mot de passe) .withExpiresAt (date) 
                    .sign (algorithme);
        } catch (Exception e) {
            e.printStackTrace ();  
    public static void main (String [] args) {
            return null;
        } 
        return token; 
    } 

    public static boolean verify (String token) { 
        / ** 
         * @desc 验证 token ， 通过 返回 true 
         * @params [token] 需要 校验 的 串
         ** / 
        try { 
            Algorithm algorithm = Algorithm.HMAC256 (TOKEN_SECRET); 
            Vérificateur JWTVerifier = JWT.require (algorithme) .build (); 
            DecodedJWT jwt = verifier.verify (token); 
            return true; 
        } catch (Exception e) { 
            e.printStackTrace (); 
            retour faux; 
        } 
    } 
       String username = "zhangsan"; 
        Mot de passe de chaîne = "123";
        Jeton de chaîne = jeton (nom d'utilisateur, mot de passe); 
        System.out.println (jeton); 
        boolean b = verify ("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJwYXNzd22yZCI6IjEyMyIsImV4cCI6MTU3ODE5NzQxMywidXNlcm5hbWUiOIJJJGJQJGJQJGJ 
        System.out.println (b); 
    } 
}