SpringBoot实现拦截Http请求并设置请求头

import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.web.client.RestTemplate;

import java.io.IOException;
import java.util.Collections;

public class HeaderInterceptor implements ClientHttpRequestInterceptor {
    
    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, 
                                      ClientHttpRequestExecution execution) throws IOException {
        // 添加请求头
        request.getHeaders().add("Authorization", "Bearer your-token");
        request.getHeaders().add("Custom-Header", "custom-value");
        
        return execution.execute(request, body);
    }
}

// 配置RestTemplate
@Bean
public RestTemplate restTemplate() {
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.setInterceptors(Collections.singletonList(new HeaderInterceptor()));
    return restTemplate;
}

import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {
    
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        return builder
                .additionalInterceptors(new HeaderInterceptor())
                .build();
    }
}

public class DynamicHeaderInterceptor implements ClientHttpRequestInterceptor {
    
    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, 
                                      ClientHttpRequestExecution execution) throws IOException {
        // 从安全上下文或其他来源动态获取值
        String token = SecurityContextHolder.getContext().getAuthentication().getCredentials().toString();
        request.getHeaders().add("Authorization", "Bearer " + token);
        
        return execution.execute(request, body);
    }
}

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@Component
@Order(1) // 执行顺序
public class GlobalHttpFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                        FilterChain chain) throws IOException, ServletException {
        
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        
        // 添加全局请求头
        if (httpRequest.getHeader("Authorization") == null) {
            // 这里可以设置默认认证头或其他通用头
        }
        
        // 记录请求日志
        System.out.println("Request URL: " + httpRequest.getRequestURL());
        System.out.println("Method: " + httpRequest.getMethod());
        
        chain.doFilter(request, response); // 继续执行过滤器链
    }
}

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class HttpRequestAspect {

    @Around("execution(* org.springframework.web.client.RestTemplate.*(..)) || " +
            "execution(* org.springframework.web.reactive.function.client.WebClient.*(..))")
    public Object aroundHttpRequest(ProceedingJoinPoint joinPoint) throws Throwable {
        
        // 在方法执行前添加请求头
        Object[] args = joinPoint.getArgs();
        for (int i = 0; i < args.length; i++) {
            if (args[i] instanceof HttpEntity) {
                HttpEntity<?> entity = (HttpEntity<?>) args[i];
                HttpHeaders headers = new HttpHeaders();
                headers.putAll(entity.getHeaders());
                headers.add("Global-Header", "common-value");
                
                // 替换为新的HttpEntity
                args[i] = new HttpEntity<>(entity.getBody(), headers);
            }
        }
        
        return joinPoint.proceed(args);
    }
}

import okhttp3.Interceptor;
import okhttp3.Response;
import java.io.IOException;

public class GlobalOkHttpInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        return chain.proceed(chain.request().newBuilder()
                .addHeader("Authorization", "Bearer token")
                .addHeader("X-Request-ID", UUID.randomUUID().toString())
                .build());
    }
}

public void setRequestHeader(String key, String value) {
        if (StringUtils.isEmpty(key) || StringUtils.isEmpty(value)) {
            return;
        }
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (null == attributes) {
            return;
        }
        HttpServletRequest request = attributes.getRequest();
        Class<? extends HttpServletRequest> requestClass = request.getClass();
        try {
            // 反射获取request属性
            Field headerField = requestClass.getDeclaredField("headerMap");
            headerField.setAccessible(true);
            Map<String, String> headerMap = (Map<String, String>) headerField.get(request);
            headerMap.put(key, value);
        } catch (Exception e) {
            log.error("set header error: ", e);
        }
    }

// 1. 定义一个打印日志的拦截器
public class LoggingInterceptor implements ClientHttpRequestInterceptor {
    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        System.out.println("【拦截器执行】准备发送请求至: " + request.getURI());
        // ... 可以在这里添加请求头
        return execution.execute(request, body);
    }
}

// 2. 将拦截器添加到 RestTemplate
@Bean
public RestTemplate restTemplate() {
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.setInterceptors(Collections.singletonList(new LoggingInterceptor()));
    return restTemplate;
}

// 3. 在服务中多次使用 RestTemplate
@Service
public class MyService {

    @Autowired
    private RestTemplate restTemplate;

    public void fetchData() {
        // 第一次调用
        String result1 = restTemplate.getForObject("https://api.example.com/data/1", String.class);
        
        // 第二次调用
        String result2 = restTemplate.getForObject("https://api.example.com/data/2", String.class);
    }
}

// 从客户端发来的请求中获取头信息
String authHeader = httpRequest.getHeader("Authorization");
String userAgent = httpRequest.getHeader("User-Agent");

// 向客户端发送响应时设置头信息
httpResponse.setHeader("Content-Type", "application/json");
httpResponse.addHeader("X-Custom-Header", "MyValue");

// 在Filter中设置属性
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
    HttpServletRequest httpRequest = (HttpServletRequest) request;
    // 认证成功后，将用户信息存入attribute
    User user = authenticateUser(httpRequest);
    httpRequest.setAttribute("currentUser", user); // 存入任何对象
    chain.doFilter(request, response);
}

// 在Controller中获取和使用属性
@GetMapping("/api/profile")
public ResponseEntity getUserProfile(HttpServletRequest request) {
    // 从attribute中取出之前存入的对象
    User currentUser = (User) request.getAttribute("currentUser");
    // ... 使用user对象处理业务
    return ResponseEntity.ok(currentUser.getProfile());
}