Spring Cloud微服务网关Zuul过滤链实现的源码解读

最新推荐文章于 2024-06-06 22:32:20 发布
最新推荐文章于 2024-06-06 22:32:20 发布
阅读量1k 收藏 22
点赞数 28
分类专栏： 微服务 Spring Cloud系列文章 文章标签： spring cloud 微服务 spring 后端 java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42008170/article/details/136299123
版权

一、Zuul过滤器的加载过程

Zuul网关的Filter需要经过初始化加载到Spring容器后，才能在请求中发挥作用：

zuul-filter-config.jpg

在上篇文章：《Spring Cloud微服务网关Zuul的注解@EnableZuulProxy或@EnableZuulServer做了什么事情》 中说到的ZuulServerAutoConfiguration中有一个内部配置类ZuulFilterConfiguration就是Zuul中Filter初始化的入口：

@Configuration
protected static class ZuulFilterConfiguration {
   @Autowired
   private Map<String, ZuulFilter> filters;
   @Bean
   public ZuulFilterInitializer zuulFilterInitializer(
         CounterFactory counterFactory, TracerFactory tracerFactory) {
      FilterLoader filterLoader = FilterLoader.getInstance();
      FilterRegistry filterRegistry = FilterRegistry.instance();
      return new ZuulFilterInitializer(this.filters, counterFactory, tracerFactory, filterLoader, filterRegistry);
   }
}

ZuulFilterInitializer：

public class ZuulFilterInitializer {

   private static final Log log = LogFactory.getLog(ZuulFilterInitializer.class);

   private final Map<String, ZuulFilter> filters;
   private final CounterFactory counterFactory;
   private final TracerFactory tracerFactory;
   private final FilterLoader filterLoader;
   private final FilterRegistry filterRegistry;

   public ZuulFilterInitializer(Map<String, ZuulFilter> filters,
                         CounterFactory counterFactory,
                         TracerFactory tracerFactory,
                         FilterLoader filterLoader,
                         FilterRegistry filterRegistry) {
      this.filters = filters;
      this.counterFactory = counterFactory;
      this.tracerFactory = tracerFactory;
      this.filterLoader = filterLoader;
      this.filterRegistry = filterRegistry;
   }

   @PostConstruct
   public void contextInitialized() {
      log.info("Starting filter initializer");

      TracerFactory.initialize(tracerFactory);
      CounterFactory.initialize(counterFactory);
      // 将ZuulFilter放到FilterRegistry中
      for (Map.Entry<String, ZuulFilter> entry : this.filters.entrySet()) {
         filterRegistry.put(entry.getKey(), entry.getValue());
      }
   }

   @PreDestroy
   public void contextDestroyed() {
      log.info("Stopping filter initializer");
      for (Map.Entry<String, ZuulFilter> entry : this.filters.entrySet()) {
         filterRegistry.remove(entry.getKey());
      }
      clearLoaderCache();

      TracerFactory.initialize(null);
      CounterFactory.initialize(null);
   }

   private void clearLoaderCache() {
      Field field = ReflectionUtils.findField(FilterLoader.class, "hashFiltersByType");
      ReflectionUtils.makeAccessible(field);
      @SuppressWarnings("rawtypes")
      Map cache = (Map) ReflectionUtils.getField(field, filterLoader);
      cache.clear();
   }

}

源码上可以看出，FilterLoader和FilterRegistry都是单例对象，然后把Spring容器中的所有ZuulFilter都交给FilterRegistry来管理，像Spring的单例池那样。FilterRegistry内部使用ConcurrentHashMap保存这些单例ZuulFilter。

在请求走到ZuulServlet的时候，会检查ZuulRunner是否初始化。如果没初始化，就去执行init方法初始化ZuulRunner；如果已经初始化，就进入service方法执行过滤链的逻辑。

ZuulRunner主要是对RequestContext的初始化，将请求上下文放入声明周期，以及获取FilterProcessor的单例对象，可以说是Zuul过滤链的执行器。最后在FilterProcessor中通过FilterLoader获取相应的Filter并初始化。

二、过滤链实现

Zuul Filter主要分为前置过滤器(pre)、路由过滤器(route)和后置过滤器(post)。

