十九.SpringCloud源码剖析-Zuul的执行流程

最新推荐文章于 2023-05-11 20:48:50 发布
最新推荐文章于 2023-05-11 20:48:50 发布
阅读量724 收藏 1
点赞数 1
分类专栏： 《升职加薪之SpringCloudNetflix源码剖析》 文章标签： zuul springcloud 源码分析 zuul源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014494148/article/details/113246142
版权

前言

在之前的章节我们详细分析了Zuul的Filter，这一章节我们来详细跟一下Zuul的执行流程

Zuul的执行流程是这样的

  • 首先请求进来会先到达ZuulController ，ZuulController把请求交给ZuulServlet去处理
  • 在ZuulServelt会调用 ZuulRunner 依次执行： init初始化，pre前置filter，route路由filter,post后置filter, error 异常filter
  • ZuulRunner通过 FilterProcessor 去执行各种Filter,FilterProcessor通过 FilterLoader 加载 各种filters
  • 执行完成之后，把结果响应给客户端

在上一章节我们分析了Zuul中的各种filter，那这一章我们来跟踪一下zuul的执行流程。那么入口肯定是我们的 ZuulServlet ，他类似于 DispatcherServlet 在请求的最前面做分发。我们来看一下他的源码

Zuul执行流程

1.ZuulController 请求入口

ZuulController 是请求的入口，把请求交给ZuulServlet去处理,ZuulServlet 类似于 DispatcherServlet 在请求的最前面做分发

public class ZuulController extends ServletWrappingController {

	public ZuulController() {	
		//1.为父类的serveltClass 做初始化，是一个 ZuulServlet
		setServletClass(ZuulServlet.class);
		setServletName("zuul");
		setSupportedMethods((String[]) null); // Allow all
	}

	@Override
	public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
		try {
			// We don't care about the other features of the base class, just want to
			// handle the request
			//2.请求交个父类
			return super.handleRequestInternal(request, response);
		}
		finally {
			// @see com.netflix.zuul.context.ContextLifecycleFilter.doFilter
			RequestContext.getCurrentContext().unset();
		}
	}

}

下面是它父类的源码

public class ServletWrappingController extends AbstractController implements BeanNameAware, InitializingBean, DisposableBean {
    @Nullable
    private Class<? extends Servlet> servletClass;
    @Nullable
    private String servletName;
    private Properties initParameters = new Properties();
    @Nullable
    private String beanName;
	//servletInstance 就是 ZuulServelt
    @Nullable
    private Servlet servletInstance;

   	...省略...
   	 public void afterPropertiesSet() throws Exception {
        if (this.servletClass == null) {
            throw new IllegalArgumentException("'servletClass' is required");
        } else {
            if (this.servletName == null) {
                this.servletName = this.beanName;
            }
			//1.反射，根据 servletClass 创建实例
            this.servletInstance = (Servlet)ReflectionUtils.accessibleConstructor(this.servletClass, new Class[0]).newInstance();
            this.servletInstance.init(new ServletWrappingController.DelegatingServletConfig());
        }
    }

    protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response) throws Exception {
        Assert.state(this.servletInstance != null, "No Servlet instance");
        //2.调用ZuulServelt的service方法
        this.servletInstance.service(request, response);
        return null;
    }
2.ZuulServlet 请求的分发

在ZuulServelt会调用 ZuulRunner 依次执行： init初始化，pre前置filter，route路由filter,post后置filter, error 异常filter，ZuulServlet 源码如下

/**
 1.核心Zuul servlet，可初始化和协调zuulFilter执行
 * Core Zuul servlet which intializes and orchestrates zuulFilter execution
 *
 * @author Mikey Cohen
 *         Date: 12/23/11
 *         Time: 10:44 AM
 */
public class ZuulServlet extends HttpServlet {

    private static final long serialVersionUID = -3374242278843351500L;
    private ZuulRunner 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方法，
        	//主要是把ServletRequest请求对象设置给RequestContext上下文
            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();
            //将此请求标记为“ Zuul引擎”，而不是servlet
            context.setZuulEngineRan();

