<properties>
		<spring-boot.version>2.3.2.RELEASE</spring-boot.version>
		<spring-cloud.version>Hoxton.SR9</spring-cloud.version>
		<spring-cloud-alibaba.version>2.2.6.RELEASE</spring-cloud-alibaba.version>
	</properties>
 
	<!-- 只聲明依賴，不引入依賴 -->
	<dependencyManagement>
		<dependencies>
			<!-- 聲明springBoot版本 -->
			<dependency>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-dependencies</artifactId>
				<version>${spring-boot.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
			<!-- 聲明springCloud版本 -->
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
			<!-- 聲明 springCloud Alibaba 版本 -->
			<dependency>
				<groupId>com.alibaba.cloud</groupId>
				<artifactId>spring-cloud-alibaba-dependencies</artifactId>
				<version>${spring-cloud-alibaba.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

<!-- 引入gateway網(wǎng)關(guān) -->
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-gateway</artifactId>
	<exclusions>
        <exclusion>
			<groupId>org.springframework.boot</groupId>
        	<artifactId>spring-boot-starter-web</artifactId>
        </exclusion>
    </exclusions>
</dependency>

server:
  port: 9023
  servlet:
    context-path: /${spring.application.name}
spring:
  application:
    name: gateway

spring:
  cloud:
    gateway:
      # 路由數(shù)組：指當(dāng)請(qǐng)求滿足什么樣的斷言時(shí)，轉(zhuǎn)發(fā)到哪個(gè)服務(wù)上
      routes:
        # 路由標(biāo)識(shí)，要求唯一，名稱任意
        - id: gateway-provider_1
		  # 請(qǐng)求最終被轉(zhuǎn)發(fā)到的目標(biāo)地址
          uri: http://localhost:9024
          # 設(shè)置斷言
          predicates:
            # Path Route Predicate Factory 斷言，滿足 /gateway/provider/** 路徑的請(qǐng)求都會(huì)被路由到 http://localhost:9024 這個(gè)uri中
            - Path=/gateway/provider/**
            # Weight Route Predicate Factory 斷言，同一分組按照權(quán)重進(jìn)行分配流量，這里分配了80%
            # 第一個(gè)group1是分組名，第二個(gè)參數(shù)是權(quán)重
            - Weight=group1, 8
          # 配置過濾器（局部）
          filters:
            # StripPrefix：去除原始請(qǐng)求路徑中的前1級(jí)路徑，即/gateway
            - StripPrefix=1            
            
        - id: gateway-provider_2
          uri: http://localhost:9025
          # 設(shè)置斷言
          predicates:
            - Path=/gateway/provider/**
            # Weight Route Predicate Factory，同一分組按照權(quán)重進(jìn)行分配流量，這里分配了20%
            - Weight=group1, 2
		  # 配置過濾器（局部）
          filters:
            # StripPrefix：去除原始請(qǐng)求路徑中的前1級(jí)路徑，即/gateway
            - StripPrefix=1            

spring:
  cloud:
    gateway:
      routes:
        - id: gateway-provider_1
          uri: http://localhost:9024
          predicates:
            - Path=/gateway/provider/**
          # 配置過濾器（局部）
          filters:
            - AddResponseHeader=X-Response-Foo, Bar
            # StripPrefix：去除原始請(qǐng)求路徑中的前1級(jí)路徑，即/gateway
            - StripPrefix=1   

/**
 * 名稱必須是xxxGatewayFilterFactory形式
 * todo：模擬授權(quán)的驗(yàn)證，具體邏輯根據(jù)業(yè)務(wù)完善
 */
@Component
@Slf4j
public class AuthorizeGatewayFilterFactory extends AbstractGatewayFilterFactory<AuthorizeGatewayFilterFactory.Config> {
 
    private static final String AUTHORIZE_TOKEN = "token";
 
    //構(gòu)造函數(shù)，加載Config
    public AuthorizeGatewayFilterFactory() {
        //固定寫法
        super(AuthorizeGatewayFilterFactory.Config.class);
        log.info("Loaded GatewayFilterFactory [Authorize]");
    }
 
    //讀取配置文件中的參數(shù) 賦值到 配置類中
    @Override
    public List<String> shortcutFieldOrder() {
        //Config.enabled
        return Arrays.asList("enabled");
    }
 
    @Override
    public GatewayFilter apply(AuthorizeGatewayFilterFactory.Config config) {
        return (exchange, chain) -> {
            //判斷是否開啟授權(quán)驗(yàn)證
            if (!config.isEnabled()) {
                return chain.filter(exchange);
            }
 
            ServerHttpRequest request = exchange.getRequest();
            HttpHeaders headers = request.getHeaders();
            //從請(qǐng)求頭中獲取token
            String token = headers.getFirst(AUTHORIZE_TOKEN);
            if (token == null) {
                //從請(qǐng)求頭參數(shù)中獲取token
                token = request.getQueryParams().getFirst(AUTHORIZE_TOKEN);
            }
 
            ServerHttpResponse response = exchange.getResponse();
            //如果token為空，直接返回401，未授權(quán)
            if (StringUtils.isEmpty(token)) {
                response.setStatusCode(HttpStatus.UNAUTHORIZED);
                //處理完成，直接攔截，不再進(jìn)行下去
                return response.setComplete();
            }
            /**
             * todo chain.filter(exchange) 之前的都是過濾器的前置處理
             *
             * chain.filter().then(
             *  過濾器的后置處理...........
             * )
             */
            //授權(quán)正常，繼續(xù)下一個(gè)過濾器鏈的調(diào)用
            return chain.filter(exchange);
        };
    }
 
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Config {
        // 控制是否開啟認(rèn)證
        private boolean enabled;
    }
}

spring:
  cloud:
    gateway:
      routes:
        - id: gateway-provider_1
          uri: http://localhost:9024
          predicates:
            - Path=/gateway/provider/**
          ## 配置過濾器（局部）
          filters:
            - AddResponseHeader=X-Response-Foo, Bar
            ## AuthorizeGatewayFilterFactory自定義過濾器配置，值為true需要驗(yàn)證授權(quán)，false不需要
            - Authorize=true

@Slf4j
@Component
@Order(value = Integer.MIN_VALUE)
public class AccessLogGlobalFilter implements GlobalFilter {
 
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //filter的前置處理
        ServerHttpRequest request = exchange.getRequest();
        String path = request.getPath().pathWithinApplication().value();
        InetSocketAddress remoteAddress = request.getRemoteAddress();
        return chain
                //繼續(xù)調(diào)用filter
                .filter(exchange)
                //filter的后置處理
                .then(Mono.fromRunnable(() -> {
            ServerHttpResponse response = exchange.getResponse();
            HttpStatus statusCode = response.getStatusCode();
            log.info("請(qǐng)求路徑:{},遠(yuǎn)程IP地址:{},響應(yīng)碼:{}", path, remoteAddress, statusCode);
        }));
    }
}

<!--nacos注冊(cè)中心-->
<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

nacos:
  namespace: 856a40d7-6548-4494-bdb9-c44491865f63
  url: 120.76.129.106:80
spring:
  cloud:
    nacos:
      discovery:
      	server-addr: ${nacos.url}
        namespace: ${nacos.namespace}
        register-enabled: true

spring:
  cloud:
    gateway:
      routes:
        - id: gateway-provider_1
          ## 使用了lb形式，從注冊(cè)中心負(fù)載均衡的獲取uri
          uri: lb://gateway-provider
          ## 配置斷言
          predicates:
            - Path=/gateway/provider/**
          filters:
            - AddResponseHeader=X-Response-Foo, Bar

# enabled：默認(rèn)為false，設(shè)置為true表明spring cloud gateway開啟服務(wù)發(fā)現(xiàn)和路由的功能，網(wǎng)關(guān)自動(dòng)根據(jù)注冊(cè)中心的服務(wù)名為每個(gè)服務(wù)創(chuàng)建一個(gè)router，將以服務(wù)名開頭的請(qǐng)求路徑轉(zhuǎn)發(fā)到對(duì)應(yīng)的服務(wù)
spring.cloud.gateway.discovery.locator.enabled = true
# lowerCaseServiceId：?jiǎn)?dòng) locator.enabled=true 自動(dòng)路由時(shí)，路由的路徑默認(rèn)會(huì)使用大寫ID，若想要使用小寫ID，可將lowerCaseServiceId設(shè)置為true
spring.cloud.gateway.discovery.locator.lower-case-service-id = true

# 重寫過濾鏈，解決項(xiàng)目設(shè)置了 server.servlet.context-path 導(dǎo)致 locator.enabled=true 默認(rèn)路由策略404的問題
spring.cloud.gateway.discovery.locator.filters[0] = PreserveHostHeader

@Configuration
public class GatewayConfig
{
    @Value ("${server.servlet.context-path}")
    private String prefix;
 
    /**
     * 過濾 server.servlet.context-path 屬性配置的項(xiàng)目路徑，防止對(duì)后續(xù)路由策略產(chǎn)生影響，因?yàn)?gateway 網(wǎng)關(guān)不支持 servlet
     */
    @Bean
    @Order (-1)
    public WebFilter apiPrefixFilter()
    {
        return (exchange, chain) ->
        {
            ServerHttpRequest request = exchange.getRequest();
            String path = request.getURI().getRawPath();
 
            path = path.startsWith(prefix) ? path.replaceFirst(prefix, "") : path;
            ServerHttpRequest newRequest = request.mutate().path(path).build();
 
            return chain.filter(exchange.mutate().request(newRequest).build());
        };
    }
}

<!-- Apollo 統(tǒng)一配置中心 -->
<dependency>
    <groupId>com.ctrip.framework.apollo</groupId>
    <artifactId>apollo-client</artifactId>
    <version>1.7.0</version>
</dependency>

import com.ctrip.framework.apollo.enums.PropertyChangeType;
import com.ctrip.framework.apollo.model.ConfigChange;
import com.ctrip.framework.apollo.model.ConfigChangeEvent;
import com.ctrip.framework.apollo.spring.annotation.ApolloConfigChangeListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.context.environment.EnvironmentChangeEvent;
import org.springframework.cloud.gateway.config.GatewayProperties;
import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
import org.springframework.cloud.gateway.route.RouteDefinitionWriter;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.context.annotation.Configuration;
 
import java.util.ArrayList;
 
/**
 * Apollo路由更改監(jiān)聽刷新
 */
@Configuration
public class GatewayPropertRefresher implements ApplicationContextAware, ApplicationEventPublisherAware
{
    private static final Logger logger = LoggerFactory.getLogger(GatewayPropertRefresher.class);
 
    private static final String ID_PATTERN = "spring\\.cloud\\.gateway\\.routes\\[\\d+\\]\\.id";
 
    private static final String DEFAULT_FILTER_PATTERN = "spring\\.cloud\\.gateway\\.default-filters\\[\\d+\\]\\.name";
 
 
    private ApplicationContext applicationContext;
 
    private ApplicationEventPublisher publisher;
 
    @Autowired
    private  GatewayProperties gatewayProperties;
 
    @Autowired
    private RouteDefinitionWriter routeDefinitionWriter;
 
 
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
 
    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.publisher = applicationEventPublisher;
    }
 
 
    /**
     * 監(jiān)聽路由修改
     */
    @ApolloConfigChangeListener(interestedKeyPrefixes = "spring.cloud.gateway.")
    public void onChange(ConfigChangeEvent changeEvent)
    {
        refreshGatewayProperties(changeEvent);
    }
 
    /**
     * 刷新路由信息
     */
    private void refreshGatewayProperties(ConfigChangeEvent changeEvent)
    {
        logger.info("gateway網(wǎng)關(guān)配置 刷新開始！");
 
        preDestroyGatewayProperties(changeEvent);
        //更新配置
        this.applicationContext.publishEvent(new EnvironmentChangeEvent(changeEvent.changedKeys()));
        //更新路由
        refreshGatewayRouteDefinition();
 
        logger.info("gateway網(wǎng)關(guān)配置 刷新完成！");
    }
 
    /***
     * GatewayProperties沒有@PreDestroy和destroy方法
     * org.springframework.cloud.context.properties.ConfigurationPropertiesRebinder#rebind(java.lang.String)中destroyBean時(shí)不會(huì)銷毀當(dāng)前對(duì)象
     * 如果把spring.cloud.gateway.前綴的配置項(xiàng)全部刪除（例如需要?jiǎng)討B(tài)刪除最后一個(gè)路由的場(chǎng)景），initializeBean時(shí)也無法創(chuàng)建新的bean，則return當(dāng)前bean
     * 若仍保留有spring.cloud.gateway.routes[n]或spring.cloud.gateway.default-filters[n]等配置，initializeBean時(shí)會(huì)注入新的屬性替換已有的bean
     * 這個(gè)方法提供了類似@PreDestroy的操作，根據(jù)配置文件的實(shí)際情況把org.springframework.cloud.gateway.config.GatewayProperties#routes
     * 和org.springframework.cloud.gateway.config.GatewayProperties#defaultFilters兩個(gè)集合清空
     */
    private synchronized void preDestroyGatewayProperties(ConfigChangeEvent changeEvent)
    {
        logger.info("Pre Destroy GatewayProperties 操作開始!");
 
        final boolean needClearRoutes = this.checkNeedClear(changeEvent, ID_PATTERN, this.gatewayProperties.getRoutes().size());
        if (needClearRoutes)
        {
            this.gatewayProperties.setRoutes(new ArrayList());
        }
 
        final boolean needClearDefaultFilters = this.checkNeedClear(changeEvent, DEFAULT_FILTER_PATTERN, this.gatewayProperties.getDefaultFilters().size());
        if (needClearDefaultFilters)
        {
            this.gatewayProperties.setRoutes(new ArrayList());
        }
 
        logger.info("Pre Destroy GatewayProperties 操作完成!");
    }
 
 
    private void refreshGatewayRouteDefinition()
    {
        logger.info("Refreshing Gateway RouteDefinition 操作開始!");
 
        this.publisher.publishEvent(new RefreshRoutesEvent(this));
 
        logger.info("Gateway RouteDefinition refreshed 操作完成!");
    }
 
    /***
     * 根據(jù)changeEvent和定義的pattern匹配key，如果所有對(duì)應(yīng)PropertyChangeType為DELETED則需要清空GatewayProperties里相關(guān)集合
     */
    private boolean checkNeedClear(ConfigChangeEvent changeEvent, String pattern, int existSize) {
 
        return changeEvent.changedKeys().stream().filter(key -> key.matches(pattern)).filter(key ->
        {
            ConfigChange change = changeEvent.getChange(key);
            return PropertyChangeType.DELETED.equals(change.getChangeType());
        }).count() == existSize;
    }
}

