SpringBoot + 网关插件热插拔 + 动态启停：无需重启即可开启/关闭限流、鉴权等能力

2026-04-09 / 2026-04-10 / SpringBoot 网关插件热插拔动态启停

前言

在现代微服务架构中，API 网关扮演着越来越重要的角色，它不仅是服务的入口，还承担着路由、限流、鉴权、监控等多种职责。传统的网关实现通常将这些功能硬编码在代码中，当需要添加、修改或移除某个功能时，往往需要重启网关服务，这会导致服务暂时不可用，影响用户体验。

想象一下这样的场景：你的网关服务正在生产环境中运行，突然发现某个接口需要紧急开启限流功能，或者某个鉴权规则需要调整。如果此时需要重启网关服务来应用这些变更，那么在重启期间，所有通过网关的请求都会失败，这对业务的影响是不可接受的。

网关插件热插拔和动态启停正是为了解决这个问题而设计的。通过将网关的各种功能模块化，以插件的形式实现，并支持在运行时动态加载、卸载和启停这些插件，我们可以在不重启网关服务的情况下，灵活地开启或关闭各种功能，如限流、鉴权等。本文将详细介绍如何在 Spring Boot 中实现网关插件的热插拔和动态启停功能。

一、核心概念

1.1 网关插件

网关插件是将网关的各种功能模块化，以插件的形式实现的组件。每个插件负责一种特定的功能，如限流、鉴权、日志记录等。插件可以独立开发、测试和部署，也可以在运行时动态加载和卸载。

1.2 热插拔

热插拔是指在不停止系统运行的情况下，动态添加或移除组件的能力。在网关插件的场景中，热插拔意味着可以在网关服务运行时，动态加载或卸载插件，而不需要重启服务。

1.3 动态启停

动态启停是指在不重启系统的情况下，动态开启或关闭组件的能力。在网关插件的场景中，动态启停意味着可以在网关服务运行时，开启或关闭某个插件的功能，而不需要重启服务。

1.4 为什么需要网关插件热插拔和动态启停

灵活性：可以根据业务需求，灵活地添加、修改或移除网关功能
高可用性：在修改网关功能时，不需要重启服务，确保服务的持续可用
快速响应：可以快速响应业务需求的变化，如紧急开启限流功能
降低风险：可以在生产环境中安全地测试新功能，而不影响现有服务
便于维护：将功能模块化，便于代码的维护和管理

二、技术方案

2.1 插件架构设计

网关插件的架构设计主要包括以下几个部分：

插件接口：定义插件的通用接口，包括插件的初始化、启动、停止和销毁方法
插件实现：实现各种具体的插件，如限流插件、鉴权插件等
插件管理：负责插件的加载、卸载、启动和停止等管理操作
插件配置：管理插件的配置信息，支持动态更新
插件注册：将插件注册到网关中，使其能够处理请求

2.2 技术选型

Spring Boot：作为基础框架，提供依赖注入、配置管理等功能
Spring Cloud Gateway：作为API网关，提供路由、过滤器等功能
ClassLoader：用于动态加载插件类
Spring Context：用于管理插件的生命周期
事件机制：用于插件的动态注册和注销

2.3 核心流程

插件加载：通过 ClassLoader 动态加载插件类，并实例化插件对象
插件初始化：调用插件的初始化方法，传入配置信息
插件启动：调用插件的启动方法，开始处理请求
插件运行：插件处理网关请求，执行相应的功能
插件停止：调用插件的停止方法，停止处理请求
插件卸载：销毁插件对象，释放资源

三、Spring Boot 网关插件热插拔实现

3.1 依赖配置

<dependencies>
    <!-- Spring Cloud Gateway -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>

    <!-- Spring Boot Actuator -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

    <!-- Micrometer -->
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-registry-prometheus</artifactId>
    </dependency>

    <!-- Spring Boot Configuration Processor -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>

    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

    <!-- Test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

3.2 插件接口定义

public interface GatewayPlugin {

    /**
     * 插件名称
     */
    String getName();

