[Java] Spring Cloud Ribbon的踩坑记录与原理详析

org.springframework.web.client.httpclienterrorexception: 404 null

@slf4j
public class customhttprequestinterceptor implements clienthttprequestinterceptor {
 
 @override
 public clienthttpresponse intercept(httprequest request, byte[] body, clienthttprequestexecution execution) throws ioexception {
  log.info("request , url:{},method:{}.", request.geturi(), request.getmethod());
  return execution.execute(request, body);
 }
}

@configuration
@conditionalonclass({ iclient.class, resttemplate.class, asyncresttemplate.class, ribbon.class})
@ribbonclients
@autoconfigureafter(name = "org.springframework.cloud.netflix.eureka.eurekaclientautoconfiguration")
@autoconfigurebefore({loadbalancerautoconfiguration.class, asyncloadbalancerautoconfiguration.class})
@enableconfigurationproperties({ribboneagerloadproperties.class, serverintrospectorproperties.class})
public class ribbonautoconfiguration {
}

public class ribbonclientconfigurationregistrar implements importbeandefinitionregistrar {
 
 @override
 public void registerbeandefinitions(annotationmetadata metadata,
 beandefinitionregistry registry) {
 map<string, object> attrs = metadata.getannotationattributes(
 ribbonclients.class.getname(), true);
 if (attrs != null && attrs.containskey("value")) {
 annotationattributes[] clients = (annotationattributes[]) attrs.get("value");
 for (annotationattributes client : clients) {
 registerclientconfiguration(registry, getclientname(client),
  client.get("configuration"));
 }
 }
 if (attrs != null && attrs.containskey("defaultconfiguration")) {
 string name;
 if (metadata.hasenclosingclass()) {
 name = "default." + metadata.getenclosingclassname();
 } else {
 name = "default." + metadata.getclassname();
 }
 registerclientconfiguration(registry, name,
  attrs.get("defaultconfiguration"));
 }
 map<string, object> client = metadata.getannotationattributes(
 ribbonclient.class.getname(), true);
 string name = getclientname(client);
 if (name != null) {
 registerclientconfiguration(registry, name, client.get("configuration"));
 }
 }
 
 private string getclientname(map<string, object> client) {
 if (client == null) {
 return null;
 }
 string value = (string) client.get("value");
 if (!stringutils.hastext(value)) {
 value = (string) client.get("name");
 }
 if (stringutils.hastext(value)) {
 return value;
 }
 throw new illegalstateexception(
 "either 'name' or 'value' must be provided in @ribbonclient");
 }
 
 private void registerclientconfiguration(beandefinitionregistry registry,
 object name, object configuration) {
 beandefinitionbuilder builder = beandefinitionbuilder
 .genericbeandefinition(ribbonclientspecification.class);
 builder.addconstructorargvalue(name);
 builder.addconstructorargvalue(configuration);
 registry.registerbeandefinition(name + ".ribbonclientspecification",
 builder.getbeandefinition());
 }
}

public class ribbonautoconfiguration {
  
 
  //上文中会解析被@ribbonclients注解修饰的类，然后注册类型为ribbonclientspecification的bean。
  //主要有两个: ribbonautoconfiguration、ribboneurekaautoconfiguration
 @autowired(required = false)
 private list<ribbonclientspecification> configurations = new arraylist<>();
  
 @bean
 public springclientfactory springclientfactory() {
  //初始化springclientfactory,并将上面的配置注入进去，这段很重要。
 springclientfactory factory = new springclientfactory();
 factory.setconfigurations(this.configurations);
 return factory;
 }
   //其他的都是提供一些默认的bean配置
 
 @bean
 @conditionalonmissingbean(loadbalancerclient.class)
 public loadbalancerclient loadbalancerclient() {
 return new ribbonloadbalancerclient(springclientfactory());
 }
 
 @bean
 @conditionalonclass(name = "org.springframework.retry.support.retrytemplate")
 @conditionalonmissingbean
 public loadbalancedretrypolicyfactory loadbalancedretrypolicyfactory(springclientfactory clientfactory) {
 return new ribbonloadbalancedretrypolicyfactory(clientfactory);
 }
 
 @bean
 @conditionalonmissingclass(value = "org.springframework.retry.support.retrytemplate")
 @conditionalonmissingbean
 public loadbalancedretrypolicyfactory neverretrypolicyfactory() {
 return new loadbalancedretrypolicyfactory.neverretryfactory();
 }
 
 @bean
 @conditionalonclass(name = "org.springframework.retry.support.retrytemplate")
 @conditionalonmissingbean
 public loadbalancedbackoffpolicyfactory loadbalancedbackoffpolicyfactory() {
 return new loadbalancedbackoffpolicyfactory.nobackoffpolicyfactory();
 }
 
