如何在Spring Boot Camel中配置Swagger API Key并启用UI授权功能

看起来你已经搞定了Swagger UI上的授权元素显示，但还缺了关键的一步——Swagger的securityDefinitions只是定义了UI的交互规则，并不会自动帮你做API Key的校验。下面是Spring Boot+Camel环境下的完整解决方案，分两种实现方式供你选择：

方式一：用Camel Processor实现API Key验证 #

这种方式更贴合Camel的路由逻辑，适合不想引入Spring Security的场景。

1. 编写API Key验证处理器 #

创建一个Camel Processor，专门负责检查请求头里的API Key是否合法：

import org.apache.camel.Exchange;
import org.apache.camel.Processor;
import org.springframework.stereotype.Component;

@Component
public class ApiKeyValidationProcessor implements Processor {

    // 建议从配置文件读取合法API Key，这里为了示例用固定值
    private static final String VALID_API_KEY = "your-secure-api-key-123";

    @Override
    public void process(Exchange exchange) throws Exception {
        String requestApiKey = exchange.getIn().getHeader("myHeader", String.class);
        
        // 校验API Key是否存在且合法
        if (requestApiKey == null || !requestApiKey.equals(VALID_API_KEY)) {
            exchange.getIn().setHeader(Exchange.HTTP_RESPONSE_CODE, 401);
            exchange.getIn().setBody("Unauthorized: Invalid or missing API Key");
            // 终止后续路由处理，直接返回错误
            exchange.setProperty(Exchange.ROUTE_STOP, Boolean.TRUE);
        }
    }
}

2. 将处理器添加到REST路由中 #

在你的Camel REST配置里，把这个处理器加到接口前面，确保每次请求都先经过校验：

// 注入刚才写的处理器
@Autowired
private ApiKeyValidationProcessor apiKeyValidationProcessor;

// 你的REST路由配置
rest("/user").tag("dude").description("User rest service") 
    // 原有的安全定义配置
    .securityDefinitions() 
        .apiKey("api_key").withHeader("myHeader").end() 
    .end() 
    .consumes("application/json").produces("application/json")
    // 新增：添加API Key验证处理器
    .process(apiKeyValidationProcessor)
    .get("/{id}/{date}").description("Find user by id and date").outType(User.class) 
    .security("api_key");

方式二：用Spring Security统一处理API Key验证 #

如果你的项目已经在用Spring Security，或者需要全局统一的权限控制，这种方式更合适。

1. 编写API Key认证过滤器 #

创建一个Spring的Filter，拦截所有请求并校验API Key：

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

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

@Component
public class ApiKeyAuthFilter extends OncePerRequestFilter {

    private static final String VALID_API_KEY = "your-secure-api-key-123";
    private static final String API_KEY_HEADER_NAME = "myHeader";

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String requestApiKey = request.getHeader(API_KEY_HEADER_NAME);
        
        if (requestApiKey == null || !requestApiKey.equals(VALID_API_KEY)) {
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            response.getWriter().write("Unauthorized: Invalid or missing API Key");
            return;
        }

        // 验证通过后，设置Spring Security的安全上下文（可选，用于后续权限控制）
        UsernamePasswordAuthenticationToken authToken = 
            new UsernamePasswordAuthenticationToken(requestApiKey, null, Collections.emptyList());
        SecurityContextHolder.getContext().setAuthentication(authToken);

        // 继续执行后续请求链
        filterChain.doFilter(request, response);
    }
}

2. 配置Spring Security规则 #

创建Spring Security配置类，注册过滤器并开放Swagger相关路径的访问权限：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    private final ApiKeyAuthFilter apiKeyAuthFilter;

    // 构造注入过滤器
    public SecurityConfig(ApiKeyAuthFilter apiKeyAuthFilter) {
        this.apiKeyAuthFilter = apiKeyAuthFilter;
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            // 关闭CSRF（REST接口通常不需要）
            .csrf(csrf -> csrf.disable())
            // 配置请求权限规则
            .authorizeHttpRequests(auth -> auth
                // 允许Swagger UI和API文档路径无需认证即可访问
                .requestMatchers("/swagger-ui/**", "/api-docs/**").permitAll()
                // 其他所有请求都需要认证
                .anyRequest().authenticated()
            )
            // 在用户名密码认证过滤器之前，添加我们的API Key过滤器
            .addFilterBefore(apiKeyAuthFilter, UsernamePasswordAuthenticationFilter.class);
        
        return http.build();
    }
}

验证效果 #

完成配置后，重启Spring Boot应用：

1. 打开Swagger UI（默认路径：http://localhost:8080/swagger-ui.html）
2. 点击右上角的「Authorize」按钮，输入你配置的合法API Key，点击「Authorize」
3. 调用/user/{id}/{date}接口，此时Swagger会自动在请求头里带上myHeader参数
4. 如果输入错误的API Key，会直接返回401 Unauthorized，符合预期

内容的提问来源于stack exchange，提问作者SP.