Verwenden Sie Spring Security und JWT, um eine sichere Authentifizierung und Autorisierung der REST-API in Java zu implementieren, die für staatenlose und skalierbare Architekturen wie Microservices, mobile Anwendungen und einseitige Anwendungen geeignet sind. 2. Fügen Sie zuerst Spring Boot Web, Spring Security und JJW -Abh?ngigkeiten in pom.xml hinzu; 3. Erstellen Sie Benutzer- und LoginRequest -Modellklassen für Benutzerinformationen und Anmeldungsanforderungen. V. 5. Konfigurieren Sie die Sicherheitsconfig -Klasse, um CSRF zu deaktivieren, die Richtlinien für die staatenlose Sitzung festlegen, die Authentifizierungsschnittstelle freigeben und JWT -Filter registrieren. 6. Implementieren Sie den JWTrequestFilter -Filter, um JWT aus dem Autorisierungsheader zu extrahieren und zu überprüfen, und legen Sie den Authentifizierungskontext fest, wenn er gültig ist. 7. Erstellen Sie einen AuthController, um eine /authentifizierte Anmeldestellung bereitzustellen, und geben Sie das JWT -Token zurück, nachdem Sie die Anmeldeinformationen überprüft haben. 8. Definieren Sie geschützte API -Endpunkte wie /gesichert, auf die nur zugegriffen werden kann, wenn auf die Anforderung einen gültigen Tr?gertoken enth?lt. 9. Zu den besten Verfahren geh?ren die Verwendung von HTTPS, sichere Speicher-Token, die Einstellung einer kurzen Ablaufzeit und die Koordinierung mit Aktualisierungstoken, die Priorisierung der Verwendung von RS256-Algorithmus, überprüfung der Token-Deklarationen und die Begrenzung der H?ufigkeit von Anmeldestellgrenztern, um Brute-Force-Risse zu verhindern. Durch die ordnungsgem??e Vermittlung der API und nach Sicherheitsspezifikationen stellt diese L?sung die Staatenlosigkeit, Sicherheit und hohe Skalierbarkeit der API sicher.

Die Sicherung von REST -APIs in Java unter Verwendung von Spring Security und JWT ist eine h?ufige Voraussetzung für moderne Webanwendungen, insbesondere beim Aufbau eines aufstandslosen, skalierbaren Backends. Hier finden Sie eine praktische Anleitung zur Implementierung einer sicheren Authentifizierung und Autorisierung mit Spring Security und JSON Web Tokens (JWT).

Warum Spring Security JWT verwenden?

Spring Security bietet einen leistungsstarken und ma?geschneiderten Rahmen für die Behandlung von Authentifizierung und Autorisierung in Java -Anwendungen. In Kombination mit JWT erm?glicht es eine staatenlose Authentifizierung , sodass der Server keine Sitzungsdaten speichern muss. Stattdessen enth?lt jede Anfrage ein signiertes Token, das die Identit?t des Benutzers beweist.

Dies ist ideal für:

• Microservices Architekturen
• Mobile und einseitige Anwendungen (SPAs)
• APIs, die horizontal skalieren müssen

Schritt 1: Abh?ngigkeiten einrichten

Fügen Sie die erforderlichen Abh?ngigkeiten in Ihr pom.xml (für Maven) hinzu:

 <Depecies>
    <De vorangehen>
        <gruppeID> org.springframework.boot </Groupid>
        <artifactid> Spring-Boot-Starter-Web </artifactid>
    </abh?ngig>
    <De vorangehen>
        <gruppeID> org.springframework.boot </Groupid>
        <artifactid> Spring-Boot-Starter-Security </artifactid>
    </abh?ngig>
    <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>
</Abh?ngigkeiten>

Schritt 2: Erstellen Sie Benutzermodell und Authentifizierungsanforderung