zuul-filter-time-line.jpg

同类型的过滤器组成一个过滤连，可以通过指定过滤器的执行顺序。它们的执行顺序在FilterLoader和FilterProcessor中被定义和执行。FilterProcessor会通过FilterLoader获取同一个类型的过滤器集合，然后遍历这些过滤器按照排序执行。

public class ZuulServlet extends HttpServlet {

    private static final long serialVersionUID = -3374242278843351500L;
    private ZuulRunner zuulRunner;


    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);

        String bufferReqsStr = config.getInitParameter("buffer-requests");
        boolean bufferReqs = bufferReqsStr != null && bufferReqsStr.equals("true") ? true : false;

        zuulRunner = new ZuulRunner(bufferReqs);
    }

    @Override
    public void service(javax.servlet.ServletRequest servletRequest, javax.servlet.ServletResponse servletResponse) throws ServletException, IOException {
        try {
            // 初始化ZuulRUnner
            init((HttpServletRequest) servletRequest, (HttpServletResponse) servletResponse);

            // Marks this request as having passed through the "Zuul engine", as opposed to servlets
            // explicitly bound in web.xml, for which requests will not have the same data attached
            RequestContext context = RequestContext.getCurrentContext();
            context.setZuulEngineRan();

            try {
                // 前置过滤器链
                preRoute();
            } catch (ZuulException e) {
                error(e);
                postRoute();
                return;
            }
            try {
                // 路由
                route();
            } catch (ZuulException e) {
                error(e);
                postRoute();
                return;
            }
            try {
                // 后置过滤器链
                postRoute();
            } catch (ZuulException e) {
                error(e);
                return;
            }

        } catch (Throwable e) {
            error(new ZuulException(e, 500, "UNHANDLED_EXCEPTION_" + e.getClass().getName()));
        } finally {
            RequestContext.getCurrentContext().unset();
        }
    }

    /**
     * executes "post" ZuulFilters
     *
     * @throws ZuulException
     */
    void postRoute() throws ZuulException {
        zuulRunner.postRoute();
    }

    /**
     * executes "route" filters
     *
     * @throws ZuulException
     */
    void route() throws ZuulException {
        zuulRunner.route();
    }

    /**
     * executes "pre" filters
     *
     * @throws ZuulException
     */
    void preRoute() throws ZuulException {
        zuulRunner.preRoute();
    }

    /**
     * initializes request
     *
     * @param servletRequest
     * @param servletResponse
     */
    void init(HttpServletRequest servletRequest, HttpServletResponse servletResponse) {
        zuulRunner.init(servletRequest, servletResponse);
    }

    /**
     * sets error context info and executes "error" filters
     *
     * @param e
     */
    void error(ZuulException e) {
        RequestContext.getCurrentContext().setThrowable(e);
        zuulRunner.error();
    }
    ...
}

三、核心路由实现源码解析

在之前动态路由配置的文章中有介绍到：Spring Cloud微服务网关Zuul动态路由配置、Spring Cloud微服务网关Zuul动态路由配置优化和手动触发路由刷新。那么在本章节将深入源码解析这个类的作用和功能，以及如何去扩展。

其组成的类图如下：

3.1 两个接口RouteLocator和RefreshableRouteLocator

核心的顶层接口RouteLocator：

public interface RouteLocator {
    // 获取忽略的路径
    Collection<String> getIgnoredPaths();
    // 获取所有的路由信息
    List<Route> getRoutes();
    // 根据请求路径获取路由信息
    Route getMatchingRoute(String path);
}

**RefreshableRouteLocator：**这个也是个接口，它是继承了接口RouteLocator。如果要实现路由刷新功能必须要实现该接口。

public interface RefreshableRouteLocator extends RouteLocator {
   // 刷新内存中路由信息
   void refresh();
}

3.2 SimpleRouteLocator源码解析

这个类是真正持有并管理路由信息的类，但是这个类只能加载配置文件中的路由信息，最终这些路由信息被封装到一个Map中：routes。同时它也实现了Ordered接口，可以对定位器优先级进行设置。Spring大量使用了策略模式，通过Ordered接口来实现优先级。

源码如下：

public class SimpleRouteLocator implements RouteLocator, Ordered {

