Spring Boot 4 – komplett guide · Lektion

OAuth2-klient och Authorization Code Flow

Konfigurera OAuth2-klienten för att hämta och förnya tokens via authorization code grant.

Lektion 2 av 413 steg

OAuth2-klient och Authorization Code Flow är en gratis lektion i Spring Boot 4 – komplett guide på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Spring Boot 4 – komplett guide, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Spring Boot 4 – komplett guide innehåller totalt 4 lektioner.

Varför en OAuth2-klient?

När er Spring Boot-applikation behöver agera på en användares vägnar mot en extern leverantör (Google, GitHub, Keycloak, Okta) blir den en OAuth2-klient.

Klienten ser aldrig användarens lösenord. I stället omdirigerar den webbläsaren till leverantörens auktoriseringsendpoint. Användaren loggar in där, och leverantören skickar tillbaka en access_token (och eventuellt en refresh_token) som klienten använder för att anropa skyddade API:er.

Authorization Code grant är det rekommenderade flödet för webbläsarbaserade applikationer.
Spring Securitys spring-boot-starter-oauth2-client implementerar hela flödet åt er.

Lägg till startern

Lägg till stöd för OAuth2-klienter. I Spring Boot 4 finns detta i spring-boot-starter-oauth2-client, som transitivt hämtar spring-security-oauth2-client samt de JOSE/JWT-bibliotek som behövs för OIDC.

Den här Maven-beroendedeklarationen är allt som behövs för att aktivera inloggning med en leverantör och hämtning av token.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Registrera en klient via properties

Det snabbaste sättet att registrera en leverantör är via application.yml. Spring binder automatiskt dessa värden till en ClientRegistration.

client-id / client-secret – utfärdas av leverantören.
scope – openid, profile, email för OIDC-inloggning.
authorization-grant-type – authorization_code.
redirect-uri – callback-adressen som Spring exponerar, vanligtvis {baseUrl}/login/oauth2/code/{registrationId}.

spring:
  security:
    oauth2:
      client:
        registration:
          keycloak:
            client-id: spring-app
            client-secret: "${KEYCLOAK_SECRET}"
            authorization-grant-type: authorization_code
            scope: openid, profile, email
            redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}"
        provider:
          keycloak:
            issuer-uri: https://auth.example.com/realms/demo

Issuer discovery jämfört med manuella endpoints

För OIDC-leverantörer kan ni ange issuer-uri, så hämtar Spring dokumentet /.well-known/openid-configuration vid uppstart och upptäcker automatiskt endpoints för auktorisering, token, JWK Set och userinfo.

För vanliga OAuth2-leverantörer utan discovery (till exempel klassiska GitHub) måste ni ange endpoints själva.

spring:
  security:
    oauth2:
      client:
        provider:
          github:
            authorization-uri: https://github.com/login/oauth/authorize
            token-uri: https://github.com/login/oauth/access_token
            user-info-uri: https://api.github.com/user
            user-name-attribute: id

Aktivera oauth2Login i SecurityFilterChain

Koppla in flödet i er SecurityFilterChain. När ni anropar oauth2Login() aktiveras hela Authorization Code-flödet: ej autentiserade förfrågningar omdirigeras till leverantören och callbacken hanteras automatiskt.

Detta är ramverkskonfiguration, inte ett fristående program.

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/", "/error").permitAll()
                .anyRequest().authenticated())
            .oauth2Login(Customizer.withDefaults());
        return http.build();
    }
}

Authorization Code-flödet steg för steg

När oauth2Login() är aktivt händer följande i bakgrunden:

1. Användaren öppnar en skyddad URL och Spring omdirigerar webbläsaren till /oauth2/authorization/{registrationId}.
2. Spring skickar webbläsaren till leverantörens auktoriseringsendpoint med response_type=code, state och en PKCE-code_challenge.
3. Användaren autentiserar sig och godkänner åtkomsten hos leverantören.
4. Leverantören omdirigerar tillbaka till /login/oauth2/code/{registrationId} med en engångs-auktoriseringskod.
5. Spring växlar in koden server-till-server vid token-endpointen mot token.

Webbläsaren ser aldrig åtkomsttoken i steg 5 – det är ett anrop via back channel.

Åtkomst till den auktoriserade klienten och token

Efter inloggningen lagras åtkomsttoken i en OAuth2AuthorizedClient. Injicera den med argumentresolvern @RegisteredOAuth2AuthorizedClient för att läsa token som applikationen hämtade.

Det är denna token ni bifogar när ni anropar den underordnade resursservern.

@RestController
public class ApiController {

    @GetMapping("/token")
    public String token(
            @RegisteredOAuth2AuthorizedClient("keycloak")
            OAuth2AuthorizedClient client) {
        OAuth2AccessToken accessToken = client.getAccessToken();
        return "type=" + accessToken.getTokenType().getValue()
             + " expires=" + accessToken.getExpiresAt();
    }
}

Anropa API:er med RestClient och token

Spring Boot 4 föredrar RestClient. Konfigurera den med OAuth2ClientHttpRequestInterceptor, så bifogas bearer-token automatiskt från den auktoriserade klienten (och förnyas vid behov).

Interceptorn läser registrerings-ID:t från attributen i förfrågan.
Ni behöver inte skapa någon Authorization-header manuellt.