            try {
            	//执行pre的filter
                preRoute();
            } catch (ZuulException e) {
            	//如果异常了会走 error的filter,然后再走post的filter
                error(e);
                postRoute();
                return;
            }
            try {
            	//执行route的filter
                route();
            } catch (ZuulException e) {
               //如果异常了会走 error的filter,然后再走post的filter
                error(e);
                postRoute();
                return;
            }
            try {
            	//执行post的filter
                postRoute();
            } catch (ZuulException e) {
               //如果异常了会走 error的filter,不会再走post的filter
                error(e);
                return;
            }

        } catch (Throwable e) {
            //如果异常了会走 error的filter,默认错误码500
            error(new ZuulException(e, 500, "UNHANDLED_EXCEPTION_" + e.getClass().getName()));
        } finally {
            RequestContext.getCurrentContext().unset();
        }
    }

    /**
     * executes "post" ZuulFilters
     *
     * @throws ZuulException
     */
     //调用zuulRunner执行 post filter
    void postRoute() throws ZuulException {
        zuulRunner.postRoute();
    }

    /**
     * executes "route" filters
     *
     * @throws ZuulException
     */
     //调用zuulRunner执行 route filter
    void route() throws ZuulException {
        zuulRunner.route();
    }

    /**
     * executes "pre" filters
     *
     * @throws ZuulException
     */
     //调用zuulRunner执行 pre filter
    void preRoute() throws ZuulException {
        zuulRunner.preRoute();
    }

    /**
     * initializes request
     *
     * @param servletRequest
     * @param servletResponse
     */
     //调用zuulRunner执行 初始化 ，主要是把servletRequest设置给ReqestContext上下文对象
     void init(HttpServletRequest servletRequest, HttpServletResponse servletResponse) {
        zuulRunner.init(servletRequest, servletResponse);
    }

    /**
     * sets error context info and executes "error" filters
     *
     * @param e
     */
     //通过RequestContext设置异常
     //通过zuulRunner执行 error filter
    void error(ZuulException e) {
        RequestContext.getCurrentContext().setThrowable(e);
        zuulRunner.error();
    }
3.ZuulRunner 执行器

上面涉及到一个非常重要的类ZuulRunner所有的请求都是通过它来执行的，此类将Servlet请求和响应初始化到RequestContext中，并将FilterProcessor调用包装为preRoute（），route（），postRoute（）和error（）方法　，我们看一下ZuulRunner的源码


/**
 * This class initializes servlet requests and responses into the RequestContext and wraps the FilterProcessor calls
 * to preRoute(), route(),  postRoute(), and error() methods
 *
 * @author mikey@netflix.com
 * @version 1.0
 */
public class ZuulRunner {

    private boolean bufferRequests;

    /**
     * Creates a new <code>ZuulRunner</code> instance.
     */
    public ZuulRunner() {
        this.bufferRequests = true;
    }

    /**
     *
     * @param bufferRequests - whether to wrap the ServletRequest in HttpServletRequestWrapper and buffer the body.
	在ZuulServlet中创建ZuulRunner的时候传入的配置参数 bufferRequests，
	 它决定了是否把 ServletRequest包装在HttpServletRequestWrapper中并缓冲主体。
     */
    public ZuulRunner(boolean bufferRequests) {
        this.bufferRequests = bufferRequests;
    }

    /**
     * sets HttpServlet request and HttpResponse
     设置 请求对象和响应对象到  RequestContext 中
     * @param servletRequest
     * @param servletResponse
     */
    public void init(HttpServletRequest servletRequest, HttpServletResponse servletResponse) {

        RequestContext ctx = RequestContext.getCurrentContext();
        if (bufferRequests) {
			//把 ServletRequest包装在HttpServletRequestWrapper中并缓冲主体。
            ctx.setRequest(new HttpServletRequestWrapper(servletRequest));
        } else {
            ctx.setRequest(servletRequest);
        }

        ctx.setResponse(new HttpServletResponseWrapper(servletResponse));
    }

