spring-gatway的使用方法 gateway自定义404页面 springboo自定义404页面

最新推荐文章于 2024-05-24 22:43:24 发布
置顶 最新推荐文章于 2024-05-24 22:43:24 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： java 文章标签： gateway
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xubaoyong/article/details/116203817
版权

源码

gitee项目地址： https://gitee.com/gxkj_admin/easyspring
如果对您有帮助，请点赞收藏。谢谢

功能说明：
1:gateway的java代码实现
2：gateway增加权限验证
3：gateway与nacos整合
4：springboot与nacos整合
5：gateway与sentinel整合
6：springboot与sentinel整合

参考文档

  • [spring中文网]https://www.springcloud.cc/spring-cloud-greenwich.html#_addrequestheader_gatewayfilter_factory
  • [官网]https://spring.io/guides/gs/gateway/
  • [官网例子]https://github.com/spring-cloud/spring-cloud-gateway/tree/main/spring-cloud-gateway-sample
  • 熔断后共享线程信息 https://www.cnblogs.com/duanxz/p/10949816.html

实现功能

  • Fluent java实现
  • 自定义应用拦截器
  • 自定义全局拦截器
  • 熔断器功能例子
  • 熔断器上下文地址信息获取
  • 完整代码

代码实现

– 第一版

下列代码主要是实现路由：

import com.example.demogateway.filters.MyPreGatewayFilterFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cloud.gateway.filter.ratelimit.RedisRateLimiter;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.security.config.web.server.ServerHttpSecurity;
import org.springframework.security.core.userdetails.MapReactiveUserDetailsService;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.web.server.SecurityWebFilterChain;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 参考网址：
 * 	https://www.springcloud.cc/spring-cloud-greenwich.html#_addrequestheader_gatewayfilter_factory
 */
@RestController
@SpringBootApplication
public class DemogatewayApplication {

	@RequestMapping("/hystrixfallback")
	public String hystrixfallback() {
		return "This is a fallback";
	}
	@Autowired
	private MyPreGatewayFilterFactory myPreGatewayFilterFactory;

//  path注意以“/”开头，支持and|or组合使用
//	order属性的数值越低，优先级越高
// 支持host和上传测试
// path可以使用通配符，例如：/foo/**

	@Bean
	public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {

		MyPreGatewayFilterFactory.Config conifg = new MyPreGatewayFilterFactory.Config();

		RouteLocator locator =  builder.routes()
//				支持路径测试
				.route("path_route", r -> r.path("/get")
						.filters(f -> f.filter(myPreGatewayFilterFactory.apply(conifg)))
						.uri("http://httpbin.org:80"))
				.route("host_form_route",
						r -> r.order(2).host("**.myhost.org").and().path("/uploadimg3")
						.filters(f -> f.filter(myPreGatewayFilterFactory.apply(conifg)))
						.uri("http://localhost:81/uploadImg2"))

				.route("path_route_complex", r -> r.path("/uploadimg4")
						.filters(f -> f.filter(myPreGatewayFilterFactory.apply(conifg)))
						.uri("http://localhost:81"))
				.route("hystrix_fallback_route", r -> r.host("*.hystrixfallback.org")
						.filters(f -> f.hystrix(c -> c.setName("slowcmd").setFallbackUri("forward:/hystrixfallback")))
								.uri("http://httpbin.org"))



				.build();
		return locator;
	}
 

	@Bean
	RedisRateLimiter redisRateLimiter() {
		return new RedisRateLimiter(1, 2);
	}

	@Bean
	SecurityWebFilterChain springWebFilterChain(ServerHttpSecurity http) throws Exception {
		return http.httpBasic().and()
				.csrf().disable()
				.authorizeExchange()
				.pathMatchers("/anything/**").authenticated()
				.anyExchange().permitAll()
				.and()
				.build();
	}

	@Bean
	public MapReactiveUserDetailsService reactiveUserDetailsService() {
		UserDetails user = User.withDefaultPasswordEncoder().username("user").password("password").roles("USER").build();
		return new MapReactiveUserDetailsService(user);
	}

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

下列代码主要实现过滤器

package com.example.demogateway.filters;

import com.example.demogateway.utils.ResponseUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.util.MultiValueMap;
import org.springframework.util.StringUtils;
import reactor.core.publisher.Mono;
import org.springframework.boot.context.properties.ConfigurationBeanFactoryMetadata;

@Component
public class MyPreGatewayFilterFactory extends AbstractGatewayFilterFactory<MyPreGatewayFilterFactory.Config> {