    /**
     * 初始化插件
     */
    void init(Map<String, Object> config);

    /**
     * 启动插件
     */
    void start();

    /**
     * 停止插件
     */
    void stop();

    /**
     * 销毁插件
     */
    void destroy();

    /**
     * 处理请求
     */
    Mono<Void> handle(ServerWebExchange exchange, GatewayFilterChain chain);

    /**
     * 获取插件状态
     */
    PluginStatus getStatus();

    /**
     * 插件状态枚举
     */
    enum PluginStatus {
        INITIALIZED, // 已初始化
        STARTED,     // 已启动
        STOPPED,     // 已停止
        DESTROYED    // 已销毁
    }

}

3.3 插件管理服务

@Service
@Slf4j
public class PluginManager {

    private final Map<String, GatewayPlugin> plugins = new ConcurrentHashMap<>();
    private final Map<String, PluginStatus> pluginStatuses = new ConcurrentHashMap<>();

    /**
     * 加载插件
     */
    public void loadPlugin(String pluginName, String pluginClass) {
        try {
            // 加载插件类
            Class<?> clazz = Class.forName(pluginClass);
            GatewayPlugin plugin = (GatewayPlugin) clazz.newInstance();

            // 初始化插件
            plugin.init(new HashMap<>());

            // 注册插件
            plugins.put(pluginName, plugin);
            pluginStatuses.put(pluginName, PluginStatus.INITIALIZED);

            log.info("Plugin loaded: {}", pluginName);
        } catch (Exception e) {
            log.error("Failed to load plugin: {}", pluginName, e);
        }
    }

    /**
     * 卸载插件
     */
    public void unloadPlugin(String pluginName) {
        GatewayPlugin plugin = plugins.get(pluginName);
        if (plugin != null) {
            // 停止插件
            plugin.stop();

            // 销毁插件
            plugin.destroy();

            // 移除插件
            plugins.remove(pluginName);
            pluginStatuses.remove(pluginName);

            log.info("Plugin unloaded: {}", pluginName);
        }
    }

    /**
     * 启动插件
     */
    public void startPlugin(String pluginName) {
        GatewayPlugin plugin = plugins.get(pluginName);
        if (plugin != null) {
            plugin.start();
            pluginStatuses.put(pluginName, PluginStatus.STARTED);
            log.info("Plugin started: {}", pluginName);
        }
    }

    /**
     * 停止插件
     */
    public void stopPlugin(String pluginName) {
        GatewayPlugin plugin = plugins.get(pluginName);
        if (plugin != null) {
            plugin.stop();
            pluginStatuses.put(pluginName, PluginStatus.STOPPED);
            log.info("Plugin stopped: {}", pluginName);
        }
    }

    /**
     * 获取插件
     */
    public GatewayPlugin getPlugin(String pluginName) {
        return plugins.get(pluginName);
    }

    /**
     * 获取所有插件
     */
    public Map<String, GatewayPlugin> getAllPlugins() {
        return plugins;
    }

    /**
     * 获取插件状态
     */
    public PluginStatus getPluginStatus(String pluginName) {
        return pluginStatuses.get(pluginName);
    }

}

3.4 插件过滤器

@Component
public class PluginGatewayFilterFactory extends AbstractGatewayFilterFactory<PluginGatewayFilterFactory.Config> {

    @Autowired
    private PluginManager pluginManager;

    public PluginGatewayFilterFactory() {
        super(Config.class);
    }

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            // 获取插件
            GatewayPlugin plugin = pluginManager.getPlugin(config.getPluginName());

            if (plugin == null) {
                return chain.filter(exchange);
            }

            // 检查插件状态
            if (plugin.getStatus() != GatewayPlugin.PluginStatus.STARTED) {
                return chain.filter(exchange);
            }

            // 处理请求
            return plugin.handle(exchange, chain);
        };
    }

    public static class Config {
        private String pluginName;

        public String getPluginName() {
            return pluginName;
        }

        public void setPluginName(String pluginName) {
            this.pluginName = pluginName;
        }
    }

}

