JWT ist ein offener Standard für die sichere übertragung von Informationen. In Java kann Authentifizierung und Autorisierung über die JJWT -Bibliothek erreicht werden. 1. Fügen Sie JJWT API, Impl und Jackson -Abh?ngigkeiten hinzu; 2. Erstellen Sie die JWTUTIL -Werkzeugklasse, um das Token zu generieren, zu analysieren und zu überprüfen. 3. Schreiben Sie JWTFilter, um Anforderungen abzufangen, und überprüfen Sie das Tr?gertoken im Autorisierungsheader. V. 5. Geben Sie eine Anmeldeschnittstelle an, um JWT zurückzugeben, nachdem Sie den Benutzer überprüfen. 6. Die geschützte Schnittstelle erh?lt die Identit?t und Rolle des Benutzers für die Zugriffskontrolle durch Parsen des Tokens und realisiert letztendlich einen zustandslosen und erweiterbaren Sicherheitsmechanismus, der für verteilte Systemanwendungen geeignet ist. Achten Sie auf Sicherheitsvorschl?ge wie wichtige Sicherheit, Token -Ablauf und HTTPS -übertragung.

In der modernen Webanwendungsentwicklung ist die Verwendung von JAVA zur Implementierung der Benutzerauthentifizierung (Authentifizierung) und der Autorisierung eine übliche Voraussetzung. JWT (JSON Web Token) ist aufgrund seiner staatenlosen, skalierbaren und Cross-Dom?nen-Unterstützung zu einer der Mainstream-L?sungen für die Implementierung der Sicherheitsauthentifizierung geworden. Im Folgenden wird beschrieben, wie Sie JWT verwenden, um die Authentifizierung und Autorisierung in Java -Anwendungen zu vervollst?ndigen.

Was ist JWT?

JWT ist ein offener Standard (RFC 7519), mit dem Informationen als JSON -Objekt zwischen Parteien sicher übertragen werden. Es wird üblicherweise für die Authentifizierung und den Informationsaustausch verwendet. Ein JWT besteht aus drei Teilen:

• Header : Enth?lt Token -Typ und Signaturalgorithmus (wie HMAC SHA256)
• Nutzlast : Enth?lt Ansprüche wie Benutzer -ID, Rolle, Ablaufzeit usw.
• Signatur : Signatur die ersten beiden Teile, um sicherzustellen, dass die Daten nicht manipuliert wurden

Das Format ist: xxxxx.yyyyy.zzzzz

Grundprozess

1. Benutzeranmeldung, Benutzername und Passwort senden
2. Serverüberprüfungsanmeldeinformationen, Generieren Sie JWT und kehren zum Client zurück
3. Der Kunde tr?gt das JWT in nachfolgenden Anfragen (normalerweise im Authorization )
4. Der Server überprüft die Gültigkeit des JWT und entscheidet, ob der Zugriff auf die Ressource basierend auf den darin enthaltenen Aussagen autorisiert wird.

Verwenden Sie Java JWT, um Authentifizierung und Autorisierung zu implementieren

1. Fügen Sie Abh?ngigkeiten hinzu (wie ein Beispiel Maven einnehmen)

Verwenden Sie die JJWT -Bibliothek, um JWT zu verarbeiten:

 <De vorangehen>
    <gruppeID> io.jsonWebtoken </Groupid>
    <artifactid> jjwt-api </artifactid>
    <version> 0.11.5 </Version>
</abh?ngig>
<De vorangehen>
    <gruppeID> io.jsonWebtoken </Groupid>
    <artifactid> jjwt-impl </artifactid>
    <version> 0.11.5 </Version>
    <Scope> Laufzeit </Scope>
</abh?ngig>
<De vorangehen>
    <gruppeID> io.jsonWebtoken </Groupid>
    <artifactid> jjwt-jackson </artifactid>
    <version> 0.11.5 </Version>
    <Scope> Laufzeit </Scope>
</abh?ngig>

Hinweis: JJWT 0.11 unterstützt die Modularit?t und erfordert die Einführung von API, Impl und Jackson -Unterstützung.

2. Erstellen Sie die JWT -Toolklasse

 importieren io.jsonWebtoken.*;
import IO.jsonWebtoken.security.keys;

importieren javax.crypto.secretkey;
import Java.util.date;

?ffentliche Klasse jwtutil {
    private static Final SecretKey Secret_key = keys.secretkeyfor (SignatureAlgorithm.hs256);
    private statische endgültige Langzeitablauf_Time = 86400000; // 24 Stunden

    // JWT erzeugen
    public static String GeneratEToken (String -Benutzername, String -Rolle) {
        return jwts.builder ()
                SETSUBJECT (Benutzername)
                .Claim ("Rolle", Rolle)
                .setISEDAT (neues Datum ())
                .setExpiration (neues Datum (System.CurrentTimemillis () expiration_time))
                .Signwith (Secret_key)
                .kompakt();
    }

    // JWT analysieren und überprüfen
    public statische Ansprüche parsetoken (String Token) {
        versuchen {
            Return jwts.parserbuilder ()
                    .SetsigningKey (Secret_key)
                    .bauen()
                    .Parseclaimsjws (Token)
                    .getBody ();
        } catch (abgelaufenJwTexception e) {
            System.out.println ("Token abgelaufen");
            null zurückkehren;
        } catch (MalmaleformedJwTexception | Signaturexception e) {
            System.out.println ("Invalid Token");
            null zurückkehren;
        }
    }

    // Benutzername ?ffentliche statische String GetUnernamefromToken (String Token) {
        Ansprüche Ansprüche = parsetoken (Token);
        Returnansprüche! = NULL? Ansprüche.GetSubject (): NULL;
    }

    // die Rolle ?ffentliche statische String GetRolefromToken (String Token) {
        Ansprüche Ansprüche = parsetoken (Token);
        return (string) caells.get ("Rolle");
    }

    // überprüfen
        String tokenusername = getUnernameFromToken (token);
        return (tokenusername! = null && tokenusername.equals (Benutzername) && parsetoken (token)! = null);
    }
}

