Spring Cloud Gateway 动态路由管理平台：Web UI 实时配置

Spring Cloud Gateway 动态路由管理平台：Web UI 实时配置 | 极客日志

dynamic-gateway-management/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── dynamicgateway/
│   │   │               ├── DynamicGatewayApplication.java
│   │   │               ├── config/
│   │   │               ├── controller/
│   │   │               ├── model/
│   │   │               ├── repository/
│   │   │               ├── service/
│   │   │               └── util/
│   │   └── resources/
│   │       ├── application.yml
│   │       ├── data.sql
│   │       └── static/
│   │           └── index.html
└── pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>dynamic-gateway-management</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>dynamic-gateway-management</name>
    <description>Dynamic Routing Management for Spring Cloud Gateway</description>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
    </parent>
    <properties>
        <java.version>11</java.version>
        <spring-cloud.version>2021.0.3</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

CREATE DATABASE IF NOT EXISTS dynamic_gateway CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
USE dynamic_gateway;

-- 创建路由定义表
CREATE TABLE IF NOT EXISTS route_definition (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    route_id VARCHAR(255) NOT NULL UNIQUE,
    route_name VARCHAR(255),
    uri VARCHAR(255) NOT NULL,
    predicates TEXT NOT NULL,
    filters TEXT,
    order_num INT DEFAULT 0,
    status TINYINT DEFAULT 1,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

-- 插入初始数据 (可选)
INSERT INTO route_definition (route_id, route_name, uri, predicates, filters, order_num, status)
VALUES ('user-service-route', 'User Service Route', 'lb://user-service', '[{"name":"Path","args":{"pattern":"/api/user/**"}}]', '[{"name":"Retry","args":{"retries":3,"statuses":"BAD_GATEWAY"}}]', 1, 1);

server:
  port: 8080

spring:
  application:
    name: dynamic-gateway-management
  datasource:
    url: jdbc:mysql://localhost:3306/dynamic_gateway?useSSL=false&serverTimezone=UTC&characterEncoding=utf8
    username: root
    password: your_password
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: none
    show-sql: true
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL8Dialect
        format_sql: true
  cloud:
    gateway:
      discovery:
        locator:
          enabled: false
      management:
        endpoints:
          web:
            exposure:
              include: health,info,route,filters,metrics

// src/main/java/com/example/dynamicgateway/model/RouteDefinition.java
package com.example.dynamicgateway.model;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;
import javax.persistence.*;
import java.time.LocalDateTime;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "route_definition")
public class RouteDefinition {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "route_id", nullable = false, unique = true)
    private String routeId;

    @Column(name = "route_name")
    private String routeName;

    @Column(name = "uri", nullable = false)
    private String uri;

    @Column(name = "predicates", columnDefinition = "TEXT", nullable = false)
    private String predicates;

    @Column(name = "filters", columnDefinition = "TEXT")
    private String filters;

    @Column(name = "order_num", nullable = false, columnDefinition = "INT DEFAULT 0")
    private Integer orderNum = 0;

    @Column(name = "status", nullable = false, columnDefinition = "TINYINT DEFAULT 1")
    private Integer status = 1;

    @Column(name = "created_at", updatable = false)
    private LocalDateTime createdAt;

    @Column(name = "updated_at")
    private LocalDateTime updatedAt;
}

// src/main/java/com/example/dynamicgateway/repository/RouteRepository.java
package com.example.dynamicgateway.repository;

import com.example.dynamicgateway.model.RouteDefinition;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;

@Repository
public interface RouteRepository extends JpaRepository<RouteDefinition, Long> {
    RouteDefinition findByRouteId(String routeId);
    List<RouteDefinition> findByStatus(Integer status);
    List<RouteDefinition> findAllByStatus(Integer status);
}

// src/main/java/com/example/dynamicgateway/util/RouteUtil.java
package com.example.dynamicgateway.util;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.TypeFactory;
import org.springframework.cloud.gateway.handler.predicate.PredicateDefinition;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.filter.FilterDefinition;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;

@Component
public class RouteUtil {
    private final ObjectMapper objectMapper;

    public RouteUtil(ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }

