黄埔班第62节：SpringCloud Gateway 服务网关

package com.icodingedu.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication(exclude = {RedisReactiveAutoConfiguration.class}) // 先排除redis自动配置,后面使用redis限流要去掉exclude
@EnableDiscoveryClient // 连接Eureka基于服务发现自动创建路由规则
public class GatewayServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayServerApplication.class,args);
    }
}

package com.icodingedu.springcloud.config;

import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpMethod;

@Configuration
public class GatewayConfiguration {

    @Bean
    @Order
    public RouteLocator customerRouters(RouteLocatorBuilder builder){
        return builder.routes()
                .route(r -> r.path("/gavinjava/**")
                             .and().method(HttpMethod.GET)
                       			.and().header("name") // 请求头必须带有name参数
                             .filters(f -> f.stripPrefix(1)
                                            .addResponseHeader("java-param","gateway-config")
                             )
                             .uri("lb://FEIGN-CLIENT")
                ).build();
    }
}

package com.icodingedu.springcloud.pojo;

import lombok.Builder;
import lombok.Data;

@Data
@Builder
public class Product {

    private Long productId;
    private String description;
    private Long stock;
}

package com.icodingedu.springcloud.controller;

import com.icodingedu.springcloud.pojo.Product;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@RestController
@Slf4j
@RequestMapping("gateway")
public class GatewayController {

    //Product要在feign-client-intf里提前定义好
    public static final Map<Long, Product> items = new ConcurrentHashMap<>();

    @GetMapping("detail")
    public Product getProduct(Long pid){
        //如果第一次没有就先创建一个
        if(!items.containsKey(pid)){
            Product product = Product.builder().productId(pid)
                    .description("new arrival")
                    .stock(100L).build();
            items.putIfAbsent(pid,product);
        }
        return items.get(pid);
    }

    @GetMapping("placeOrder")
    public String buy(Long pid){
        Product product = items.get(pid);
        if(product==null){
            return "Product Not Found";
        }else if(product.getStock()<=0L){
            return "Sold Out";
        }
        //如果是单体应用,即便是集群也可以保留这个代码,集群解决需要用到分布式锁将控制放到中心节点即可
        synchronized (product){
            if(product.getStock()<=0L){
                return "Sold Out";
            }
            product.setStock(product.getStock()-1);
        }
        return "Order Placed";
    }
}

@Configuration
public class GatewayConfiguration {
    @Bean
    @Order
    public RouteLocator customerRouters(RouteLocatorBuilder builder){
        return builder.routes()
                .route(r -> r.path("/gavinjava/**")
                             .and().method(HttpMethod.POST)
                             .and().query("name","gavin")
                             .filters(f -> f.stripPrefix(1)
                                            .addResponseHeader("java-param","gateway-config")
                             )
                             .uri("lb://FEIGN-CLIENT")
                )
                .route(r -> r.path("/secondkill/**")
                             .and().after(ZonedDateTime.now().plusSeconds(30)) // 30秒后才生效
                             .filters(f -> f.stripPrefix(1))
                             .uri("lb://FEIGN-CLIENT")
                )
                .build();
    }
}

@Configuration
public class GatewayConfiguration {

    @Bean
    @Order
    public RouteLocator customerRouters(RouteLocatorBuilder builder){
        LocalDateTime ldt = LocalDateTime.of(2020,10,24,20,31,10);
      	LocalDateTime ldt2 = LocalDateTime.of(2020,10,24,20,32,10);
        return builder.routes()
                .route(r -> r.path("/gavinjava/**")
                             .and().method(HttpMethod.POST)
                             .and().query("name","gavin")
                             .filters(f -> f.stripPrefix(1)
                                            .addResponseHeader("java-param","gateway-config")
                             )
                             .uri("lb://FEIGN-CLIENT")
                )
                .route(r -> r.path("/secondkill/**")
                             //.and().after(ZonedDateTime.of(ldt, ZoneId.of("Asia/Shanghai")))
                       .and().between(ZonedDateTime.of(ldt,ZoneId.of("Asia/Shanghai")),ZonedDateTime.of(ldt2,ZoneId.of("Asia/Shanghai")))
                             .filters(f -> f.stripPrefix(1).redirect("304","https://www.icodingedu.com/"))
                             .uri("lb://FEIGN-CLIENT")
                )
                .build();
    }
}

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);

