Spring Cloud 微服务实战系列-Ribbon整合RestTemplate实现负载均衡

灰太狼 2022-12-29 01:47 103阅读 0赞

> **导语**  
>   在Spring Cloud项目中想要整合Ribbon只需要在pom文件中加入对应的依赖就可以了，那么在这次的分享中就来看看在Ribbon怎么通过RestTemplate来进行负载均衡，以及扩展的说明一下其他的一些存在的问题。

### 文章目录 ###

*   *  整合Ribbon
     *  RestTemplate负载均衡小例子
     *  @LoadBalanced注解的原理
     *  总结

## 整合Ribbon ##

需要整合Ribbon只需要在Pom文件中加入如下的操作

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.1.RELEASE</version>
        </parent>
    
        <groupId>com.nihui.springcloud.resttemplate_ribbon_consumer</groupId>
        <artifactId>rest-template-ribbon-consumer</artifactId>
        <version>1.0-SNAPSHOT</version>
    
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
                <version>2.1.1.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-netflix-ribbon</artifactId>
            </dependency>
    
        </dependencies>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Finchley.SR2</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
    
    </project>

## RestTemplate负载均衡小例子 ##

在之前的分享中，都是通过具体的服务器接口来进行调用的，那么怎么通过RestTemplate结合Eureka来进行服务发现的负载均衡呢？这里首先要做的一件事情就是修改RestTemplate的配置，让其能有负载均衡的能力，这个时候就需要用到一个注解就是@LoadBalanced，如下。

@Configuration
    public class BeanConfiguration { 
    
        @Bean
        @LoadBalanced
        public RestTemplate getRestTemplate(){ 
            return  new RestTemplate();
        }
    }

这个时候就可以将对应的数据请求地址改成对应的服务名称的形式，如下

@GetMapping("/call/data")
        public HouseInfo getData(@RequestParam("name") String name){ 
    // return restTemplate.getForObject("http://localhost:8081/house/data?name="+name,HouseInfo.class);
            return restTemplate.getForObject("http://eureka-client-house-service/house/data?name="+name,HouseInfo.class);
        }

那么这个时候，在接口调用的时候，框架的内部就会将服务名称替换成所对应的IP信息，然后对其进行调用。

## @LoadBalanced注解的原理 ##

在这里，我们知道@LoadBalanced注解是用来解决负载均衡的，那么它是如何解决这个棘手的负载均衡的问题呢？  
  在Spring Cloud的底层做了大量的工作，因为它们都是封装好的东西，所以用起来才会觉得Spring框架很简单，Spring框架对于Java的发展有着很大的推动作用。那么它到底是如何工作呢？在Spring MVC的时候我们有过一个拦截器的概念，那么在这里的实现逻辑就是通过RestTemplate增加拦截器来实现的，也就是说在请求之前对请求地址进行前置的一个解析操作，或者是根据具体的路由负载均衡策略来实现服务地址的选择，然后在进行调用，这个就是@LoadBalanced的简单的一个原理。  
  在下面的就来看看如何实现一个自定义的拦截器代码如下

public class MyLoadBalancerInterceptor implements ClientHttpRequestInterceptor { 
    
        private LoadBalancerClient loadBalancer;
    
        private LoadBalancerRequestFactory requestFactory;
    
    
    
        public MyLoadBalancerInterceptor(LoadBalancerClient loadBalancer, LoadBalancerRequestFactory requestFactory){ 
            this.loadBalancer = loadBalancer;
            this.requestFactory = requestFactory;
        }
    
        public MyLoadBalancerInterceptor(LoadBalancerClient loadBalancer){ 
            this(loadBalancer,new LoadBalancerRequestFactory(loadBalancer));
        }
    
        public MyLoadBalancerInterceptor(){ 
    
        }
    
        @Override
        public ClientHttpResponse intercept(final HttpRequest request, final byte[] body, final ClientHttpRequestExecution execution) throws IOException { 
            final URI originalUri = request.getURI();
            String serviceName = originalUri.getHost();
            System.out.println("进入自定义的请求拦截器中"+serviceName);
            Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
            return this.loadBalancer.execute(serviceName,requestFactory.createRequest(request,body,execution));
        }
    }

当然配置完成之后在来定义一个自己的负载均衡的注解，代码如下