四、动态启停实现

4.1 插件配置管理

@Data
@ConfigurationProperties(prefix = "gateway.plugin")
public class GatewayPluginProperties {

    private boolean enabled = true;
    private List<PluginConfig> plugins = new ArrayList<>();

    @Data
    public static class PluginConfig {
        private String name;
        private String className;
        private boolean enabled = true;
        private Map<String, Object> config = new HashMap<>();
    }

}

4.2 插件控制器

@RestController
@RequestMapping("/actuator/plugins")
public class PluginController {

    @Autowired
    private PluginManager pluginManager;

    @Autowired
    private GatewayPluginProperties properties;

    @GetMapping("/list")
    public ResponseEntity<Map<String, Object>> listPlugins() {
        Map<String, Object> result = new HashMap<>();
        Map<String, GatewayPlugin> plugins = pluginManager.getAllPlugins();
        Map<String, Object> pluginInfo = new HashMap<>();

        for (Map.Entry<String, GatewayPlugin> entry : plugins.entrySet()) {
            Map<String, Object> info = new HashMap<>();
            info.put("status", pluginManager.getPluginStatus(entry.getKey()));
            pluginInfo.put(entry.getKey(), info);
        }

        result.put("plugins", pluginInfo);
        return ResponseEntity.ok(result);
    }

    @PostMapping("/load")
    public ResponseEntity<String> loadPlugin(@RequestBody Map<String, String> request) {
        String name = request.get("name");
        String className = request.get("className");

        if (name == null || className == null) {
            return ResponseEntity.badRequest().body("Missing name or className");
        }

        pluginManager.loadPlugin(name, className);
        return ResponseEntity.ok("Plugin loaded");
    }

    @PostMapping("/unload")
    public ResponseEntity<String> unloadPlugin(@RequestBody Map<String, String> request) {
        String name = request.get("name");

        if (name == null) {
            return ResponseEntity.badRequest().body("Missing name");
        }

        pluginManager.unloadPlugin(name);
        return ResponseEntity.ok("Plugin unloaded");
    }

    @PostMapping("/start")
    public ResponseEntity<String> startPlugin(@RequestBody Map<String, String> request) {
        String name = request.get("name");

        if (name == null) {
            return ResponseEntity.badRequest().body("Missing name");
        }

        pluginManager.startPlugin(name);
        return ResponseEntity.ok("Plugin started");
    }

    @PostMapping("/stop")
    public ResponseEntity<String> stopPlugin(@RequestBody Map<String, String> request) {
        String name = request.get("name");

        if (name == null) {
            return ResponseEntity.badRequest().body("Missing name");
        }

        pluginManager.stopPlugin(name);
        return ResponseEntity.ok("Plugin stopped");
    }

}

4.3 插件事件监听

@Component
public class PluginEventListener {

    @Autowired
    private PluginManager pluginManager;

    @Autowired
    private GatewayPluginProperties properties;

    @EventListener(ContextRefreshedEvent.class)
    public void onContextRefreshed() {
        // 加载配置的插件
        for (GatewayPluginProperties.PluginConfig config : properties.getPlugins()) {
            if (config.isEnabled()) {
                pluginManager.loadPlugin(config.getName(), config.getClassName());
                pluginManager.startPlugin(config.getName());
            }
        }
    }

}

五、限流、鉴权等插件实现

5.1 限流插件

@Slf4j
public class RateLimitPlugin implements GatewayPlugin {

    private PluginStatus status = PluginStatus.INITIALIZED;
    private RateLimiter rateLimiter;

    @Override
    public String getName() {
        return "rateLimit";
    }

    @Override
    public void init(Map<String, Object> config) {
        // 初始化限流插件
        int permitsPerSecond = (int) config.getOrDefault("permitsPerSecond", 10);
        rateLimiter = RateLimiter.create(permitsPerSecond);
        log.info("RateLimit plugin initialized with permitsPerSecond: {}", permitsPerSecond);
    }