    private Logger logger = LoggerFactory.getLogger(MyPreGatewayFilterFactory.class);

    public MyPreGatewayFilterFactory() {
        super(Config.class);
    }

    @Override
    public GatewayFilter apply(Config config) {
        // grab configuration from Config object
        return (exchange, chain) -> {
            ServerHttpRequest request = exchange.getRequest();
            String path = request.getPath().toString();
            if(path.equals("dologin") ||"dologout".equals(path)){

                return chain.filter(exchange.mutate().request(request).build());
            }else{
                MultiValueMap<String, String> queryMap =  request.getQueryParams();
                String userName = queryMap.getFirst("userName");
//            String userName = config.getName();
                if(!StringUtils.hasText(userName)){
                    Mono<Void>  info = ResponseUtils.getResponseTextError(exchange,"非法用户,请在参数中使用：userName=xxx来尝试验证");
                    return info;
                }else if(!userName.equals("测试")){
                    Mono<Void>  info = ResponseUtils.getResponseTextError(exchange,"请使用用户名：'测试'进行登录");
                    return info;
                }
                //If you want to build a "pre" filter you need to manipulate the
                //request before calling chain.filter

//            ServerHttpRequest.Builder builder = exchange.getRequest().mutate();

                //use builder to manipulate the request
                return chain.filter(exchange.mutate().request(request).build());
            }

        };
    }

    public static class Config {
        private String name;

        public Config() {
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }

}

下面代码主要是个工具：


import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

public class ResponseUtils {
    public static Mono<Void> getResponseTextError(ServerWebExchange exchange, String msg) {
        ServerHttpResponse response = exchange.getResponse();
       String repString = String.format("{\"code\":-1,\"message\",%s}",msg);
        byte[] bits = repString.getBytes(StandardCharsets.UTF_8);
        DataBuffer buffer = response.bufferFactory().wrap(bits);
        response.setStatusCode(HttpStatus.UNAUTHORIZED);
        //指定编码，否则在浏览器中会中文乱码
        response.getHeaders().add("Content-Type", "text/plain;charset=UTF-8");
        return response.writeWith(Mono.just(buffer));
    }
}

补充知识：

1： 本地跳转的方法。具体参考HystrixGatewayFilterFactory.java类。参考下面的代码，希望对forward,等有参考实现价值。

protected Observable<Void> resumeWithFallback() {
            if (this.fallbackUri == null) {
                return super.resumeWithFallback();
            } else {
                URI uri = this.exchange.getRequest().getURI();
                boolean encoded = ServerWebExchangeUtils.containsEncodedParts(uri);
                URI requestUrl = UriComponentsBuilder.fromUri(uri).host((String)null).port((String)null).uri(this.fallbackUri).build(encoded).toUri();
                this.exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR, requestUrl);
                ServerHttpRequest request = this.exchange.getRequest().mutate().uri(requestUrl).build();
                ServerWebExchange mutated = this.exchange.mutate().request(request).build();
                return RxReactiveStreams.toObservable(HystrixGatewayFilterFactory.this.dispatcherHandler.handle(mutated));
            }
        }

使用方式在官网的例子里：

.route("hystrix_fallback_route", 
r -> r.host("*.hystrixfallback.org")
.filters(
	f -> f.hystrix(c -> c.setName("slowcmd")
		.setFallbackUri("forward:/hystrixfallback"))
)
.uri("http://httpbin.org"))

2：更多实现功能请参考网址：
[spring中文网]https://www.springcloud.cc/spring-cloud-greenwich.html#_addrequestheader_gatewayfilter_factory。里面有介绍负载均衡、限制次数等业务需求场景，大家可以自己实现。
3： 过滤器： SetPath、RequestSize（控制参数大小）、ModifyRequestBody（修改请求体，只能用java代码实现）、ModifyResponseBody（修改响应主体），GlobalFilter （全局过滤器）、ForwardRoutingFilter（转发过滤器）、LoadBalancerClientFilter（均衡过滤器）
4： 参看网址[spring中文网]中有前置过滤器PreGatewayFilterFactory 、后置过滤器PostGatewayFilterFactory、全局前置过滤器GlobalFilter customGlobalFilter和全局后置过滤器GlobalFilter customGlobalPostFilter 的例子

spring:
  cloud:
    gateway:
      routes:
      - id: setpath_route
        uri: https://example.org
        predicates:
        - Path=/foo/{segment}
        filters:
        - SetPath=/{segment}

– -- ----- 版本2-- – -----优化点如下：

