【微服务】Ribbon的实现原理

1、场景：这里有两个服务，user-server和store-server

1.1、user服务

接口：

package com.lkx.user.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;


/**
 * @Author: lkx
 * @Date: 2023/8/23/13:20
 * @Description:
 */
@RestController
public class UserController {

    @GetMapping("/testUser")
    public Object testUser() {
        return "HelloWorld";
    }
}

1.2、store服务

配置类：

package com.lkx.store.config;

import org.springframework.boot.SpringBootConfiguration;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.web.client.RestTemplate;

/**
 * @Author: lkx
 * @Date: 2023/8/23/13:18
 * @Description:
 */
@SpringBootConfiguration
@ComponentScan(basePackages = {"com.lkx.store"})
public class AppConfig {


    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

接口：

package com.lkx.store.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;


/**
 * @Author: lkx
 * @Date: 2023/8/23/13:20
 * @Description:
 */
@RestController
public class StoreController {

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/testStore")
    public Object testStore() {
    	 /**
         * 原生调用方式实际上存在一种问题
         * 每多一次新地址的调用 都要维护一个全地址 这样维护起来相对就比较复杂了
         *
         * Ribbon ：这个组件实际上就是为了来做服务的发现的
         * Ribbon最终服务的调用还是使用的是  restTemplate
    	 */
    	// 原生调用
        return restTemplate.getForObject("http://192.168.230.1:8081/testUser",String.class);
        // Ribbon调用
//        return restTemplate.getForObject("http://user-server/testUser",String.class);
    }
}

代码中，store服务通过url（ip地址加端口/方法）去调用user服务的接口，这是原生的调用方式。可以成功调用。Ribbon调用通过服务名称也可成功.

2、Ribbon的实现原理。

  解释：两个服务启动时，会将自己的服务名称，以及IP地址和端口注册到注册中心，当有服务调用时，就会拉取注册中心的注册表，里面包含了所有的注册信息。当我们使用Ribbon方式去调用其他服务时，ribbon的拦截器会拦截请求，然后根据拉取到的注册信息，去找到服务名称对应的ip地址和端口，然后重组请求地址，最后以原生的RestTemplate方式去实现服务的调用。

3、源码跟踪

配置类中，我们在设置Bean RestTemplate时，加了一个注解@LoadBalanced。这个注解尤为重要，它就是Ribbon实现原理最为重要的一环。

@LoadBalanced 源码：

/*
 * Copyright 2013-2015 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.cloud.client.loadbalancer;

import org.springframework.beans.factory.annotation.Qualifier;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Annotation to mark a RestTemplate bean to be configured to use a LoadBalancerClient.
 * @author Spencer Gibb
 */
@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Qualifier
public @interface LoadBalanced {
}

这里的解释翻译是：标记一个RestTemplate bean来配置使用LoadBalancerClient。那么，这个LoadBalancerClient是什么呢？

/*
 * Copyright 2013-2015 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.cloud.client.loadbalancer;

import org.springframework.cloud.client.ServiceInstance;

import java.io.IOException;
import java.net.URI;

/**
 * Represents a client-side load balancer.
 * @author Spencer Gibb
 */
public interface LoadBalancerClient extends ServiceInstanceChooser {

	/**
	 * Executes request using a ServiceInstance from the LoadBalancer for the specified
	 * service.
	 * @param serviceId The service ID to look up the LoadBalancer.
	 * @param request Allows implementations to execute pre and post actions, such as
	 * incrementing metrics.
	 * @return The result of the LoadBalancerRequest callback on the selected
	 * ServiceInstance.
	 */
	<T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException;

	/**
	 * Executes request using a ServiceInstance from the LoadBalancer for the specified
	 * service.
	 * @param serviceId The service ID to look up the LoadBalancer.
	 * @param serviceInstance The service to execute the request to.
	 * @param request Allows implementations to execute pre and post actions, such as
	 * incrementing metrics.
	 * @return The result of the LoadBalancerRequest callback on the selected
	 * ServiceInstance.
	 */
	<T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) throws IOException;

	/**
	 * Creates a proper URI with a real host and port for systems to utilize.
	 * Some systems use a URI with the logical service name as the host,
	 * such as http://myservice/path/to/service.  This will replace the
	 * service name with the host:port from the ServiceInstance.
	 * @param instance
	 * @param original A URI with the host as a logical service name.
	 * @return A reconstructed URI.
	 */
	URI reconstructURI(ServiceInstance instance, URI original);
}

翻译一下注释：Represents a client-side load balancer.这是一个客户端负载平衡器。而@LoadBalanced注解标记的RestTemplate就是来配置这个平衡器的，这里我们就需要找到这个配置类，同文件夹下有一个LoadBalancerAutoConfiguration，给它的解释是功能区的自动配置（客户端负载平衡）

	@Configuration
	@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
	static class LoadBalancerInterceptorConfig {
		@Bean
		public LoadBalancerInterceptor ribbonInterceptor(
				LoadBalancerClient loadBalancerClient,
				LoadBalancerRequestFactory requestFactory) {
			return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
		}

		@Bean
		@ConditionalOnMissingBean
		public RestTemplateCustomizer restTemplateCustomizer(
				final LoadBalancerInterceptor loadBalancerInterceptor) {
			return restTemplate -> {
                List<ClientHttpRequestInterceptor> list = new ArrayList<>(
                        restTemplate.getInterceptors());
                list.add(loadBalancerInterceptor);
                restTemplate.setInterceptors(list);
            };
		}
	}

而在这个配置类里就有我们的ribbon的拦截器设置了。然后进入LoadBalancerInterceptor拦截器,通过拦截器的执行代码，然后到RibbonLoadBalancerClient的execute方法，这个方法就是通过我们的key来找到对应的服务器去执行请求，后面方法太多，就不一 一叙述，最后发现，最底层调用的还是原生的请求去实现调用的。