//RestTemplate的getForObject还是其他方法,最终调用的都是该方法
	protected <T> T doExecute(URI url, @Nullable HttpMethod method, @Nullable RequestCallback requestCallback,
			@Nullable ResponseExtractor<T> responseExtractor) throws RestClientException {
	    ...		
		ClientHttpResponse response = null;
		try {
		   //创建请求对象--ClientHttpRequest只提供了一个execute接口,该接口完成具体请求执行过程
		   //该接口分别有UrlConnection,HttpClient,OkHttp相关支持的实现类
			ClientHttpRequest request = createRequest(url, method);
			 ...
			 //执行请求
			response = request.execute();
			//处理返回结果的过程
			handleResponse(url, method, response);
			return (responseExtractor != null ? responseExtractor.extractData(response) : null);
		}
		... 
	}

	protected ClientHttpRequest createRequest(URI url, HttpMethod method) throws IOException {
	    //获取ClientHttpRequestFactory来创建具体的请求对象
		ClientHttpRequest request = getRequestFactory().createRequest(url, method);
		initialize(request);
		if (logger.isDebugEnabled()) {
			logger.debug("HTTP " + method.name() + " " + url);
		}
		return request;
	}

	@Override
	public ClientHttpRequestFactory getRequestFactory() {
	    //如果我们设置了请求拦截器--那么就使用interceptingRequestFactory对原始请求工厂和请求对象进行包装
		List<ClientHttpRequestInterceptor> interceptors = getInterceptors();
		if (!CollectionUtils.isEmpty(interceptors)) {
			ClientHttpRequestFactory factory = this.interceptingRequestFactory;
			if (factory == null) {
				factory = new InterceptingClientHttpRequestFactory(super.getRequestFactory(), interceptors);
				this.interceptingRequestFactory = factory;
			}
			return factory;
		}
		//如果没有设置拦截器,那么返回原始的请求工厂
		else {
			return super.getRequestFactory();
		}
	}

public class InterceptingClientHttpRequestFactory extends AbstractClientHttpRequestFactoryWrapper {
	private final List<ClientHttpRequestInterceptor> interceptors;
	public InterceptingClientHttpRequestFactory(ClientHttpRequestFactory requestFactory,
			@Nullable List<ClientHttpRequestInterceptor> interceptors) {
		super(requestFactory);
		this.interceptors = (interceptors != null ? interceptors : Collections.emptyList());
	}

	@Override
	protected ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod, ClientHttpRequestFactory requestFactory) {
	    //最终包装行为体现在InterceptingClientHttpRequest中
		return new InterceptingClientHttpRequest(requestFactory, this.interceptors, uri, httpMethod);
	}
}

class InterceptingClientHttpRequest extends AbstractBufferingClientHttpRequest {
    //原始的请求工厂和请求相关信息
	private final ClientHttpRequestFactory requestFactory;
	private HttpMethod method;
	private URI uri;
	//请求拦截器链
	private final List<ClientHttpRequestInterceptor> interceptors;
	...
	@Override
	protected final ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput) throws IOException {
	    //InterceptingRequestExecution是拦截器链模式的体现
		InterceptingRequestExecution requestExecution = new InterceptingRequestExecution();
		return requestExecution.execute(this, bufferedOutput);
	}


	private class InterceptingRequestExecution implements ClientHttpRequestExecution {
		private final Iterator<ClientHttpRequestInterceptor> iterator;
		public InterceptingRequestExecution() {
			this.iterator = interceptors.iterator();
		}
        //注意: 我们可以在拦截器中调用InterceptingRequestExecution的execute方法回到拦截器链继续往下执行,也可以
        //不调用,终止拦截器链的执行
		@Override
		public ClientHttpResponse execute(HttpRequest request, byte[] body) throws IOException {
		    //先将拦截器执行完毕
			if (this.iterator.hasNext()) {
				ClientHttpRequestInterceptor nextInterceptor = this.iterator.next();
				return nextInterceptor.intercept(request, body, this);
			}
			//执行完拦截器再利用原始的请求工厂创建出对应的请求对象,然后执行请求,返回结果
			else {
			     ... 
				ClientHttpRequest delegate = requestFactory.createRequest(request.getURI(), method);
				...
				return delegate.execute();
			}
		}
	}
}

public class LoadBalancerInterceptor implements ClientHttpRequestInterceptor {

	private LoadBalancerClient loadBalancer;

	private LoadBalancerRequestFactory requestFactory;

	public LoadBalancerInterceptor(LoadBalancerClient loadBalancer,
			LoadBalancerRequestFactory requestFactory) {
		this.loadBalancer = loadBalancer;
		this.requestFactory = requestFactory;
	}

	public LoadBalancerInterceptor(LoadBalancerClient loadBalancer) {
		this(loadBalancer, new LoadBalancerRequestFactory(loadBalancer));
	}