    public RouteDefinition convertToGatewayRoute(com.example.dynamicgateway.model.RouteDefinition dbRouteDefinition) {
        if (dbRouteDefinition == null) {
            return null;
        }
        RouteDefinition gatewayRouteDefinition = new RouteDefinition();
        gatewayRouteDefinition.setId(dbRouteDefinition.getRouteId());
        gatewayRouteDefinition.setUri(dbRouteDefinition.getUri());
        gatewayRouteDefinition.setOrder(dbRouteDefinition.getOrderNum());

        try {
            if (dbRouteDefinition.getPredicates() != null && !dbRouteDefinition.getPredicates().isEmpty()) {
                TypeFactory typeFactory = objectMapper.getTypeFactory();
                List<PredicateDefinition> predicateDefinitions = objectMapper.readValue(
                        dbRouteDefinition.getPredicates(),
                        typeFactory.constructCollectionType(List.class, PredicateDefinition.class));
                gatewayRouteDefinition.setPredicates(predicateDefinitions);
            }
        } catch (Exception e) {
            throw new RuntimeException("Failed to parse predicates for route ID: " + dbRouteDefinition.getRouteId(), e);
        }

        try {
            if (dbRouteDefinition.getFilters() != null && !dbRouteDefinition.getFilters().isEmpty()) {
                TypeFactory typeFactory = objectMapper.getTypeFactory();
                List<FilterDefinition> filterDefinitions = objectMapper.readValue(
                        dbRouteDefinition.getFilters(),
                        typeFactory.constructCollectionType(List.class, FilterDefinition.class));
                gatewayRouteDefinition.setFilters(filterDefinitions);
            }
        } catch (Exception e) {
            throw new RuntimeException("Failed to parse filters for route ID: " + dbRouteDefinition.getRouteId(), e);
        }
        return gatewayRouteDefinition;
    }

    public com.example.dynamicgateway.model.RouteDefinition convertToDbRoute(RouteDefinition gatewayRouteDefinition) {
        if (gatewayRouteDefinition == null) {
            return null;
        }
        com.example.dynamicgateway.model.RouteDefinition dbRouteDefinition = new com.example.dynamicgateway.model.RouteDefinition();
        dbRouteDefinition.setRouteId(gatewayRouteDefinition.getId());
        dbRouteDefinition.setUri(gatewayRouteDefinition.getUri().toString());
        dbRouteDefinition.setOrderNum(gatewayRouteDefinition.getOrder());

        try {
            if (gatewayRouteDefinition.getPredicates() != null && !gatewayRouteDefinition.getPredicates().isEmpty()) {
                dbRouteDefinition.setPredicates(objectMapper.writeValueAsString(gatewayRouteDefinition.getPredicates()));
            }
        } catch (Exception e) {
            throw new RuntimeException("Failed to serialize predicates for route ID: " + gatewayRouteDefinition.getId(), e);
        }

        try {
            if (gatewayRouteDefinition.getFilters() != null && !gatewayRouteDefinition.getFilters().isEmpty()) {
                dbRouteDefinition.setFilters(objectMapper.writeValueAsString(gatewayRouteDefinition.getFilters()));
            }
        } catch (Exception e) {
            throw new RuntimeException("Failed to serialize filters for route ID: " + gatewayRouteDefinition.getId(), e);
        }
        dbRouteDefinition.setStatus(1);
        return dbRouteDefinition;
    }
}

// src/main/java/com/example/dynamicgateway/config/GatewayConfig.java
package com.example.dynamicgateway.config;

import com.example.dynamicgateway.model.RouteDefinition;
import com.example.dynamicgateway.repository.RouteRepository;
import com.example.dynamicgateway.util.RouteUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
import org.springframework.cloud.gateway.route.RouteDefinitionLocator;
import org.springframework.cloud.gateway.route.RouteDefinitionWriter;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import reactor.core.publisher.Flux;
import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;

@Configuration
public class GatewayConfig implements ApplicationEventPublisherAware {
    @Autowired
    private RouteRepository routeRepository;
    @Autowired
    private RouteUtil routeUtil;
    @Autowired
    private RouteDefinitionWriter routeDefinitionWriter;
    @Autowired
    private RouteDefinitionLocator routeDefinitionLocator;
    