@Bean
RestClient restClient(OAuth2AuthorizedClientManager manager) {
    OAuth2ClientHttpRequestInterceptor interceptor =
        new OAuth2ClientHttpRequestInterceptor(manager);
    interceptor.setPrincipalResolver(
        new SecurityContextHolderPrincipalResolver());
    return RestClient.builder()
        .requestInterceptor(interceptor)
        .build();
}

Hanteraren för auktoriserade klienter

OAuth2AuthorizedClientManager är motorn som hämtar, cachar och förnyar token. Ni konfigurerar en provider-kedja som beskriver vilka grant-typer den stöder.

Det är aktiveringen av refreshToken() här som gör tyst tokenförnyelse möjlig när en åtkomsttoken löper ut.

@Bean
OAuth2AuthorizedClientManager authorizedClientManager(
        ClientRegistrationRepository clients,
        OAuth2AuthorizedClientRepository authorizedClients) {

    OAuth2AuthorizedClientProvider provider =
        OAuth2AuthorizedClientProviderBuilder.builder()
            .authorizationCode()
            .refreshToken()
            .build();

    DefaultOAuth2AuthorizedClientManager manager =
        new DefaultOAuth2AuthorizedClientManager(clients, authorizedClients);
    manager.setAuthorizedClientProvider(provider);
    return manager;
}

Så fungerar förnyelse

För att kunna förnya token måste två saker vara uppfyllda:

Leverantören har utfärdat en refresh_token – detta kräver vanligtvis scopet offline_access (Keycloak) eller en offline-grant.
Åtkomsttoken har löpt ut (eller ligger inom den konfigurerade klockförskjutningen) när hanteraren nästa gång hämtar klienten.

När ni anropar API:et via en tokenmedveten RestClient upptäcker RefreshTokenOAuth2AuthorizedClientProvider att token har löpt ut, skickar grant_type=refresh_token till token-endpointen och ersätter åtkomsttoken transparent med den nya. Ingen omdirigering av användaren behövs.

spring:
  security:
    oauth2:
      client:
        registration:
          keycloak:
            scope: openid, profile, offline_access
            authorization-grant-type: authorization_code

Modellera tokenförfall i vanlig Java

Beslutet om förnyelse handlar i grunden om att jämföra en tidpunkt för förfall i Instant med nuvarande tid, med en buffert för klockförskjutning. Här är den centrala logiken som ett komplett fristående program som ni kan köra för att se när en förnyelse skulle utlösas.

import java.time.Duration;
import java.time.Instant;

public class Main {
    static boolean shouldRefresh(Instant expiresAt, Instant now, Duration skew) {
        return expiresAt == null || now.isAfter(expiresAt.minus(skew));
    }

    public static void main(String[] args) {
        Instant now = Instant.parse("2026-01-01T10:00:00Z");
        Duration skew = Duration.ofSeconds(60);

        Instant valid = now.plusSeconds(300);   // 5 min left
        Instant nearly = now.plusSeconds(30);    // inside skew window
        Instant expired = now.minusSeconds(10);

        System.out.println("valid  -> refresh? " + shouldRefresh(valid, now, skew));
        System.out.println("nearly -> refresh? " + shouldRefresh(nearly, now, skew));
        System.out.println("expired-> refresh? " + shouldRefresh(expired, now, skew));
    }
}

Snabb kontroll

Ni har konfigurerat oauth2Login() och anropar ett underordnat API via en tokenmedveten RestClient. Åtkomsttoken löper ut efter 5 minuter, men användarna stannar på sidan i 30 minuter utan att autentisera sig igen. Vilken enda ändring aktiverar mest direkt tyst tokenförnyelse utan att skicka tillbaka användaren till inloggningssidan?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har konfigurerat Spring Boot 4 som en OAuth2-klient som driver Authorization Code-flödet:

Starter: spring-boot-starter-oauth2-client aktiverar flödet.
Registrering: client-id/secret, grant-typen authorization_code, scopes och en redirect-uri; OIDC-leverantörer upptäcker automatiskt endpoints via issuer-uri.
Aktivering: oauth2Login() hanterar omdirigering, PKCE-kodväxling och callback.
Använda token: injicera @RegisteredOAuth2AuthorizedClient eller anropa API:er via en tokenmedveten RestClient som använder en OAuth2AuthorizedClientManager.
Förnyelse: begär ett scope som stöder förnyelse och bygg hanteraren med .refreshToken(), så att utgångna åtkomsttoken förnyas tyst via grant_type=refresh_token.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 21
Lektioner: 84

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”OAuth2-klient och Authorization Code Flow” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Spring Boot 4 – komplett guide, inklusive ”OAuth2-klient och Authorization Code Flow”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Spring Boot 4 – komplett guide innehåller totalt 4 lektioner.

Vad lär jag mig i ”OAuth2-klient och Authorization Code Flow”?

Konfigurera OAuth2-klienten för att hämta och förnya tokens via authorization code grant. Ni övar på Spring Boot 4 – komplett guide med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Spring Boot 4 – komplett guide?

Du behöver inga förkunskaper. Utbildningen i Spring Boot 4 – komplett guide på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”OAuth2-klient och Authorization Code Flow”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Spring Boot 4 – komplett guide-lektionen?

Ja. Varje Spring Boot 4 – komplett guide-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

JWT-validering och claims för Resource Server
OAuth2-klient och Authorization Code Flow
Metodsäkerhet med SpEL och egna voters
Introspektion av opaka token och tokenutbyte

← Tillbaka till Spring Boot 4 – komplett guide