如何在Spring Boot中通过@FeignClient发送Bearer授权令牌

Alright, let's break down how to get your Spring Boot app talking to Wit.ai's REST API using their Bearer token auth—since you already have a working curl example, we can mirror that setup directly in Spring.

Wit.ai uses OAuth2 as its authorization layer, but for server-side integrations like yours, the static Bearer token approach (matching your curl request) is straightforward and effective. Below are two common implementation options using Spring's built-in HTTP clients.

Option 1: Using RestTemplate (Traditional Sync Approach) #

This is the simplest way to replicate your curl request in Spring Boot. We'll configure a RestTemplate with a header interceptor to automatically add the Bearer token and other required headers to every request.

First, create a configuration class to set up the RestTemplate:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpHeaders;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.web.client.RestTemplate;

import java.util.Collections;

@Configuration
public class WitAiConfig {

    // Replace with your actual Wit.ai Bearer token
    private static final String WIT_AI_TOKEN = "XXXXXXXXXXXXX";

    @Bean
    public RestTemplate witAiRestTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        
        // Add interceptor to inject auth and cache headers automatically
        ClientHttpRequestInterceptor authInterceptor = (request, body, execution) -> {
            HttpHeaders headers = request.getHeaders();
            headers.add(HttpHeaders.AUTHORIZATION, "Bearer " + WIT_AI_TOKEN);
            headers.add(HttpHeaders.CACHE_CONTROL, "no-cache");
            return execution.execute(request, body);
        };
        
        restTemplate.setInterceptors(Collections.singletonList(authInterceptor));
        return restTemplate;
    }
}

Next, create a service class to handle the API call to Wit.ai's /message endpoint:

import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;

@Service
public class WitAiService {

    private final RestTemplate witAiRestTemplate;
    private static final String WIT_AI_BASE_URL = "https://api.wit.ai/message";

    // Inject the configured RestTemplate via constructor
    public WitAiService(RestTemplate witAiRestTemplate) {
        this.witAiRestTemplate = witAiRestTemplate;
    }

    public String getMessageResponse(String userQuery) {
        // Build the full URL with the query parameter
        String requestUrl = UriComponentsBuilder.fromHttpUrl(WIT_AI_BASE_URL)
                .queryParam("q", userQuery)
                .toUriString();
        
        // Replace String with a custom DTO class if you want to map the JSON response directly
        return witAiRestTemplate.getForObject(requestUrl, String.class);
    }
}

Option 2: Using WebClient (Reactive Approach) #

If you're using Spring WebFlux or prefer a non-blocking reactive client, WebClient is the modern alternative to RestTemplate.

First, configure the WebClient:

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

@Configuration
public class WitAiWebClientConfig {

    private static final String WIT_AI_TOKEN = "XXXXXXXXXXXXX";
    private static final String WIT_AI_BASE_URL = "https://api.wit.ai";

    @Bean
    public WebClient witAiWebClient() {
        return WebClient.builder()
                .baseUrl(WIT_AI_BASE_URL)
                // Set default headers for all requests
                .defaultHeader(HttpHeaders.AUTHORIZATION, "Bearer " + WIT_AI_TOKEN)
                .defaultHeader(HttpHeaders.CACHE_CONTROL, "no-cache")
                .build();
    }
}

Then create a reactive service class:

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

@Service
public class WitAiReactiveService {

    private final WebClient witAiWebClient;

    public WitAiReactiveService(WebClient witAiWebClient) {
        this.witAiWebClient = witAiWebClient;
    }

    public Mono<String> getMessageResponse(String userQuery) {
        return witAiWebClient.get()
                .uri(uriBuilder -> uriBuilder.path("/message")
                        .queryParam("q", userQuery)
                        .build())
                .retrieve()
                .bodyToMono(String.class);
    }
}

Quick Notes on OAuth2 Compliance #

While Wit.ai's documentation references OAuth2, the static Bearer token setup works perfectly for server-to-server integrations like yours. If you ever need to handle user-specific authentication (e.g., per-user tokens), you could extend this with Spring Security's OAuth2 client support to dynamically fetch and refresh tokens. But for now, the above implementations will mirror your working curl request exactly.

内容的提问来源于stack exchange，提问作者Trey Bernstien