public int getOrder(){
  return 0;
}
// Pre类型的过滤器来说，数字越大表示优先级越高，也就越早被执行。但对于Post类型过滤器，则是数字越小越先被执行

.filters(f -> f.addResponseHeader("name","gateway-server"))
//相当于向header中添加一个name属性，对应的值是gateway-server

.route(r -> r.path("/gateway-test/**")
						 .filters(f -> f.stripPrefix(1))
       			 .uri("lb://FEIFN-SERVICE/")
)
//假如HTTP请求访问的是/gateway-test/sample/update，如果没有StripPrefix过滤器，那么转发到FEIGN-SERVIC服务的访问路径也是一样的//FEIGN-SERVICE/gateway-test/sample/update，如果添加了这个过滤器，gateway就会根据stripPrefix(1)中的配置截取URL的路径，比如这里设置的是1，那么就去掉一个前缀，最终发送给后台服务的路径就变成//FEIGN-SERVICE/sample/update

.route(r -> r.path("/gateway-test/**")
						 .filters(f -> f.prefixPath("go"))
       			 .uri("lb://FEIGN-SERVICE/")
)
//假如我们访问的路径是/gateway-test/sample，如果使用这个过滤器就会变成//FEIGN-SERVICE/go/gateway-test/sample

.filters(f -> f.redirect(304,"https://www.baidu.com"))
//Caused by: java.lang.IllegalArgumentException: status must be a 3xx code, but was 404
 // 遇到3xx的返回状态，跳转到baidu

package com.icodingedu.springcloud.filter;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Slf4j
@Component
public class TimerFilter implements GatewayFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //给接口计时并能输出log
        StopWatch timer = new StopWatch();
        //开始计时,
        timer.start(exchange.getRequest().getURI().getRawPath());
        //我们也可以对调用链进行加工，手工放入请求参数
        exchange.getAttributes().put("requestTimeBegin",System.currentTimeMillis());
        return chain.filter(exchange).then(
            //这里就是执行完过滤进行调用的地方
            Mono.fromRunnable(() -> {
                timer.stop();;
                log.info(timer.prettyPrint());
            })
        );
    }

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

@Configuration
public class GatewayConfiguration {

    @Autowired
    private TimerFilter timerFilter;

    @Bean
    @Order
    public RouteLocator customerRouters(RouteLocatorBuilder builder){
        LocalDateTime ldt = LocalDateTime.of(2020,10,24,21,05,10);
        return builder.routes()
                .route(r -> r.path("/gavinjava/**")
                             .and().method(HttpMethod.GET)
                             .filters(f -> f.stripPrefix(1)
                                            .addResponseHeader("java-param","gateway-config")
                                            .filter(timerFilter)
                             )
                             .uri("lb://FEIGN-CLIENT")
                )
                .route(r -> r.path("/secondkill/**")
                             .and().after(ZonedDateTime.of(ldt, ZoneId.of("Asia/Shanghai")))
                             .filters(f -> f.stripPrefix(1))
                             .uri("lb://FEIGN-CLIENT/")
                )
                .build();
    }
}

@Slf4j
@Component
public class TimerFilter implements GlobalFilter, Ordered

package com.icodingedu.springcloud.entity;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Account implements Serializable {

    private String username;

    private String token;

    //当token接近失效的时候可以用refreshToken生成一个新的token
    private String refreshToken;
}

package com.icodingedu.springcloud.entity;

public class AuthResponseCode {
	/**
	 * 成功
	 */
	public static final Long SUCCESS = 1L;

	/**
	 * 无效密码
	 */
	public static final Long INCORRENT_PWD = 1000L;

	/**
	 * 用户不存在
	 */
	public static final Long USER_NOT_FOUND = 1001L;

	/**
	 * 无效TOKEN
	 */
	public static final Long INVALID_TOKEN = 1002L;
}

package com.icodingedu.springcloud.entity;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AuthResponse {
	/**
	 * 账号
	 */
	private Account account;

	/**
	 * 响应结果码
	 */
	private Long code;
}

package com.icodingedu.springcloud.service;

import com.icodingedu.springcloud.entity.AuthResponse;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

