Spring Cloud入门1——Eureka&Ribbon&Hystrix

最新推荐文章于 2024-08-28 15:09:19 发布
最新推荐文章于 2024-08-28 15:09:19 发布
阅读量5.4k 收藏 3
点赞数
分类专栏： MicroService spring-cloud 文章标签： spring cloud 微服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a60782885/article/details/69267934
版权

上篇中，主要了解了Spring Cloud的一些简单组件以及他们的功能。

现在动手简单的使用一下Spring Cloud的一些组件。


服务发现：(Eureka)

前面提到，Eureka分为服务端和客户端，服务端是服务注册中心，而客户端是提供服务的。


创建服务注册中心(服务端)

首先在pom文件中加入以下依赖：

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.3.8.RELEASE</version>
	<relativePath /> <!-- lookup parent from repository -->
</parent>

<dependencies>
	<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-eureka-server</artifactId>
	</dependency>
</dependencies>

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-dependencies</artifactId>
			<version>Brixton.SR7</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>
在Application文件中增加@EnableEurekaServer注解，表明这是服务端 

@EnableEurekaServer
@SpringBootApplication
public class SpringcloudEurekaServerApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringcloudEurekaServerApplication.class, args);
	}
}
在默认设置下，该服务注册中心也会将自己作为客户端来尝试注册它自己，所以我们需要禁用它的客户端注册行为。在application.properties或yml中禁止客户端注册行为，否则会报错。 

server.port=1111

eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.client.serviceUrl.defaultZone=http://localhost:${server.port}/eureka/

服务端就写好了，可以访问localhost:1111进行访问。可以看到，这时候是没有服务的。



接下来创建客户端

创建客户端，并在注册中心中注册自己。

还是首先添加依赖：这里和上面不同的地方只有对Eureka的依赖。

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.3.8.RELEASE</version>
	<relativePath /> <!-- lookup parent from repository -->
</parent>


<dependencies>
	<dependency>
		<groupId>org.springframework.cloud</groupId>
		<artifactId>spring-cloud-starter-eureka</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
</dependencies>

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-dependencies</artifactId>
			<version>Brixton.SR7</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>
在Application文件中加入@EnableDiscoveryClient注解，表明这是一个客户端。 

@EnableDiscoveryClient
@SpringBootApplication
public class SpringcloudEurekaServiceApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringcloudEurekaServiceApplication.class, args);
	}
}
然后我们需要向注册中心中注册自己，只需要在application.properties或yml文件中增加配置即可： 

spring.application.name=compute-service
server.port=2222
eureka.client.serviceUrl.defaultZone=http://localhost:1111/eureka/
defaultZone指定了服务注册中心的位置。

注册了之后我们就可以在客户端编写客户端提供的服务了。比如这里提供了add加法服务。

@RestController
public class ComputeController {
	
    private final Logger logger = Logger.getLogger(getClass());
    
    @Autowired
    private DiscoveryClient client;
    
    @RequestMapping(value = "/add" ,method = RequestMethod.GET)
    public Integer add(@RequestParam Integer a, @RequestParam Integer b) {
        ServiceInstance instance = client.getLocalServiceInstance();
        Integer r = a + b;
        logger.info("/add, host:" + instance.getHost() + ", service_id:" + instance.getServiceId() + ", result:" + r);
        return r;
    }
}
在提供的服务中，只需要使用DiscoveryClient就可以得到关于调用者的信息。

客户端也完成了，这个时候可以再次访问localhost:1111。


可以发现，客户端已经在服务端上注册了。


我们看一下架构图：


很显然，工作流程是这样的：Service Consumer -> Proxy Server -> Client(Load Balancer) -> Servie Discovery -> Target Service

我们编写好了上图的红色的部分，接下来应该对服务进行负载均衡了，也就是对客户端的负载均衡，我们使用Ribbon来完成这件事。

首先我们启动服务端和两个客户端，客户端分别开在2222和2223端口。即：


开启了两个服务，接下来我们使用Ribbon进行负载均衡。


新建一个项目。

在pom文件中添加如下依赖：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.3.5.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-ribbon</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</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>
</dependencies>
<dependencyManagement>
    <dependencies>
        <dependency>
	    <groupId>org.springframework.cloud</groupId>
	    <artifactId>spring-cloud-dependencies</artifactId>
	    <version>Brixton.RELEASE</version>
	    <type>pom</type>
	    <scope>import</scope>
	</dependency>
    </dependencies>
</dependencyManagement>
使用@EnableDiscoveryClient注解在将其注册在注册中心。并且提供一个返回RestTemplate的bean实例，使用@LoadBalanced注解对这个实例进行负载均衡这样，使用这个实例去获取服务的时候，就会帮我们进行负载均衡了。 
@SpringBootApplication
@EnableDiscoveryClient
public class RibbonApplication {
	
