6、服务网关

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
<!-- 导入Eureka的客户端依赖包 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

@SpringCloudApplication
@EnableZuulProxy
public class ZuulApplication {
    public static void main(String[] args) {
        SpringApplication.run(ZuulApplication.class,args);
    }
}

#配置端口
server:
  port: 10000
#配置项目名称
spring:
  application:
    name: zuul
#配置eureka注册路径
eureka:
  client:
    service-url:
      defaultZone: http://localhost:9000/eureka
#配置路由
zuul:
  routes:
    #路由ID/名称（可以随便写）
    micro-base-server:
      #访问路径（不能随便写，它需要对应微服务中Controller发布的接口）
      path:
        /auction/**
        /market/**
      #在eureka中注册的微服务名称
      serverId: micro-base-server
    micro-user-server:
      path:
        /feign/**
        /rent/**
      serverId: micro-user-server

zuul:
  routes:
  	#eureka中微服务id: 访问路径
    micro-base-server: /auction/**,/market/**
    micro-user-server: /feign/**,/rent/**

//需要被spring容器管理
@Component
public class MyZuulFilter extends ZuulFilter {

    /**
     * 用来指定过滤器的类型
     * pre：路由之前
     * routing：路由之时
     * post： 路由之后
     * error：发送错误调用
     */
    public String filterType() {
        return "pre";
    }
    /**
     * 过滤器的顺序
     * @return 返回的Int越小，越先执行
     * 每个过滤器，默认都有一个中间值5
     */
    public int filterOrder() {
        return 0;
    }
    /**
     * 用来判断哪些路径，是需要做过滤处理的
     * @return true 需要做过滤（就是需要执行run()）  false 不需要做过滤(就是不需要执行run()）
     */
    public boolean shouldFilter() {
        return true;
    }
    /**
     * 具体的过滤器规则
     */
    public Object run() throws ZuulException {
        RequestContext context = RequestContext.getCurrentContext();
        HttpServletRequest request = context.getRequest();
        System.out.println("进入路由的过滤器 "+request.getServletPath());
        //true：成功响应，false：拒绝响应
        context.setSendZuulResponse(true);
        context.setResponseStatusCode(200);
        return null;
    }
}

<dependencies>
    <dependency>
        <groupId>top.ygang</groupId>
        <artifactId>star-common</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-spring-cloud-gateway-adapter</artifactId>
    </dependency>
</dependencies>

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

server:
  port: 80
spring:
  application:
    name: gateway
  cloud:
    gateway:
      # 自定义配置路由规则
      routes:
        # 路由标识，必须唯一，默认是UUID
        - id: student-sys
          # 路由的目标地址
          uri: http://localhost:8080
          # 路由的优先级，数字越小代表路由的优先级越高
          order: 1
          # 断言
          predicates:
            # 路径断言，当请求路径匹配Path时，就会路由到uri
            - Path=/student-sys/**
          # 过滤器
          filters:
            # 转发之前，去掉1层路径
            - StripPrefix=1

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

@SpringBootApplication
@EnableDiscoveryClient
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class,args);
    }
}

server:
  port: 80
spring:
  application:
    name: gateway
  cloud:
    nacos:
      discovery:
        # 将服务注册到nacos
        server-addr: http://localhost:8848
    gateway:
      discovery:
        locator:
          # 从nacos中获取服务信息，自动生成routes，开启会导致断言失效
          enabled: false
      # 自定义配置路由规则
      routes:
        # 路由标识，必须唯一，默认是UUID
        - id: student-sys
          # 路由的目标地址，lb(loadblance)表示使用负载均衡，其后是微服务的标识
          uri: lb://student-system
          # 路由的优先级，数字越小代表路由的优先级越高
          order: 1
          # 断言
          predicates:
            # 路径断言，当请求路径匹配Path时，就会路由到uri
            - Path=/student-sys/**
          # 过滤器
          filters:
            # 转发之前，去掉1层路径
            - StripPrefix=1

server:
  port: 80
spring:
  application:
    name: gateway
  cloud:
    nacos:
      discovery:
        # 将服务注册到nacos
        server-addr: http://localhost:8848
    gateway:
      discovery:
        locator:
          # 让gateway从nacos中获取服务信息，自动生成routes，开启会导致断言失效
          enabled: true

@Component
public class AgeRoutePredicateFactory extends AbstractRoutePredicateFactory<AgeRoutePredicateFactory.Config> {
    public AgeRoutePredicateFactory(){
        super(AgeRoutePredicateFactory.Config.class);
    }

    // 读取配置文件中的参数，并封装到Config内部类的对象中
    @Override
    public List<String> shortcutFieldOrder() {
        // 该集合中元素的顺序，必须与配置文件中参数的顺序一致
        return Arrays.asList("minAge", "maxAge");
    }

    @Override
    public Predicate<ServerWebExchange> apply(AgeRoutePredicateFactory.Config config) {

        return new Predicate<ServerWebExchange>(){

            @Override
            public boolean test(ServerWebExchange serverWebExchange) {
                //通过路由获得传递的参数
                String age = serverWebExchange.getRequest().getQueryParams().getFirst("age");
                //判断是否有值
                if(!StringUtils.isEmpty(age)){
                    //转型
                    Integer a = Integer.parseInt(age);
                    return a>=config.getMinAge()&&a<=config.getMaxAge();
                }
                return false;
            }
        };
    }

    public static class Config {
        private Integer minAge;
        private Integer maxAge;
        public Integer getMinAge() {
            return minAge;
        }

        public void setMinAge(Integer minAge) {
            this.minAge = minAge;
        }

        public Integer getMaxAge() {
            return maxAge;
        }

        public void setMaxAge(Integer maxAge) {
            this.maxAge = maxAge;
        }
    }
}

server:
  port: 9009
spring:
  application:
    name: star-gateway
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    gateway:
      discovery:
        locator:
          enabled: false
      routes:
        - id: product_route
          uri: lb://star-product
          order: 1
          predicates:
            - Path=/product-serv/**
          filters:
            - StripPrefix=1
            - SetStatus=202				#修改 response的状态码

@Component
public class LogGatewayFilterFactory extends AbstractGatewayFilterFactory<LogGatewayFilterFactory.Config> {
    public LogGatewayFilterFactory(){
        super(LogGatewayFilterFactory.Config.class);
    }

    @Override
    public GatewayFilter apply(Config config) {
        return new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                if(config.isConsolelog()){
                    System.out.println("控制台日志功能开启！！");
                }
                if(config.isCachelog()){
                    System.out.println("缓存日志功能开启！！");
                }
                return chain.filter(exchange);
            }
        };
    }

    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("consoleLog", "cacheLog");
    }

    public static class Config {
        private boolean consolelog;
        private boolean cachelog;

        public boolean isConsolelog() {
            return consolelog;
        }

        public void setConsolelog(boolean consolelog) {
            this.consolelog = consolelog;
        }

        public boolean isCachelog() {
            return cachelog;
        }

        public void setCachelog(boolean cachelog) {
            this.cachelog = cachelog;
        }
    }
}

@Component
public class AuthGlobalFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = exchange.getRequest().getQueryParams().getFirst("token");
        if(!"test".equals(token)){
            System.out.println("未认证");
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return 0;
    }
}