@FeignClient("auth-service")
public interface AuthService {
  /**
	 * 登录
	 * @param username
	 * @param password
	 * @return
	 */
	@PostMapping("/login")
	@ResponseBody
	AuthResponse login(@RequestParam("username") String username,
	                   @RequestParam("password") String password);

	/**
	 * 认证
	 * @param token
	 * @param username
	 * @return
	 */
	@GetMapping("/verify")
	@ResponseBody
	AuthResponse verify(@RequestParam("token") String token,
	                           @RequestParam("username") String username);

	/**
	 * 刷新token
	 * @param refreshToken
	 * @return
	 */
	@PostMapping("/refresh")
	@ResponseBody
	AuthResponse refresh(@RequestParam("refresh") String refreshToken);
}

@SpringBootApplication
@EnableDiscoveryClient
public class AuthServiceApplication {
	public static void main(String[] args) {
		new SpringApplicationBuilder(AuthServiceApplication.class).web(WebApplicationType.SERVLET).run(args);
	}
}

@Slf4j
@Service
public class JwtService {
	// 密钥，生产环境中应该从外部加密后获取，通过配置中心加密后获取，解密得到
	private static final String SERCET = "you must change it";
	// 发行人，生产环境中应该从外部加密后获取，通过配置中心加密后获取，解密得到
	private static final String ISSUER = "icodingedu";
	// 过期时间,60分钟
	private static final long EXPIRE = 1000*60*60;
	// 自包含的数据
	private static final String USERNAME = "username";


	/**
	 * 生成token
	 * @param account
	 * @return
	 */
	public String getToken(Account account){
		Date now = new Date();
		// 签名加密
		Algorithm algorithm = Algorithm.HMAC256(SERCET);
		String token = JWT.create().withSubject("member-user")
				.withIssuer(ISSUER) // 解密的时候如果不知道发行方也无法解密
				.withIssuedAt(now)
				.withExpiresAt(new Date(now.getTime() + EXPIRE)) // 过期时间
 				.withClaim(USERNAME,account.getUserName()) // 自包含的数据
				.sign(algorithm); // 签名
		log.info("jwt generated username={}",account.getUserName());
		return token;
	}

	/**
	 * 验证token
	 */
	public boolean verifyToken(String token,String username){
		log.info("verify jwt user={}",username);
		try{
			// 签名加密
			Algorithm algorithm = Algorithm.HMAC256(SERCET);
			// 构建验证器
			JWTVerifier verifier = JWT.require(algorithm).withIssuer(ISSUER).withClaim(USERNAME, username).build();
			// 验证,没有错误就直接通过
			verifier.verify(token);
			return true;
		}catch (Exception e){
			log.error("verify fail",e);
			return false;
		}
	}
  
  	/**
	 * 获取token中的用户名
	 */
	public String getUsername(String token){
		// 签名加密
		Algorithm algorithm = Algorithm.HMAC256(SERCET);
		// 构建验证器
		JWTVerifier verifier = JWT.require(algorithm).withIssuer(ISSUER).build();
		Claim claim = verifier.verify(token).getClaim(USERNAME);
		return  claim.asString();
	}
}

import com.icodingedu.springcloud.pojo.Account;
import com.icodingedu.springcloud.pojo.AuthResponse;
import com.icodingedu.springcloud.pojo.AuthResponseCode;
import com.icodingedu.springcloud.service.AuthService;
import com.icodingedu.springcloud.service.JwtService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.RestController;

import java.util.Objects;
import java.util.UUID;

@RestController
public class JwtController implements AuthService {
	@Autowired
	RedisTemplate redisTemplate;
	@Autowired
	JwtService jwtService;


	@Override
	public AuthResponse login(String username, String password) {
		Account account = Account.builder().userName(username).build();
		// TODO 从数据库根据用户名查询密码进行比较验证，这里假设验证通过
		// 1、生成token
		String token = jwtService.getToken(account);
		account.setToken(token);
		// 刷新token
		account.setRefreshToken(UUID.randomUUID().toString());
		// 2、保存refresh-token与token的关系
		redisTemplate.opsForValue().set(account.getRefreshToken(),account);

		return AuthResponse.builder().account(account).code(AuthResponseCode.SUCCESS).build();
	}