Definieren Sie ein einfaches Benutzermodell und login DTO an:

 Benutzer der ?ffentlichen Klasse {
    privater String -Benutzername;
    privates Zeichenfolgenkennwort;
    // Konstruktoren, Getters, Setters
}

 LoginRequest der ?ffentlichen Klasse {
    privater String -Benutzername;
    privates Zeichenfolgenkennwort;
    // Getter und Setzer
}

Schritt 3: JWT erzeugen und validieren

Erstellen Sie eine Versorgungsklasse, um Token zu generieren und zu analysieren:

 @Komponente
?ffentliche Klasse jwtutil {

    private String screy_key = "Ihr Seetkret-Key"; // Umgebungsvariable oder Keystore in der Produktion verwenden

    public String GeneratEToken (UserDetails UserDetails) {
        return jwts.builder ()
                SETSUBJECT (userDetails.getUnername ())
                .setISEDAT (neues Datum ())
                .setExpiration (neues Datum (System.currentTimemillis () 1000 * 60 * 60 * 10)) // 10 Stunden
                .Signwith (SignatureAlgorithm.HS256, Secret_key)
                .kompakt();
    }

    public boolean validatEToken (String Token, UserDetails UserDetails) {
        Final String userername = extractUserName (Token);
        return (userername.equals (userDetails.getUnername ()) &&! isTokenExpired (token));
    }

    public String extractUnername (String Token) {
        return jwts.parser ().
    }

    private boolean isTokenexpired (String Token) {
        return jwts.parser (). setSigningKey (secry_key) .ParSeclaimsjws (token) .getBody (). getExpiration () vor (neuer Datum ());
    }
}

? Sicherheitstipp : Niemals den geheimen Schlüssel harte. Verwenden Sie @Value("${jwt.secret}") mit Umgebungsvariablen oder einem sicheren Schlüsselverwaltungssystem.

Schritt 4: Konfigurieren Sie die Spring Security

Erstellen Sie eine Sicherheitskonfigurationsklasse:

 @Konfiguration
@EnableWebecurity
?ffentliche Klasse SecurityConfig {

    @Autowired
    private userdetailsService userDetailsService;

    @Autowired
    Privat JwTrequestFilter JwTrequestFilter;

    @Bohne
    public passwayEncoder passwordEncoder () {
        Neue bcryptPasswordEnCoder () zurückgeben;
    }

    @Bohne
    public AuthenticationManager AuthenticationManager (AuthenticationConfiguration config) l?st Ausnahme {
        return config.getAuthenticationManager ();
    }

    @Bohne
    Protected SecurityFilterChain Filterchain (httpecurity http) l?st Ausnahme {
        http.csrf (). Disable ())
            .AuthorizeHttprequests (Auth -> Auth
                .RequestMatchers ("/authenticate"). erlaubtenAll ()
                .anyRequest (). authentifiziert ()
            )
            .

        http.addFilterBefore (jwtrequestFilter, usernamePasswordAuthenticationFilter.Class);

        return http.build ();
    }
}

Schritt 5: Implementieren Sie den JWT -Filter

Erstellen Sie einen Filter, um eingehende Anforderungen abzufangen und die JWT zu validieren:

 @Komponente
Public Class JwTrequestFilter erstreckt sich einst einPerRequestFilter {

    @Autowired
    private userdetailsService userDetailsService;

    @Autowired
    Privat JWTUTIL JWTUTIL;

    @Override
    Protected Void Dofilterinternal (httpServletRequest -Anforderung, HttpServletResponse -Antwort, Filterchain -Kette)
            l?st ServletException aus, ioException {

        Final String AuthorizationHeader = Request.Getheader ("Autorisierung");

        String username = null;
        String jwt = null;

        if (AuthorizationHeader! = NULL && AuthorizationHeader
            Jwt = AuthorizationHeader.substring (7);
            userername = jwtutil.extractractusername (jwt);
        }

        if (Benutzername! = NULL && SecurityContextHolder.getContext ().
            UserDetails userDetails = this.userDetailsService.loadUserByUserName (Benutzername);

            if (jwtutil.validatetoken (jwt, userdetails)) {
                UserernamepasswordAuthenticationToken authToken = new usernamepasswordAuthenticationToken (
                        UserDetails, Null, userDetails.getAuthorities ());
                AuthToken.SetDetails (neue WebAuthenticationDetailsSource (). BuildDetails (Anfrage));
                SecurityContextHolder.getContext (). SetAuthentication (authToken);
            }
        }
        chain.dofilter (Anfrage, Antwort);
    }
}