	private static final Log log = LogFactory.getLog(SimpleRouteLocator.class);
	private static final int DEFAULT_ORDER = 0;
    // 读取配置文件中zuul的配置
	private ZuulProperties properties;
	private PathMatcher pathMatcher = new AntPathMatcher();
	private String dispatcherServletPath = "/";
	private String zuulServletPath;
    // 所有的路由配置最终都会保存到这里
	private AtomicReference<Map<String, ZuulRoute>> routes = new AtomicReference<>();
	private int order = DEFAULT_ORDER;

	public SimpleRouteLocator(String servletPath, ZuulProperties properties) {
        this.properties = properties;
		if (StringUtils.hasText(servletPath)) {
			this.dispatcherServletPath = servletPath;
		}
        // 每一个servlet path 对应一个路由
		this.zuulServletPath = properties.getServletPath();
	}

	@Override
	public List<Route> getRoutes() {
        // 获取所有的路由配置
		List<Route> values = new ArrayList<>();
        // 遍历路由
		for (Entry<String, ZuulRoute> entry : getRoutesMap().entrySet()) {
			ZuulRoute route = entry.getValue();
			String path = route.getPath();
			values.add(getRoute(route, path));
		}
		return values;
	}

	@Override
	public Collection<String> getIgnoredPaths() {
        // 获取配置文件中的忽略路径
		return this.properties.getIgnoredPatterns();
	}

	@Override
	public Route getMatchingRoute(final String path) {
        // 根据请求路径获取对应的路由配置
		return getSimpleMatchingRoute(path);
	}

	protected Map<String, ZuulRoute> getRoutesMap() {
        // 如果路由信息为空，会把路由配置信息加载到内存
		if (this.routes.get() == null) {
            // 这里的locateRoutes方法这个类的方法，读取的是配置文件中的路由配置
			this.routes.set(locateRoutes());
		}
		return this.routes.get();
	}

	protected Route getSimpleMatchingRoute(final String path) {
        // 根据请求路径来获取路由配置信息
		if (log.isDebugEnabled()) {
			log.debug("Finding route for path: " + path);
		}
		// 调用以下，确保保存路由的map路由配置加载完成
		getRoutesMap();
		if (log.isDebugEnabled()) {
			log.debug("servletPath=" + this.dispatcherServletPath);
			log.debug("zuulServletPath=" + this.zuulServletPath);
			log.debug("RequestUtils.isDispatcherServletRequest()="
					+ RequestUtils.isDispatcherServletRequest());
			log.debug("RequestUtils.isZuulServletRequest()="
					+ RequestUtils.isZuulServletRequest());
		}
        // 调整请求路径
		String adjustedPath = adjustPath(path);
        // 根据路径获取路由表
		ZuulRoute route = getZuulRoute(adjustedPath);
        // 把ZuulRoute封装成Route
		return getRoute(route, adjustedPath);
	}

	protected ZuulRoute getZuulRoute(String adjustedPath) {
		if (!matchesIgnoredPatterns(adjustedPath)) {
			for (Entry<String, ZuulRoute> entry : getRoutesMap().entrySet()) {
				String pattern = entry.getKey();
				log.debug("Matching pattern:" + pattern);
				if (this.pathMatcher.match(pattern, adjustedPath)) {
					return entry.getValue();
				}
			}
		}
		return null;
	}

	protected Route getRoute(ZuulRoute route, String path) {
		if (route == null) {
			return null;
		}
		if (log.isDebugEnabled()) {
			log.debug("route matched=" + route);
		}
		String targetPath = path;
		String prefix = this.properties.getPrefix();
		if(prefix.endsWith("/")) {
			prefix = prefix.substring(0, prefix.length() - 1);
		}
		if (path.startsWith(prefix + "/") && this.properties.isStripPrefix()) {
			targetPath = path.substring(prefix.length());
		}
		if (route.isStripPrefix()) {
			int index = route.getPath().indexOf("*") - 1;
			if (index > 0) {
				String routePrefix = route.getPath().substring(0, index);
				targetPath = targetPath.replaceFirst(routePrefix, "");
				prefix = prefix + routePrefix;
			}
		}
		Boolean retryable = this.properties.getRetryable();
		if (route.getRetryable() != null) {
			retryable = route.getRetryable();
		}
		return new Route(route.getId(), targetPath, route.getLocation(), prefix,
				retryable,
				route.isCustomSensitiveHeaders() ? route.getSensitiveHeaders() : null, 
				route.isStripPrefix());
	}

