Eurkea,Ribbon和RestTemplate是如何结合到一起完成服务注册与发现功能的? --下

	public interface Specification {
	    //该Specification返回的配置类是否只放入对应服务的子容器中,这是name是服务名
		String getName();
		//该Specification返回的配置类
		Class<?>[] getConfiguration();
	}

	public <T> T getInstance(String name, Class<T> type) {
		//每个服务名都对应一个子容器,根据服务名获取对应的子容器
		AnnotationConfigApplicationContext context = getContext(name);
		try {
		   //去当前子容器中获取对应包装服务实例列表的bean,这里的bean类型不固定
			return context.getBean(type);
		}
		catch (NoSuchBeanDefinitionException e) {
			// ignore
		}
		return null;
	}

	protected AnnotationConfigApplicationContext getContext(String name) {
	    //DOUBLE CHECK确保多线程下对添加缓存操作实现的原子性
		if (!this.contexts.containsKey(name)) {
			synchronized (this.contexts) {
				if (!this.contexts.containsKey(name)) {
					this.contexts.put(name, createContext(name));
				}
			}
		}
		return this.contexts.get(name);
	}

	protected AnnotationConfigApplicationContext createContext(String name) {
	    //创建子容器
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
		//如果我们手动设置了针对某个服务名单独提供的配置类，那么会首先被加入到当前服务名关联的子容器中
		//这里的configurations是NamedContextFactory内部的Specification列表
		if (this.configurations.containsKey(name)) {
			for (Class<?> configuration : this.configurations.get(name)
					.getConfiguration()) {
				context.register(configuration);
			}
		}
		//如果Specification返回的name以default开头,那么默认对所有服务名生效
		//即返回的配置类会添加到每个服务名对应的子容器中
		for (Map.Entry<String, C> entry : this.configurations.entrySet()) {
			if (entry.getKey().startsWith("default.")) {
				for (Class<?> configuration : entry.getValue().getConfiguration()) {
					context.register(configuration);
				}
			}
		}
		//PropertyPlaceholderAutoConfiguration负责加载解析占位符和el表达式的bean
		context.register(PropertyPlaceholderAutoConfiguration.class,
		//向当前服务子容器中注入与当前客户端负载均衡器相关的默认配置类
		//如果是ribbon,这里默认加载的是RibbonClientConfiguration配置类
				this.defaultConfigType);
		//向子容器环境上下文中添加当前负载均衡器的相关属性
		//如果采用的是ribbon作为客户端负载均衡器		
		context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(
				//key为: ribbon
				this.propertySourceName,
				//value是一个map: 该map默认存放一个键值对，key为: ribbon.client.name value为: 服务名
				Collections.<String, Object>singletonMap(this.propertyName, name)));
		//设置当前容器为子容器的父容器		
		if (this.parent != null) {
			context.setParent(this.parent);
			context.setClassLoader(this.parent.getClassLoader());
		}
		//设置当前子容器展示名
		context.setDisplayName(generateDisplayName(name));
		//刷新容器,注册到容器中的配置类在这一步被解析
		context.refresh();
		return context;
	}

@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER,
		ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Value("${ribbon.client.name}")
public @interface RibbonClientName {
}