  1. 使用predicate
  2. 使用断路器
  3. 断路器传递MDC等上下文

参考文档增加：
https://blog.csdn.net/zhanglh046/article/details/78652133

代码如下：

启动类


import com.example.demogateway.filters.MyPreGatewayFilterFactory;
import com.example.demogateway.plugins.HystrixCallableWrapper;
import com.example.demogateway.plugins.MdcAwareCallableWrapper;
import com.example.demogateway.plugins.RequestAttributeAwareCallableWrapper;
import com.example.demogateway.plugins.RequestContextHystrixConcurrencyStrategy;
import com.example.demogateway.predicates.MyRoutePredicateFactory;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import com.netflix.hystrix.strategy.HystrixPlugins;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.actuate.endpoint.SecurityContext;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cloud.gateway.filter.factory.HystrixGatewayFilterFactory;
import org.springframework.cloud.gateway.filter.factory.RewritePathGatewayFilterFactory;
import org.springframework.cloud.gateway.filter.ratelimit.RedisRateLimiter;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.http.server.PathContainer;
import org.springframework.http.server.RequestPath;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.security.config.web.server.ServerHttpSecurity;
import org.springframework.security.core.userdetails.MapReactiveUserDetailsService;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.web.server.SecurityWebFilterChain;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.reactive.DispatcherHandler;
import org.springframework.web.server.ServerWebExchange;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Predicate;

import static org.springframework.web.context.request.RequestAttributes.SCOPE_REQUEST;

/**
 * 参考网址：
 * 	https://www.springcloud.cc/spring-cloud-greenwich.html#_addrequestheader_gatewayfilter_factory
 */
@RestController
@SpringBootApplication
public class DemogatewayApplication {
	private Logger logger = LoggerFactory.getLogger(DemogatewayApplication.class);


	@Bean(name = "requestAttributeAwareCallableWrapper")
	public HystrixCallableWrapper requestAttributeAwareCallableWrapper() {
		return new RequestAttributeAwareCallableWrapper();
	}

	@Bean(name = "mdcAwareCallableWrapper")
	public HystrixCallableWrapper mdcAwareCallableWrapper(){
		return new MdcAwareCallableWrapper();
	}

	@Autowired(required = false)
	private List<HystrixCallableWrapper> wrappers = new ArrayList<>();



	@Autowired
	@Qualifier(value = "requestAttributeAwareCallableWrapper" )
	private  HystrixCallableWrapper requestAttributeAwareCallableWrapper;

	@Autowired
	@Qualifier(value = "mdcAwareCallableWrapper" )
	private  HystrixCallableWrapper mdcAwareCallableWrapper;

	@PostConstruct
	public void init() {
		wrappers.add(requestAttributeAwareCallableWrapper);
		wrappers.add(mdcAwareCallableWrapper);
		HystrixPlugins.getInstance().registerConcurrencyStrategy(new RequestContextHystrixConcurrencyStrategy(wrappers));
	}


	@RequestMapping("/hystrixfallback")
	public String hystrixfallback() {
		SecurityContext s = SecurityContext.NONE ;
		String  traceId = MDC.get("traceId");
		logger.info("hystrixfallback-traceId={}",traceId);

		return "This is a fallback";
	}
	
	@Autowired
	private MyPreGatewayFilterFactory myPreGatewayFilterFactory;
 

//	熔断器
	@Bean
	public HystrixGatewayFilterFactory hystrixGatewayFilterFactory(DispatcherHandler dispatcherHandler) {
		return new HystrixGatewayFilterFactory(dispatcherHandler);
	}



//  path注意以“/”开头，支持and|or组合使用
//	order属性的数值越低，优先级越高
// 支持host和上传测试

