Java后端爱上SpringCloud 第二节:内部负载均衡 Ribbon和Feign

最新推荐文章于 2024-04-01 09:06:18 发布
最新推荐文章于 2024-04-01 09:06:18 发布
阅读量238 收藏 1
点赞数
分类专栏： 微服务 SpringCloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_37307156/article/details/85217695
版权
本文介绍了SpringCloud中负载均衡的概念，并详细讲解了Ribbon和Feign的区别及使用。通过创建My-Spring-Ribbon和My-Spring-Feign工程，演示了如何将它们注册到Eureka并进行调用。在Ribbon中利用RestTemplate进行了HTTP请求，而Feign则通过声明式方式简化了服务调用。文章最后展示了Ribbon调用Feign以及Feign调用Ribbon的示例，探讨了可能出现的问题。
摘要由CSDN通过智能技术生成

Java后端爱上SpringCloud 第一节:内部负载均衡 Ribbon和Feign


PS:为什么说是内部负载均衡？因为Ribbon和Feign都是在SpringClodu服务间的调用做的，之后会讲到在外部请求做负载均衡。至于负载均衡是啥，大家可以自行搜索一下，老规矩先贴一些连接，让大家明确概念，在进行实现。
这里先简单的贴一下负载均衡的概念：

负载均衡：英文名称为Load Balance， 建立在现有网络结构之上，它提供了一种廉价有效透明的方法扩展网络设备和服务器的带宽、增加吞吐量、加强网络数据处理能力、提高网络的灵活性和可用性。其意思就是分摊到多个操作单元上进行执行，例如Web服务器、FTP服务器、企业关键应用服务器和其它关键任务服务器等，从而共同完成工作任务。

一些链接

Ribbon和Feign的区别和比较

RibbonFeign
软负载软负载
支持TCP,HTTP,UPU支持HTTP
支持容错支持容错
和RestTemplate结合起来实现负载均衡简单的HTTP生命调用

当前架构

之前有个工程起名为spring-first，太low了，我把它改名为My-Cloud-First虽然也很low。贴一下现在的架构图：

在这里插入图片描述
下面开始实现正题。

创建My-Spring-Ribbon

创建一个My-Spring-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>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.hyn</groupId>
	<artifactId>My-Spring-Ribbon</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>My-Spring-Ribbon</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Greenwich.RC1</spring-cloud.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
		</dependency>
	</dependencies>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
		</repository>
	</repositories>
</project>

注册到Eureka上面：

spring:
  application:
    name: spring-boot-ribbo
server:
  port: 8765
# tag::configuration-eureka[]

management:
  endpoints:
    web:
      exposure:
        include: "*"  #<2>
  endpoint:
    health:
      show-details: ALWAYS
# end::configuration-eureka[]
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

记得在启动类上加上：@EnableEurekaClient
写一个controller：RibbonControler

package com.hyn.cloud.ribbon.controler;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/ribbon")
public class RibbonControler {

    @RequestMapping(value = "/name",method=RequestMethod.GET)
    @ResponseBody
    public String ribbon(@RequestParam String name){
    	String respResult="I am ribbon,My name is "+name;
		return respResult;
    }
}

依次启动Eureka，Admin，Ribbon，测试一下：http://127.0.0.1:8765/ribbon/name?name=hyn
在这里插入图片描述

创建My-Spring-Feign

创建一个My-Spring-Feign工程。
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>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.hyn</groupId>
	<artifactId>My-Spring-Feign</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>My-Cloud-Feign</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Greenwich.RC2</spring-cloud.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-openfeign</artifactId>
		</dependency>
        <dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
		</dependency>
	</dependencies>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
		</repository>
	</repositories>

</project>

注册到Eureka上面：

spring:
  application:
    name: spring-boot-feign
server:
  port: 8763
# tag::configuration-eureka[]

management:
  endpoints:
    web:
      exposure:
        include: "*"  #<2>
  endpoint:
    health:
      show-details: ALWAYS