    @Override
    public void start() {
        status = PluginStatus.STARTED;
        log.info("RateLimit plugin started");
    }

    @Override
    public void stop() {
        status = PluginStatus.STOPPED;
        log.info("RateLimit plugin stopped");
    }

    @Override
    public void destroy() {
        status = PluginStatus.DESTROYED;
        log.info("RateLimit plugin destroyed");
    }

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, GatewayFilterChain chain) {
        if (rateLimiter.tryAcquire()) {
            return chain.filter(exchange);
        } else {
            exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
            return exchange.getResponse().setComplete();
        }
    }

    @Override
    public PluginStatus getStatus() {
        return status;
    }

}

5.2 鉴权插件

@Slf4j
public class AuthPlugin implements GatewayPlugin {

    private PluginStatus status = PluginStatus.INITIALIZED;
    private Set<String> validTokens;

    @Override
    public String getName() {
        return "auth";
    }

    @Override
    public void init(Map<String, Object> config) {
        // 初始化鉴权插件
        validTokens = new HashSet<>();
        List<String> tokens = (List<String>) config.getOrDefault("validTokens", new ArrayList<>());
        validTokens.addAll(tokens);
        log.info("Auth plugin initialized with {} valid tokens", validTokens.size());
    }

    @Override
    public void start() {
        status = PluginStatus.STARTED;
        log.info("Auth plugin started");
    }

    @Override
    public void stop() {
        status = PluginStatus.STOPPED;
        log.info("Auth plugin stopped");
    }

    @Override
    public void destroy() {
        status = PluginStatus.DESTROYED;
        log.info("Auth plugin destroyed");
    }

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = exchange.getRequest().getHeaders().getFirst("Authorization");
        if (token != null && validTokens.contains(token)) {
            return chain.filter(exchange);
        } else {
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
    }

    @Override
    public PluginStatus getStatus() {
        return status;
    }

}

5.3 日志插件

@Slf4j
public class LoggingPlugin implements GatewayPlugin {

    private PluginStatus status = PluginStatus.INITIALIZED;

    @Override
    public String getName() {
        return "logging";
    }

    @Override
    public void init(Map<String, Object> config) {
        // 初始化日志插件
        log.info("Logging plugin initialized");
    }

    @Override
    public void start() {
        status = PluginStatus.STARTED;
        log.info("Logging plugin started");
    }

    @Override
    public void stop() {
        status = PluginStatus.STOPPED;
        log.info("Logging plugin stopped");
    }

    @Override
    public void destroy() {
        status = PluginStatus.DESTROYED;
        log.info("Logging plugin destroyed");
    }

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 记录请求信息
        log.info("Request: {} {}", exchange.getRequest().getMethod(), exchange.getRequest().getPath());

        // 记录响应信息
        return chain.filter(exchange).then(Mono.fromRunnable(() -> {
            log.info("Response: {}", exchange.getResponse().getStatusCode());
        }));
    }

    @Override
    public PluginStatus getStatus() {
        return status;
    }

}

六、Spring Boot 完整实现

6.1 项目依赖

<dependencies>
    <!-- Spring Cloud Gateway -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>

    <!-- Spring Boot Actuator -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

    <!-- Micrometer -->
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-registry-prometheus</artifactId>
    </dependency>

    <!-- Spring Boot Configuration Processor -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>

    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

    <!-- Guava (for RateLimiter) -->
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>31.0.1-jre</version>
    </dependency>

    <!-- Test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

6.2 配置文件

server:
  port: 8080

