Spring Boot中获取Token：已有获取方法不知如何集成使用

Hey there! Let's get that token method integrated into your Spring Boot app smoothly. I'll walk you through two approaches: one using your existing HttpClient code (refactored for Spring best practices) and another using Spring's modern WebClient (the recommended approach for new projects).

First, I'll assume your incomplete grant_type parameter is "password" (since you're passing username and password)—I'll fill that in for you in the examples below.

Option 1: Refactor Your Existing HttpClient Method for Spring Boot #

This approach keeps your core logic but wraps it in Spring-managed components for reusability and maintainability.

Step 1: Add Required Dependencies #

Make sure Apache HttpClient is in your build file. For Maven, add this to pom.xml:

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.14</version> <!-- Use the latest stable version -->
</dependency>

Step 2: Create a Spring-Managed Token Service #

Wrap your token logic in a @Service class so Spring can handle dependency injection and lifecycle management:

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class TokenService {

    private final HttpClient httpClient;
    private final ObjectMapper objectMapper;

    // Constructor injection (preferred in Spring)
    public TokenService() {
        this.httpClient = HttpClientBuilder.create().build();
        this.objectMapper = new ObjectMapper();
    }

    public String getToken(String username, String password) throws Exception {
        HttpPost request = new HttpPost("https://idp.comprobanteselectronicos.go.cr/auth/realms/rut-stag/protocol/openid-connect/token");
        
        // Complete the required form parameters
        List<NameValuePair> urlParameters = new ArrayList<>();
        urlParameters.add(new BasicNameValuePair("grant_type", "password"));
        urlParameters.add(new BasicNameValuePair("username", username));
        urlParameters.add(new BasicNameValuePair("password", password));
        // Add client_id if your IDP requires it:
        // urlParameters.add(new BasicNameValuePair("client_id", "your-client-id"));
        
        request.setEntity(new UrlEncodedFormEntity(urlParameters));
        
        HttpResponse response = httpClient.execute(request);
        String responseBody = EntityUtils.toString(response.getEntity());
        
        // Parse the JSON response to extract the access token
        JsonNode jsonNode = objectMapper.readTree(responseBody);
        return jsonNode.get("access_token").asText();
    }
}

Step 3: Use the Service in Your App #

Inject the TokenService into controllers, services, or other components where you need a token:

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

@RestController
public class TokenController {

    private final TokenService tokenService;

    // Constructor injection
    public TokenController(TokenService tokenService) {
        this.tokenService = tokenService;
    }

    @GetMapping("/fetch-token")
    public String fetchToken(@RequestParam String username, @RequestParam String password) {
        try {
            return tokenService.getToken(username, password);
        } catch (Exception e) {
            // Replace with proper logging and error handling in production
            e.printStackTrace();
            return "Failed to retrieve token: " + e.getMessage();
        }
    }
}

Option 2: Use Spring's WebClient (Modern, Reactive Approach) #

Spring recommends WebClient over HttpClient/RestTemplate for new projects, especially if you're using reactive programming. Here's how to implement it:

Step 1: Add WebClient Dependency #

For Maven, add this to pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

Step 2: Configure WebClient as a Bean #

Create a WebClient bean in a configuration class to reuse it across your app:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.WebClient;

@Configuration
public class WebClientConfig {

    @Bean
    public WebClient idpWebClient() {
        return WebClient.builder()
                .baseUrl("https://idp.comprobanteselectronicos.go.cr/auth/realms/rut-stag/protocol/openid-connect")
                .build();
    }
}

Step 3: Build a Reactive Token Service #

Rewrite your token logic using WebClient for non-blocking calls:

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;
import org.springframework.web.reactive.function.BodyInserters;

@Service
public class TokenService {

    private final WebClient idpWebClient;

    public TokenService(WebClient idpWebClient) {
        this.idpWebClient = idpWebClient;
    }

    public Mono<String> getToken(String username, String password) {
        return idpWebClient.post()
                .uri("/token")
                .body(BodyInserters.fromFormData("grant_type", "password")
                        .with("username", username)
                        .with("password", password))
                .header("Content-Type", "application/x-www-form-urlencoded")
                .retrieve()
                .bodyToMono(TokenResponse.class)
                .map(TokenResponse::getAccessToken)
                .onErrorResume(e -> Mono.just("Failed to retrieve token: " + e.getMessage()));
    }

    // DTO to map the JSON response from the IDP
    private static class TokenResponse {
        private String access_token;

        public String getAccessToken() {
            return access_token;
        }

        public void setAccessToken(String access_token) {
            this.access_token = access_token;
        }
    }
}

Step 4: Use the Reactive Service #

In a controller, return the Mono directly for a reactive response:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;

@RestController
public class TokenController {

    private final TokenService tokenService;

    public TokenController(TokenService tokenService) {
        this.tokenService = tokenService;
    }

    @GetMapping("/fetch-token")
    public Mono<String> fetchToken(@RequestParam String username, @RequestParam String password) {
        return tokenService.getToken(username, password);
    }
}

Key Best Practices to Follow #

• Secure Credentials: Never hardcode usernames, passwords, or client IDs. Use Spring's @Value to read them from application.properties:

  @Value("${idp.client-id}")
  private String clientId;
  

• Token Caching: If your token has an expiration time, cache it using Spring's @Cacheable annotation to avoid unnecessary calls to the IDP.
• Proper Error Handling: Replace print statements with structured logging (use org.slf4j.Logger) and return meaningful HTTP error codes (like 401 for invalid credentials).

内容的提问来源于stack exchange，提问作者Jason Smith