# end::configuration-eureka[]
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

记得在启动类上加上：@EnableEurekaClient
写一个controller：RibbonControler

package com.hyn.cloud.feign.controler;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/feign")
public class FeignControler {

    @RequestMapping(value = "/name",method=RequestMethod.GET)
    @ResponseBody
    public String feign(@RequestParam String name){
    	String respResult="I am feign,My name is "+name;
		return respResult;
    }
}

依次启动Feign，测试一下：http://127.0.0.1:8763/feign/name?name=hyn

在这里插入图片描述

现在可以看到，在SpringBootAdmin上如下结构：
在这里插入图片描述

Ribbon调用

说明一下RestTemplate：

  • RestTemplate是Spring提供的用于访问Rest服务的客户端。
  • RestTemplate提供了多种便捷访问远程Http服务的方法，能够大大提高客户端的编写效率。
  • 调用RestTemplate的默认构造函数，RestTemplate对象在底层通过使用java.net包下的实现创建HTTP 请求，可以通过使用ClientHttpRequestFactory指定不同的HTTP请求方式。
  • ClientHttpRequestFactory接口主要提供了两种实现方式，一种是SimpleClientHttpRequestFactory，使用J2SE提供的方式（既java.net包提供的方式）创建底层的Http请求连接，还有一种方式是使用HttpComponentsClientHttpRequestFactory方式，底层使用HttpClient访问远程的Http服务，使用HttpClient可以配置连接池和证书等信息。

启动类修改：

package com.hyn.cloud.ribbon;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableEurekaClient
@EnableDiscoveryClient
public class MyCloudRibbonApplication {

   public static void main(String[] args) {
   	SpringApplication.run(MyCloudRibbonApplication.class, args);
   }

    /**
    * Spring提供的用于访问Rest服务的客户端
    * @return
    */
   @Bean
   @LoadBalanced
   RestTemplate restTemplate() {
       return new RestTemplate();
   }
}

controller 类修改

package com.hyn.cloud.ribbon.controler;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@RequestMapping("/ribbon")
public class RibbonControler {

   /**
    * 注入RestTemplate
    */
   @Autowired
   RestTemplate restTemplate;
   
   @RequestMapping(value = "/name",method=RequestMethod.GET)
   @ResponseBody
   public String ribbon(@RequestParam String name){
   	String respResult="I am ribbon,My name is "+name;
   	String url="http://SPRING-BOOT-FEIGN/feign/name?name=";
       return restTemplate.getForObject(url+respResult, String.class);
   }
}

在调用一下：
在这里插入图片描述
可以看到通过Ribbon去调用了Feign，虽然栗子举的有些生硬。哈哈哈哈

Feign调用

启动类修改：

package com.hyn.cloud.feign;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients //开启spring cloud feign的支持
public class MyCloudFeignApplication {

   public static void main(String[] args) {
   	SpringApplication.run(MyCloudFeignApplication.class, args);
   }
}

controller修改：

package com.hyn.cloud.feign.controler;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.hyn.cloud.feign.service.FeignService;

@RestController
@RequestMapping("/feign")
public class FeignControler {

	@Autowired
	FeignService feignService;
	
    @RequestMapping(value = "/name",method=RequestMethod.GET)
    public String feign(@RequestParam String name){
		return feignService.getName(name);
    }
}

添加一个service：

package com.hyn.cloud.feign.service;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

@FeignClient(value = "SPRING-BOOT-RIBBO")
public interface FeignService {
	
    @RequestMapping(value = "/ribbon/name",method = RequestMethod.GET)
	String getName(@RequestParam("name")String name);

}

然后我掉了一下http://127.0.0.1:8763/feign/name?name=hyn，然后feign去调了ribbon，ribbon又去调了feign，然后就没有然后了，会报一大堆错，没有仔细分析。
这里我们在ribbon项目Controller里面再添加一个Request，

package com.hyn.cloud.ribbon.controler;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;