spring:
  application:
    name: gateway-plugin-demo
  cloud:
    gateway:
      routes:
        - id: test-route
          uri: http://httpbin.org
          predicates:
            - Path=/api/**
          filters:
            - Plugin=rateLimit
            - Plugin=auth
            - Plugin=logging

# 网关插件配置
gateway:
  plugin:
    enabled: true
    plugins:
      - name: rateLimit
        className: com.example.demo.plugin.RateLimitPlugin
        enabled: true
        config:
          permitsPerSecond: 10
      - name: auth
        className: com.example.demo.plugin.AuthPlugin
        enabled: true
        config:
          validTokens:
            - token1
            - token2
            - token3
      - name: logging
        className: com.example.demo.plugin.LoggingPlugin
        enabled: true

# 监控配置
management:
  endpoints:
    web:
      exposure:
        include: health,info,prometheus,plugins

6.3 核心配置类

6.3.1 插件接口

public interface GatewayPlugin {

    /**
     * 插件名称
     */
    String getName();

    /**
     * 初始化插件
     */
    void init(Map<String, Object> config);

    /**
     * 启动插件
     */
    void start();

    /**
     * 停止插件
     */
    void stop();

    /**
     * 销毁插件
     */
    void destroy();

    /**
     * 处理请求
     */
    Mono<Void> handle(ServerWebExchange exchange, GatewayFilterChain chain);

    /**
     * 获取插件状态
     */
    PluginStatus getStatus();

    /**
     * 插件状态枚举
     */
    enum PluginStatus {
        INITIALIZED, // 已初始化
        STARTED,     // 已启动
        STOPPED,     // 已停止
        DESTROYED    // 已销毁
    }

}

6.3.2 插件管理服务

@Service
@Slf4j
public class PluginManager {

    private final Map<String, GatewayPlugin> plugins = new ConcurrentHashMap<>();
    private final Map<String, GatewayPlugin.PluginStatus> pluginStatuses = new ConcurrentHashMap<>();

    /**
     * 加载插件
     */
    public void loadPlugin(String pluginName, String pluginClass) {
        try {
            // 加载插件类
            Class<?> clazz = Class.forName(pluginClass);
            GatewayPlugin plugin = (GatewayPlugin) clazz.newInstance();

            // 初始化插件
            plugin.init(new HashMap<>());

            // 注册插件
            plugins.put(pluginName, plugin);
            pluginStatuses.put(pluginName, GatewayPlugin.PluginStatus.INITIALIZED);

            log.info("Plugin loaded: {}", pluginName);
        } catch (Exception e) {
            log.error("Failed to load plugin: {}", pluginName, e);
        }
    }

    /**
     * 卸载插件
     */
    public void unloadPlugin(String pluginName) {
        GatewayPlugin plugin = plugins.get(pluginName);
        if (plugin != null) {
            // 停止插件
            plugin.stop();

            // 销毁插件
            plugin.destroy();

            // 移除插件
            plugins.remove(pluginName);
            pluginStatuses.remove(pluginName);

            log.info("Plugin unloaded: {}", pluginName);
        }
    }

    /**
     * 启动插件
     */
    public void startPlugin(String pluginName) {
        GatewayPlugin plugin = plugins.get(pluginName);
        if (plugin != null) {
            plugin.start();
            pluginStatuses.put(pluginName, GatewayPlugin.PluginStatus.STARTED);
            log.info("Plugin started: {}", pluginName);
        }
    }

    /**
     * 停止插件
     */
    public void stopPlugin(String pluginName) {
        GatewayPlugin plugin = plugins.get(pluginName);
        if (plugin != null) {
            plugin.stop();
            pluginStatuses.put(pluginName, GatewayPlugin.PluginStatus.STOPPED);
            log.info("Plugin stopped: {}", pluginName);
        }
    }

    /**
     * 获取插件
     */
    public GatewayPlugin getPlugin(String pluginName) {
        return plugins.get(pluginName);
    }

    /**
     * 获取所有插件
     */
    public Map<String, GatewayPlugin> getAllPlugins() {
        return plugins;
    }

    /**
     * 获取插件状态
     */
    public GatewayPlugin.PluginStatus getPluginStatus(String pluginName) {
        return pluginStatuses.get(pluginName);
    }

}

6.3.3 插件过滤器

@Component
public class PluginGatewayFilterFactory extends AbstractGatewayFilterFactory<PluginGatewayFilterFactory.Config> {

    @Autowired
    private PluginManager pluginManager;