	@Bean
	public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {

		MyPreGatewayFilterFactory.Config conifg = new MyPreGatewayFilterFactory.Config();


		Consumer<HystrixGatewayFilterFactory.Config> configConsumer = new Consumer<HystrixGatewayFilterFactory.Config>() {
			@Override
			public void accept(HystrixGatewayFilterFactory.Config config) {
				config.setFallbackUri("forward:/hystrixfallback");
				config.setName("test3000");
			}
		};

		RouteLocator locator =  builder.routes()
				.route("predicate_route", r -> r.order(1)
						.predicate(exchange ->{
							//自定义匹配器，如果匹配"/httpbin"开头,则跳转到对应的网站
							ServerHttpRequest request = exchange.getRequest();
							RequestPath requestPath =  request.getPath();
							String requestPathString = requestPath.value().toString();

							boolean isMatch = requestPathString.startsWith("/httpbin");
							return isMatch;

						})
						.filters(f->
								  {
									  return f.removeRequestHeader("Origin")
											  .rewritePath("/httpbin","")
											  .hystrix(configConsumer)
											  ;


								}
						)
						.uri("http://localhost:81"))
//				支持路径测试
				.route("path_route", r -> r.order(2).path("/get")
						.filters(f -> f.filter(myPreGatewayFilterFactory.apply(conifg)))
						.uri("http://httpbin.org:80"))
				.route("host_form_route",
						r -> r.order(3).host("**.myhost.org").and().path("/uploadimg3")
						.filters(f -> f.filter(myPreGatewayFilterFactory.apply(conifg)))
						.uri("http://localhost:81/uploadImg2"))

				.route("path_route_complex", r -> r.order(4).path("/uploadimg4")
						.filters(f -> f.filter(myPreGatewayFilterFactory.apply(conifg)))
						.uri("http://localhost:81"))
				.route("hystrix_fallback_route", r -> r.order(5).host("*.hystrixfallback.org")
						.filters(f -> f.hystrix(c -> c.setName("slowcmd").setFallbackUri("forward:/hystrixfallback")))
								.uri("http://httpbin.org"))




				.build();
		return locator;
	} 
	public static void main(String[] args) {
		SpringApplication.run(DemogatewayApplication.class, args);
	}

}

HystrixCallableWrapper类

import java.util.concurrent.Callable;

public interface HystrixCallableWrapper {

    /**
     * 包装Callable实例
     *
     * @param callable 待包装实例
     * @param <T>      返回类型
     * @return 包装后的实例
     */
    <T> Callable<T> wrap(Callable<T> callable);

}

MdcAwareCallableWrapper类


import org.slf4j.MDC;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;

public class MdcAwareCallableWrapper implements HystrixCallableWrapper {
    @Override
    public <T> Callable<T> wrap(Callable<T> callable) {
        return new MdcAwareCallable<>(callable, MDC.getCopyOfContextMap());
    }

    private class MdcAwareCallable<T> implements Callable<T> {

        private final Callable<T> delegate;

        private final Map<String, String> contextMap;

        public MdcAwareCallable(Callable<T> callable, Map<String, String> contextMap) {
            this.delegate = callable;
            this.contextMap = contextMap != null ? contextMap : new HashMap();
        }

        @Override
        public T call() throws Exception {
            try {
                MDC.setContextMap(contextMap);
                return delegate.call();
            } finally {
                MDC.clear();
            }
        }
    }
}

RequestAttributeAwareCallableWrapper 类


import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;

import java.util.concurrent.Callable;

public final class RequestAttributeAwareCallableWrapper implements HystrixCallableWrapper {
    @Override
    public <T> Callable<T> wrap(Callable<T> callable) {
        return new RequestAttributeAwareCallable(callable, RequestContextHolder.getRequestAttributes());
    }

    static class RequestAttributeAwareCallable<T> implements Callable<T> {

        private final Callable<T> delegate;
        private final RequestAttributes requestAttributes;

        RequestAttributeAwareCallable(Callable<T> callable, RequestAttributes requestAttributes) {
            this.delegate = callable;
            this.requestAttributes = requestAttributes;
        }