	protected void doRefresh() {
        // 刷新路由信息，这里刷新操作实质是重新加载配置文件中的路由配置
		this.routes.set(locateRoutes());
	}

	protected Map<String, ZuulRoute> locateRoutes() {
		LinkedHashMap<String, ZuulRoute> routesMap = new LinkedHashMap<>();
		for (ZuulRoute route : this.properties.getRoutes().values()) {
			routesMap.put(route.getPath(), route);
		}
		return routesMap;
	}

	protected boolean matchesIgnoredPatterns(String path) {
		for (String pattern : this.properties.getIgnoredPatterns()) {
			log.debug("Matching ignored pattern:" + pattern);
			if (this.pathMatcher.match(pattern, path)) {
				log.debug("Path " + path + " matches ignored pattern " + pattern);
				return true;
			}
		}
		return false;
	}

	private String adjustPath(final String path) {
		String adjustedPath = path;

		if (RequestUtils.isDispatcherServletRequest()
				&& StringUtils.hasText(this.dispatcherServletPath)) {
			if (!this.dispatcherServletPath.equals("/")) {
				adjustedPath = path.substring(this.dispatcherServletPath.length());
				log.debug("Stripped dispatcherServletPath");
			}
		}
		else if (RequestUtils.isZuulServletRequest()) {
			if (StringUtils.hasText(this.zuulServletPath)
					&& !this.zuulServletPath.equals("/")) {
				adjustedPath = path.substring(this.zuulServletPath.length());
				log.debug("Stripped zuulServletPath");
			}
		}
		else {
			// do nothing
		}

		log.debug("adjustedPath=" + adjustedPath);
		return adjustedPath;
	}

	@Override
	public int getOrder() {
		return order;
	}
	
	public void setOrder(int order) {
		this.order = order;
	}
}

3.3 DiscoveryClientRouteLocator

这个类是继承了SimpleRouteLocator，并实现了RefreshableRouteLocator。重写了的locateRoutes()是核心，这个路由定位器的功能就是可以读取注册中心中的服务然后加载其路由配置信息，从源码里面可以看到依赖了DiscoveryClient。