@Target({ ElementType.FIELD,ElementType.PARAMETER,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @Qualifier
    public @interface MyLoadBalanced { 
    }

根据Spring Boot的原理，想要将这个拦截器自动注入的容器中，就必须来进行一个自动注入的操作，如下

/** * @Classname MyLoadBalancerAutoConfiguration * @Description TODO * @Date 2019/11/26 9:45 AM * @Created by nihui */
    @Configuration
    public class MyLoadBalancerAutoConfiguration { 
    
    
        @MyLoadBalanced
        @Autowired(required = false)
        private List<RestTemplate> restTemplates = Collections.emptyList();
    
    
        @Bean
        public MyLoadBalancerInterceptor myLoadBalancerInterceptor(){ 
            return new MyLoadBalancerInterceptor();
        }
    
        @Bean
        public SmartInitializingSingleton myLoadBalancedRestTemplateInitializer(){ 
            return new SmartInitializingSingleton() { 
                @Override
                public void afterSingletonsInstantiated() { 
                    for (RestTemplate restTemplate:MyLoadBalancerAutoConfiguration.this.restTemplates){ 
                        List<ClientHttpRequestInterceptor> list = new ArrayList<>(restTemplate.getInterceptors());
                        list.add(myLoadBalancerInterceptor());
                        restTemplate.setInterceptors(list);
                    }
                }
            };
        }
    
    }

首先维护一个@MyLoadBalanced的RestTemplate的列表，在SmartInitializingSingleton 中对这个RestTemplate列表进行拦截器的设置，对于拦截器来说主要用到的Java设计模式就是责任链模式。那么这个时候就可以将上面的配置类上的信息改成自定义的负载均衡注解了。

重启服务之后就可以看到控制台输出的是自定义的请求拦截器。

通过上面的这个小例子，就可以很清楚的理解了@LoadBalanced的工作原理，这里简单的来看一下具体的Spring Cloud提供的内容，首先根据上面的分析应该有一个对应的自动注入的类。

@Configuration
    @ConditionalOnClass(RestTemplate.class)
    @ConditionalOnBean(LoadBalancerClient.class)
    @EnableConfigurationProperties(LoadBalancerRetryProperties.class)
    public class LoadBalancerAutoConfiguration { 
    
    	@LoadBalanced
    	@Autowired(required = false)
    	private List<RestTemplate> restTemplates = Collections.emptyList();
    
    	@Bean
    	public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated(
    			final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) { 
    		return () -> restTemplateCustomizers.ifAvailable(customizers -> { 
                for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) { 
                    for (RestTemplateCustomizer customizer : customizers) { 
                        customizer.customize(restTemplate);
                    }
                }
            });
    	}
    
    	@Autowired(required = false)
    	private List<LoadBalancerRequestTransformer> transformers = Collections.emptyList();
    
    	@Bean
    	@ConditionalOnMissingBean
    	public LoadBalancerRequestFactory loadBalancerRequestFactory(
    			LoadBalancerClient loadBalancerClient) { 
    		return new LoadBalancerRequestFactory(loadBalancerClient, transformers);
    	}
    
    	@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);
                };
    		}
    	}
    
    	@Configuration
    	@ConditionalOnClass(RetryTemplate.class)
    	public static class RetryAutoConfiguration { 
    
    		@Bean
    		@ConditionalOnMissingBean
    		public LoadBalancedRetryFactory loadBalancedRetryFactory() { 
    			return new LoadBalancedRetryFactory() { };
    		}
    	}
    
    	@Configuration
    	@ConditionalOnClass(RetryTemplate.class)
    	public static class RetryInterceptorAutoConfiguration { 
    		@Bean
    		@ConditionalOnMissingBean
    		public RetryLoadBalancerInterceptor ribbonInterceptor(
    				LoadBalancerClient loadBalancerClient, LoadBalancerRetryProperties properties,
    				LoadBalancerRequestFactory requestFactory,
    				LoadBalancedRetryFactory loadBalancedRetryFactory) { 
    			return new RetryLoadBalancerInterceptor(loadBalancerClient, properties,
    					requestFactory, loadBalancedRetryFactory);
    		}
    
    		@Bean
    		@ConditionalOnMissingBean
    		public RestTemplateCustomizer restTemplateCustomizer(
    				final RetryLoadBalancerInterceptor loadBalancerInterceptor) { 
    			return restTemplate -> { 
                    List<ClientHttpRequestInterceptor> list = new ArrayList<>(
                            restTemplate.getInterceptors());
                    list.add(loadBalancerInterceptor);
                    restTemplate.setInterceptors(list);
                };
    		}
    	}
    }

从上面的代码中可以看到拦截器是用LoadBalancerInterceptor，RestTemplateCustomizer 用来添加拦截器。通过上面得代码的深入的分析可以知道。在createRequest 中通过ServiceRequestWrapper来执行替换URI的逻辑，ServiceRequestWrapper中将URI获取交给了reconstructURI方法。

## 总结 ##

以上的内容就是整个的@LoadBalanced的执行流程，对于更加深入的流程那就要自己看看源码理解Spring Boot的原理进行分析了。有时间博主会在后续的分享中对这段内容进行一个深入的分析。敬请期待。