实现动态从数据库获取匹配路径规则，并将对应请求转发到远程HTTP端服务

在Spring Boot Gateway中动态从数据库获取匹配路径规则，并根据HTTP和WebSocket请求规则进行本地调用和远程调用，你可以使用Spring Cloud Gateway和RestTemplate结合的方式。以下是一个示例：

创建一个Spring Boot项目：

使用Spring Initializer生成一个基础的Spring Boot项目，添加以下依赖：

Spring Cloud Gateway
Spring Web
Spring Data JPA
H2 Database (或其他你选择的数据库依赖)
RestTemplate
配置数据库：

在application.properties中配置H2数据库：

properties
Copy code
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
创建数据库实体类：

java
Copy code
// RuleEntity.java
package com.example.gateway.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class RuleEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String path;

    private String targetUrl;

    private boolean isWebSocket; // 新增字段，标记是否为WebSocket规则

    // getters and setters
}
创建Spring Data JPA Repository：

java
Copy code
// RuleRepository.java
package com.example.gateway.repository;

import com.example.gateway.entity.RuleEntity;
import org.springframework.data.jpa.repository.JpaRepository;

public interface RuleRepository extends JpaRepository<RuleEntity, Long> {

    RuleEntity findByPath(String path);

    RuleEntity findByPathAndIsWebSocket(String path, boolean isWebSocket);
}
创建动态路由过滤器：

java
Copy code
// DynamicRoutingFilter.java
package com.example.gateway.filter;

import com.example.gateway.entity.RuleEntity;
import com.example.gateway.repository.RuleRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class DynamicRoutingFilter extends AbstractGatewayFilterFactory<Object> {

    @Autowired
    private RuleRepository ruleRepository;

    @Autowired
    private RestTemplate restTemplate;

    @Override
    public GatewayFilter apply(Object config) {
        return (exchange, chain) -> {
            String requestPath = exchange.getRequest().getURI().getPath();
            boolean isWebSocket = exchange.getRequest().getHeaders().containsKey("Sec-WebSocket-Key");

            RuleEntity ruleEntity;
            if (isWebSocket) {
                ruleEntity = ruleRepository.findByPathAndIsWebSocket(requestPath, true);
            } else {
                ruleEntity = ruleRepository.findByPathAndIsWebSocket(requestPath, false);
            }

            if (ruleEntity != null) {
                String targetUrl = ruleEntity.getTargetUrl();

                // 本地调用
                String localResponse = "Local Response for " + requestPath;

                // 远程调用逻辑
                String remoteResponse = restTemplate.getForObject(targetUrl, String.class);

                // 设置响应
                exchange.getResponse().getHeaders().add("Content-Type", "application/json");
                exchange.getResponse().setStatusCodeValue(200);

                // 本地响应
                exchange.getResponse().getHeaders().add("local-response", localResponse);
                exchange.getResponse().writeWith(Mono.just(exchange.getResponse().bufferFactory().wrap(localResponse.getBytes())));

                // 远程响应
                exchange.getResponse().getHeaders().add("remote-response", remoteResponse);
                exchange.getResponse().writeWith(Mono.just(exchange.getResponse().bufferFactory().wrap(remoteResponse.getBytes())));

                return Mono.empty();
            }

            return chain.filter(exchange);
        };
    }
}
创建RestTemplate Bean：

java
Copy code
// RestTemplateConfig.java
package com.example.gateway.config;

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() {
        return new RestTemplate();
    }
}
配置动态路由过滤器：

yaml
Copy code
# application.yml
spring:
  cloud:
    gateway:
      routes:
        - id: dynamic_route
          uri: forward:/notused
          filters:
            - DynamicRoutingFilter
这里配置了一个名为 dynamic_route 的路由，使用了 DynamicRoutingFilter 过滤器。实际上，uri: forward:/notused 是一个占位符，真正的目标URL会在过滤器中动态设置。

创建动态路由Controller：

java
Copy code
// DynamicRoutingController.java
package com.example.gateway.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DynamicRoutingController {

    @GetMapping("/dynamic-route-test")
    public String dynamicRouteTest() {
        return "Dynamic Route Test";
    }
}
在这个例子中，当访问 /dynamic-route-test 时，动态路由将根据数据库中的规则进行转发，并根据HTTP和WebSocket请求规则进行本地调用和远程调用。

确保你的数据库连接配置正确，同时确保数据库中有相应的规则数据。通过这个例子，你可以看到如何使用Spring Cloud Gateway和RestTemplate结合，实现网关动态从数据库获取匹配路径规则，并根据HTTP和WebSocket请求规则进行本地调用和远程调用。