Schritt 6: Authentifizierungsendpunkt erstellen

Entdecken Sie einen Endpunkt, um ein Token beim Login zu generieren:

 @Restcontroller
public class authcontroller {

    @Autowired
    Private AuthenticationManager AuthenticationManager;

    @Autowired
    private userdetailsService userDetailsService;

    @Autowired
    Privat JWTUTIL JWTUTIL;

    @Postmapping ("/authenticate")
    public responseentity <?> createAuthenticationToken (@RequestBody LoginRequest LoginRequest) l?st Ausnahme {aus {
        versuchen {
            AuthenticationManager.Authenticate (
                Neue usernamepasswordAuthenticationToken (loginRequest.getUnername (), loginRequest.getPassword ())
            );
        } catch (badcredentialSexception e) {
            Neue Ausnahme ("falscher Benutzername oder Passwort", e);
        }

        endgültige userDetails userDetails = userDetailsService.loadUserByUserName (loginRequest.getUnername ());
        endgültige Zeichenfolge jwt = jwtutil.generatetoken (userDetails);

        return responseentity.ok (New JwTeRsponse (JWT));
    }
}

Und die Antwort DTO:

 ?ffentliche Klasse jwTresponse {
    privates String -Token;

    public JWTresponse (String Token) {
        this.token = token;
    }

    // Getter
}

Schritt 7: Testen Sie die gesicherte API

Jeder andere Endpunkt als /authenticate erfordert nun ein gültiges JWT:

 @Restcontroller
Demokontroller der ?ffentlichen Klasse {

    @Getmapping ("/gesichert")
    public String Segeedendpoint () {
        Rückkehr "Hallo, du bist authentifiziert!";
    }
}

Um Zugang zu /secured , schlie?en Sie den Header ein:

 Autorisierung: Tr?ger <Your-Jwt-token>

Best Practices und Sicherheitstipps

• ? HTTPS in der Produktion verwenden
• ? Store JWTS sicher auf dem Client (meiden Sie nach M?glichkeit localStorage ; bevorzugen Sie httpOnly -Cookies für Web -Apps).
• ? Setzen Sie die kurzen Ablaufzeiten und implementieren Sie Aktualisierungstoken
• ? Verwenden Sie starke Geheimnisse oder RSA -Schlüssel (RS256 anstelle von HS256 für eine bessere Schlüsseltrennung)
• ? Validieren Sie Emittent, Publikum und Ansprüche in der Produktion
• ? Endpunkte der Rate-Limit-Authentifizierung, um Brute-Force-Angriffe zu verhindern

Abschluss

Spring Security mit JWT bietet Ihnen eine robuste Grundlage für die Sicherung von REST -APIs in Java. W?hrend das Setup mehrere Komponenten umfasst - Filter, Token -Generierung und Konfiguration - ist das Muster wiederverwendbar und passt gut zu modernen Anwendungsarchitekturen.

Mit dem richtigen Schlüsselmanagement und Token -Handhabung h?lt dieser Ansatz Ihre APIs sicher, zustandsfrei und skalierbar.

Verdrehen Sie im Grunde den Filter einfach, schützen Sie Ihre Endpunkte und validieren Sie auf jeder Anfrage Token - und Sie k?nnen loslegen.

Das obige ist der detaillierte Inhalt vonSicherung von REST -APIs in Java mit Frühlingssicherheit und JWT. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!