@RestController
@RequestMapping("/ribbon")
public class RibbonControler {

    /**
     * 注入RestTemplate
     */
    @Autowired
    RestTemplate restTemplate;
	
    @RequestMapping(value = "/name",method=RequestMethod.GET)
    @ResponseBody
    public String ribbon(@RequestParam String name){
    	String respResult="I am ribbon,My name is "+name;
    	String url="http://SPRING-BOOT-FEIGN/feign/name?name=";
        return restTemplate.getForObject(url+respResult, String.class);
    }
    
    @RequestMapping(value = "/name2",method=RequestMethod.GET)
    @ResponseBody
    public String ribbon2(@RequestParam String name){
    	String respResult="I am ribbon,My name2 is "+name;
        return respResult;
    }

}

修改FeignService调用的url

package com.hyn.cloud.feign.service;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

@FeignClient(value = "SPRING-BOOT-RIBBO")
public interface FeignService {
	
    @RequestMapping(value = "/ribbon/name2",method = RequestMethod.GET)
	String getName(@RequestParam("name")String name);

}

然后请求feign项目：

在这里插入图片描述
可以看到feign工程去调用了ribbon工程的name2的controller

粉蒸肉加馍
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Ribbon和Feign的区别
varyall的专栏
07-23 4万+
Ribbon和Feign都是用于调用其他服务的，不过方式不同。 1.启动类使用的注解不同，Ribbon用的是@RibbonClient，Feign用的是@EnableFeignClients。 2.服务的指定位置不同，Ribbon是在@RibbonClient注解上声明，Feign则是在定义抽象方法的接口中使用@FeignClient声明。 3.调用方式不同，Ribbon需要自己构建http...
Ribbon和Feign的区别？
qq_33240556的博客
12-20 1009
总结：Ribbon和Feign都是Spring Cloud中常用的声明式Web服务客户端，它们都提供了一种声明式的接口，使得开发者无需编写大量的代码就可以实现Web服务调用。然而，它们在功能特性、使用场景和适用框架方面存在一些区别。根据具体需求和项目环境选择合适的客户端。Ribbon和Feign都是Spring Cloud中常用的声明式Web服务客户端，它们都提供了一种声明式的接口，使得开发者无需编写大量的代码就可以实现Web服务调用。然而，它们之间有一些关键的区别。
Ribbon与Feign的区别
Angus博客
11-20 2696
Ribbon添加maven依赖 spring-starter-ribbon 使用@RibbonClient(value="服务名称") 使用RestTemplate调用远程服务对应的方法 feign添加maven依赖 spring-starter-feign 服务提供方提供对外接口 调用方使用 在接口上使用@FeignClient("指定服务名") Ribbon和Feign的区别： Ribb...
Ribbon 和 Feign的区别
最新发布
weixin_43784341的博客
04-01 672
使用方式：Ribbon 需要手动构建 HTTP 请求，使用 RestTemplate 调用服务；而 Feign 通过定义接口和注解的方式，以更加声明式的方法调用服务。代码简洁性：Feign 的代码更加简洁，易于理解和维护，而 Ribbon 的代码相对繁琐一些。集成性：Feign 默认集成了 Ribbon，因此在使用 Feign 时，已经拥有了 Ribbon 的负载均衡能力。扩展性：Ribbon 提供了更多的配置选项和扩展点，而 Feign 则更加专注于声明式调用的简洁性。
02Spring Cloud Ribbon：负载均衡的服务调用1
08-04
在Spring Cloud生态系统中，Spring Cloud Ribbon是一个至关重要的组件，它主要负责实现客户端的负载均衡，以确保服务间的调用能够均匀地分散到各个实例上，从而提高系统的整体可用性和性能。Ribbon是Netflix开发的一...
springcloud入门代码基于Spring Cloud实现的Ribbon客户端负载均衡模板代码
06-15
在本文中，我们将深入探讨如何使用Spring Cloud来实现Ribbon客户端负载均衡，这对于构建微服务架构至关重要。Spring Cloud是Spring生态系统中的一个集合，它提供了一系列工具和服务，帮助开发者快速搭建分布式系统，...
springCloud的ribbon和feign
01-21
在Spring Cloud生态体系中，Ribbon和Feign是两种重要的客户端负载均衡器，它们用于在微服务架构中实现服务间的调用。理解并熟练运用这两个组件对于构建高可用、高性能的分布式系统至关重要。 首先，Ribbon是Netflix...
SpringCloud客户端的负载均衡Ribbon的实现
08-27
SpringCloud客户端的负载均衡Ribbon的实现 微服务架构中，单个微服务有多个实例是不可避免的，这就需要对客户端的请求进行负载均衡，以便将请求分摊到多个微服务的实例上。Ribbon是一个由Netflix发布的负载均衡器，...
73-Spring Cloud客户端负载均衡Ribbon笔记1
08-08
Spring Cloud中的Ribbon是实现客户端负载均衡的关键组件。在传统的服务端负载均衡中，像Nginx这样的代理服务器会接收请求并根据预设的算法（如轮询、权重轮询、随机等）转发到后端服务。而在客户端负载均衡模式下，...
Ribbon Disabler
02-05
去除工具栏
Ribbon 和 Feign 的区别
zb0002011的博客
03-26 281
Ribbon 和 Feign 的区别 spring cloud的 Netflix 中提供了两个组件实现软负载均衡调用：ribbon 和 feign 。 Ribbon 是一个基于 HTTP 和 TCP 客户端 的负载均衡的工具。 它可以 在客户端 配置 RibbonServerList（服务端列表），使用 HttpClient 或 RestTemplate 模拟http请求，步骤相当繁琐。 Fe...
ribbon和feign的区别
热门推荐
lucky的专栏
10-11 2万+
    pring cloud的Netflix中提供了两个组件实现软负载均衡调用：ribbon和feign。 Ribbon  是一个基于 HTTP 和 TCP 客户端的负载均衡器  它可以在客户端配置 ribbonServerList（服务端列表），然后轮询请求以实现均衡负载。   Feign  Spring Cloud Netflix 的微服务都是以 HTTP 接口的形式暴露的，所...