@Configuration(proxyBeanMethods = false)
public class EurekaRibbonClientConfiguration {
    ....
    //@RibbonClientName上面已经给出了,本质是从当前子容器的IOC环境中使用ribbon.client.name作为key,去取出对应的value
    //也就是说,这里serviceId,拿到的是createContext创建子容器方法中放入子容器环境上下文中的服务名
	@RibbonClientName
	private String serviceId = "client";
    //Eureka相关配置类
	@Autowired(required = false)
	private EurekaClientConfig clientConfig;
	@Autowired(required = false)
	private EurekaInstanceConfig eurekaConfig;
	@Autowired
	private PropertiesFactory propertiesFactory;
    ...
	@Bean
	@ConditionalOnMissingBean
	public ServerList<?> ribbonServerList(IClientConfig config,
	       //拿到Eureka客户端
			Provider<EurekaClient> eurekaClientProvider) {
	    //先查缓存,如果有直接返回		
		if (this.propertiesFactory.isSet(ServerList.class, serviceId)) {
			return this.propertiesFactory.get(ServerList.class, config, serviceId);
		}
		//DomainExtractingServerList由于内部组合了EurekaClient,所以不用想也知道
		//是根据EurekaClient请求EurekaServer获取到服务实例列表
		DiscoveryEnabledNIWSServerList discoveryServerList = new DiscoveryEnabledNIWSServerList(
				config, eurekaClientProvider);
		DomainExtractingServerList serverList = new DomainExtractingServerList(
				discoveryServerList, config, this.approximateZoneFromHostname);
		return serverList;
	}
	...
}

		//PropertyPlaceholderAutoConfiguration负责加载解析占位符和el表达式的bean
		context.register(PropertyPlaceholderAutoConfiguration.class,
		//向当前服务子容器中注入与当前客户端负载均衡器相关的默认配置类
		//如果是ribbon,这里默认加载的是RibbonClientConfiguration配置类
				this.defaultConfigType);

	@Bean
	@ConditionalOnMissingBean
	public ILoadBalancer ribbonLoadBalancer(IClientConfig config,
	        //获取到当前容器中的serverList列表实例
			ServerList<Server> serverList, ServerListFilter<Server> serverListFilter,
			IRule rule, IPing ping, ServerListUpdater serverListUpdater) {
		if (this.propertiesFactory.isSet(ILoadBalancer.class, name)) {
			return this.propertiesFactory.get(ILoadBalancer.class, config, name);
		}
		//将服务列表实例信息交给ZoneAwareLoadBalancer进行管理
		return new ZoneAwareLoadBalancer<>(config, rule, ping, serverList,
				serverListFilter, serverListUpdater);
	}

	public <T> T getInstance(String name, Class<T> type) {
		AnnotationConfigApplicationContext context = getContext(name);
		try {
		    //可以从容器中获取到类型为ILoadBalancer的负载均衡器了
			return context.getBean(type);
		}
		catch (NoSuchBeanDefinitionException e) {
			// ignore
		}
		return null;
	}

@Configuration(proxyBeanMethods = false)
@ConditionalOnRibbonNacos
public class NacosRibbonClientConfiguration {

	@Autowired
	private PropertiesFactory propertiesFactory;

	@Bean
	@ConditionalOnMissingBean
	public ServerList<?> ribbonServerList(IClientConfig config,
			NacosDiscoveryProperties nacosDiscoveryProperties) {
		//针对服务做特定配置的--下面会将	
		if (this.propertiesFactory.isSet(ServerList.class, config.getClientName())) {
			ServerList serverList = this.propertiesFactory.get(ServerList.class, config,
					config.getClientName());
			return serverList;
		}
		//注入的是NacosServerList 
		NacosServerList serverList = new NacosServerList(nacosDiscoveryProperties);
		//设置服务名
		serverList.initWithNiwsConfig(config);
		return serverList;
	}

	@Bean
	@ConditionalOnMissingBean
	public NacosServerIntrospector nacosServerIntrospector() {
		return new NacosServerIntrospector();
	}

}

public class NacosServerList extends AbstractServerList<NacosServer> {

	private NacosDiscoveryProperties discoveryProperties;

	private String serviceId;

	public NacosServerList(NacosDiscoveryProperties discoveryProperties) {
		this.discoveryProperties = discoveryProperties;
	}

	@Override
	public List<NacosServer> getInitialListOfServers() {
		return getServers();
	}

	@Override
	public List<NacosServer> getUpdatedListOfServers() {
		return getServers();
	}

	private List<NacosServer> getServers() {
		try {
		    //分组信息
			String group = discoveryProperties.getGroup();
			List<Instance> instances = discoveryProperties.namingServiceInstance()
					//通过服务名,分组去查询对应的真实服务实例列表了
					.selectInstances(serviceId, group, true);
			return instancesToServerList(instances);
		}
		catch (Exception e) {
			throw new IllegalStateException(
					"Can not get service instances from nacos, serviceId=" + serviceId,
					e);
		}
	}

	private List<NacosServer> instancesToServerList(List<Instance> instances) {
		List<NacosServer> result = new ArrayList<>();
		if (CollectionUtils.isEmpty(instances)) {
			return result;
		}
		for (Instance instance : instances) {
			result.add(new NacosServer(instance));
		}

		return result;
	}

	public String getServiceId() {
		return serviceId;
	}

	@Override
	public void initWithNiwsConfig(IClientConfig iClientConfig) {
		this.serviceId = iClientConfig.getClientName();
	}

}

@Configuration(proxyBeanMethods = false)
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE })
@Documented
@Import(RibbonClientConfigurationRegistrar.class)
public @interface RibbonClients {
	RibbonClient[] value() default {};
	Class<?>[] defaultConfiguration() default {};
}