    public PluginGatewayFilterFactory() {
        super(Config.class);
    }

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            // 获取插件
            GatewayPlugin plugin = pluginManager.getPlugin(config.getPluginName());

            if (plugin == null) {
                return chain.filter(exchange);
            }

            // 检查插件状态
            if (plugin.getStatus() != GatewayPlugin.PluginStatus.STARTED) {
                return chain.filter(exchange);
            }

            // 处理请求
            return plugin.handle(exchange, chain);
        };
    }

    public static class Config {
        private String pluginName;

        public String getPluginName() {
            return pluginName;
        }

        public void setPluginName(String pluginName) {
            this.pluginName = pluginName;
        }
    }

}

6.3.4 插件配置管理

@Data
@ConfigurationProperties(prefix = "gateway.plugin")
public class GatewayPluginProperties {

    private boolean enabled = true;
    private List<PluginConfig> plugins = new ArrayList<>();

    @Data
    public static class PluginConfig {
        private String name;
        private String className;
        private boolean enabled = true;
        private Map<String, Object> config = new HashMap<>();
    }

}

6.3.5 插件控制器

@RestController
@RequestMapping("/actuator/plugins")
public class PluginController {

    @Autowired
    private PluginManager pluginManager;

    @Autowired
    private GatewayPluginProperties properties;

    @GetMapping("/list")
    public ResponseEntity<Map<String, Object>> listPlugins() {
        Map<String, Object> result = new HashMap<>();
        Map<String, GatewayPlugin> plugins = pluginManager.getAllPlugins();
        Map<String, Object> pluginInfo = new HashMap<>();

        for (Map.Entry<String, GatewayPlugin> entry : plugins.entrySet()) {
            Map<String, Object> info = new HashMap<>();
            info.put("status", pluginManager.getPluginStatus(entry.getKey()));
            pluginInfo.put(entry.getKey(), info);
        }

        result.put("plugins", pluginInfo);
        return ResponseEntity.ok(result);
    }

    @PostMapping("/load")
    public ResponseEntity<String> loadPlugin(@RequestBody Map<String, String> request) {
        String name = request.get("name");
        String className = request.get("className");

        if (name == null || className == null) {
            return ResponseEntity.badRequest().body("Missing name or className");
        }

        pluginManager.loadPlugin(name, className);
        return ResponseEntity.ok("Plugin loaded");
    }

    @PostMapping("/unload")
    public ResponseEntity<String> unloadPlugin(@RequestBody Map<String, String> request) {
        String name = request.get("name");

        if (name == null) {
            return ResponseEntity.badRequest().body("Missing name");
        }

        pluginManager.unloadPlugin(name);
        return ResponseEntity.ok("Plugin unloaded");
    }

    @PostMapping("/start")
    public ResponseEntity<String> startPlugin(@RequestBody Map<String, String> request) {
        String name = request.get("name");

        if (name == null) {
            return ResponseEntity.badRequest().body("Missing name");
        }

        pluginManager.startPlugin(name);
        return ResponseEntity.ok("Plugin started");
    }

    @PostMapping("/stop")
    public ResponseEntity<String> stopPlugin(@RequestBody Map<String, String> request) {
        String name = request.get("name");

        if (name == null) {
            return ResponseEntity.badRequest().body("Missing name");
        }

        pluginManager.stopPlugin(name);
        return ResponseEntity.ok("Plugin stopped");
    }

}

6.3.6 插件事件监听

@Component
public class PluginEventListener {

    @Autowired
    private PluginManager pluginManager;

    @Autowired
    private GatewayPluginProperties properties;

    @EventListener(ContextRefreshedEvent.class)
    public void onContextRefreshed() {
        // 加载配置的插件
        for (GatewayPluginProperties.PluginConfig config : properties.getPlugins()) {
            if (config.isEnabled()) {
                pluginManager.loadPlugin(config.getName(), config.getClassName());
                pluginManager.startPlugin(config.getName());
            }
        }
    }

}

6.4 插件实现

6.4.1 限流插件