public class DiscoveryClientRouteLocator extends SimpleRouteLocator
		implements RefreshableRouteLocator {

	private static final Log log = LogFactory.getLog(DiscoveryClientRouteLocator.class);
	public static final String DEFAULT_ROUTE = "/**";
	private DiscoveryClient discovery;
	private ZuulProperties properties;
	private ServiceRouteMapper serviceRouteMapper;

	...

	public void addRoute(String path, String location) {
		this.properties.getRoutes().put(path, new ZuulRoute(path, location));
		refresh();
	}

	public void addRoute(ZuulRoute route) {
		this.properties.getRoutes().put(route.getPath(), route);
		refresh();
	}

	@Override
	protected LinkedHashMap<String, ZuulRoute> locateRoutes() {
		LinkedHashMap<String, ZuulRoute> routesMap = new LinkedHashMap<>();
		routesMap.putAll(super.locateRoutes());
		if (this.discovery != null) {
			Map<String, ZuulRoute> staticServices = new LinkedHashMap<>();
			for (ZuulRoute route : routesMap.values()) {
				String serviceId = route.getServiceId();
				if (serviceId == null) {
					serviceId = route.getId();
				}
				if (serviceId != null) {
					staticServices.put(serviceId, route);
				}
			}
			// Add routes for discovery services by default
			List<String> services = this.discovery.getServices();
			String[] ignored = this.properties.getIgnoredServices()
					.toArray(new String[0]);
			for (String serviceId : services) {
				// Ignore specifically ignored services and those that were manually
				// configured
				String key = "/" + mapRouteToService(serviceId) + "/**";
				if (staticServices.containsKey(serviceId)
						&& staticServices.get(serviceId).getUrl() == null) {
					// Explicitly configured with no URL, cannot be ignored
					// all static routes are already in routesMap
					// Update location using serviceId if location is null
					ZuulRoute staticRoute = staticServices.get(serviceId);
					if (!StringUtils.hasText(staticRoute.getLocation())) {
						staticRoute.setLocation(serviceId);
					}
				}
				if (!PatternMatchUtils.simpleMatch(ignored, serviceId)
						&& !routesMap.containsKey(key)) {
					// Not ignored
					routesMap.put(key, new ZuulRoute(key, serviceId));
				}
			}
		}
		if (routesMap.get(DEFAULT_ROUTE) != null) {
			ZuulRoute defaultRoute = routesMap.get(DEFAULT_ROUTE);
			// Move the defaultServiceId to the end
			routesMap.remove(DEFAULT_ROUTE);
			routesMap.put(DEFAULT_ROUTE, defaultRoute);
		}
		LinkedHashMap<String, ZuulRoute> values = new LinkedHashMap<>();
		for (Entry<String, ZuulRoute> entry : routesMap.entrySet()) {
			String path = entry.getKey();
			// Prepend with slash if not already present.
			if (!path.startsWith("/")) {
				path = "/" + path;
			}
			if (StringUtils.hasText(this.properties.getPrefix())) {
				path = this.properties.getPrefix() + path;
				if (!path.startsWith("/")) {
					path = "/" + path;
				}
			}
			values.put(path, entry.getValue());
		}
		return values;
	}

	@Override
	public void refresh() {
		doRefresh();
	}

	protected String mapRouteToService(String serviceId) {
		return this.serviceRouteMapper.apply(serviceId);
	}

	protected void addConfiguredRoutes(Map<String, ZuulRoute> routes) {
		Map<String, ZuulRoute> routeEntries = this.properties.getRoutes();
		for (ZuulRoute entry : routeEntries.values()) {
			String route = entry.getPath();
			if (routes.containsKey(route)) {
				log.warn("Overwriting route " + route + ": already defined by "
						+ routes.get(route));
			}
			routes.put(route, entry);
		}
	}
}

3.4 CompositeRouteLocator

这是组合所有的RouteLocator的类，并且CompositeRouteLocator注入到Spring容器时，是使用了@Primary注解，也就是说。当你想要在Spring容器中获取RouteLocator时，默认是CompositeRouteLocator。该类并没有什么实质性的修改，它是会引入Spring容器中所有的RouteLocator。然后逐个执行RouteLocator。

public class CompositeRouteLocator implements RefreshableRouteLocator {
	private final Collection<? extends RouteLocator> routeLocators;
	private ArrayList<RouteLocator> rl;

	public CompositeRouteLocator(Collection<? extends RouteLocator> routeLocators) {
		Assert.notNull(routeLocators, "'routeLocators' must not be null");
		rl = new ArrayList<>(routeLocators);
		AnnotationAwareOrderComparator.sort(rl);
		this.routeLocators = rl;
	}

	@Override
	public Collection<String> getIgnoredPaths() {
		List<String> ignoredPaths = new ArrayList<>();
		for (RouteLocator locator : routeLocators) {
			ignoredPaths.addAll(locator.getIgnoredPaths());
		}
		return ignoredPaths;
	}

	@Override
	public List<Route> getRoutes() {
		List<Route> route = new ArrayList<>();
		for (RouteLocator locator : routeLocators) {
			route.addAll(locator.getRoutes());
		}
		return route;
	}

	@Override
	public Route getMatchingRoute(String path) {
		for (RouteLocator locator : routeLocators) {
			Route route = locator.getMatchingRoute(path);
			if (route != null) {
				return route;
			}
		}
		return null;
	}

	@Override
	public void refresh() {
		for (RouteLocator locator : routeLocators) {
			if (locator instanceof RefreshableRouteLocator) {
				((RefreshableRouteLocator) locator).refresh();
			}
		}
	}
}

3.5 自定义路由定位器

最后

可以关注我的微信公众号，有更多的技术干货文章
在这里插入图片描述

