浅谈Spring Cloud zuul http请求转发原理

 @override
  public void dofilter(servletrequest servletrequest, servletresponse servletresponse, filterchain filterchain) throws ioexception, servletexception {
    try {
      init((httpservletrequest) servletrequest, (httpservletresponse) servletresponse);
      try {
        prerouting();
      } catch (zuulexception e) {
        error(e);
        postrouting();
        return;
      }
      
      // only forward onto to the chain if a zuul response is not being sent
      if (!requestcontext.getcurrentcontext().sendzuulresponse()) {
        filterchain.dofilter(servletrequest, servletresponse);
        return;
      }
      
      try {
        routing();
      } catch (zuulexception e) {
        error(e);
        postrouting();
        return;
      }
      try {
        postrouting();
      } catch (zuulexception e) {
        error(e);
        return;
      }
    } catch (throwable e) {
      error(new zuulexception(e, 500, "uncaught_exception_from_filter_" + e.getclass().getname()));
    } finally {
      requestcontext.getcurrentcontext().unset();
    }
  }

 void postrouting() throws zuulexception {
    zuulrunner.postroute();
  }

  public void postroute() throws zuulexception {
    filterprocessor.getinstance().postroute();
  }

  public void preroute() throws zuulexception {
    try {
      runfilters("pre");
    } catch (zuulexception e) {
      throw e;
    } catch (throwable e) {
      throw new zuulexception(e, 500, "uncaught_exception_in_pre_filter_" + e.getclass().getname());
    }
  }

 public object runfilters(string stype) throws throwable {
    if (requestcontext.getcurrentcontext().debugrouting()) {
      debug.addroutingdebug("invoking {" + stype + "} type filters");
    }
    boolean bresult = false;
    //通过stype获取 zuulfilter的列表
    list<zuulfilter> list = filterloader.getinstance().getfiltersbytype(stype);
    if (list != null) {
      for (int i = 0; i < list.size(); i++) {
        zuulfilter zuulfilter = list.get(i);
        object result = processzuulfilter(zuulfilter);
        if (result != null && result instanceof boolean) {
          bresult |= ((boolean) result);
        }
      }
    }
    return bresult;
  }

public abstract class zuulfilter implements izuulfilter, comparable<zuulfilter> {

  private final dynamicbooleanproperty filterdisabled =
      dynamicpropertyfactory.getinstance().getbooleanproperty(disablepropertyname(), false);

  /**
   * 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
   */
  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
   */
  abstract public int filterorder();

  /**
   * by default zuulfilters are static; they don't carry state. this may be overridden by overriding the isstaticfilter() property to false
   *
   * @return true by default
   */
  public boolean isstaticfilter() {
    return true;
  }

 public zuulfilterresult runfilter() {
    zuulfilterresult zr = new zuulfilterresult();
    if (!isfilterdisabled()) {
      if (shouldfilter()) {
        tracer t = tracerfactory.instance().startmicrotracer("zuul::" + this.getclass().getsimplename());
        try {
          object res = run();
          zr = new zuulfilterresult(res, executionstatus.success);
        } catch (throwable e) {
          t.setname("zuul::" + this.getclass().getsimplename() + " failed");
          zr = new zuulfilterresult(executionstatus.failed);
          zr.setexception(e);
        } finally {
          t.stopandlog();
        }
      } else {
        zr = new zuulfilterresult(executionstatus.skipped);
      }
    }
    return zr;
  }

public interface izuulfilter {
  /**
   * a "true" return from this method means that the run() method should be invoked
   *
   * @return true if the run() method should be invoked. false will not invoke the run() method
   */
  boolean shouldfilter();