	@Bean
	@LoadBalanced
	RestTemplate restTemplate() {
		return new RestTemplate();
	}
	
	public static void main(String[] args) {
		SpringApplication.run(RibbonApplication.class, args);
	}
}

在application.properties中注册：

spring.application.name=ribbon-consumer
server.port=3333
eureka.client.serviceUrl.defaultZone=http://localhost:1111/eureka/

创建了bean实例，我们就可以通过@Autowired来获取这个RestTemplate了，并且使用这个实例去调用服务。 
@RestController
public class ConsumerController {
	
    @Autowired
    RestTemplate restTemplate;
    
    @RequestMapping(value = "/add", method = RequestMethod.GET)
    public String add() {
        return restTemplate.getForEntity("http://COMPUTE-SERVICE/add?a=10&b=20", String.class).getBody();
    }
}
启动这个项目，并且访问多次localhost:3333/add可以发现确实进行了负载均衡。


在微服务架构中，服务被拆分成一个一个的单元，各个单元之间相互依赖调用。如果某个单元由于网络原因或者别的单元故障奔溃，那么会直接导致调用方对外的服务也发生延迟。若此时调用方的请求不断增加，最后就会出现因等待出现故障的依赖方响应而形成任务积压，最终导致自身服务的瘫痪，这样的结构相对于传统的web开发模式来说更加可怕，为了解决这个问题，我们可以采用断路器。

在分布式架构中，当某个服务单元发生故障，使用断路器返回一个错误的相应，而不是进行长时间的等待，这样就不会使得线程被长时间占用，导致服务器的瘫痪。

Spring Cloud提供了Hystrix这么一个组件来实现断路器的功能。


首先启动Eureka服务端和客户端。

对Ribbon的项目进行以下修改：

首先在pom文件中增加以下依赖：

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-hystrix</artifactId>
</dependency>
在application中增加@EnableCircuitBreaker注解，表明使用断路器。 

@SpringBootApplication
@EnableDiscoveryClient
@EnableCircuitBreaker
public class RibbonApplication {
	
	@Bean
	@LoadBalanced
	RestTemplate restTemplate() {
		return new RestTemplate();
	}
	
	public static void main(String[] args) {
		SpringApplication.run(RibbonApplication.class, args);
	}
}
Hystrix使用消息队列的方式，如果连接的服务崩溃，则异步回调某个方法进行处理。

新增一个Service类，在这个类中定义好如何访问，以及失败之后的返回等。

@Service
public class ComputeService {
	
    @Autowired
    RestTemplate restTemplate;
    
    @HystrixCommand(fallbackMethod = "addServiceFallback")
    public String addService() {
        return restTemplate.getForEntity("http://COMPUTE-SERVICE/add?a=10&b=20", String.class).getBody();
    }
    
    public String addServiceFallback() {
        return "error";
    }
}
这里重点是@HystrixCommand注解：表明该方法为hystrix包裹，可以对依赖服务进行隔离、降级、快速失败、快速重试等等hystrix相关功能

列举几个属性：
1. fallbackMethod 降级方法
2. commandProperties 普通配置属性，可以配置HystrixCommand对应属性，例如采用线程池还是信号量隔离、熔断器熔断规则等等
3. ignoreExceptions 忽略的异常，默认HystrixBadRequestException不计入失败
4. groupKey() 组名称，默认使用类名称
5. commandKey 命令名称，默认使用方法名

最后修改一下Controller即可：

@RestController
public class ConsumerController {
	
	@Autowired
    private ComputeService computeService;
	
    @RequestMapping(value = "/add", method = RequestMethod.GET)
    public String add() {
    	return computeService.addService();
    }
}
对于断路器，针对生产环境,，Netflix还给我们准备了一个非常好用的运维工具, 那就是Hystrix Dashboard和Turbine.可以帮助我们更好的观察。


当客户端关闭时访问：


客户端启动时访问：


成功！