@Slf4j
public class RateLimitPlugin implements GatewayPlugin {

    private PluginStatus status = PluginStatus.INITIALIZED;
    private RateLimiter rateLimiter;

    @Override
    public String getName() {
        return "rateLimit";
    }

    @Override
    public void init(Map<String, Object> config) {
        // 初始化限流插件
        int permitsPerSecond = (int) config.getOrDefault("permitsPerSecond", 10);
        rateLimiter = RateLimiter.create(permitsPerSecond);
        log.info("RateLimit plugin initialized with permitsPerSecond: {}", permitsPerSecond);
    }

    @Override
    public void start() {
        status = PluginStatus.STARTED;
        log.info("RateLimit plugin started");
    }

    @Override
    public void stop() {
        status = PluginStatus.STOPPED;
        log.info("RateLimit plugin stopped");
    }

    @Override
    public void destroy() {
        status = PluginStatus.DESTROYED;
        log.info("RateLimit plugin destroyed");
    }

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, GatewayFilterChain chain) {
        if (rateLimiter.tryAcquire()) {
            return chain.filter(exchange);
        } else {
            exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
            return exchange.getResponse().setComplete();
        }
    }

    @Override
    public PluginStatus getStatus() {
        return status;
    }

}

6.4.2 鉴权插件

@Slf4j
public class AuthPlugin implements GatewayPlugin {

    private PluginStatus status = PluginStatus.INITIALIZED;
    private Set<String> validTokens;

    @Override
    public String getName() {
        return "auth";
    }

    @Override
    public void init(Map<String, Object> config) {
        // 初始化鉴权插件
        validTokens = new HashSet<>();
        List<String> tokens = (List<String>) config.getOrDefault("validTokens", new ArrayList<>());
        validTokens.addAll(tokens);
        log.info("Auth plugin initialized with {} valid tokens", validTokens.size());
    }

    @Override
    public void start() {
        status = PluginStatus.STARTED;
        log.info("Auth plugin started");
    }

    @Override
    public void stop() {
        status = PluginStatus.STOPPED;
        log.info("Auth plugin stopped");
    }

    @Override
    public void destroy() {
        status = PluginStatus.DESTROYED;
        log.info("Auth plugin destroyed");
    }

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = exchange.getRequest().getHeaders().getFirst("Authorization");
        if (token != null && validTokens.contains(token)) {
            return chain.filter(exchange);
        } else {
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
    }

    @Override
    public PluginStatus getStatus() {
        return status;
    }

}

6.4.3 日志插件

@Slf4j
public class LoggingPlugin implements GatewayPlugin {

    private PluginStatus status = PluginStatus.INITIALIZED;

    @Override
    public String getName() {
        return "logging";
    }

    @Override
    public void init(Map<String, Object> config) {
        // 初始化日志插件
        log.info("Logging plugin initialized");
    }

    @Override
    public void start() {
        status = PluginStatus.STARTED;
        log.info("Logging plugin started");
    }

    @Override
    public void stop() {
        status = PluginStatus.STOPPED;
        log.info("Logging plugin stopped");
    }

    @Override
    public void destroy() {
        status = PluginStatus.DESTROYED;
        log.info("Logging plugin destroyed");
    }

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 记录请求信息
        log.info("Request: {} {}", exchange.getRequest().getMethod(), exchange.getRequest().getPath());

        // 记录响应信息
        return chain.filter(exchange).then(Mono.fromRunnable(() -> {
            log.info("Response: {}", exchange.getResponse().getStatusCode());
        }));
    }

    @Override
    public PluginStatus getStatus() {
        return status;
    }

}

6.5 应用入口

@SpringBootApplication
public class GatewayPluginDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(GatewayPluginDemoApplication.class, args);
    }

}

七、最佳实践

7.1 插件设计

原则：

单一职责：每个插件只负责一种特定的功能
可配置性：插件的配置应该可以动态调整
无状态：插件应该是无状态的，便于水平扩展
可测试：插件应该易于测试，确保功能的正确性