	//这里通过 FilterProcessor 执行器调用各种 ZuulFilters
    /**
     * executes "post" filterType  ZuulFilters
     *
     * @throws ZuulException
     */
    public void postRoute() throws ZuulException {
        FilterProcessor.getInstance().postRoute();
    }

    /**
     * executes "route" filterType  ZuulFilters
     *
     * @throws ZuulException
     */
    public void route() throws ZuulException {
        FilterProcessor.getInstance().route();
    }

    /**
     * executes "pre" filterType  ZuulFilters
     *
     * @throws ZuulException
     */
    public void preRoute() throws ZuulException {
        FilterProcessor.getInstance().preRoute();
    }

    /**
     * executes "error" filterType  ZuulFilters
     */
    public void error() {
        FilterProcessor.getInstance().error();
    }
4.FilterProcessor filter执行器

继续跟踪一下 FilterProcessor的源码

public class FilterProcessor {
  ...省略代码...
  /**
     * runs "post" filters which are called after "route" filters. ZuulExceptions from ZuulFilters are thrown.
     * Any other Throwables are caught and a ZuulException is thrown out with a 500 status code
     *
     * @throws ZuulException
     */
    public void postRoute() throws ZuulException {
        try {
        	//执行 post 类型的filter
            runFilters("post");
        } catch (ZuulException e) {
            throw e;
        } catch (Throwable e) {
            throw new ZuulException(e, 500, "UNCAUGHT_EXCEPTION_IN_POST_FILTER_" + e.getClass().getName());
        }
    }

    /**
     * runs all "error" filters. These are called only if an exception occurs. Exceptions from this are swallowed and logged so as not to bubble up.
     */
    public void error() {
        try {
        	//执行 error 类型的filter
            runFilters("error");
        } catch (Throwable e) {
            logger.error(e.getMessage(), e);
        }
    }

    /**
     * Runs all "route" filters. These filters route calls to an origin.
     *
     * @throws ZuulException if an exception occurs.
     */
    public void route() throws ZuulException {
        try {
        	//执行 post 类型的filter
            runFilters("post");
        } catch (ZuulException e) {
            throw e;
        } catch (Throwable e) {
            throw new ZuulException(e, 500, "UNCAUGHT_EXCEPTION_IN_ROUTE_FILTER_" + e.getClass().getName());
        }
    }

    /**
     * runs all "pre" filters. These filters are run before routing to the orgin.
     *
     * @throws ZuulException
     */
    public void preRoute() throws ZuulException {
        try {
        	//执行 pre 类型的filter
            runFilters("pre");
        } catch (ZuulException e) {
            throw e;
        } catch (Throwable e) {
            throw new ZuulException(e, 500, "UNCAUGHT_EXCEPTION_IN_PRE_FILTER_" + e.getClass().getName());
        }
    }

    /**
    
     * runs all filters of the filterType sType/ Use this method within filters to run custom filters by type
     *
     * @param sType the filterType.
     * @return
     * @throws Throwable throws up an arbitrary exception
     */
     //执行Filter的核心方法，运行所有过滤器/在过滤器中使用此方法可按类型运行自定义过滤器
    public Object runFilters(String sType) throws Throwable {
        if (RequestContext.getCurrentContext().debugRouting()) {
            Debug.addRoutingDebug("Invoking {" + sType + "} type filters");
        }
        boolean bResult = false;
        //通过 FilterLoader 加载 filters
        List<ZuulFilter> list = FilterLoader.getInstance().getFiltersByType(sType);
        if (list != null) {
            for (int i = 0; i < list.size(); i++) {
                ZuulFilter zuulFilter = list.get(i);
                //拿到每个filter，调用 processZuulFilter 去执行
                Object result = processZuulFilter(zuulFilter);
                if (result != null && result instanceof Boolean) {
                    bResult |= ((Boolean) result);
                }
            }
        }
        //返回结果
        return bResult;
    }