 @bean
 @conditionalonclass(name = "org.springframework.retry.support.retrytemplate")
 @conditionalonmissingbean
 public loadbalancedretrylistenerfactory loadbalancedretrylistenerfactory() {
 return new loadbalancedretrylistenerfactory.defaultretrylistenerfactory();
 }
 
 @bean
 @conditionalonmissingbean
 public propertiesfactory propertiesfactory() {
 return new propertiesfactory();
 }
 
 @bean
 @conditionalonproperty(value = "ribbon.eager-load.enabled", matchifmissing = false)
 public ribbonapplicationcontextinitializer ribbonapplicationcontextinitializer() {
 return new ribbonapplicationcontextinitializer(springclientfactory(),
 ribboneagerloadproperties.getclients());
 }
 
 @configuration
 @conditionalonclass(httprequest.class)
 @conditionalonribbonrestclient
 protected static class ribbonclientconfig {
 
 @autowired
 private springclientfactory springclientfactory;
 
 @bean
 public resttemplatecustomizer resttemplatecustomizer(
 final ribbonclienthttprequestfactory ribbonclienthttprequestfactory) {
 return new resttemplatecustomizer() {
 @override
 public void customize(resttemplate resttemplate) {
  resttemplate.setrequestfactory(ribbonclienthttprequestfactory);
 }
 };
 }
 
 @bean
 public ribbonclienthttprequestfactory ribbonclienthttprequestfactory() {
 return new ribbonclienthttprequestfactory(this.springclientfactory);
 }
 }
 
 //todo: support for autoconfiguring restemplate to use apache http client or okhttp
 
 @target({ elementtype.type, elementtype.method })
 @retention(retentionpolicy.runtime)
 @documented
 @conditional(onribbonrestclientcondition.class)
 @interface conditionalonribbonrestclient { }
 
 private static class onribbonrestclientcondition extends anynestedcondition {
 public onribbonrestclientcondition() {
 super(configurationphase.register_bean);
 }
 
 @deprecated //remove in edgware"
 @conditionalonproperty("ribbon.http.client.enabled")
 static class zuulproperty {}
 
 @conditionalonproperty("ribbon.restclient.enabled")
 static class ribbonproperty {}
 }
}

@bean
 @conditionalonmissingbean
 public resttemplatecustomizer resttemplatecustomizer(
 final loadbalancerinterceptor loadbalancerinterceptor) {
 return new resttemplatecustomizer() {
 @override
 public void customize(resttemplate resttemplate) {
  list<clienthttprequestinterceptor> list = new arraylist<>(
  resttemplate.getinterceptors());
  list.add(loadbalancerinterceptor);
  resttemplate.setinterceptors(list);
 }
 };
 }

public class loadbalancerinterceptor implements clienthttprequestinterceptor {
 
 private loadbalancerclient loadbalancer;
 private loadbalancerrequestfactory requestfactory;
 
 @override
 public clienthttpresponse intercept(final httprequest request, final byte[] body,
 final clienthttprequestexecution execution) throws ioexception {
 final uri originaluri = request.geturi(); //这里传入的url是解析之前的，即http://serviceid/服务地址的形式
 string servicename = originaluri.gethost(); //解析拿到对应的serviceid
 assert.state(servicename != null, "request uri does not contain a valid hostname: " + originaluri);
 return this.loadbalancer.execute(servicename, requestfactory.createrequest(request, body, execution));
 }
}

public class ribbonloadbalancerclient implements loadbalancerclient {
@override
 public <t> t execute(string serviceid, loadbalancerrequest<t> request) throws ioexception {
 iloadbalancer loadbalancer = getloadbalancer(serviceid); //获取对应的loadbalancer
 server server = getserver(loadbalancer); //获取服务器，这里会执行对应的分流策略，比如轮训
  //、随机等
 if (server == null) {
 throw new illegalstateexception("no instances available for " + serviceid);
 }
 ribbonserver ribbonserver = new ribbonserver(serviceid, server, issecure(server,
 serviceid), serverintrospector(serviceid).getmetadata(server));
 
 return execute(serviceid, ribbonserver, request);
 }
}

