import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
/**
 * Creates new instance of {@link StoreProxyRouteLocator}
 * 
 * @param servletPath the application servlet path
 * @param discovery the discovery service
 * @param properties the zuul properties
 * @param store the route store
 */
public StoreProxyRouteLocator(String servletPath, DiscoveryClient discovery,
    ZuulProperties properties, ZuulRouteService store) {
  super(servletPath, discovery, properties);
  this.store = store;
  refreshExecutor.scheduleAtFixedRate(new Runnable() {

    @Override
    public void run() {
      try {
        refresh();
      } catch (Throwable e) {
        log.error(e.getMessage(), e);
      }
    }
  }, 0, 1, TimeUnit.MINUTES);
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
@ConditionalOnMissingBean(RouteStore.class)
@Bean
public RouteStore routeStore() {
    return new RouteStore() {
        @Override
        public List<ZuulProperties.ZuulRoute> getAllRoutes() {
            return Collections.emptyList();
        }

        @Override
        public void onRoutesChange(Consumer<List<ZuulProperties.ZuulRoute>> handleFunction) {
            handleFunction.accept(getAllRoutes());
        }

        @Override
        public List<ServiceRoute> getAllServiceRoutes() {
            return Collections.emptyList();
        }
    };
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
@Test
public void shouldReportDownState() {

    // given
    final ZuulProperties.ZuulRoute route = new ZuulProperties.ZuulRoute("/zuul", "proxied-service");
    zuulProperties.getRoutes().put(route.getId(), route);

    // when
    final Health health = zuulRouteHealthIndicator.health();

    // then
    assertNotNull(health);
    assertEquals(Status.DOWN, health.getStatus());
    assertNull(health.getDetails().get("available"));
    assertFalse(((Collection) health.getDetails().get("unavailable")).isEmpty());
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
@Test
public void shouldReportUpState() {

    // given
    final ZuulProperties.ZuulRoute route = new ZuulProperties.ZuulRoute("/zuul", "proxied-service");
    zuulProperties.getRoutes().put(route.getId(), route);

    final List<ServiceInstance> services = new ArrayList<>();
    services.add(mock(ServiceInstance.class));
    when(discoveryClient.getInstances("proxied-service")).thenReturn(services);

    // when
    final Health health = zuulRouteHealthIndicator.health();

    // then
    assertNotNull(health);
    assertEquals(Status.UP, health.getStatus());
    assertFalse(((Collection) health.getDetails().get("available")).isEmpty());
    assertNull(health.getDetails().get("unavailable"));
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
private String getRestoredPath(ZuulProperties zuulProperties, Route route,
		UriComponents redirectedUriComps) {
	StringBuilder path = new StringBuilder();
	String redirectedPathWithoutGlobal = downstreamHasGlobalPrefix(zuulProperties)
			? redirectedUriComps.getPath()
					.substring(("/" + zuulProperties.getPrefix()).length())
			: redirectedUriComps.getPath();

	if (downstreamHasGlobalPrefix(zuulProperties)) {
		path.append("/" + zuulProperties.getPrefix());
	}
	else {
		path.append(zuulHasGlobalPrefix(zuulProperties)
				? "/" + zuulProperties.getPrefix() : "");
	}

	path.append(downstreamHasRoutePrefix(route) ? "" : "/" + route.getPrefix())
			.append(redirectedPathWithoutGlobal);

	return path.toString();
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
protected static Setter getSetter(final String commandKey,
		ZuulProperties zuulProperties, IClientConfig config) {

	// @formatter:off
	Setter commandSetter = Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("RibbonCommand"))
							.andCommandKey(HystrixCommandKey.Factory.asKey(commandKey));
	final HystrixCommandProperties.Setter setter = createSetter(config, commandKey, zuulProperties);
	if (zuulProperties.getRibbonIsolationStrategy() == ExecutionIsolationStrategy.SEMAPHORE){
		final String name = ZuulConstants.ZUUL_EUREKA + commandKey + ".semaphore.maxSemaphores";
		// we want to default to semaphore-isolation since this wraps
		// 2 others commands that are already thread isolated
		final DynamicIntProperty value = DynamicPropertyFactory.getInstance()
				.getIntProperty(name, zuulProperties.getSemaphore().getMaxSemaphores());
		setter.withExecutionIsolationSemaphoreMaxConcurrentRequests(value.get());
	} else if (zuulProperties.getThreadPool().isUseSeparateThreadPools()) {
		final String threadPoolKey = zuulProperties.getThreadPool().getThreadPoolKeyPrefix() + commandKey;
		commandSetter.andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey(threadPoolKey));
	}
	
	return commandSetter.andCommandPropertiesDefaults(setter);
	// @formatter:on
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
@Test
public void shouldAddBackGlobalPrefixIfPresent() {
	RequestContext context = RequestContext.getCurrentContext();
	ZuulProperties zuulProperties = new ZuulProperties();
	zuulProperties.setPrefix("global");
	zuulProperties.setStripPrefix(true);
	LocationRewriteFilter filter = setFilterUpWith(context, zuulProperties,
			new Route("service1", "/something/redirectingUri", "service1", "prefix",
					false, Collections.EMPTY_SET, true),
			"/global/prefix/redirectingUri",
			"/something/redirectedUri;someparam?param1=abc");
	filter.run();
	assertThat(getLocationHeader(context).second()).isEqualTo(String.format(
			"%s/global/prefix/something/redirectedUri;someparam?param1=abc",
			ZUUL_BASE_URL));
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
@Test
public void shouldNotAddBackGlobalPrefixIfNotStripped() {
	RequestContext context = RequestContext.getCurrentContext();
	ZuulProperties zuulProperties = new ZuulProperties();
	zuulProperties.setPrefix("global");
	zuulProperties.setStripPrefix(false);
	LocationRewriteFilter filter = setFilterUpWith(context, zuulProperties,
			new Route("service1", "/something/redirectingUri", "service1", "prefix",
					false, Collections.EMPTY_SET, true),
			"/global/prefix/redirectingUri",
			"/global/something/redirectedUri;someparam?param1=abc");
	filter.run();
	assertThat(getLocationHeader(context).second()).isEqualTo(String.format(
			"%s/global/prefix/something/redirectedUri;someparam?param1=abc",
			ZUUL_BASE_URL));
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
private LocationRewriteFilter setFilterUpWith(RequestContext context,
		ZuulProperties zuulProperties, Route route, String toZuulRequestUri,
		String redirectedUri) {
	MockHttpServletRequest httpServletRequest = new MockHttpServletRequest();
	httpServletRequest.setRequestURI(toZuulRequestUri);
	httpServletRequest.setServerName(ZUUL_HOST);
	httpServletRequest.setScheme(ZUUL_SCHEME);
	httpServletRequest.setServerPort(ZUUL_PORT);
	context.setRequest(httpServletRequest);

	MockHttpServletResponse httpServletResponse = new MockHttpServletResponse();
	context.getZuulResponseHeaders().add(new Pair<>("Location",
			String.format("%s%s", SERVER_BASE_URL, redirectedUri)));
	context.setResponse(httpServletResponse);

	RouteLocator routeLocator = mock(RouteLocator.class);
	when(routeLocator.getMatchingRoute(toZuulRequestUri)).thenReturn(route);
	LocationRewriteFilter filter = new LocationRewriteFilter(zuulProperties,
			routeLocator);

	return filter;
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
private SendResponseFilter createFilter(ZuulProperties properties, String content, String characterEncoding, MockHttpServletResponse response, boolean streamContent) throws Exception {
	HttpServletRequest request = new MockHttpServletRequest();
	RequestContext context = new RequestContext();
	context.setRequest(request);
	context.setResponse(response);

	if (characterEncoding != null) {
		response.setCharacterEncoding(characterEncoding);
	}

	if (streamContent) {
		context.setResponseDataStream(new ByteArrayInputStream(content.getBytes(characterEncoding)));
	} else {
		context.setResponseBody(content);
	}

	context.addZuulResponseHeader(HttpHeaders.CONTENT_LENGTH, String.valueOf(content.length()));

	context.set("error.status_code", HttpStatus.NOT_FOUND.value());
	RequestContext.testSetCurrentContext(context);
	SendResponseFilter filter = new SendResponseFilter(properties);
	return filter;
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
@Test
public void testHystrixTimeoutValueRibbonTimeouts() throws Exception {
	SpringClientFactory springClientFactory = mock(SpringClientFactory.class);
	ZuulProperties zuulProperties = new ZuulProperties();
	OkHttpLoadBalancingClient loadBalancingHttpClient = mock(OkHttpLoadBalancingClient.class);
	IClientConfig clientConfig = new DefaultClientConfigImpl();
	clientConfig.set(IClientConfigKey.Keys.ConnectTimeout, 100);
	clientConfig.set(IClientConfigKey.Keys.ReadTimeout, 500);
	doReturn(loadBalancingHttpClient).when(springClientFactory).getClient(anyString(),
			eq(OkHttpLoadBalancingClient.class));
	doReturn(clientConfig).when(springClientFactory).getClientConfig(anyString());
	OkHttpRibbonCommandFactory commandFactory = new OkHttpRibbonCommandFactory(springClientFactory, zuulProperties, new HashSet<FallbackProvider>());
	RibbonCommandContext context = mock(RibbonCommandContext.class);
	doReturn("service").when(context).getServiceId();
	OkHttpRibbonCommand ribbonCommand = commandFactory.create(context);
	assertEquals(600, ribbonCommand.getProperties().executionTimeoutInMilliseconds().get().intValue());
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
@Test
public void testHystrixTimeoutValueRibbonTimeouts() throws Exception {
	SpringClientFactory springClientFactory = mock(SpringClientFactory.class);
	ZuulProperties zuulProperties = new ZuulProperties();
	RibbonLoadBalancingHttpClient loadBalancingHttpClient = mock(RibbonLoadBalancingHttpClient.class);
	IClientConfig clientConfig = new DefaultClientConfigImpl();
	clientConfig.set(IClientConfigKey.Keys.ConnectTimeout, 100);
	clientConfig.set(IClientConfigKey.Keys.ReadTimeout, 500);
	doReturn(loadBalancingHttpClient).when(springClientFactory).getClient(anyString(),
			eq(RibbonLoadBalancingHttpClient.class));
	doReturn(clientConfig).when(springClientFactory).getClientConfig(anyString());
	HttpClientRibbonCommandFactory ribbonCommandFactory = new HttpClientRibbonCommandFactory(springClientFactory, zuulProperties, new HashSet<FallbackProvider>());
	RibbonCommandContext context = mock(RibbonCommandContext.class);
	doReturn("service").when(context).getServiceId();
	HttpClientRibbonCommand ribbonCommand = ribbonCommandFactory.create(context);
	assertEquals(600, ribbonCommand.getProperties().executionTimeoutInMilliseconds().get().intValue());
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
@Override
protected LinkedHashMap<String, ZuulProperties.ZuulRoute> locateRoutes() {
    LinkedHashMap<String, ZuulProperties.ZuulRoute> routeMap = super.locateRoutes();

    routeStore.getAllRoutes().forEach(route -> routeMap.put(route.getPath(), route));

    return routeMap;
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
@Override
protected LinkedHashMap<String, ZuulRoute> locateRoutes() {
  LinkedHashMap<String, ZuulRoute> routesMap = new LinkedHashMap<String, ZuulRoute>();
  routesMap.putAll(super.locateRoutes());
  for (ZuulProperties.ZuulRoute route : findAll()) {
    routesMap.put(route.getPath(), route);
  }
  return routesMap;
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
private List<ZuulProperties.ZuulRoute> findAll() {
  Set<ZuulRouteDto> routers = Sets.newHashSet();
  if (!hasLoaded) {
    routers.addAll(store.loadAllRoute());
    hasLoaded = true;
  } else {
    routers.addAll(store.loadTop10Route());
  }
  routesCache.addAll(routers);
  return Lists.transform(Lists.newArrayList(routesCache),
      new Function<ZuulRouteDto, ZuulProperties.ZuulRoute>() {

        @Override
        public ZuulRoute apply(ZuulRouteDto input) {
          String id = input.getRouteId();
          String path = input.getRoutePath();
          String service_id = input.getServiceId();
          String url = input.getRouteUrl();
          boolean strip_prefix = input.getStripPrefix() != null ? input.getStripPrefix() : true;
          Boolean retryable = input.getRetryAble();
          String sensitiveHeader = input.getSensitiveHeaders();
          String[] sensitiveHeaders = null;
          if (sensitiveHeader != null) {
            sensitiveHeaders = StringUtils.split(sensitiveHeader, ",");
          } else {
            sensitiveHeaders = new String[] {};
          }
          return new ZuulRoute(id, path, service_id, url, strip_prefix, retryable,
              new HashSet<String>(Arrays.asList(sensitiveHeaders)));

        }

      });
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
/**
 *
 */
@Bean
@RefreshScope
@ConfigurationProperties("zuul")
public ZuulProperties zuulProperties() {
    return new ZuulProperties();
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
@Override
public String getRouteHost(ZuulWebSocketProperties.WsBrokerage wsBrokerage) {
    ZuulProperties.ZuulRoute zuulRoute = zuulProperties.getRoutes().get(wsBrokerage.getId());
    if (zuulRoute == null || StringUtils.isEmpty(zuulRoute.getServiceId())) return null;

    List<ServiceInstance> instances = discoveryClient.getInstances(zuulRoute.getServiceId());
    ServiceInstance serviceInstance = instances.get(0);
    return serviceInstance.getUri().toString();
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
public ZuulPropertiesResolver zuulPropertiesResolver(
        final ZuulProperties zuulProperties, final DiscoveryClient discoveryClient) {
    Set<ZuulPropertiesResolver> resolvers = new HashSet<>();
    resolvers.add(new UrlPropertiesResolver(zuulProperties));
    resolvers.add(new EurekaPropertiesResolver(discoveryClient, zuulProperties));

    return new CompositeZuulPropertiesResolver(resolvers);
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
/**
 * Creates new instance of {@link StoreProxyRouteLocator}
 * @param servletPath the application servlet path
 * @param discovery the discovery service
 * @param properties the zuul properties
 * @param store the route store
 */
public StoreProxyRouteLocator(String servletPath,
                              DiscoveryClient discovery,
                              ZuulProperties properties,
                              ZuulRouteStore store) {
    super(servletPath, discovery, properties);
    this.store = store;
}
 

import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
protected void addConfiguredRoutes(Map<String, ZuulProperties.ZuulRoute> routes) {
    for (ZuulProperties.ZuulRoute route : store.findAll()) {
        routes.put(route.getPath(), route);
    }
}