14、 Ribbon和Feign的区别
m0_53914150的博客
12-18 180
1.Ribbon都是调用其他服务的，但方式不同。 2.启动类注解不同，Ribbon是@RibbonClient feign的是@EnableFeignClients 3.服务指定的位置不同，Ribbon是在@RibbonClient注解上声明，Feign则是在定义抽象方法的接口中使用@FeignClient声明。 4.调用方式不同，Ribbon需要自己构建http请求，模拟http请求。
SpringCloud的Ribbon和Feign
Flynn_Chen的博客
06-09 743
1.Ribbon和Feign都可以负载均衡    a.Ribbon使用（在consumer端）        pom.xml                            &lt;!-- Ribbon相关 --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.cloud&lt;/groupId&gt; &l...
面试系列微服务：Ribbon、Fegin的区别
CancerKing的博客
11-24 282
面试系列微服务：Ribbon、Fegin的区别
springcloud bus Greenwich.RC2 版本启动错误Error processing condition
bug Maker
01-03 6152
错误信息 . ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\_...
谈谈Ribbon和Feign区别
越努力越幸运。
01-19 467
Feign使用注解和模板方法简化了远程调用的编写，使得调用远程服务的代码更加清晰和简洁。它更注重简洁的声明式编程模型，你只需编写接口并使用注解描述HTTP请求，Feign会在运行时生成实现类来执行实际的HTTP请求。，需要配合其他库如RestTemplate来发送http请求，而Feign则采用声明式编程模型，只需编写接口和注解即可。总的来说，如果你需要更多的控制和自定义负载均衡策略，可以选择Ribbon；Ribbon和Feign都用于构建分布式系统中的微服务，但两者在用途、编程模型和集成上存在差异。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值