    private ApplicationEventPublisher publisher;

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

    @PostConstruct
    public void initRoutes() {
        loadAllRoutes();
    }

    public void loadAllRoutes() {
        List<RouteDefinition> enabledRoutes = routeRepository.findByStatus(1);
        List<org.springframework.cloud.gateway.route.RouteDefinition> gatewayRoutes = new ArrayList<>();
        for (RouteDefinition dbRoute : enabledRoutes) {
            try {
                org.springframework.cloud.gateway.route.RouteDefinition gatewayRoute = routeUtil.convertToGatewayRoute(dbRoute);
                if (gatewayRoute != null) {
                    gatewayRoutes.add(gatewayRoute);
                }
            } catch (Exception e) {
                System.err.println("Error converting route ID: " + dbRoute.getRouteId() + ", Error: " + e.getMessage());
            }
        }
        refreshRoutes(gatewayRoutes);
    }

    private void refreshRoutes(List<org.springframework.cloud.gateway.route.RouteDefinition> gatewayRoutes) {
        publisher.publishEvent(new RefreshRoutesEvent(this));
    }

    public void addRoute(org.springframework.cloud.gateway.route.RouteDefinition routeDefinition) {
        routeDefinitionWriter.save(Flux.just(routeDefinition)).subscribe();
        publisher.publishEvent(new RefreshRoutesEvent(this));
    }

    public Flux<org.springframework.cloud.gateway.route.RouteDefinition> getAllRoutes() {
        return routeDefinitionLocator.getRouteDefinitions();
    }
}

// src/main/java/com/example/dynamicgateway/service/RouteService.java
package com.example.dynamicgateway.service;

import com.example.dynamicgateway.model.RouteDefinition;
import com.example.dynamicgateway.repository.RouteRepository;
import com.example.dynamicgateway.util.RouteUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.Optional;

@Service
@Transactional
public class RouteService {
    @Autowired
    private RouteRepository routeRepository;
    @Autowired
    private RouteUtil routeUtil;

    public List<RouteDefinition> getAllRoutes() {
        return routeRepository.findAll();
    }

    public List<RouteDefinition> getEnabledRoutes() {
        return routeRepository.findByStatus(1);
    }

    public Optional<RouteDefinition> getRouteById(Long id) {
        return routeRepository.findById(id);
    }

    public Optional<RouteDefinition> getRouteByRouteId(String routeId) {
        return Optional.ofNullable(routeRepository.findByRouteId(routeId));
    }

    public RouteDefinition createRoute(RouteDefinition routeDefinition) {
        if (routeRepository.findByRouteId(routeDefinition.getRouteId()) != null) {
            throw new IllegalArgumentException("Route ID already exists: " + routeDefinition.getRouteId());
        }
        return routeRepository.save(routeDefinition);
    }

    public RouteDefinition updateRoute(Long id, RouteDefinition routeDefinition) {
        RouteDefinition existingRoute = routeRepository.findById(id).orElseThrow(() -> new IllegalArgumentException("Route not found with ID: " + id));
        existingRoute.setRouteName(routeDefinition.getRouteName());
        existingRoute.setUri(routeDefinition.getUri());
        existingRoute.setPredicates(routeDefinition.getPredicates());
        existingRoute.setFilters(routeDefinition.getFilters());
        existingRoute.setOrderNum(routeDefinition.getOrderNum());
        existingRoute.setStatus(routeDefinition.getStatus());
        return routeRepository.save(existingRoute);
    }

    public void deleteRoute(Long id) {
        routeRepository.deleteById(id);
    }

    public void enableRoute(Long id) {
        RouteDefinition route = routeRepository.findById(id).orElseThrow(() -> new IllegalArgumentException("Route not found with ID: " + id));
        route.setStatus(1);
        routeRepository.save(route);
    }

    public void disableRoute(Long id) {
        RouteDefinition route = routeRepository.findById(id).orElseThrow(() -> new IllegalArgumentException("Route not found with ID: " + id));
        route.setStatus(0);
        routeRepository.save(route);
    }
}