        @Override
        public T call() throws Exception {
            try {
                RequestContextHolder.setRequestAttributes(requestAttributes);
                return delegate.call();
            } finally {
                RequestContextHolder.resetRequestAttributes();
            }
        }
    }
}

RequestContextHystrixConcurrencyStrategy 类

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy;

import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.Callable;
public class RequestContextHystrixConcurrencyStrategy extends HystrixConcurrencyStrategy {
    private final Collection<HystrixCallableWrapper> wrappers;

    public RequestContextHystrixConcurrencyStrategy(Collection<HystrixCallableWrapper> wrappers) {
        this.wrappers = wrappers;
    }

    @Override
    public <T> Callable<T> wrapCallable(Callable<T> callable) {
        return new CallableWrapperChain(callable, wrappers.iterator()).wrapCallable();
    }

    private static class CallableWrapperChain<T> {

        private final Callable<T> callable;

        private final Iterator<HystrixCallableWrapper> wrappers;

        CallableWrapperChain(Callable<T> callable, Iterator<HystrixCallableWrapper> wrappers) {
            this.callable = callable;
            this.wrappers = wrappers;
        }

        Callable<T> wrapCallable() {
            Callable<T> delegate = callable;
            while (wrappers.hasNext()) {
                delegate = wrappers.next().wrap(delegate);
            }
            return delegate;
        }
    }
}

MyRoutePredicateFactory 类


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.gateway.handler.predicate.AbstractRoutePredicateFactory;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.web.server.ServerWebExchange;

import java.util.function.Predicate;

public class MyRoutePredicateFactory extends AbstractRoutePredicateFactory<MyRoutePredicateFactory.Config> {
    private Logger logger = LoggerFactory.getLogger(MyRoutePredicateFactory.class);
    public MyRoutePredicateFactory() {
        super(Config.class);
    }

    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        // grab configuration from Config object
        return exchange -> {
            //grab the request
            ServerHttpRequest request = exchange.getRequest();
            //take information from the request to see if it
            //matches configuration.
            return matches(config, request);
        };
    }

    private boolean matches(Config config, ServerHttpRequest request) {
        logger.info("请求到达");
        return true;
    }

    public static class Config {
        //Put the configuration properties for your filter here
    }

}

这里做个全局过滤器，测试当熔断时traceId是否传到回调方法里


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.util.UUID;

import static org.springframework.web.context.request.RequestAttributes.SCOPE_REQUEST;


@Component
public class AccessLogGlobalFilter implements GlobalFilter {
    private Logger log = LoggerFactory.getLogger(AccessLogGlobalFilter.class);
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();

        String path = request.getPath().pathWithinApplication().value();
        String   traceId = getTraceId();
        log.info("traceId={}",traceId);
        MDC.put("traceId",traceId);
        log.info("请求路径:{}", path);
        RequestContextHolder.currentRequestAttributes().setAttribute("traceId", traceId, SCOPE_REQUEST);

        long start = System.currentTimeMillis();

        Mono<Void> rep = null;
        try{
         rep = chain.filter(exchange).then(Mono.fromRunnable(() -> {

            ServerHttpResponse response = exchange.getResponse();
            HttpStatus statusCode = response.getStatusCode();
            long end = System.currentTimeMillis();
            log.info("请求路径:{},响应码:{},耗时：{},traceId="+traceId, path, statusCode,(end-start));
        }));
        }catch (Exception e){
            throw e;
        }finally {
            // 这行不能要，否则熔断跳转后这个就丢失了 MDC.remove("traceId");
        }

        return rep;
    }
    public String getTraceId(){
        String   traceId = MDC.get("traceId");
        if(StringUtils.hasLength(traceId)){
            return traceId;
        }else{
            traceId = UUID.randomUUID().toString().replace("-", "");
            return traceId;
        }
    }
}

配置不同熔断器的响应时间，在application.yml里如下配置

hystrix:
  shareSecurityContext: true
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 2000
    test3000:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 3000

