Ribbon如何在springcloud中使用
Ribbon如何在spring cloud 中使用？相信很多没有经验的人对此束手无策，为此本文总结了问题出现的原因和解决方法，通过这篇文章希望你能解决这个问题。
十余年的徐闻网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。成都营销网站建设的优势是能够根据用户设备显示端的尺寸不同，自动调整徐闻建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联从事“徐闻网站设计”,“徐闻网站推广”以来，每个客户项目都认真落实执行。
基本使用
这里使用基于zookeeper注册中心+ribbon的方式实现一个简单的客户端负载均衡案例。
服务提供方
首先是一个服务提供方。代码如下。
application.properties配置文件
spring.application.name=discovery-service
server.port=0
service-B.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule
bootstrap.properties配置文件
spring.cloud.zookeeper.connect-string=192.168.0.15:2181
引导程序，提供了一个ribbonService的rest接口服务，注册程序到zookeeper中。
@SpringBootApplication
@EnableDiscoveryClient
@RestController
public class DiscoverClient {
public static void main(String[] args) {
SpringApplication.run(DiscoverClient.class, args);
}
@RequestMapping("/ribbonService")
public String ribbonService(){
return "hello too ribbon";
}
}服务调用方
服务调用方就是进行负载均衡的一方，利用ribbo的RestTemplate进行负载调用服务。
RibbonConfig,配置ribbon的RestTemplate，通过@LoadBalanced注解实现，具体原理稍后分析。
@Configuration
public class RibbonConfig {
/**
* 实例化ribbon使用的RestTemplate
* @return
*/
@Bean
@LoadBalanced
public RestTemplate rebbionRestTemplate(){
return new RestTemplate();
}
/**
* 配置随机负载策略，需要配置属性service-B.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule
*/
@Bean
public IRule ribbonRule() {
return new RandomRule();
}
}引导程序
@SpringBootApplication(scanBasePackages = "garine.learn.ribbon.loadblance")
@EnableDiscoveryClient
@RestController
public class TestRibbonApplocation {
public static void main(String[] args) {
SpringApplication.run(TestRibbonApplocation.class, args);
}
@Autowired
@LoadBalanced
RestTemplate restTemplate;
@GetMapping("/{applicationName}/ribbonService")
public String ribbonService(@PathVariable("applicationName") String applicationName){
return restTemplate.getForObject("http://" + applicationName+"/ribbonService", String.class);
}
}配置文件同上，服务名称修改即可。
测试
启动两个discovery-service，由于端口设置为0，所以是随机端口。
启动服务调用方
浏览器访问服务调用方的提供的接口，路径参数需要加上调用的服务名称，例如http://localhost:8080/discovery-service/ribbonService，然后服务调用方使用ribbon的RestTemplate调用服务提供方的接口。
结果返回：hello too ribbon ，同时服务提供方启动的两个服务都可能被调用，取决于怎么配置负载策略。
上面就是一个简单使用ribbon的例子，结合feign使用基本上是做类似上面所写的工作，那么ribbon到底是怎么实现的呢？
原理与源码分析
ribbon实现的关键点是为ribbon定制的RestTemplate，ribbon利用了RestTemplate的拦截器机制，在拦截器中实现ribbon的负载均衡。负载均衡的基本实现就是利用applicationName从服务注册中心获取可用的服务地址列表，然后通过一定算法负载，决定使用哪一个服务地址来进行http调用。
Ribbon的RestTemplate
RestTemplate中有一个属性是List
ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException;
也就是说拦截器需要完成http请求，并封装一个标准的response返回。
ribbon中的拦截器
在Ribbon 中也定义了这样的一个拦截器，并且注入到RestTemplate中，是怎么实现的呢？
在Ribbon实现中，定义了一个LoadBalancerInterceptor,具体的逻辑先不说，ribbon就是通过这个拦截器进行拦截请求，然后实现负载均衡调用。
拦截器定义在org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration.LoadBalancerInterceptorConfig#ribbonInterceptor
@Configuration
@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
static class LoadBalancerInterceptorConfig {
@Bean
//定义ribbon的拦截器
public LoadBalancerInterceptor ribbonInterceptor(
LoadBalancerClient loadBalancerClient,
LoadBalancerRequestFactory requestFactory) {
return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
}
@Bean
@ConditionalOnMissingBean
//定义注入器，用来将拦截器注入到RestTemplate中，跟上面配套使用
public RestTemplateCustomizer restTemplateCustomizer(
final LoadBalancerInterceptor loadBalancerInterceptor) {
return restTemplate -> {
List list = new ArrayList<>(
restTemplate.getInterceptors());
list.add(loadBalancerInterceptor);
restTemplate.setInterceptors(list);
};
}
} ribbon中的拦截器注入到RestTemplate
定义了拦截器，自然需要把拦截器注入到、RestTemplate才能生效，那么ribbon中是如何实现的？上面说了拦截器的定义与拦截器注入器的定义，那么肯定会有个地方使用注入器来注入拦截器的。
在org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration#loadBalancedRestTemplateInitializerDeprecated方法里面，进行注入，代码如下。
@Configuration
@ConditionalOnClass(RestTemplate.class)
@ConditionalOnBean(LoadBalancerClient.class)
@EnableConfigurationProperties(LoadBalancerRetryProperties.class)
public class LoadBalancerAutoConfiguration {
@LoadBalanced
@Autowired(required = false)
private List restTemplates = Collections.emptyList();
@Bean
public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated(
final ObjectProvider> restTemplateCustomizers) {
//遍历context中的注入器，调用注入方法。
return () -> restTemplateCustomizers.ifAvailable(customizers -> {
for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {
for (RestTemplateCustomizer customizer : customizers) {
customizer.customize(restTemplate);
}
}
});
}
//......
} 遍历context中的注入器，调用注入方法，为目标RestTemplate注入拦截器，注入器和拦截器都是我们定义好的。
还有关键的一点是：需要注入拦截器的目标restTemplates到底是哪一些？因为RestTemplate实例在context中可能存在多个，不可能所有的都注入拦截器，这里就是@LoadBalanced注解发挥作用的时候了。
LoadBalanced注解
严格上来说，这个注解是spring cloud实现的，不是ribbon中的，它的作用是在依赖注入时，只注入实例化时被@LoadBalanced修饰的实例。
例如我们定义Ribbon的RestTemplate的时候是这样的
@Bean
@LoadBalanced
public RestTemplate rebbionRestTemplate(){
return new RestTemplate();
}因此才能为我们定义的RestTemplate注入拦截器。
那么@LoadBalanced是如何实现这个功能的呢？其实都是spring的原生操作，@LoadBalance的源码如下
/**
* 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 {
}很明显，‘继承'了注解@Qualifier，我们都知道以前在xml定义bean的时候，就是用Qualifier来指定想要依赖某些特征的实例，这里的注解就是类似的实现，restTemplates通过@Autowired注入，同时被@LoadBalanced修饰，所以只会注入@LoadBalanced修饰的RestTemplate，也就是我们的目标RestTemplate。
拦截器逻辑实现
LoadBalancerInterceptor源码如下。
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) {
// for backwards compatibility
this(loadBalancer, new LoadBalancerRequestFactory(loadBalancer));
}
@Override
public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
final ClientHttpRequestExecution execution) throws IOException {
final URI originalUri = request.getURI();
String serviceName = originalUri.getHost();
Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
return this.loadBalancer.execute(serviceName, requestFactory.createRequest(request, body, execution));
}
}拦截请求执行
@Override publicT execute(String serviceId, LoadBalancerRequest request) throws IOException { ILoadBalancer loadBalancer = getLoadBalancer(serviceId); //在这里负载均衡选择服务 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); }
我们重点看getServer方法，看看是如何选择服务的
protected Server getServer(ILoadBalancer loadBalancer) {
if (loadBalancer == null) {
return null;
}
//
return loadBalancer.chooseServer("default"); // TODO: better handling of key
}代码配置随机loadBlancer，进入下面代码
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;
}
}
}这里配置的是RandomRule，所以进入RandomRule代码
public Server choose(ILoadBalancer lb, Object key) {
if (lb == null) {
return null;
}
Server server = null;
while (server == null) {
if (Thread.interrupted()) {
return null;
}
//获取可用服务列表
List upList = lb.getReachableServers();
List allList = lb.getAllServers();
//随机一个数
int serverCount = allList.size();
if (serverCount == 0) {
/*
* No servers. End regardless of pass, because subsequent passes
* only get more restrictive.
*/
return null;
}
int index = rand.nextInt(serverCount);
server = upList.get(index);
if (server == null) {
/*
* The only time this should happen is if the server list were
* somehow trimmed. This is a transient condition. Retry after
* yielding.
*/
Thread.yield();
continue;
}
if (server.isAlive()) {
return (server);
}
// Shouldn't actually happen.. but must be transient or a bug.
server = null;
Thread.yield();
}
return server;
} 看完上述内容，你们掌握Ribbon如何在spring cloud 中使用的方法了吗？如果还想学到更多技能或想了解更多相关内容，欢迎关注创新互联行业资讯频道，感谢各位的阅读！
当前文章：Ribbon如何在springcloud中使用
文章链接：http://ybzwz.com/article/pojcce.html