// src/main/java/com/example/dynamicgateway/controller/RouteController.java
package com.example.dynamicgateway.controller;

import com.example.dynamicgateway.model.RouteDefinition;
import com.example.dynamicgateway.service.RouteService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/routes")
public class RouteController {
    @Autowired
    private RouteService routeService;

    @GetMapping
    public ResponseEntity<List<RouteDefinition>> getAllRoutes() {
        List<RouteDefinition> routes = routeService.getAllRoutes();
        return ResponseEntity.ok(routes);
    }

    @GetMapping("/enabled")
    public ResponseEntity<List<RouteDefinition>> getEnabledRoutes() {
        List<RouteDefinition> routes = routeService.getEnabledRoutes();
        return ResponseEntity.ok(routes);
    }

    @GetMapping("/{id}")
    public ResponseEntity<RouteDefinition> getRouteById(@PathVariable Long id) {
        Optional<RouteDefinition> route = routeService.getRouteById(id);
        return route.map(ResponseEntity::ok).orElse(ResponseEntity.notFound().build());
    }

    @PostMapping
    public ResponseEntity<RouteDefinition> createRoute(@RequestBody RouteDefinition routeDefinition) {
        try {
            RouteDefinition createdRoute = routeService.createRoute(routeDefinition);
            return ResponseEntity.status(HttpStatus.CREATED).body(createdRoute);
        } catch (IllegalArgumentException e) {
            return ResponseEntity.badRequest().build();
        }
    }