	@Override
	public AuthResponse verify(String token, String username) {
		boolean flag = jwtService.verifyToken(token,username);
		return AuthResponse.builder().code(flag?AuthResponseCode.SUCCESS:AuthResponseCode.INVALID_TOKEN).build();
	}

	@Override
	public AuthResponse refresh(String refreshToken) {
		Account account = (Account) redisTemplate.opsForValue().get(refreshToken);
		if(Objects.isNull(account)){
			return AuthResponse.builder().code(AuthResponseCode.USER_NOT_FOUND).build();
		}
		// 1、生成一个新的token
		String token = jwtService.getToken(account);
		account.setToken(token);
		// 2、更新refreshToken
		account.setRefreshToken(UUID.randomUUID().toString());
		// 3、删除redis上的旧值
		redisTemplate.delete(refreshToken);
		// 4、保存refresh-token与token的关系
		redisTemplate.opsForValue().set(account.getRefreshToken(),account);

		return AuthResponse.builder().account(account).code(AuthResponseCode.SUCCESS).build();
	}
}

@Component                                                                                                  
@Slf4j                                                                                                      
public class AuthFilter implements GatewayFilter, Ordered {                                                 
	private static final String AUTH="Authorization";                                                       
	private static final String USERNAME = "icodingedu-username";                                           
                                                                                                            
	@Autowired                                                                                              
	AuthService authService;                                                                                
                                                                                    
	@Override                                                                                               
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {                        
		log.info("Auth start");                                                                             
		ServerHttpRequest request = exchange.getRequest();                                                  
		HttpHeaders headers = request.getHeaders();                                                         
		// 获取请求头上的toen                                                                                      
		String token = headers.getFirst(AUTH);                                                              
		// 获取请求头上的username                                                                                  
		String username = headers.getFirst(USERNAME);                                                       
		                                                                                                    
		// 响应返回                                                                                             
		ServerHttpResponse response = exchange.getResponse();                                               
		if(StringUtils.isBlank(token)){                                                                     
			log.error("token not found");                                                                   
			response.setStatusCode(HttpStatus.UNAUTHORIZED);                                                
			return response.setComplete();                                                                  
		}                                                                                                   
		// 验证token                                                                                          
		AuthResponse res = authService.verify(token, username);                                             
		if(res.getCode() != AuthResponseCode.SUCCESS){                                                      
			log.error("invalid token");                                                                     
		    response.setStatusCode(HttpStatus.FORBIDDEN);                                                   
		    return response.setComplete();                                                                  
		}                                                                                                   
		// 将用户信息再次放到请求的header中传递给下游                                                                 
		ServerHttpRequest.Builder mutate = request.mutate();                                                
		mutate.header(USERNAME,username);                                                                   
		ServerHttpRequest buildRequest = mutate.build();                                                    
                                                                                                            
		// 如果响应中要存放数据，可以放到response的header中                                                           
		response.setStatusCode(HttpStatus.OK);                                                              
		response.getHeaders().add("icodingedu-user",username);                                              
                                                                                                            
		// 传递给下一个路由过滤器                                                                                   
		return chain.filter(exchange.mutate().request(buildRequest).response(response).build());            
	}                                                                                                       
                                                                                                            
	@Override                                                                                               
	public int getOrder() {                                                                                 
		return 0;                                                                                           
	}                                                                                                       
}                                                                                                                                                                                                                       

@SpringBootApplication(exclude = {RedisReactiveAutoConfiguration.class})
@EnableDiscoveryClient
@EnableFeignClients
public class GatewayServerApplication {
	public static void main(String[] args) {
		SpringApplication.run(GatewayServerApplication.class);
	}
}

//	@Autowired
//	AuthService authService;

	@Autowired
	RestTemplate restTemplate;
... 
// 验证token                                                                                           
// AuthResponse res = authService.verify(token, username);                                           
String path = String.format("http://auth-service/verify?token=%s&username=%s",token,username);        
AuthResponse res = restTemplate.getForObject(path,AuthResponse.class);     
if(res.getCode() != AuthResponseCode.SUCCESS){                                                      
			log.error("invalid token");                                                                     
		    response.setStatusCode(HttpStatus.FORBIDDEN);                                                   
		    return response.setComplete();                                                                  
		}     