Spring Cloud微服务网关Zuul过滤链和整合OAuth2+JWT入门实战
20年码农
04-11 755
OAuth2是OAuth协议的第二个版本，是对授权认证比较成熟地面向资源的授权协议，在业界中广泛应用。出了定义了常用的用户名密码登录之后，还可以使用第三方一个用登录。例如在某些网站上可以使用QQ、微信、Github等进行登录。其主要流程如下：至于JWT则是一种使用JSON格式来规约Token和Session的协议。因为传统的认证方式中会产生一个凭证，比如Session会话是保存在服务端，然后依赖于Cookie返回给客户端，Session是有状态的。
Spring Cloud Zuul源码详解
怀揣梦想，努力前行
02-05 806
目录 代码示例 实现原理 DispatcherServlet ZuulHandlerMapping RouteLocator ZuulController ZuulServlet ZuulFilterConfiguration 查看路由规则 路由规则配置 忽略路由规则 自定义路由规则 查看Filter 自定义Filter Java版本：1.8 Spring版本：5....
zuul过滤器
Leon_Jinhai_Sun的博客
02-01 292
过滤器 Zuul作为网关的其中一个重要功能，就是实现请求的鉴权。而这个动作我们往往是通过Zuul提供的过滤器来实现的。 ZuulFilter ZuulFilter是过滤器的顶级父类。在这里我们看一下其中定义的4个最重要的方法： public abstract ZuulFilter implements IZuulFilter{ abstract public String fi...
zuul源码分析之Filter管理
haha7289的博客
01-11 4472
zuul支持动加载Filter类文件。实现原理是监控存放Filter文件的目录，定期扫描这些目录，如果发现有新Filter源码文件或者Filter源码文件有改动，则对文件进行编译加载。目前zuul支持使用Groovy编写的Filter。FilterFileManagerFilterFileManager用于管理Filter存放目录，并定期扫描目录的变化。 他的功能如下： - 开启一个线程，
Spring-Cloud-Gateway--源码分析及应用
lbmydream的博客
06-06 1852
Spring Cloud Gateway 是Spring Cloud 生态全新项目，基于Spring 5、Spring Boot 2.X、Project Reactor实现的API网关，旨在为微服务提供简单高效的API路由管理方法。Spring Cloud Gateway 作为Spring Cloud 生态中的网关，目标是代替Zuul 1.X。Spring Cloud 2.X版本目前仍未对Zuul 2.X高性能版本进行集成，仍使用的是非Reactor的老版本Zuul网关。
Spring Cloud微服务网关Zuul过滤链的解析
2301_76607156的博客
04-17 202
Zuul网关的Filter需要经过初始化加载到Spring容器后，才能在请求中发挥作用：中说到的中有一个内部配置类源码上可以看出，和都是单例对象，然后把Spring容器中的所有ZuulFilter都交给来管理，像Spring的单例池那样。内部使用保存这些单例ZuulFilter。在请求走到的时候，会检查ZuulRunner是否初始化。如果没初始化，就去执行init方法初始化ZuulRunner；如果已经初始化，就进入service方法执行过滤链的逻辑。ZuulRunner主要是对。
SpringCloud微服务网关zuul开发实例（整理三）
吾行远方
09-21 501
1、微服务网关作用和使用场景 1.1、什么是网关？ API Gateway，是系统的唯一对外的入口，介于客户端和服务器端之间的中间层，处理非业务功能 提供路由请求、鉴权、监控、缓存、限流等功能 统一接入 智能路由 AB测试、灰度测试 负载均衡、容灾处理 日志埋点（类似Nignx日志） 流量监控 限流处理 服务降级 安全防护 鉴权处理 ...
springcloud zuul 网关实现源码
11-01
springcloud zuul 网关开发实践，模拟了在Spring Cloud微服务系统中，客户端的请求首先经过负载均衡（zuul、Ngnix），再到达服务网关（zuul集群），然后再到具体的服的实现过程。
基于Spring Cloud微服务架构的openapi设计与实现源码
最新发布
10-08
该项目为基于Spring Cloud微服务架构的openapi设计与实现源码，共计503个文件。其中，包含95个JavaScript文件、89个Java源文件、85个PNG图像文件、84个GIF图像文件、73个CSS文件、17个XML配置文件、14个HTML文件、8...
Spring Cloud微服务网关Zuul的注解@EnableZuulProxy或@EnableZuulServer做了什么事情
m0_71777195的博客
04-15 259
本文配了较多的源码，主要是和这两个SpringBoot自动配置类，涵盖了很多Zuul的组件，花点时间去阅读、debug会让你很快去了解去很多的工作流程和原理。虽然Zuul在国内越来越少人用了，但是源码还是值得学习的。
基于Spring Cloud技术栈的自定义ZuulFilter的使用
一杯Java不加糖
01-11 8104
ZuulFilter基础 Zuul作为整个微服务架构的网关实现，是整个后台系统的入口，因此，经常会有对所有经过网关的请求进行操作的场景。这里，我们可以继承ZuulFilter类来实现自定义的过滤器。 Zuul定义的四种Filter的类型： PRE：在请求被路由之前调用，可以使用这种过滤器实现身份验证、在集群中选择请求的微服务、记录调试Log等。 ROUTE：将请求路由到对应的
Springcloud+ZuulFilter微服务中过滤器的实现
花开富贵的博客
12-08 2686
1.简介: Zuul作为网关的中一个重要功能，就是实现请求的鉴定权限。我们是通过Zuul提供的过滤器来实现的。 2.ZuulFilter: ZuulFilter是过滤器的顶级父类。 他定义了四个方法: public abstract class ZuulFilter implements IZuulFilter{ boolean shouldFilter(); Object run...
zuul源码分析之Request生命周期管理
haha7289的博客
01-10 1万+
zuul核心框架zuul是可以认为是一种API-Gateway。zuul的核心是一系列的filters, 其作用可以类比Servlet框架的Filter，或者AOP。其原理就是在zuul把Request route到源web-service的时候，处理一些逻辑，比如Authentication，Load Shedding等。 下图是zuul的核心框架。对于框架中的核心类将一一分析。ZuulFilte
SpringCloud - Zuul 源码
Andy_Health的博客
06-15 182
对 zuul 工程的请求是有一个 controller 来接收的 所有请求都会走到这个方法 对应的 HandlerMapping 所有的请求会有这个 zuulServlet 来处理 在 zuulServlet 中就涉及到 pre、route、post、error 过滤器的调用 其中分析一个 route 过滤器，这个过滤器是 zuul 做路由的调用的 这里走的依然是 hystrix 那一套 ...
Springcloud之zuul的ZuulFilter
choubayan4320的博客
07-02 290
Springcloud的版本是Greenwich.SR2，Springboot版本是2.1.6.release. 最近使用到Springcloud的zuul，分析了下源码，记录下。 如下List-1，我们自己定义的ZuulFilter继承zuul的zuulFilte...
zuul入门（1）zuul 的概念和原理
weixin_34357267的博客
06-26 2861
一、zuul是什么 zuul 是netflix开源的一个API Gateway 服务器, 本质上是一个web servlet应用。 Zuul 在云平台上提供动态路由，监控，弹性，安全等边缘服务的框架。Zuul 相当于是设备和 Netflix 流应用的 Web 网站后端所有请求的前门。 zuul的例子可以参考 netflix 在github上的 simple webapp，可以按照netflix 在...
说一下zuul网关的过滤器
Andre_dong的博客
10-28 820
zuul网关的过滤器工作示意图： 这是个完整的过滤器图，我们可以看到，一开始先由HTTP也就是客户那边发送请求过来，然后第一次是要经过预先的过滤器也就是：“pre”过滤器，过滤掉一些没有意义的信息和进行客户验证，然后再经由路由过滤器进行分发任务，在原始服务器中找到对应的服务来提供信息，然后再发送到响应过滤器，这时，响应过滤器就会接收这些信息，然后发送响应数据给客户端，让客户能够接收到，但是如果在出错的情况下，路由过滤器会直接发送错误信息到错误过滤器，错误过滤器知道这是个错误了，就会通知响应过滤器做出反应给
微服务 ZuulFilter 过滤器
qq_24814723的博客
03-20 1万+
spring 官网
深入理解Zuul之源码解析
热门推荐
方志朋的专栏
07-27 8万+
本文从源码的深入讲解了Spring Cloud Zuul。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值
>