a60782885
关注
专栏目录
SpringCloud概述&快速入门&Eureka注册中心&Ribbon负载均衡&Hystrix熔断器
9.冄2.7.號的博客
07-08 424
学习目标 能够使用RestTemplate发送请求 能够说出SpringCloud的作用 能够搭建Eureka注册中心 能够使用Robbin负载均衡 能够使用Hystrix熔断器 系统架构演变 随着互联网的发展，网站应用的规模不断扩大。需求的激增，带来的是技术上的压力。系统架构也因此也不断的演进、升级、迭代。从单一应用，到垂直拆分，到分布式服务，到SOA，以及现在火热的微服务架构，还有在Google带领下来势汹涌的Service Mesh。我们到底是该乘坐微服务的船只驶向远方，还是偏安逸得过且过？ 其实
Spring Cloud中五大神兽总结(Eureka/Ribbon/Feign/Hystrix/zuul)
huxiutao的博客
02-25 5257
一、常用的模块 1、Eureka Eureka是Netflix的一个子模块，也是核心模块之一。Eureka是一个基于REST的服务，用于定位服务，以实现云端中间层服务发现和故障转移。服务注册与发现对于微服务架构来说是非常重要的，有了服务发现与注册，只需要使用服务的标识符，就可以访问到服务，而不需要修改服务调用的配置文件了。功能类似于dubbo的注册中心，比如Zookeeper。 Eureka包含两...
微服务系列：Spring Cloud 之 Feign、Ribbon、Hystrix 三者超时时间配置
wdj_yyds的博客
01-23 3984
Feign 和 Ribbon 1. 设置 OpenFeign 的超时时间 我们首先来看一下 OpenFeign 自己的请求超时配置，直接在 yml 文件中配置： feign: # 设置 feign 超时时间 client: config: # default 设置的全局超时时间，指定服务名称可以设置单个服务的超时时间 default: connectTimeout: 5000 readTimeout: 5000 复制代码 d
SpringCloud_Ribbon和Hystrix
qq_44193036的博客
03-17 384
在之前的案例中，我们所启用的服务提供方和服务消费方都只有一个，然后使用RestTemplate通过DiscoveryClient进行动态去调用服务。 但是在实际开发中，微服务一般都是以集群的形式存在的，此时我们获取的服务信息背后就会有多台服务器，那么到底应该访问哪一个呢？ 一般在这个时候我们编写负载均衡算法，在多个实例列表中进行选择，不过SpringCloud已经帮我们集成了负载均衡组件：Ribo...
【第一章】Kubernetes快速入门
最新发布
董坤的博客
08-28 947
Kubernetes是⼀个可移植、可扩展的 “分布式开源平台”，这个平台主要是⽤来管理我们运⾏的容器化应⽤，只不过这个平台它是⼀个分布式的，那Kubernetes这个分布式平台是如何实现的呢。Kubernetes是将多个OS节点组织在⼀起，构建出⼀个庞⼤的虚拟资源池，⽽后对⽤户提供操作该集群的接⼝，⽤户就可以通过Kubernetes提供的对应接⼝对容器进⾏增删查改等操作。所以对于⽤户⽽⾔，它⽆需关⼼Kubernetes底层是如何对容器进⾏的创建、⼜是如何调度到对应的节点。
SpringColud——Ribbon（负载均衡）&Hystrix（熔断器）
程序员阿龙的博客
12-07 1052
Ribbon和Histrix的学习笔记
Ribbon与Hystrix
weixin_61195714的博客
12-14 931
负载均衡： 因为请求量特别大的情况下，必须有多台服务来进行处理，配置集群。 集群中的机器可能出现忙闲不均的情况，就需要有一套机制，实现平均分配请求量到每台机器上一一进行负载均衡 负载均衡分类： 硬件负载均衡 软件负载均衡 Ribbon的使用 以及 配置方法 1.引入依赖nefilx-ribbon eureka-client依赖中已经包含此依赖 2.配置Rest...
Ribbon使用Hystrix
weixin_34236497的博客
12-29 529
1、导入依赖spring-cloud-starter-hystrix &lt;dependency&gt; &lt;groupId&gt;org.springframework.cloud&lt;/groupId&gt; &lt;artifactId&gt;spring-cloud-starter-hystrix&lt;/artifactId&gt; &lt;/depe...
springcloud全家桶(eureka+ribbon+feign+hystrix+turbine)
11-16
spring-cloud微服务框架demo，可以完整运行。这里面包含的组件和内容有: spring cloud eureka，服务注册和服务发现 spring cloud config，动态配置项 ribbon，客户端负载均衡 feign， hystrix，熔断 turbine Spring ...
spring cloud eureka zuul ribbon hystrix feign config 示例
03-08
在给定的标题和描述中，我们看到了几个关键组件：Eureka、Zuul、Ribbon、Hystrix 和 Feign，这些都是Spring Cloud生态中的重要组成部分。下面将详细阐述这些组件及其在实际应用中的作用。 1. **Eureka**：它是...
SpringCloud-Eureka-Ribbon
05-05
在分布式系统中，Spring Cloud Eureka 和 Ribbon 是两个重要的组件，它们主要负责服务发现和服务间的负载均衡。本文将深入探讨这两个技术以及它们在Spring Cloud框架中的应用。 **Eureka服务注册中心** Eureka是...
SpringCloud案例(集成了Eureka、Ribbon、Feign)
04-09
本案例是SpringCloud项目案例，集成了Eureka、Ribbon、Feign等。
Ribbon、Hystrix实现服务负载均衡、资源隔离与熔断降级
theRengar的博客
07-08 891
一、组件介绍 1、Ribbon ribbon是属于Netflix的一款基于客户端http、tcp负载均衡的一个小框架，何为客户端负载均衡，简单理解就是客户端获取了服务注册中心的所有注册数缓存在本地，并定时维护本地缓存的注册数据；客户端发起远程服务请求，则采用一系列的负载均衡策略从本地获取一个服务的地址数据并对其发送网络请求。 我们平常所了解的SpringCloud ribbon则是对Netflix的ribbon进行了一系列的封装，使其无缝对接SpringCloud环境开发，并且能够无缝对接各大主流服务治理框
Spring Cloud ：Ribbon和Hystrix
2301_77350672的博客
07-30 209
spring cloud 用的是 hystrix，是一个容错组件。当自身 依赖的服务不可用时，服务自身不会被拖垮。防止微服务级联异常Hystrix实现了 超时机制和断路器模式。Hystrix是Netflix开源的一个类库，用于隔离远程系统、服务或者第三方库，防止级联失败，从而提升系统的可用性与容错性。为系统提供保护机制。在依赖的服务出现高延迟或失败时，为系统提供保护和控制。防止雪崩。
模拟实战(2) - 一文秒懂Ribbon、Hystrix实现服务负载均衡、资源隔离与熔断降级
热门推荐
无名氏灬的博客
04-08 3万+
前言：本篇为SpringCloud Greenwich版本模拟业务实战系列文章第二篇，上篇文章主要讲了服务治理、高可用安全的服务注册中心，那么本文将对ribbon、hystrix进行介绍，对其如何实现服务负载均衡，以及如何保证服务之间调用资源的隔离、以及发生紧急情况时对服务进行熔断降级操作进行详细讲解 一、组件介绍 1、Ribbon ribbon是属于Netflix的一款基于客户端http、...
spring cloud微服务分布式云架构--hystrix的使用
weixin_33901926的博客
03-20 99
hystrix主要作用在服务消费者，进行应用的保护，当请求的服务请求超时时，做出相应的处理，避免客户端一直进行请求等待，避免在高并发的情况出现服务器死机（请求过多，内存不足） 接下来的通过一个案例对hystrix的使用进行说明，案例完成的功能：Spring Cloud大型企业分布式微服务云架构源码请加一七九一七四三三八零 服务消费者根据Id调用服务提供者的接口，获取User表单的对应的记录，若请求...
SpringCloud学习总结之 Ribbon 和 Hystrix (三)
m0_47912936的博客
06-27 217
按照 《spring cloud 微服务实战》这本书的书写顺序，我们首先对Ribbon 进行一个介绍。 Spring Cloud Ribbon 是一个基于 HTTP 和 TCP的客户端负载均衡工具, 它不同于Nginx的服务端负载均衡，他侧重于将需要的访问清单从服务注册中心中取出，放在自己的访问服务器列表(ServerList)中,当需要访问某一台具体的服务器的时候，他会经过不同的轮询策略去访问相应的负载均衡设备。 同时他也不同于硬件设施的负载均衡，硬件设施经常通过配置citrix netscaler，
springcloud之负载均衡
星星都没我亮的博客
10-31 1213
文章目录1.1 两种负载均衡客户端负载均衡服务端负载均衡1.2 概念1.3 Ribbon组成1.4 编码及测试1.4.1 利用Eureka手写负载均衡：1.4.2 ribbon负载均衡1.4.1 编码1.4.2 测试13.4.3 扩展1.5 @LoadBalanced原理源码源码总结1.6 自定义Ribbon配置Java代码定义属性定义1.7 Ribbon脱离Eureka1.8 饥饿加载1.9 自定义负载均衡策略1.10 小结 1.1 两种负载均衡 ​ 当系统面临大量的用户访问，负载过高的时候，通常会增加
Spring-Cloud之Ribbon
起岸星辰
05-17 317
原文：https://blog.vchar.top/java/1620820800.html Ribbon的引入将为我们解决服务集群部署时需要实现相关的负载均衡的算法，简化服务调用的过程；引入Ribbon后在进行服务调用时只需要指定服务名称即可，无需去关心服务的部署地址以及负载均衡实现。下面我们通过一些Ribbon的示例带你快速了解如何使用它。下面示例使用的Spring-Cloud的版本是Hoxton.SR8，Spring-Boot的版本是2.3.4.RELEASE。示例项目的源代码 添加相关的依赖 由.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值