熔断后的上线文传递主要参考的是下列网址：
https://www.cnblogs.com/duanxz/p/10949816.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.gxkj.easy-spring</groupId>
	<artifactId>easy-spring-gateway</artifactId>
	<version>1.0.5</version>
	<packaging>jar</packaging>

	<name>spring-cloud-gateway-sample</name>
	<description>Demo project for Spring Cloud Gateway</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.2.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
		<spring-cloud.version>Finchley.RC2</spring-cloud.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-actuator</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-webflux</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-gateway</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-security</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>io.projectreactor</groupId>
			<artifactId>reactor-test</artifactId>
			<scope>test</scope>
		</dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>RELEASE</version>
            <scope>compile</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>

	<repositories>
		<repository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<snapshots>
				<enabled>true</enabled>
			</snapshots>
		</repository>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</repository>
	</repositories>

	<pluginRepositories>
		<pluginRepository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<snapshots>
				<enabled>true</enabled>
			</snapshots>
		</pluginRepository>
		<pluginRepository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</pluginRepository>
	</pluginRepositories>


</project>
阳光下的小鱼
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Cloud Gateway 动态路由管理，一点都不吹，应该没有比这更好的管理系统了吧
扛麻袋的少年的博客
04-18 3633
  本文介绍的 Spring Cloud Gateway 动态路由。不比其他博客通篇 copy 的 Gateway 动态路由，我为你们提供了一套完整的动态路由管理系统。提供以下3个项目： Spring Cloud Gateway 动态路由配置源码 Spring Cloud Gateway 动态路由后台管理项目源码 Spring Cloud Gateway 动态路由后台页面源码（基于Vue） 先来几个截图吧。   以往一篇文章：Spring Cloud Gateway 微服务新一代网关，已经有详细介