3.. Abfanganfragen: Implementieren von Filtern (Filter)

Erstellen Sie einen JwtFilter um Anforderungen abzufangen und JWT zu überprüfen.

 Javax.servlet importieren.*;
importieren javax.servlet.http.httpServletRequest;
importieren javax.servlet.http.httpServletResponse;
importieren java.io.ioException;

?ffentliche Klasse JWTFilter implementiert Filter {

    @Override
    Public Void Dofilter (ServletRequest Request, ServletResponse -Antwort, Filterchain -Kette)
            l?st ioException, ServletException {aus

        HttpServletRequest httprequest = (httpServletRequest) Anfrage;
        HttpServletResponse httpresponse = (httpServletResponse) Antwort;

        String token = httprequest.Getheader ("Autorisierung");

        if (token! = null && token.startswith ("Bearer")) {
            token = token.substring (7); // "Tr?ger" entfernen
            String username = jwtutil.getUnernameFromToken (Token);

            if (Benutzername! = null && jwtutil.istokenvalid (Token, Benutzername)) {
                // Benutzerinformationen k?nnen im Anforderungsattribut oder im Sicherheitskontext gespeichert werden
                httprequest.setAttribute ("CurrentUser", Benutzername);
                httprequest.setAttribute ("Rolle", jwtutil.getRolfromToken (Token));
                chain.dofilter (Anfrage, Antwort);
            } anders {
                httpresponse.setStatus (httpServletResponse.sc_unauthorized);
                httPresponse.getWriter (). Schreiben ("Ungültig oder abgelaufener Token");
            }
        } anders {
            httpresponse.setStatus (httpServletResponse.sc_unauthorized);
            httPresponse.getWriter (). Schreiben ("fehlendes Token");
        }
    }
}

4. Konfigurieren Sie den Filter (Federstart als Beispiel)

Wenn Sie Spring Start verwenden, k?nnen Sie den Filter in der Konfigurationsklasse registrieren:

 @Bohne
public filterregistrationBean <Jwtfilter> jwtfilter () {
    FilterregistrationBean <Jwtfilter> RegistrierungBean = new FilterregistrationBean <> ();
    RegistrierungBean.SetFilter (New JWTFilter ());
    RegistrierungBean.addurlpatterns ("/api/sichere/*"); // geschützte Pfadrückgaberegistrierung;
}

5. Beispiel für Login -Schnittstelle

 @Postmapping ("/login")
public responseentity <?> Login (@RequestBody userLoginRequest -Anfrage) {{
    // vereinfacht: Tats?chlich sollte das Datenbankkennwort zur Verschlüsselungsüberprüfung überprüft werden, wenn ("admin" .equals (request.getUnername ()) && "password" .equals (request.getPassword ()) {
        String token = jwtutil.generatetoken (request.getUnername (), "admin");
        return responseentity.ok (). body (map.of ("token", token));
    }
    return responseentity.status (401) .body ("unter Benutzername oder Passwort");
}

6. Beschützter Grenzfl?chenbeispiel

 @Getmapping ("/sicher/data")
public responseentity <?> GetSecuredata (httpServletRequest -Anfrage) {{
    String user = (String) request.getAttribute ("currentUser");
    String rol = (String) request.getAttribute ("rollen");

    if ("admin" .equals (rolle)) {
        return responseentity.ok ("Hallo" Benutzer ", Sie haben Administratorzugriff!");
    } anders {
        Return Responseentity.Status (403) .Body ("unzureichende Erlaubnis");
    }
}

Sicherheitsberatung

• Schlüsselverwaltung : Hardcode -Tasten in Code, verwenden Sie Umgebungsvariablen oder Konfigurationszentren nicht
• Token -Ablaufzeit : Legen Sie die Ablaufzeit vernünftig fest. Es wird empfohlen, kurzfristige Token bei sensiblen Operationen zu verwenden.
• TEFRESH -Token : Kann die Benutzererfahrung mit dem Aktualisierungs -Token -Mechanismus verbessern
• HTTPS : Stellen Sie sicher
• Vermeiden Sie sensible Informationen : Speichern Sie keine sensiblen Daten wie Passw?rter in der JWT -Nutzlast

Zusammenfassen

Die Verwendung von JWT zur Implementierung der Authentifizierung und Autorisierung in Java ist nicht kompliziert, der Kern ist:

• Generieren Sie Token nach erfolgreichem Anmeldung
• Der Kunde tr?gt eine Token -Anfrage
• Der Server überprüft das Token über Filter und extrahiert Benutzerinformationen
• Implementieren Sie die Autorisierungskontrolle gem?? der Rolle

Dieser Mechanismus eignet sich für verteilte und Microservice -Architekturen, wodurch der Overhead von Serverspeichersitzungen vermieden wird.

Grunds?tzlich ist es nicht kompliziert, aber es ist leicht, Details wie Ausnahmehandhabung und wichtige Sicherheit zu ignorieren.

Das obige ist der detaillierte Inhalt vonJava -Authentifizierung und -autorisierung mit JWT. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!