...

@SpringBootApplication(exclude = {RedisReactiveAutoConfiguration.class})
@EnableDiscoveryClient
@EnableFeignClients
public class GatewayServerApplication {
	@Bean
	@LoadBalanced // 支持负载均衡的功能
	public RestTemplate restTemplate(){
		return new RestTemplate();
	}

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

import org.reactivestreams.Publisher;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.server.reactive.ServerHttpResponse;
import reactor.core.publisher.Mono;
import java.util.function.BiFunction;

/**
 * @Author jude
 * @Date 2022/5/16 7:58 PM
 * @Version 1.0
 */
public interface BodyHackerFunction extends BiFunction<ServerHttpResponse, Publisher<? extends DataBuffer>, Mono<Void>> {
}

import org.reactivestreams.Publisher;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.http.server.reactive.ServerHttpResponseDecorator;
import reactor.core.publisher.Mono;

/**
 * @Author jude
 * @Date 2022/5/16 11:17 PM
 * @Version 1.0
 * ServerHttpResponseDecorator 是装饰基类，
 * 这里写具体装饰类，一定要记住装饰模式的结构
 */
public class BodyHackerHttpResponseDecorator extends ServerHttpResponseDecorator {
	/**
	 * 负责具体写入body内容的代理类
	 */
	private BodyHackerFunction delegate = null;

	public BodyHackerHttpResponseDecorator(BodyHackerFunction bodyHandler, ServerHttpResponse delegate){
		super(delegate);
		this.delegate = bodyHandler;
	}

	@Override
	public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
		return this.delegate.apply(getDelegate(),body);
	}
}

import com.icodingedu.springcloud.tool.BodyHackerFunction;
import com.icodingedu.springcloud.tool.BodyHackerHttpResponseDecorator;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.core.Ordered;
import org.springframework.http.HttpHeaders;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

/**
 * @Author jude
 * @Date 2022/5/17 12:51 PM
 * @Version 1.0
 */
@Slf4j
@Component
public class ErrorFilter implements GatewayFilter, Ordered {
	@Override
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
		ServerHttpRequest request = exchange.getRequest();
		// 声明Function函数式接口
		BodyHackerFunction delegate = (resp,body)->
			Flux.from(body).flatMap(orgBody->{
				// 原始的responseBody，即业务服务返回的responseBody
				byte[] orgContent = new byte[orgBody.readableByteCount()];
				orgBody.read(orgContent);
				String content = new String(orgContent);
				log.info("original content{}",content);

				// 如果是500，则替换为json字符串返回
      HttpHeaders headers = resp.getHeaders();
				if(resp.getStatusCode().value() == 500){
					content = String.format("{\"status\":%d,\"path\":\"%s\"}",resp.getStatusCode().value(),request.getPath().value());
          headers.setContentType(MediaType.APPLICATION_JSON);
				}
				// 告知客户端body的长度，如果不设置，客户端会一直等待
				headers.setContentLength(content.length());

				return resp.writeWith(Flux.just(content).map(c->resp.bufferFactory().wrap(c.getBytes())));
			}).then();

		// 具体装饰类返回，它继承装饰基类ServerHttpResponseDecorator也是接口ServerHttpResponse的实现类
		BodyHackerHttpResponseDecorator responseDecorator = new BodyHackerHttpResponseDecorator(delegate,exchange.getResponse());
		return chain.filter(exchange.mutate().response(responseDecorator).build()   ) ;
	}

	@Override
	public int getOrder() {
		// 更高的优先级执行。WHRITE_RESPONSE_FILTER的执行顺序是-1，这里-2比它更优先执行
		return -2;
	}
}

@Configuration
public class GatewayConfiguration {
//	@Autowired
//	TimerFilter timerFilter;
	@Autowired
	AuthFilter authFilter;
	
	@Autowired
	ErrorFilter errorFilter;