建议：

为每个插件创建独立的模块，便于开发和维护
插件的配置应该支持动态更新，不需要重启服务
插件应该提供详细的日志和监控指标
插件的实现应该考虑性能影响，避免成为性能瓶颈

7.2 插件管理

原则：

统一管理：通过统一的插件管理服务管理所有插件
生命周期管理：正确管理插件的生命周期，包括加载、初始化、启动、停止和销毁
状态监控：监控插件的运行状态，及时发现问题
异常处理：妥善处理插件运行过程中的异常，避免影响整个网关服务

建议：

使用 ConcurrentHashMap 存储插件实例，确保线程安全
为插件提供详细的状态信息，便于监控和管理
实现插件的热插拔和动态启停，避免重启服务
为插件提供健康检查机制，确保插件的正常运行

7.3 安全考虑

原则：

权限控制：控制插件的加载和管理权限
安全检查：对插件代码进行安全检查，避免恶意代码
隔离机制：隔离插件的运行环境，避免插件之间的相互影响
审计日志：记录插件的操作日志，便于审计和追溯

建议：

只允许加载经过验证的插件
对插件的操作进行权限控制，避免未授权的操作
实现插件的沙箱机制，限制插件的权限
记录插件的操作日志，便于审计和问题排查

7.4 性能优化

原则：

懒加载：只在需要时加载插件
缓存：缓存插件的配置和状态，减少重复计算
异步处理：对耗时的操作进行异步处理，避免阻塞请求
资源管理：合理管理插件的资源使用，避免资源泄漏

建议：

使用懒加载机制，只在需要时加载插件
缓存插件的配置和状态，减少重复计算
对耗时的操作进行异步处理，避免阻塞请求
实现插件的资源管理，确保资源的正确释放

八、总结

网关插件热插拔和动态启停是一种灵活、高效的网关功能管理方式，它可以在不重启网关服务的情况下，动态添加、修改或移除网关功能，如限流、鉴权等。通过本文的实现方案，开发者可以构建一个灵活、高效、可扩展的网关系统，根据业务需求动态调整网关功能，提高系统的可用性和可维护性。网关插件热插拔和动态启停不仅可以减少服务重启的次数，提高服务的可用性，还可以快速响应业务需求的变化，为业务的发展提供有力的支持。

互动话题：

你在实际项目中是如何管理网关功能的？
你认为网关插件热插拔和动态启停最大的挑战是什么？
你有使用过类似的插件化方案吗？

欢迎在评论区留言讨论！更多技术文章，欢迎关注公众号：服务端技术精选

标题：SpringBoot + 网关插件热插拔 + 动态启停：无需重启即可开启/关闭限流、鉴权等能力
作者：jiangyi
地址：http://www.jiangyi.space/articles/2026/04/09/1775465920617.html
公众号：服务端技术精选

前言
一、核心概念
1.1 网关插件
1.2 热插拔
1.3 动态启停
1.4 为什么需要网关插件热插拔和动态启停
二、技术方案
2.1 插件架构设计
2.2 技术选型
2.3 核心流程
三、Spring Boot 网关插件热插拔实现
3.1 依赖配置
3.2 插件接口定义
3.3 插件管理服务
3.4 插件过滤器
四、动态启停实现
4.1 插件配置管理
4.2 插件控制器
4.3 插件事件监听
五、限流、鉴权等插件实现
5.1 限流插件
5.2 鉴权插件
5.3 日志插件
六、Spring Boot 完整实现
6.1 项目依赖
6.2 配置文件
6.3 核心配置类
6.3.1 插件接口
6.3.2 插件管理服务
6.3.3 插件过滤器
6.3.4 插件配置管理
6.3.5 插件控制器
6.3.6 插件事件监听
6.4 插件实现
6.4.1 限流插件
6.4.2 鉴权插件
6.4.3 日志插件
6.5 应用入口
七、最佳实践
7.1 插件设计
7.2 插件管理
7.3 安全考虑
7.4 性能优化
八、总结

0 评论