/**
 * 用于網(wǎng)關(guān)的全局異常處理
 * @Order(-1)：優(yōu)先級(jí)一定要比ResponseStatusExceptionHandler低
 */
@Slf4j
@Order(-1)
@Component
@RequiredArgsConstructor
public class GlobalErrorExceptionHandler implements ErrorWebExceptionHandler {
 
 private final ObjectMapper objectMapper;
 
 @SuppressWarnings({"rawtypes", "unchecked", "NullableProblems"})
 @Override
 public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {
  ServerHttpResponse response = exchange.getResponse();
  if (response.isCommitted()) {
   return Mono.error(ex);
  }
 
  // JOSN格式返回
  response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
  if (ex instanceof ResponseStatusException) {
   response.setStatusCode(((ResponseStatusException) ex).getStatus());
  }
 
  return response.writeWith(Mono.fromSupplier(() -> {
   DataBufferFactory bufferFactory = response.bufferFactory();
   try {
    //todo 返回響應(yīng)結(jié)果，根據(jù)業(yè)務(wù)需求，自己定制
    CommonResponse resultMsg = new CommonResponse("500",ex.getMessage(),null);
    return bufferFactory.wrap(objectMapper.writeValueAsBytes(resultMsg));
   }
   catch (JsonProcessingException e) {
    log.error("Error writing response", ex);
    return bufferFactory.wrap(new byte[0]);
   }
  }));
 }
}