  /**
   * if shouldfilter() is true, this method will be invoked. this method is the core method of a zuulfilter
   *
   * @return some arbitrary artifact may be returned. current implementation ignores it.
   */
  object run();
}  

@override
  public object run() {
    requestcontext ctx = requestcontext.getcurrentcontext();
    final string requesturi = this.urlpathhelper.getpathwithinapplication(ctx.getrequest());
    route route = this.routelocator.getmatchingroute(requesturi);
    if (route != null) {
      string location = route.getlocation();
      if (location != null) {
        ctx.put("requesturi", route.getpath());
        ctx.put("proxy", route.getid());
        if (!route.iscustomsensitiveheaders()) {
          this.proxyrequesthelper
              .addignoredheaders(this.properties.getsensitiveheaders().toarray(new string[0]));
        }
        else {
          this.proxyrequesthelper.addignoredheaders(route.getsensitiveheaders().toarray(new string[0]));
        }

        if (route.getretryable() != null) {
          ctx.put("retryable", route.getretryable());
        }
        // 如果配置的转发地址是http开头，会设置 routehost
        if (location.startswith("http:") || location.startswith("https:")) {
          ctx.setroutehost(geturl(location));
          ctx.addoriginresponseheader("x-zuul-service", location);
        }
         // 如果配置的转发地址forward，则会设置forward.to
        else if (location.startswith("forward:")) {
          ctx.set("forward.to",
              stringutils.cleanpath(location.substring("forward:".length()) + route.getpath()));
          ctx.setroutehost(null);
          return null;
        }
        else {
           // 否则以serviceid进行转发
          // set serviceid for use in filters.route.ribbonrequest
          ctx.set("serviceid", location);
          ctx.setroutehost(null);
          ctx.addoriginresponseheader("x-zuul-serviceid", location);
        }
        if (this.properties.isaddproxyheaders()) {
          addproxyheaders(ctx, route);
          string xforwardedfor = ctx.getrequest().getheader("x-forwarded-for");
          string remoteaddr = ctx.getrequest().getremoteaddr();
          if (xforwardedfor == null) {
            xforwardedfor = remoteaddr;
          }
          else if (!xforwardedfor.contains(remoteaddr)) { // prevent duplicates
            xforwardedfor += ", " + remoteaddr;
          }
          ctx.addzuulrequestheader("x-forwarded-for", xforwardedfor);
        }
        if (this.properties.isaddhostheader()) {
          ctx.addzuulrequestheader("host", tohostheader(ctx.getrequest()));
        }
      }
    }
    else {
      log.warn("no route found for uri: " + requesturi);

      string fallbackuri = requesturi;
      string fallbackprefix = this.dispatcherservletpath; // default fallback
                                // servlet is
                                // dispatcherservlet

      if (requestutils.iszuulservletrequest()) {
        // remove the zuul servletpath from the requesturi
        log.debug("zuulservletpath=" + this.properties.getservletpath());
        fallbackuri = fallbackuri.replacefirst(this.properties.getservletpath(), "");
        log.debug("replaced zuul servlet path:" + fallbackuri);
      }
      else {
        // remove the dispatcherservlet servletpath from the requesturi
        log.debug("dispatcherservletpath=" + this.dispatcherservletpath);
        fallbackuri = fallbackuri.replacefirst(this.dispatcherservletpath, "");
        log.debug("replaced dispatcherservlet servlet path:" + fallbackuri);
      }
      if (!fallbackuri.startswith("/")) {
        fallbackuri = "/" + fallbackuri;
      }
      string forwarduri = fallbackprefix + fallbackuri;
      forwarduri = forwarduri.replaceall("//", "/");
      ctx.set("forward.to", forwarduri);
    }
    return null;
  }

  @override
  public boolean shouldfilter() {
    return requestcontext.getcurrentcontext().getroutehost() != null
        && requestcontext.getcurrentcontext().sendzuulresponse();
  }

@override
  public object run() {
    requestcontext context = requestcontext.getcurrentcontext();
    httpservletrequest request = context.getrequest();
    multivaluemap<string, string> headers = this.helper
        .buildzuulrequestheaders(request);
    multivaluemap<string, string> params = this.helper
        .buildzuulrequestqueryparams(request);
    string verb = getverb(request);
    inputstream requestentity = getrequestbody(request);
    if (request.getcontentlength() < 0) {
      context.setchunkedrequestbody();
    }

    string uri = this.helper.buildzuulrequesturi(request);
    this.helper.addignoredheaders();

    try {
      httpresponse response = forward(this.httpclient, verb, uri, request, headers,
          params, requestentity);
      setresponse(response);
    }
    catch (exception ex) {
      context.set(error_status_code, httpservletresponse.sc_internal_server_error);
      context.set("error.exception", ex);
    }
    return null;
  }