详解SpringCloud Finchley Gateway 统一异常处理
08-26
SpringCloud Finchley Gateway 统一异常处理是指在使用 SpringCloud Finchley 版本的 Gateway 时，如何统一处理系统级异常的方法。默认情况下，SpringCloud Gateway 会返回 HTML 格式的错误页面，而不是我们期望的 ...
SpringCloud Gateway配置自定义路由404坑
热门推荐
茅坤宝骏氹的博客
02-04 1万+
一、场景复现 微服务自定义路由，返回404页面。 如图： （1）springcloud-gateway的路由设置 @Configuration public class RouteConfig { @Bean public RouteLocator customRouteLocator(RouteLocatorBuilder builder) { return builder.routes() .route("test", r
gateway网关路由配置访问404
最新发布
Rogue_Yao的博客
05-24 559
最终url`http://localhost:7070/oss/policy`，uri是`http://localhost:7070`，path是`$\{segment}=oss/policy`
Spring cloud gateway 拦截请求404 等HTTP 状态码
荡漾
03-09 1万+
不废话 可以直接debug 一步一步跟 或者直接拿 AbstractErrorWebExceptionHandler 找到这个class 拿出来 并创建一个 一模一样的包放到里面， 因为是就近原则所有会走后提出来的文件 org.springframework.boot.autoconfigure.web.reactive.error 在handle 方法中进行添加状态的拦截...
springcloud gateway网关已配置路由，访问404解决方案
yuzheh521的博客
06-07 4599
先说明一下我的情况，我们公司之前有一个springcloud的微服务项目，还有一个springboot项目，但是访问的时候，都是一个地址，就是前端集体访问nginx，然后nginx在负载到这两个项目，微服务下面的服务在由getway负载一遍。然后我就又去看一眼，服务列表，以为是不是新服务没有注册到nacos中，看了一遍以后，还没有没问题，然后我就开始各种询问+百度。后来就想，是不是，没有重启新服务啊，我就重启了一遍新服务，可是还是不好使，万般无奈之际，同事问我，你getway的配置文件改完以后，发布了么？
springcloud gateway404问题
m0_67402731的博客
03-23 1224
在配置之前 最后发现discovery位置写错了，应该写在和routes一个级别下，我真是服了 Parameter 0 of method modifyRequestBodyGatewayFilterFactory in org.springframework.cloud.gateway.config.GatewayAutoConfiguration required a bean of type ‘org.springframework.http.codec.ServerCodecConfigurer’
MicroserviceGateway:使用Spring Cloud Gateway，自定义过滤器，Eureka Discovery Server-Client的微服务网关
03-10
在Spring Cloud Gateway中，我们可以使用`@LoadBalanced`注解和`RestTemplate`，或者直接使用`WebClient`来自动从Eureka获取服务实例的地址，从而实现对后端微服务的智能路由。 集成步骤如下： 1. 添加Eureka客户端...
微服务 spring cloud gateway搭建
01-21
gateway组件搭建 pom文件 org.springframework.cloud spring-cloud-starter-gateway org.springframework.cloud spring-cloud-starter-netflix-eureka-client org.springframework.boot spring-boot-...
Spring Cloud Gateway 2.1 使用手册中文版
08-25
Spring Cloud Gateway旨在提供一种简单而有效的API路由方式，并为其提供横切关注点，例如：安全，监控/指标和弹性。 特征： （1）构建于Spring Framework 5，Project Reactor 和 Spring Boot 2.0 （2）能够匹配任何...
SpringCloud Finchley Gateway 缓存请求Body和Form表单的实现
10-17
在构建微服务架构时，Spring Cloud Gateway作为API网关，起着至关重要的作用。它提供了路由、过滤器等功能，能够方便地对上游请求进行处理和转发。然而，有些场景下，我们可能需要缓存请求的Body（如JSON数据）或...
springcloud使用gateway访问项目接口404
Destiny121325的博客
11-28 1万+
使用gateway/服务名/接口 访问接口一直404，折腾了半天终于发现是自己在项目配置里边加入了server.servlet.context-path！！！。切记，如果加入了项目名称则用gateway访问必须是 gateway/服务名称/项目名/接口。在此记录，希望帮助到有需要的人。 ...
SpringCloud Gateway网关多路由配置访问404解决方案
一个喜欢诗和远方的程序媛
06-05 6494
网关中如果有 spring-boot-starter-actuator、spring-boot-starter-web 依赖，删除。启动类没有直接写在主包下面，而是写在了子包下面，需要在启动类加上@ComponentScan(“xxx”)，xxx一定是你的主包名。配置 filters: - StripPrefix=1，与路由id同级，去除前缀。如果这几种办法都没有解决，也可以尝试将target删除，重新编译试试。可以通过以下几种方式尝试解决，不是必须都配置，根据自己项目情况处理。
spring cloud 错误页配置
zhang_zining的专栏
01-17 1394
1、在spring cloud启动类中添加一个bean @EnableEurekaClient @SpringBootApplication public class UserApplication { @Bean public EmbeddedServletContainerCustomizer containerCustomizer() { return (container -
springcloud gateway网关多路由配置访问404解决方案
m0_48336806的博客
02-10 9060
springcloud gateway网关多路由配置访问404解决方案
gateway的application配置及404问题解决、redis配置
wearejava的博客
03-10 1536
server:eureka:client:spring:cloud:gateway:mvc:routes:- id: basefilters:
07）springcloud学习 SpringCloud Gateway 网关，API 路由管理
qq445829096的博客
03-19 402
1.抄一段SpringCloud Gateway简介 SpringCloud Gateway 是 Spring Cloud 的一个全新项目，该项目是基于 Spring 5.0，Spring Boot 2.0 和 Project Reactor 等技术开发的网关，它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。 SpringCloud Gateway 作为 Spring Cloud 生态系统中的网关，目标是替代 Zuul，在Spring Cloud 2.0以上版本中，没有对新版本的Z..
【实战】gateway开始动态路由报错404
qq_35701988的博客
01-02 3109
通过debug网关服务FilteringWebHandler类排查问题，发现gateway 开启动态路由（spring.cloud.gateway.discovery.locator.enabled: true），并且该路由的优先级（order=0）,高于配置的目标（order=1）,所以该路由先于配置的路由拦截请求，转发到了错误的uri路径上。所以： /demo-server/demo/test/gateway/yaml 被转换成 /demo/test/gateway/yaml 就报404。
Java中如何使用gatway？
04-19
为了更好地理解您的问题，您能否提供更多细节或背景信息？ Gateway一般指什么？ 例如，您是想了解如何使用Java客户端访问HTTP网关，还是如何使用Java API网关？ 针对不同的gateway，Java实现的方式通常也不同。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值