	@Bean
	@Order
	public RouteLocator customerRouters(RouteLocatorBuilder builder){
		LocalDateTime ldt = LocalDateTime.of(2022,4,28,22,55,10);
		LocalDateTime ldt2 = LocalDateTime.of(2022,4,28,22,56,10);

		return builder.routes().route(r-> r.path("/gavinjava/**")
				.and().method(HttpMethod.GET)
				.and().header("name")
				.filters(f->f.stripPrefix(1).addResponseHeader("java-param","gateway-config")
					.filter(errorFilter)
					//.filter(authFilter)
					//.filter(timerFilter)
				)
				.uri("lb://EUREKA-CLIENT")
		).route(r->r.path("/secondkill/**")
				.and().method(HttpMethod.GET)
				//.and().after(ZonedDateTime.now().plusSeconds(60))
				//.and().after(ZonedDateTime.of(ldt, ZoneId.of("Asia/Shanghai")))
				.and().between(ZonedDateTime.of(ldt,ZoneId.of("Asia/Shanghai")),ZonedDateTime.of(ldt2,ZoneId.of("Asia/Shanghai")))
				.filters(f->f.stripPrefix(1).redirect("304","https://www.icodingedu.com/"))
				.uri("lb://FEIGN-CLIENT")).build();
	}
}

@RestController
public class HelloController {
	@Value("${server.port}")
	private String port;
  
	@GetMapping("/sayhello")
	public String sayHello(){
		return "my port is "+port;
	}
	
	@GetMapping("/valid")
	public String valid(){
		int i =1/0;
		return "valid";
	}
}

import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.cloud.gateway.filter.ratelimit.RedisRateLimiter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import reactor.core.publisher.Mono;

/**
 * @Author jude
 * @Date 2022/5/18 12:49 PM
 * @Version 1.0
 */
@Configuration
public class RedisLimiterConfiguration {
	// ID 限流的业务标识
	// 根据用户请求IP地址进行限流
	@Bean  // 注入spring 容器
	@Primary
	public KeyResolver remoteAddressKeyResolver(){
		return exchange -> Mono.just(exchange.getRequest().getRemoteAddress().getAddress().getHostAddress());
	}
 
	@Bean("redisLimiterUser")
  @Primary
	public RedisRateLimiter redisRateLimiterUser(){
		// 第一个参数defaultReplensihRate 生成redis令牌的速率，这里每秒1个 
		// 第二个参数defaultBurstCapacity 令牌桶的容量，这里定义可容纳2个令牌 
		return n ew RedisRateLimiter(1,2);
	}

	@Bean("redisLimiterProduct")
	public RedisRateLimiter redisRateLimiterProduct(){
		// 第一个参数defaultReplensihRate 生成redis令牌的速率，这里每秒10个 
		// 第二个参数defaultBurstCapacity 令牌桶的容量，这里定义可容纳30个令牌 
		return new RedisRateLimiter(20,60);
	}
}

@Configuration
public class GatewayConfiguration {
//	@Autowired
//	TimerFilter timerFilter;

	@Autowired
	AuthFilter authFilter;

	@Autowired
	ErrorFilter errorFilter;

	@Autowired
	KeyResolver hostNameResolver;

	@Autowired
	@Qualifier("redisLimiterUser")
	RedisRateLimiter redisLimiterUser;

	@Bean
	@Order
	public RouteLocator customerRouters(RouteLocatorBuilder builder){
		LocalDateTime ldt = LocalDateTime.of(2022,4,28,22,55,10);
		LocalDateTime ldt2 = LocalDateTime.of(2022,4,28,22,56,10);

		return builder.routes().route(r-> r.path("/gavinjava/**")
				.and().method(HttpMethod.GET)
				//.and().header("name")
				.filters(f->f.stripPrefix(1).addResponseHeader("java-param","gateway-config")
					.filter(errorFilter).requestRateLimiter(c->{
						c.setKeyResolver(hostNameResolver);
						c.setRateLimiter(redisLimiterUser);
					})
					//.filter(authFilter)
					//.filter(timerFilter)
				)
				.uri("lb://EUREKA-CLIENT")
		).route(r->r.path("/secondkill/**")
				.and().method(HttpMethod.GET)				.and().between(ZonedDateTime.of(ldt,ZoneId.of("Asia/Shanghai")),ZonedDateTime.of(ldt2,ZoneId.of("Asia/Shanghai")))
				.filters(f->f.stripPrefix(1).redirect("304","https://www.icodingedu.com/"))
				.uri("lb://FEIGN-CLIENT")).build();
	}
}