public class springclientfactory extends namedcontextfactory<ribbonclientspecification> {
 protected annotationconfigapplicationcontext createcontext(string name) {
 annotationconfigapplicationcontext context = new annotationconfigapplicationcontext();
 if (this.configurations.containskey(name)) {
 for (class<?> configuration : this.configurations.get(name)
  .getconfiguration()) {
 context.register(configuration);
 }
 }
 for (map.entry<string, c> entry : this.configurations.entryset()) {
 if (entry.getkey().startswith("default.")) {
 for (class<?> configuration : entry.getvalue().getconfiguration()) {
  context.register(configuration);
 }
 }
 }
 context.register(propertyplaceholderautoconfiguration.class,
 this.defaultconfigtype);
 context.getenvironment().getpropertysources().addfirst(new mappropertysource(
 this.propertysourcename,
 collections.<string, object> singletonmap(this.propertyname, name)));
 if (this.parent != null) {
 // uses environment from parent as well as beans
 context.setparent(this.parent);
 }
 context.refresh();
 return context;
 }
}

public class ribbonloadbalancerclient implements loadbalancerclient {
@override
 public <t> t execute(string serviceid, loadbalancerrequest<t> request) throws ioexception {
 iloadbalancer loadbalancer = getloadbalancer(serviceid); //获取对应的loadbalancer
 server server = getserver(loadbalancer); //获取服务器，这里会执行对应的分流策略，比如轮训
  //、随机等
 if (server == null) {
 throw new illegalstateexception("no instances available for " + serviceid);
 }
 ribbonserver ribbonserver = new ribbonserver(serviceid, server, issecure(server,
 serviceid), serverintrospector(serviceid).getmetadata(server));
 
 return execute(serviceid, ribbonserver, request);
 }
}

protected server getserver(iloadbalancer loadbalancer) {
 if (loadbalancer == null) {
 return null;
 }
  // 选择对应的服务器
 return loadbalancer.chooseserver("default"); // todo: better handling of key
 }
public class zoneawareloadbalancer<t extends server> extends dynamicserverlistloadbalancer<t> {
@override
 public server chooseserver(object key) {
  if (!enabled.get() || getloadbalancerstats().getavailablezones().size() <= 1) {
   logger.debug("zone aware logic disabled or there is only one zone");
   return super.chooseserver(key); //默认不配置可用区，走的是这段
  }
  server server = null;
  try {
   loadbalancerstats lbstats = getloadbalancerstats();
   map<string, zonesnapshot> zonesnapshot = zoneavoidancerule.createsnapshot(lbstats);
   logger.debug("zone snapshots: {}", zonesnapshot);
   if (triggeringload == null) {
  triggeringload = dynamicpropertyfactory.getinstance().getdoubleproperty(
    "zoneawareniwsdiscoveryloadbalancer." + this.getname() + ".triggeringloadperserverthreshold", 0.2d);
   }
 
   if (triggeringblackoutpercentage == null) {
  triggeringblackoutpercentage = dynamicpropertyfactory.getinstance().getdoubleproperty(
    "zoneawareniwsdiscoveryloadbalancer." + this.getname() + ".avoidzonewithblackoutpercetage", 0.99999d);
   }
   set<string> availablezones = zoneavoidancerule.getavailablezones(zonesnapshot, triggeringload.get(), triggeringblackoutpercentage.get());
   logger.debug("available zones: {}", availablezones);
   if (availablezones != null && availablezones.size() < zonesnapshot.keyset().size()) {
  string zone = zoneavoidancerule.randomchoosezone(zonesnapshot, availablezones);
  logger.debug("zone chosen: {}", zone);
  if (zone != null) {
   baseloadbalancer zoneloadbalancer = getloadbalancer(zone);
   server = zoneloadbalancer.chooseserver(key);
  }
   }
  } catch (exception e) {
   logger.error("error choosing server using zone aware logic for load balancer={}", name, e);
  }
  if (server != null) {
   return server;
  } else {
   logger.debug("zone avoidance logic is not invoked.");
   return super.chooseserver(key);
  }
 }
 
 //实际走到的方法
 public server chooseserver(object key) {
  if (counter == null) {
   counter = createcounter();
  }
  counter.increment();
  if (rule == null) {
   return null;
  } else {
   try {
  return rule.choose(key);
   } catch (exception e) {
  logger.warn("loadbalancer [{}]: error choosing server for key {}", name, key, e);
  return null;
   }
  }
 }
}

public interface irule{
 
 public server choose(object key);
 
 public void setloadbalancer(iloadbalancer lb);
 
 public iloadbalancer getloadbalancer(); 
}

public class baseloadbalancer extends abstractloadbalancer implements
  primeconnections.primeconnectionlistener, iclientconfigaware {
 public baseloadbalancer() {
  this.name = default_name;
  this.ping = null;
  setrule(default_rule); // 这里会设置irule的loadbalancer
  setuppingtask();
  lbstats = new loadbalancerstats(default_name);
 }
}