	@Override
	public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
			final ClientHttpRequestExecution execution) throws IOException {
	    //获取到请求的URI		
		final URI originalUri = request.getURI();
		//获取主机名: 这里主机名可能是服务名,我们需要将其转换为对应服务的真实地址
		String serviceName = originalUri.getHost();
		//由客户端负载均衡器LoadBalancerClient根据服务名转换为真实服务地址,然后执行请求
		return this.loadBalancer.execute(serviceName,
				this.requestFactory.createRequest(request, body, execution));
	}
}

public class LoadBalancerRequestFactory {
	private LoadBalancerClient loadBalancer;
	private List<LoadBalancerRequestTransformer> transformers;
     ...
	public LoadBalancerRequest<ClientHttpResponse> createRequest(
			final HttpRequest request, final byte[] body,
			final ClientHttpRequestExecution execution) {
	    //返回一个LoadBalancerRequest实例对象,注意LoadBalancerRequest是函数式接口	
		return instance -> {
		    //ServiceRequestWrapper对象主要负责重新请求对象的getUri方法,返回服务名被替换为服务真实ip地址后的URI
			HttpRequest serviceRequest = new ServiceRequestWrapper(request, instance,
					this.loadBalancer);
		    //回调接口,可以对请求进行修改			
			if (this.transformers != null) {
				for (LoadBalancerRequestTransformer transformer : this.transformers) {
					serviceRequest = transformer.transformRequest(serviceRequest,
							instance);
				}
			}
			//URI替换完成后,继续交由原始请求对象执行请求，当然拦截器链如果还存在其他拦截器还需要继续执行
			return execution.execute(serviceRequest, body);
		};
	}
}

public interface LoadBalancerRequest<T> {
	T apply(ServiceInstance instance) throws Exception;
}

public class ServiceRequestWrapper extends HttpRequestWrapper {
	private final ServiceInstance instance;
	private final LoadBalancerClient loadBalancer;
     ...
     //核心是重写getURI,完成服务名到服务真实IP地址的替换
	@Override
	public URI getURI() {
		URI uri = this.loadBalancer.reconstructURI(this.instance, getRequest().getURI());
		return uri;
	}
}

//serviceId这里就是服务名--application-name
public interface LoadBalancerClient extends ServiceInstanceChooser {
	<T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException;
	<T> T execute(String serviceId, ServiceInstance serviceInstance,
			LoadBalancerRequest<T> request) throws IOException;
	URI reconstructURI(ServiceInstance instance, URI original);
}

public interface ServiceInstanceChooser {
	ServiceInstance choose(String serviceId);
}

//客户端负载均衡器会根据服务名寻找到一批具体的服务实例列表
//服务实例列表中封装了当前服务的具体ip,port,是否采用https进行通信等信息
public interface ServiceInstance {
	default String getInstanceId() {
		return null;
	}
	String getServiceId();
	String getHost();
	int getPort();
	boolean isSecure();
	URI getUri();
	Map<String, String> getMetadata();
	default String getScheme() {
		return null;
	}
}

	@Override
	public <T> T execute(String serviceId, LoadBalancerRequest<T> request)
			throws IOException {
		return execute(serviceId, request, null);
	}
	
	public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint)
			throws IOException {
		//1.根据服务名获取到对应的服务实例列表--ILoadBalancer负责管理服务实例列表
		ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
		//2.利用负载均衡算法从服务实例列表取出一个服务实例--server是ribbon提供的对服务实例信息封装的类
		Server server = getServer(loadBalancer, hint);
		if (server == null) {
			throw new IllegalStateException("No instances available for " + serviceId);
		}
		//3.RibbonServer继承至ServerInstance接口--将server信息适配到springcloud规定获取服务实例信息的接口上
		RibbonServer ribbonServer = new RibbonServer(serviceId, server,
				isSecure(server, serviceId),
				serverIntrospector(serviceId).getMetadata(server));
        //4.执行请求
		return execute(serviceId, ribbonServer, request);
	}

//ribbon提供的对于服务实例进行管理的类
public interface ILoadBalancer {
    //添加服务实例
	public void addServers(List<Server> newServers);
	//负责根据负责均衡算法选择一个合适的服务实例
	public Server chooseServer(Object key);
	//标记某个实例服务下线
	public void markServerDown(Server server);
	@Deprecated
	public List<Server> getServerList(boolean availableOnly);
	//只获取未下线的服务实例
    public List<Server> getReachableServers();
	public List<Server> getAllServers();
}

	protected ILoadBalancer getLoadBalancer(String serviceId) {
	    //clientFactory即SpringClientFactory负责根据服务名寻找到服务实例列表
	    //SpringClientFactory是ribbon提供的继承NamedContextFactory
		return this.clientFactory.getLoadBalancer(serviceId);
	}