    /**
     * Processes an individual ZuulFilter. This method adds Debug information. Any uncaught Thowables are caught by this method and converted to a ZuulException with a 500 status code.
     *
     * @param filter
     * @return the return value for that filter
     * @throws ZuulException
     */
     //filter的执行方法
    public Object processZuulFilter(ZuulFilter filter) throws ZuulException {

        RequestContext ctx = RequestContext.getCurrentContext();
        //获取时候开启：debug
        boolean bDebug = ctx.debugRouting();
        final String metricPrefix = "zuul.filter-";
        long execTime = 0;
        String filterName = "";
        try {
            long ltime = System.currentTimeMillis();
            //filter的类名
            
            filterName = filter.getClass().getSimpleName();
            
            RequestContext copy = null;
            Object o = null;
            Throwable t = null;

            if (bDebug) {
                Debug.addRoutingDebug("Filter " + filter.filterType() + " " + filter.filterOrder() + " " + filterName);
                copy = ctx.copy();
            }
            //【重要】调用 ZuulFilter.runFilter方法真正执行Filter
            ZuulFilterResult result = filter.runFilter();
            //拿到响应状态
            ExecutionStatus s = result.getStatus();
            execTime = System.currentTimeMillis() - ltime;

            switch (s) {
            	//执行失败
                case FAILED:
                    t = result.getException();
                    //将过滤器名称和状态附加到当前请求的过滤器执行历史记录中
                    ctx.addFilterExecutionSummary(filterName, ExecutionStatus.FAILED.name(), execTime);
                    break;
            	//执行成功
                case SUCCESS:
                    o = result.getResult();
                    ctx.addFilterExecutionSummary(filterName, ExecutionStatus.SUCCESS.name(), execTime);
                    if (bDebug) {
                        Debug.addRoutingDebug("Filter {" + filterName + " TYPE:" + filter.filterType() + " ORDER:" + filter.filterOrder() + "} Execution time = " + execTime + "ms");
                        Debug.compareContextState(filterName, copy);
                    }
                    break;
                default:
                    break;
            }
            
            if (t != null) throw t;

            usageNotifier.notify(filter, s);
            return o;

        } catch (Throwable e) {
            if (bDebug) {
                Debug.addRoutingDebug("Running Filter failed " + filterName + " type:" + filter.filterType() + " order:" + filter.filterOrder() + " " + e.getMessage());
            }
            usageNotifier.notify(filter, ExecutionStatus.FAILED);
            if (e instanceof ZuulException) {
                throw (ZuulException) e;
            } else {
                ZuulException ex = new ZuulException(e, "Filter threw Exception", 500, filter.filterType() + ":" + filterName);
                ctx.addFilterExecutionSummary(filterName, ExecutionStatus.FAILED.name(), execTime);
                throw ex;
            }
        }
    }
...省略代码...

不管是前置，后置，路由，异常的Filter ，FilterProcessor 都通过 runFilters("类型"); 方法去执行filter,方法中通过 FilterLoader加载指定类型的Filter列表，然后交给 processZuulFilter方法去执行 ，该方法最终调用ZuulFilter.runFilter();方法去执行具体的Filter 。它会以下面的顺序去执行内置的Filter:

类型过滤器描述顺序
preServletDetectionFilter在pre过滤器中，ServletDetectionFilter是第一个执行的过滤器，检测请求是用 DispatcherServlet还是 ZuulServlet，将结果设置到RequestContext中-3
preServlet30WrapperFilter主要是将原始请求进行包装，将原始的HttpServletRequest请求包装成Servlet30RequestWrapper类型-2
preFormBodyWrapperFilter同Servlet30RequestWrapper一样，也是对请求的一个包装，只不过他只包装表单数据，即：content-type中必须带有“application/x-www-form-urlencoded”或“multipart/form-data”-1
errorSendErrorFilter这个是用来发送错误的Filter0
preDebugFilter设置请求过程是否开启debug,将当前请求上下文中的debugRouting和debugRequest参数设置为true1
prePreDecorationFilter基本的路由转发配置,根据uri调用哪一个route过滤器5
routeRibbonRoutingFilter服务路由的过滤器，使用用Ribbon 做负载均衡，hystrix做熔断10
routeSimpleHostRoutingFilter简单主机路由过滤器，如果使用url路由，则用这个过滤器100
routeSendForwardFilter它使用RequestDispatcher转发请求500
postSendResponseFilterSendResponseFilter是Zuul的最后一个Filter，负责最终响应结果的输出。1000

error类型的filter在出异常的时候才会执行

5.ZuulFilter

ZuulFilter 是所有Filter的抽象类，它的接口是IZuulFilter ，它里面有四个很重要的方法

//这个是
public interface IZuulFilter {
	//是否要执行Run方法
    boolean shouldFilter();
	//filter的核心业务方法
    Object run() throws ZuulException;
}

public abstract class ZuulFilter implements IZuulFilter, Comparable<ZuulFilter> {