    @PutMapping("/{id}")
    public ResponseEntity<RouteDefinition> updateRoute(@PathVariable Long id, @RequestBody RouteDefinition routeDefinition) {
        try {
            RouteDefinition updatedRoute = routeService.updateRoute(id, routeDefinition);
            return ResponseEntity.ok(updatedRoute);
        } catch (IllegalArgumentException e) {
            return ResponseEntity.notFound().build();
        }
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteRoute(@PathVariable Long id) {
        routeService.deleteRoute(id);
        return ResponseEntity.noContent().build();
    }

    @PatchMapping("/{id}/enable")
    public ResponseEntity<Void> enableRoute(@PathVariable Long id) {
        routeService.enableRoute(id);
        return ResponseEntity.noContent().build();
    }

    @PatchMapping("/{id}/disable")
    public ResponseEntity<Void> disableRoute(@PathVariable Long id) {
        routeService.disableRoute(id);
        return ResponseEntity.noContent().build();
    }
}

<!-- src/main/resources/static/index.html -->
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>动态路由管理平台</title>
    <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
    <style>
        body { padding-top: 20px; background-color: #f8f9fa; }
        .card { box-shadow: 0 0.125rem 0.25rem rgba(0, 0, 0, 0.075); margin-bottom: 1rem; }
        .btn-primary { background-color: #0d6efd; border-color: #0d6efd; }
        .btn-success { background-color: #198754; border-color: #198754; }
        .btn-danger { background-color: #dc3545; border-color: #dc3545; }
        .table th { border-top: none; }
    </style>
</head>
<body>
<div class="container">
    <h1 class="mb-4">动态路由管理平台</h1>
    <div class="row mb-4">
        <div class="col-md-12 text-end">
            <button class="btn btn-primary me-2" onclick="showAddForm()">添加路由</button>
            <button class="btn btn-secondary" onclick="loadRoutes()">刷新列表</button>
        </div>
    </div>
    <div class="card">
        <div class="card-header"><h5 class="mb-0">路由列表</h5></div>
        <div class="card-body">
            <div id="loadingSpinner" class="text-center d-none">
                <div class="spinner-border text-primary" role="status"><span class="visually-hidden">Loading...</span></div>
                <p class="mt-2">加载中...</p>
            </div>
            <table id="routesTable" class="table table-striped table-hover d-none">
                <thead><tr><th>ID</th><th>路由 ID</th><th>路由名称</th><th>URI</th><th>状态</th><th>操作</th></tr></thead>
                <tbody id="routesTableBody"></tbody>
            </table>
            <div id="noRoutesMessage" class="text-center d-none"><p class="text-muted">暂无路由数据</p></div>
        </div>
    </div>
    <div id="addEditFormContainer" class="card d-none">
        <div class="card-header"><h5 class="mb-0" id="formTitle">添加路由</h5></div>
        <div class="card-body">
            <form id="routeForm">
                <input type="hidden" id="editId">
                <div class="mb-3">
                    <label for="routeId" class="form-label">路由 ID *</label>
                    <input type="text" class="form-control" id="routeId" required>
                </div>
                <div class="mb-3">
                    <label for="routeName" class="form-label">路由名称</label>
                    <input type="text" class="form-control" id="routeName">
                </div>
                <div class="mb-3">
                    <label for="uri" class="form-label">URI *</label>
                    <input type="text" class="form-control" id="uri" required>
                </div>
                <div class="mb-3">
                    <label for="predicates" class="form-label">谓词 (JSON 格式)*</label>
                    <textarea class="form-control" id="predicates" rows="3" required></textarea>
                </div>
                <div class="mb-3">
                    <label for="filters" class="form-label">过滤器 (JSON 格式)</label>
                    <textarea class="form-control" id="filters" rows="3"></textarea>
                </div>
                <div class="mb-3">
                    <label for="orderNum" class="form-label">排序</label>
                    <input type="number" class="form-control" id="orderNum" value="0">
                </div>
                <div class="mb-3">
                    <label for="status" class="form-label">状态</label>
                    <select class="form-select" id="status">
                        <option value="1">启用</option>
                        <option value="0">禁用</option>
                    </select>
                </div>
                <button type="submit" class="btn btn-success">提交</button>
                <button type="button" class="btn btn-secondary" onclick="hideForm()">取消</button>
            </form>
        </div>
    </div>
</div>
<script>
const API_BASE_URL = 'http://localhost:8080/api/routes';
document.addEventListener('DOMContentLoaded', function() { loadRoutes(); });

async function loadRoutes() {
    try {
        const response = await axios.get(API_BASE_URL);
        renderRoutes(response.data);
    } catch (error) {
        console.error('Error loading routes:', error);
    }
}

function renderRoutes(routes) {
    const tbody = document.getElementById('routesTableBody');
    const noRoutesMessage = document.getElementById('noRoutesMessage');
    const routesTable = document.getElementById('routesTable');
    tbody.innerHTML = '';
    if (routes.length === 0) {
        noRoutesMessage.classList.remove('d-none');
        routesTable.classList.add('d-none');
        return;
    }
    noRoutesMessage..();
    routesTable..();
    routes.( {
         row = .();
        row. = ;
        tbody.(row);
    });
}

 () {
    .(). = ;
    .(). = ;
    .().();
    .()..();
}

 () {
    .()..();
}

  () {
     {
         response =  axios.();
         route = response.;
        .(). = ;
        .(). = route.;
        .(). = route.;
        .(). = route. || ;
        .(). = route.;
        .(). = route.;
        .(). = route. || ;
        .(). = route.;
        .(). = route.;
        .()..();
    }  (error) {
        .(, error);
    }
}

  () {
     (!()) ;
     {
         axios.();
        ();
    }  (error) {
        .(, error);
    }
}

  () {
     (!()) ;
     {
         axios.();
        ();
    }  (error) {
        .(, error);
    }
}

  () {
     (!()) ;
     {
         axios.();
        ();
    }  (error) {
        .(, error);
    }
}

.().(,  () {
    e.();
     formData =  ();
     routeData = {
        : formData.() ? (formData.()) : ,
        : formData.(),
        : formData.(),
        : formData.(),
        : formData.(),
        : formData.(),
        : (formData.()) || ,
        : (formData.())
    };
     {
         response;
         (routeData.) {
            response =  axios.(, routeData);
        }  {
            response =  axios.(, routeData);
        }
        ();
        ();
    }  (error) {
        .(, error);
    }
});
</script>
</body>
</html>

// src/main/java/com/example/dynamicgateway/controller/SseController.java
package com.example.dynamicgateway.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;

@RestController
public class SseController {
    private static final CopyOnWriteArraySet<SseEmitter> emitters = new CopyOnWriteArraySet<>();

    @GetMapping("/sse/updates")
    public SseEmitter handleSseUpdates() {
        SseEmitter emitter = new SseEmitter(Long.MAX_VALUE);
        emitters.add(emitter);
        emitter.onTimeout(() -> emitters.remove(emitter));
        emitter.onCompletion(() -> emitters.remove(emitter));
        return emitter;
    }

    public static void sendRouteUpdate(String event) {
        for (SseEmitter emitter : emitters) {
            try {
                emitter.send(SseEmitter.event().name("route-update").data(event));
            } catch (IOException e) {
                emitters.remove(emitter);
            }
        }
    }
}

const sseSource = new EventSource('http://localhost:8080/sse/updates');
sseSource.addEventListener('route-update', function(event) {
    console.log('Received route update:', event.data);
    loadRoutes();
});
window.addEventListener('beforeunload', function() {
    sseSource.close();
});

@GetMapping("/export")
public ResponseEntity<byte[]> exportRoutes() {
    List<RouteDefinition> routes = routeService.getAllRoutes();
    try {
        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(routes);
        byte[] content = json.getBytes();
        return ResponseEntity.ok()
                .header("Content-Disposition", "attachment; filename=\"routes.json\"")
                .contentType(org.springframework.http.MediaType.APPLICATION_JSON)
                .body(content);
    } catch (Exception e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
    }
}

@PostMapping("/import")
public ResponseEntity<Void> importRoutes(@RequestBody List<RouteDefinition> routes) {
    try {
        for (RouteDefinition route : routes) {
            if (routeRepository.findByRouteId(route.getRouteId()) == null) {
                routeRepository.save(route);
            }
        }
        return ResponseEntity.ok().build();
    } catch (Exception e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
    }
}

@Column(name = "version", nullable = false, columnDefinition = "INT DEFAULT 1")
private Integer version = 1;

CREATE TABLE IF NOT EXISTS route_history (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    route_id VARCHAR(255) NOT NULL,
    action VARCHAR(50) NOT NULL,
    old_data TEXT,
    new_data TEXT,
    changed_by VARCHAR(255),
    changed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

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

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/api/routes/**").authenticated()
            .antMatchers("/static/**", "/").permitAll()
            .and().httpBasic()
            .and().csrf().disable();
    }
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

Spring Cloud Gateway 动态路由管理平台：Web UI 实时配置

Spring Cloud Gateway 动态路由管理平台：通过 Web UI 实时配置路由

一、引言

1.1 微服务架构中的路由挑战

1.2 动态路由的价值

1.3 本文目标

二、环境准备

2.1 技术栈概览

2.2 项目结构

2.3 Maven 依赖配置

2.4 数据库准备

2.4.1 初始化数据库

2.4.2 创建路由表

2.5 应用配置

三、核心概念与设计思路

3.1 动态路由的工作原理

3.2 数据模型设计

3.2.1 RouteDefinition 实体类

3.2.2 数据访问接口

3.3 路由转换工具类

3.4 动态路由配置类

3.5 路由业务逻辑服务

3.6 路由控制器

3.7 动态路由工作流程说明

四、Web UI 开发

4.1 前端页面设计

4.2 启动与访问

五、高级功能与优化

5.1 路由状态实时同步

5.1.1 SSE 方案

5.1.2 前端监听 SSE

5.2 路由导入导出

5.2.1 导出功能

5.2.2 导入功能

5.3 路由版本控制

5.3.1 添加版本信息

5.3.2 增加历史记录表

5.4 权限控制

5.4.1 添加 Spring Security 依赖

5.4.2 配置安全策略

六、性能优化与最佳实践

6.1 数据库优化

6.2 Gateway 性能优化

6.3 安全性

6.4 可靠性

七、常见问题与解决方案

7.1 路由更新后 Gateway 未及时生效

7.2 JSON 格式错误导致解析失败

7.3 前端 UI 响应缓慢

八、与现有系统的集成

8.1 与服务注册中心集成

8.2 与配置中心集成

8.3 与监控系统集成

九、总结与展望

9.1 关键要点回顾

9.2 未来发展趋势

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具