public interface ServerList<T extends Server> {
    public List<T> getInitialListOfServers();
    public List<T> getUpdatedListOfServers();   
}

public interface ServerIntrospector {
	boolean isSecure(Server server);
	Map<String, String> getMetadata(Server server);
}

	public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint)
			throws IOException {
	    //我们此时已经成功根据服务名获取到了对应的客户端负载均衡器		
		ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
		//下一步就是根据负载均衡器挑选一个可用服务实例
		Server server = getServer(loadBalancer, hint);
		...
		return execute(serviceId, ribbonServer, request);
	}

	protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
		...
		return loadBalancer.chooseServer(hint != null ? hint : "default");
	}

    @Override
    public Server chooseServer(Object key) {
        //如果zone只存在一个,那么调用父类方法正常选择一个可用服务实例
        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;
        ...
                //随机选择一个zone
                String zone = ZoneAvoidanceRule.randomChooseZone(zoneSnapshot, availableZones);
                ...
                //然后从该zone下的serverList中挑选出一个可用的server
                if (zone != null) {
                    BaseLoadBalancer zoneLoadBalancer = getLoadBalancer(zone);
                    server = zoneLoadBalancer.chooseServer(key);
                }
        ...
        return server;
    }

    public Server chooseServer(Object key) {
        if (counter == null) {
            counter = createCounter();
        }
        counter.increment();
        if (rule == null) {
            return null;
        } else {
            try {
                //具体采用何种负载均衡算法,取决于Rule的实现
                return rule.choose(key);
            } catch (Exception e) {
                logger.warn("LoadBalancer [{}]:  Error choosing server for key {}", name, key, e);
                return null;
            }
        }
    }

userservice:
  ribbon:
    NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule  # 负载均衡规则

public class PropertiesFactory {

	@Autowired
	private Environment environment;
     
    //我们可以对哪些组件按照服务的不同进行特殊指定，如果要指定，又如何标识我指定的是哪个组件呢？ 
	private Map<Class, String> classToProperty = new HashMap<>();
	public PropertiesFactory() {
		classToProperty.put(ILoadBalancer.class, "NFLoadBalancerClassName");
		classToProperty.put(IPing.class, "NFLoadBalancerPingClassName");
		classToProperty.put(IRule.class, "NFLoadBalancerRuleClassName");
		classToProperty.put(ServerList.class, "NIWSServerListClassName");
		classToProperty.put(ServerListFilter.class, "NIWSServerListFilterClassName");
	}
    
    //检查当前容器的环境变量中是否存在userservice.ribbon.NFLoadBalancerRuleClassName的key
    //如果存在,说明针对userservice服务的IRule实现进行1
	public boolean isSet(Class clazz, String name) {
		return StringUtils.hasText(getClassName(clazz, name));
	}

	public String getClassName(Class clazz, String name) {
		if (this.classToProperty.containsKey(clazz)) {
			String classNameProperty = this.classToProperty.get(clazz);
			//userservice.ribbon.NFLoadBalancerRuleClassName
			//val就是我们指定的IRule实现类全类名
			String className = environment
					.getProperty(name + "." + NAMESPACE + "." + classNameProperty);
			return className;
		}
		return null;
	}

    //实例化对应的组件
	public <C> C get(Class<C> clazz, IClientConfig config, String name) {
		String className = getClassName(clazz, name);
		if (StringUtils.hasText(className)) {
			try {
				Class<?> toInstantiate = Class.forName(className);
				return (C) SpringClientFactory.instantiateWithConfig(toInstantiate,
						config);
			}
			catch (ClassNotFoundException e) {
				throw new IllegalArgumentException("Unknown class to load " + className
						+ " for class " + clazz + " named " + name);
			}
		}
		return null;
	}

}

	public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint)
			throws IOException {
		ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
		Server server = getServer(loadBalancer, hint);
		if (server == null) {
			throw new IllegalStateException("No instances available for " + serviceId);
		}
		//RibbonServer是ServiceInstance的子类，包装一个具体的服务实例信息
		RibbonServer ribbonServer = new RibbonServer(serviceId, server,
				isSecure(server, serviceId),
				serverIntrospector(serviceId).getMetadata(server));
        //执行请求
		return execute(serviceId, ribbonServer, request);
	}

	public <T> T execute(String serviceId, ServiceInstance serviceInstance,
			LoadBalancerRequest<T> request) throws IOException {
		...
		    //执行请求,返回结果
			T returnVal = request.apply(serviceInstance);
	   ...
			return returnVal;
		...
	}