    private final AtomicReference<DynamicBooleanProperty> filterDisabledRef = new AtomicReference<>();

    /**
     * to classify a filter by type. Standard types in Zuul are "pre" for pre-routing filtering,
     * "route" for routing to an origin, "post" for post-routing filters, "error" for error handling.
     * We also support a "static" type for static responses see  StaticResponseFilter.
     * Any filterType made be created or added and run by calling FilterProcessor.runFilters(type)
     *
     * @return A String representing that type
     */
     //这个是filter的类型 ，有 pre ,route,post error
    abstract public String filterType();

    /**
     * filterOrder() must also be defined for a filter. Filters may have the same  filterOrder if precedence is not
     * important for a filter. filterOrders do not need to be sequential.
     *
     * @return the int order of a filter
     */
     //这个是filter的执行顺序，越小越先执行
    abstract public int filterOrder();
    ...省略...
}

详细看一下ZuulFilter 的源码

public abstract class ZuulFilter implements IZuulFilter, Comparable<ZuulFilter> {
...省略...
 public ZuulFilterResult runFilter() {
        ZuulFilterResult zr = new ZuulFilterResult();
        if (!isFilterDisabled()) {
        	//调用shouldFilter方法，这是个抽象方法，子类需要复写该方法返回 bool值决定要不要执行run方法
            if (shouldFilter()) {
                Tracer t = TracerFactory.instance().startMicroTracer("ZUUL::" + this.getClass().getSimpleName());
                try {
             		 //调用 filter的run方法去执行，也是个抽象方法，需要子类去实现自己的业务逻辑
                    Object res = run();
                    //执行成功，包装一个成功状态的ZuulFilterResult对象返回
                    zr = new ZuulFilterResult(res, ExecutionStatus.SUCCESS);
                } catch (Throwable e) {
                    t.setName("ZUUL::" + this.getClass().getSimpleName() + " failed");
                    //执行失败，包装一个失败状态的ZuulFilterResult对象返回
                    zr = new ZuulFilterResult(ExecutionStatus.FAILED);
                    zr.setException(e);
                } finally {
                    t.stopAndLog();
                }
            } else {
                zr = new ZuulFilterResult(ExecutionStatus.SKIPPED);
            }
        }
        return zr;
    }

ZuulFilter 是个抽象类，需要具体的子类类去复写其中的四个方法，然后 ZuulFilter 做的事情就依次调用 shouldFilter 方法，如果返回true就调用 run方法执行子类的业务逻辑，然后把结果封装成ZuulFilterResult返回。

到这里Zuul的执行流程的跟踪就算结束了，剩下的就是具体的Filter本身的业务代码的理解了，Zuul通过依次调用这个写Filter来完成整个生命周期的执行。最后总结一下流程

在这里插入图片描述

墨家巨子@俏如来
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
spring-cloud-starter-netflix-zuul-2.0.0.RELEASE
01-17
可用的spring-cloud-starter-netflix-zuul-2.0.0.RELEASE包，maven上的spring-cloud-starter-netflix-zuul-2.0.0.RELEASE已经没了。
spring-cloud-starter-netflix-zuul.zip已经闭源的jar包，pom
10-28
spring-cloud-starter-netflix-zuul.zip已经闭源的jar包，
SpringCloud Zuul执行流程与源码分析
Logger
12-27 307
文章目录请求在网关内的执行流程过滤器的具体调用逻辑 请求在网关内的执行流程 用户请求大致上是按这个顺序来进行的，我们再看具体内部这四种Filter的执行顺序，搬一段ZuulServlet.service()源码： public void service(javax.servlet.ServletRequest servletRequest, javax.servlet.ServletResponse servletResponse) throws ServletException, IOException
网关zuul的执行流程
weixin_37862824的博客
08-26 1401
自定义路由 既然是网关那么就一定要有路由，那么在zuul中怎么设置我们自定义的路由呢，下面介绍下，通过bean设置路由。 public class CustomRouteLocator extends SimpleRouteLocator implements RefreshableRouteLocator{ //刷新路由 @Override public void refresh(){ this.routes.set(this.locateRoutes());
SpringCloud中的Zuul的工作原理(四大过滤器链的执行流程pre、routing、post、error)
m0_56245143的博客
05-11 679
首先的zuul的底层是通过各种的Filter来实现的，zuul中的filter按照执行顺序分为了“pre”前置（"custom"自定义一般是前置），"routing"路由，“post"后置，以及"error"异常Filter组成的，当各种Filter出现了异常，请求会跳转到"error filter”，然后再经过"post filter"最后返回结果。
Zuul本地转发（访问Controller）
whatzhang007的博客
07-05 524
文档： https://jbone.cn/translate/spring-cloud-netflix-zuul/strangulation-patterns-and-local-forwards.html http://docs.springcloud.cn/user-guide/zuul/#_1 核心代码 org.springframework.cloud.netflix.zuul.filters.route.SendForwardFilter类
zuul 里面写controller_深夜思考之利用Zuul网关实现接口透传
weixin_39538847的博客
11-20 781
前言最近参考个项目是"透传"第三方接口，第一个想到的是利用Spring Cloud的网关组件去实现， 但在实现过程中遇到几个问题，解决后记录下来，便于给其他人作为参考。借鉴文章 代码人生 codingforever.cn问题一 对真实接口的包装, 隐藏真实的请求接口大致是有个/getOrderDetail的接口，这个接口的逻辑是如...
SpringCloud-Zuul执行流程分析
esunlang的博客
02-10 410
前言 如果使用了微服务的springcloud中间件，可能前期早些时候的项目还是在使用zuul，后期的项目基本都要是选择了gateway，但是这里还是想理一理这个zull的流程，毕竟是一个开创网关先补补祖。 知识前提 我们知道，HTTP请求是受HttpServlet接收的，早期项目中其实也是由HttpServlet的doGet doPost方法接收请求进行初始处理并且进行相关逻辑处理。那个年代的项目写到真是想吐。 而zuul是继承了这个HttpServlet，之后便是通过相关的type获取要执行的filte
zuul源码解析1
weixin_43831204的博客
11-06 196
zuul源码解析 此次源码分析的版本是1.x，如果你看的是2.0版本以上的请忽略本文章。 servlet源码解析 我们知道一个web项目少不了一个servlet，它也是服务处理的入口和出口。所以先从ZuulServlet开始介绍。 public class ZuulServlet extends HttpServlet { private static final long serialVersionUID = -3374242278843351500L; // zuul执行器，Z
zuul 里面写controller_SpringCloud极简入门｜zuul 动态转发url困扰很久功能终于实现了6...
weixin_39722759的博客
12-12 435
前情回顾上一节(第5讲)，我们讲解了zuul的基本配置，如下链接SpringCloud极简入门｜zuul智能路由回退、认证、转发功能(五)：https://www.toutiao.com/i6643405381466849800/本章知识点很重要！很重要！很重要！,真的很重要，网上资料不是很多，所以建议收藏下转发动态路由设置使zuul变得很灵活，但是网上的资料大多是基于动态配置实现的，这样导致如果...
spring-cloud-zuul2:Zuul2与Spring Cloud集成
05-09
Spring Cloud Zuul2 Zuul与Spring Cloud的集成。 警告：正在进行中入门启动zuul服务器./src/test/java/rocks/devmesh/spring/cloud/zuul/Application#main请求到'/ healthcheck'端点$ curl ...
spring-cloud-netflix-zuul-websocket, Zuul反向代理网络套接字支持.zip
10-09
spring-cloud-netflix-zuul-websocket, Zuul反向代理网络套接字支持 spring-cloud-netflix-zuul-websocketspring 应用程序中支持Zuul反向代理web套接字支持的简单库。用法spring-cloud-netflix-zuul-websocket可以从...
spring-cloud-netflix-zuul-2.1.0.RELEASE.jar
最新发布
05-09
spring-cloud-netflix-zuul-2.1.0.RELEASE
SpringCloud源码学习笔记—— Zuul网关源码分析
weixin_43577692的博客
05-09 409
Zuul是netflix旗下开源网关，作为微服务系统的网关组件，是微服务请求的前门。微服务网关的作用有点类似于AOP，将负载均衡限流熔断等"横切关注点"都集中于此，避免每一个服务都需要写重复的功能（解决不了的问题，我们就加一层doge）且微服务网关是统一入口,系统有多个服务，不能每个服务一个对外地址，用户需要一个统一的系统入口进行操作，故zuul网关是系统的统一入口。
springcloud：网关组件zuul的功能介绍、运行机制
weixin_39885962的博客
07-11 1148
Spring Cloud集群中，用于内部通信的组件有服务管理组件Eureka、负载均衡组件Ribbon。不过如果是集群提供了Api或者WEB服务的话，就需要与外部进行通信。这时候需要一个代理层作为集群的大门，网关可以将集群的服务隐藏在后面，而对于外部客户端来说只需关心网关的配置，不许关系集群的内部结构。官方定义：Zuul 是在云平台上提供动态路由,监控,弹性,安全等边缘服务的框架。Zuul 相当于是设备和 Netflix 流应用的 Web 网站后端所有请求的前门。即Zuul为微服务集群提供代理、过滤和路由等
SpringCloud--路由Zuul的使用和基本流程解析
xlecho的博客
06-17 1521
xl_echo编辑整理，欢迎转载，转载请声明文章来源。更多IT编程案例、资料请联系QQ：1280023003 ，群：298140694 百战不败，依不自称常胜，百败不颓，依能奋力前行。——这才是真正的堪称强大！！ 路由顾名思义那是一个帮助我们能够快速寻找到我们需要服务的组件，在springcloud中，路由主要用于和ribbon工作作用，实现负载均衡。其主要作用就是转发和过滤，也是微服务...
spring cloud zuul工作流程
m0_38008272的博客
03-18 1683
本文基础理论：Netty， spring-cloud-netflix-zuul先上工作流程图：这样看来其实工作流程比较简单了，如果大家有对netty比较熟悉，应该一下子可以看懂了；1. zuul作为一个netty服务端server2. 接受Internet Request之后，出发netty inbound事件；3. Request经过处理之后，经过Endpoint Filter拦截，获取到Req...
zuul中请求的流程
weixin_30421809的博客
03-31 308
Zuul架构图： 图一 zuulServlet中的service方法 1 public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException { 2 try { 3 ...
一.SpringCloud源码剖析-Eureka核心API
墨家巨子@俏如来
08-20 1687
前言 SpringCloud已经成为落地Java微服务架构最流行的框架之一，对于一个优秀的程序员而言不仅需要灵活的使用SpringCloud，还要知道他的实现原理和思想，知其然知其所以然，只有这样我们写出来的代码才有灵魂，熟读源码无论对解决开发中的BUG，还是应对面试对我们都有很大的帮助，本章将带领大家一步一步分析SpringCloud的源码。 一.Eureak核心功能 我们先来回顾一下Eureka的几个核心功能 1.1.服务注册 Eureka是一个服务注册与发现组件,它包含了EurekaServer 服务
spring-cloud-starter-netflix-zuul和spring-cloud-starter-zuul区别
03-08
spring-cloud-starter-netflix-zuul和spring-cloud-starter-zuul是Spring Cloud框架中用于构建微服务网关的两个组件。它们之间的区别如下： 1. spring-cloud-starter-netflix-zuul：这是基于Netflix Zuul的Spring ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

墨家巨子@俏如来

你的鼓励是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值