Spring Boot + JWT = sorgenfreie RESTful API

Sicherheit ist ein integraler Bestandteil bei der Erstellung moderner Webanwendungen. JSON Web Token (JWT) bietet eine einfache Möglichkeit, unsere RESTful-Schnittstellen zu sichern. In diesem Blog erfahren Sie Schritt für Schritt, wie Sie JWT in Spring Boot-Anwendungen integrieren, um sicherzustellen, dass Ihre API sicher, effizient und einfach zu verwalten ist.

Einführung in JWT

JWT (JSON Web Token) ist ein offener Standard (RFC 7519), der eine kompakte und eigenständige Möglichkeit zur sicheren Übertragung von Informationen als JSON-Objekt zwischen Parteien definiert. Diese Informationen können überprüft und vertrauenswürdig sein, da sie digital signiert sind.

Warum JWT wählen?

Für Webanwendungen, insbesondere wenn es um Single Page Applications (SPA) geht, bietet JWT einen effektiven Authentifizierungsmechanismus. Im Vergleich zur herkömmlichen Sitzungsauthentifizierung ist JWT zustandslos und muss keine Benutzerstatusinformationen auf dem Server speichern, wodurch es sich sehr gut für verteilte Microservice-Architekturen eignet.

JWT in Spring Boot integrieren

Um JWT in Spring Boot zu integrieren, müssen wir die folgenden Schritte ausführen:

1. Abhängigkeiten hinzufügen
2. Konfigurieren Sie die JWT-Bibliothek
3. Implementieren Sie den JWT-Authentifizierungsfilter
4. Konfigurieren Sie Spring Security
5. Testen Sie die geschützte API

Praktische Anleitung: Erstellen einer Beispielanwendung

Lassen Sie uns den JWT-Integrationsprozess demonstrieren, indem wir eine einfache Spring Boot-Anwendung erstellen.

Abhängigkeiten hinzufügen

pom.xmlFügen Sie zunächst die folgenden Abhängigkeiten zu Ihrem hinzu:

<dependencies>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <!-- 其他依赖 -->
</dependencies>

Konfigurieren Sie die JWT-Bibliothek

Als nächstes müssen wir eine Dienstprogrammklasse erstellen, um JWT zu generieren und zu analysieren:

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;

public class JwtUtil {
    private static final String KEY = "mySecretKey";

    public static String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .setExpiration(new Date(System.currentTimeMillis() + 3600000)) // 1小时有效期
                .signWith(SignatureAlgorithm.HS512, KEY)
                .compact();
    }

    public static String validateTokenAndGetSubject(String token) {
        return Jwts.parser()
                .setSigningKey(KEY)
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
    }
}

Implementieren Sie den JWT-Authentifizierungsfilter

Jetzt erstellen wir einen JWT-Authentifizierungsfilter, um die Gültigkeit des Tokens zu überprüfen:

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import javax.servlet.FilterChain;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.filter.OncePerRequestFilter;

public class JwtAuthenticationFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) {
        String token = request.getHeader("Authorization");
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            String username = JwtUtil.validateTokenAndGetSubject(token);
            if (username != null) {
                UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken(username, null, new ArrayList<>());
                SecurityContextHolder.getContext().setAuthentication(auth);
            }
        }
        filterChain.doFilter(request, response);
    }
}

Konfigurieren Sie Spring Security

Wir müssen Spring Security für die Verwendung unseres JWT-Filters konfigurieren:

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/api/public").permitAll()
            .anyRequest().authenticated()
            .and()
            .addFilter(new JwtAuthenticationFilter(authenticationManager()));
    }
}

Testen Sie die geschützte API

Abschließend erstellen wir testweise einen geschützten API-Endpunkt und einen öffentlichen Endpunkt:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {
    @GetMapping("/api/public")
    public String publicEndpoint() {
        return "Public content";
    }

    @GetMapping("/api/private")
    public String privateEndpoint() {
        return "Private content";
    }
}

Best Practices für JWT

• Bewahren Sie Ihre Schlüssel sicher auf
• Legen Sie eine angemessene Ablaufzeit fest
• Umgang mit Token-Ungültigkeitssituationen
• Übertragen Sie JWT nur über HTTPS

Zusammenfassen

Anhand dieses einfachen Beispiels haben wir gesehen, wie man JWT zur Sicherheitsauthentifizierung in einer Spring Boot-Anwendung verwendet. Die Integration von JWT verbessert die Sicherheit unserer API bei gleichzeitig guter Leistung und Skalierbarkeit. Wenn Sie eine sichere und moderne Webanwendung erstellen möchten, sind Spring Boot und JWT zweifellos die beste Wahl.