SrpingCloud 服务与消费 初识Eureka Consumer Ribbon

最新推荐文章于 2024-08-17 19:48:03 发布
最新推荐文章于 2024-08-17 19:48:03 发布
阅读量197 收藏 1
点赞数
分类专栏： springCloud 文章标签： eureka spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15700115/article/details/119102359
版权

        因为Spring Boot 的更迭，很多资料的不匹配，特别是依赖的问题，让我折腾了两天才正常的运行起来。深受其苦，所以，写一个完整的流程，希望可以帮助到大家。

  1. 搭建服务注册中心

     

      pom.xml 的依赖内容如下，spring-cloud-dependencies 和 spring-cloud-starter-netflix-eureka-server 一定要注意版本：

    <?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 https://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.5.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>eureka-server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>eureka-server</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>2020.0.3</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            <version>3.0.3</version>
        </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>${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>

</project>

      
      application.properties 配置信息：

    ​
server.port=1111

eureka.instance.hostname=localhost
# 让服务中心不注册自己
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.client.serviceUrl.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/

​

        完成了上面的配置后，启动应用并访问 http://localhost:1111/​ 

  2. 注册服务提供者
        继续快速创建一个 spring Boot 项目，将其作为一个微服务应用向服务注册中心发布自己。因为涉及控制台输出，所以额外引入了 log4j 
    <?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 https://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.5.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.hello</groupId>
    <artifactId>consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>consumer</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>2020.0.3</spring-cloud.version>
    </properties>
    <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-server</artifactId>
            <version>3.0.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j</artifactId>
            <version>1.3.7.RELEASE</version>
            <type>pom</type>
        </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>${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>

</project>

            接着，实现 /hello 请求处理接口，通过注入 DiscoveryCLient 对象，在日志中打印相关的服务。

    package com.hello.consumer;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.client.serviceregistry.Registration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class HelloController {

    private final Logger logger = Logger.getLogger(getClass());

    @Autowired
    private DiscoveryClient client;
    @Autowired
    private Registration registration; // 服务注册
    
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String index() {
        ServiceInstance instance = null;
        String serviceId = registration.getServiceId();
        List<ServiceInstance> instanceList = client.getInstances(serviceId);
        if (instanceList != null && instanceList.size() > 0) {
            instance = instanceList.get(0);
        }
        System.out.println(instance.toString());
        logger.info("/hello, host:" + instance.getHost() + ", service_id:" + instance.getServiceId());
        return "Hello World";
    }
}

            然后，在主类中通过加上 @EnablesDiscoveryClient 注解，激活 Eureka 中的 DiscoveryClient 实现。
     

    package com.hello.consumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@EnableDiscoveryClient
@SpringBootApplication
public class ConsumerApplication {

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

}

            application.properties 配置文件

    # 服务名
spring.application.name=hello-service
# 指定服务注册中心地址
eureka.client.serviceUrl.defaultZone=http://peer1:1111/eureka/

            下面分别启动服务注册中心和服务提供者。Tomcat 启动之后，打印了注册信息，表示服务注册成功。

    而此时，服务注册中心的控制台中，可以看到类似的输出，表示 hello-service  注册成功了！

             通过访问 Eureka 的信息面板，一样可以看到服务的注册信息

              通过访问  http://localhost:8080/hello，发起请求，在控制台中可以看懂如下输出：

            这些输出内容就是之前在 HelloController 注入的 DiscoveryClient 接口对象，从服务注册中心获取的相关服务信息。 要配置log4j的打印级别，才会输出。

  3. 高可用注册中心
            在 Eureka 的服务治理设计中，所有节点即是服务提供方，也是服务消费方。Eureka Server 的高可用实际上就是将自己作为服务向其他服务注册中心注册自己，这样就可以形成一组互相注册的服务中心，以实现服务清单的互相同步，达到高可用效果。

          创建 application-peer1.properties，作为 peer1 服务中心的配置，并将 serviceUrl  指向 peer2
            
    spring.application.name=eureka-server
server.port=1111

eureka.instance.hostname=peer1
eureka.client.serviceUrl.defaultZone=http://peer2:1112/eureka/
          创建 application-peer2.properties，作为 peer2 服务中心的配置，并将 serviceUrl  指向 peer1 
    
spring.application.name=eureka-server
server.port=1112

eureka.instance.hostname=peer2
eureka.client.serviceUrl.defaultZone=http://peer1:1111/eureka/
            在/etc/hosts 文件中添加对 peer1 和 peer2 的转换，让上面配置的 host 形式 serviceUrl   能在本地正确访问到。 
    127.0.0.1 peer1
127.0.0.1 peer2
            通过 spring.profiles.active 属性分别来启动 peer1 和 peer2。
            
    java -jar eureka-server-0.0.1-SNAPSHOT.jar --spring.profiles.active=peer1
java -jar eureka-server-0.0.1-SNAPSHOT.jar --spring.profiles.active=peer2

            此时访问 peer1 的注册中心，发现 registere-replicas 中已经有 peer2 节点的 eureka-server 了。同样的，访问 peer2 的注册中心，发现 registere-replicas 中已经有 peer1节点的 eureka-server 了。

           但是  available-replicas （可用分片）之中，没有节点。要在 application-peer1.properties 和 application-peer2.properties 添加如下配置：让服务中心注册自己

    eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true

            再进去就可以看到，可用分片之中就有了节点。

    但是关闭 peer1节点，在peer2的服务注册中心，发现peer1一直都还在可用节点中。application-peer1.properties 和 application-peer2.properties添加如下配置：

    # 注册表：缓存过期时间，默认180s
eureka.server.response-cache-auto-expiration-in-seconds=5
# 注册表：缓存更新间隔
eureka.server.response-cache-update-interval-ms=5000
# 启用主动失效，主动失效检测间隔3s
eureka.server.eviction-interval-timer-in-ms=3000
# 服务过期时间，默认90s，超过这个时间没收到心跳，EurekaServer会剔除该实例
eureka.instance.lease-expiration-duration-in-seconds=15
# 服务刷新时间间隔，默认30s会主动心跳一次
eureka.instance.lease-renewal-interval-in-seconds=5

# 关闭自我保护模式 【注意】保护模式未关闭时，上面即使配置了过期，eureka还是不会剔除下线的实例
eureka.server.enable-self-preservation=false

    在设置了多节点的服务注册中心之后，服务提供方还需要做一些简单的配置才能将服务注册到 Eureka Server 集群中。

    # 服务名
spring.application.name=hello-service
# 指定服务注册中心地址
eureka.client.serviceUrl.defaultZone=http://peer1:1111/eureka/,http://peer1:1112/eureka/

          

  4. 服务发现与消费

          现在已经有了 服务注册中心 和 服务提供者，下面构建一个服务消费者，它主要完成两个目标 ，发现服务已经消费服务。其中服务发现的任务由  Eureka 的客户端完成，而服务消费的任务由  Ribbon 完成。Ribbon 是有一个基于 HTTP 和 TCP 的客户端负载均衡器，它可以通过客户端中配置的 ribbonServerList 服务端列表去轮询访问以达到负载均衡的作用。

          首先，启动之前实现的服务注册中心 以及 hello-service 服务，为了实验 Ribbon 的客户端负载均衡功能，启动两个不同端口的 hello-service。 
    java -jar consumer-0.0.1-SNAPSHOT.jar --server.port=8081
java -jar consumer-0.0.1-SNAPSHOT.jar --server.port=8082

           在启动成功后，Eureka 信息面板如下所示：

            创建一个 Spring Boot的基础工程来实现服务消费者，取名为 ribbon-consumer，pom.xml依赖如下。刚开始按照hello-service的pom.xml配置，服务启动，在注册中心显示都没问题，但是调用hello-serivice服务就有问题，SpringCloud、Eureka、ribbon报错No instances available for xxx！搜了一天半各种办法，最后参考这个 https://blog.csdn.net/qq_40781284/article/details/113830607 把spring-cloud-starter-netflix-ribbon依赖删除即可 ，因为pom.xml导入的jar包冲突，spring-cloud-starter-netflix-eureka-client 3.0版本的已经内置ribbon 。就没问题了！！！

    <?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 https://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.4.9</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.tripodfan</groupId>
    <artifactId>ribbon-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>consumer</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>2020.0.3</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--eureka-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>3.0.1</version>
        </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>${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>

</project>

            创建应用主类 ConsumerApplication。

    
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.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@EnableDiscoveryClient
@SpringBootApplication
public class ConsumerApplication {
    
     @Bean
     @LoadBalanced
     RestTemplate  restTemplate() {
        return new RestTemplate();
    }

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

}

     创建 ConsumerController 并实现  /ribbon-consumer 接口。这里的 HELLO-SERVICE 我试了大小写都没问题。

    
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.RestController;
import org.springframework.web.client.RestTemplate;


@RestController
public class ConsumerController {

    @Autowired
    RestTemplate restTemplate;

    @RequestMapping(value = "/ribbon-consumer", method = RequestMethod.GET)
    public String helloConsumer() {
        String url="http://hello-service/hello";
//        String url="http://HELLO-SERVICE/hello";
        return restTemplate.getForEntity(url, String.class).getBody();
    }
}

      在 application.properties 配置 Eureka 服务注册中心的位置

    spring.application.name=ribbon-consumer
server.port=9000


eureka.client.serviceUrl.defaultZone=http://localhost:1111/eureka/

    启动 ribbon-consumer 应用。

     通过访问 http://localhost:9000/ribbon-consumer，陈宫返回了 “Hello World”。

  5.  关闭一个 hello-service，继续测试，没有问题。wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==两个服务的时候，8081 和 8082交替被调用。可以看到 控制台会交替打印下面的日志：

        在微服务架构中，存在着那么多的服务单元，若一个单元出现故障，就很容易因依赖关系而引发故障的蔓延，最终导致整个系统的瘫痪，这样的架构相较传统架构更加不稳定。如何解决这样的问题呢？服务容错保护， Spring Cloud Hystrix  https://blog.csdn.net/qq_15700115/article/details/119459686

      

剑风偏冷
关注
专栏目录
【Spring Cloud实战:Eureka】服务注册与发现
Strive_Peter的博客
03-01 2655
Spring Cloud Eureka 服务注册与发现 Spring Cloud Eureka是Spring Cloud Netflix 子项目的核心组件之一，主要用于微服务架构中的服务治理。 文章针对 搭建Eureka注册中心，搭建Eureka客户端，搭建Eureka集群及给Eureka注册中心添加登录认证进行介绍和实操。 Eureka简介 在微服务架构中往往会有一个注册中心，每个微服务都会向注册中心去注册自己的地址及端口信息，注册中心维护着服务名称与服务实例的对应关系。 每个微服务都会定时从注册中心获取
SpringCloud概述&快速入门&Eureka注册中心&Ribbon负载均衡&Hystrix熔断器
9.冄2.7.號的博客
07-08 453
学习目标 能够使用RestTemplate发送请求 能够说出SpringCloud的作用 能够搭建Eureka注册中心 能够使用Robbin负载均衡 能够使用Hystrix熔断器 系统架构演变 随着互联网的发展，网站应用的规模不断扩大。需求的激增，带来的是技术上的压力。系统架构也因此也不断的演进、升级、迭代。从单一应用，到垂直拆分，到分布式服务，到SOA，以及现在火热的微服务架构，还有在Google带领下来势汹涌的Service Mesh。我们到底是该乘坐微服务的船只驶向远方，还是偏安逸得过且过？ 其实
Spring Cloud 从入门到精通
热门推荐
GitChat
07-03 79万+
Spring Cloud 是一套完整的微服务解决方案，基于 Spring Boot 框架，准确的说，它不是一个框架，而是一个大的容器，它将市面上较好的微服务框架集成进来，从而简化了开发者的代码量。 本课程由浅入深带领大家一步步攻克 Spring Cloud 各大模块，接着通过一个实例带领大家了解大型分布式微服务架构的搭建过程，最后深入源码加深对它的了解。 本课程共分为四个部分： 第一部分（第...
史上最简单的 SpringCloud 教程 | 第一篇： 服务的注册与发现Eureka(Finchley版本)
weixin_30525825的博客
07-14 8765
转载请标明出处： 原文首发于：https://www.fangzhipeng.com/springcloud/2018/08/30/sc-f1-eureka/ 本文出自方志朋的博客 一、spring cloud简介 鉴于《史上最简单的Spring Cloud教程》很受读者欢迎，再次我特意升级了一下版本，目前支持的版本为Spring Bo...
Spring Cloud 入门，一篇搞定！
最新发布
hooheha的博客
08-17 918
SpringCloud是目前国内使用最广泛的微服务框架。官网地址：https://spring.io/projects/spring-cloud。SpringCloud集成了各种微服务功能组件，并基于SpringBoot实现了这些组件的自动装配，从而提供了良好的开箱即用体验。原理流程：Ribbon 通过 @LoadBalanced 注解标记了 RestTemplate 工具类，所以 Ribbon 就会去拦截 RestTemplate 所发起的 HTTP 请求，并做出一系列对策。
SrpingCloud基本介绍
fulushan的技术专栏
05-01 310
一、Spring Cloud介绍 Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智能路由，微代理，控制总线）。分布式系统的协调导致了样板模式, 使用Spring Cloud开发人员可以快速地支持实现这些模式的服务和应用程序。他们将在任何分布式环境中运行良好，包括开发人员自己的笔记本电脑，裸机数据中心，以及Cloud Foundry等...
SrpingCloud系统学习 -配置管理
蓝星花
12-31 434
前言 Spring Cloud官网对配置服务的描述: 使用Config Server，您可以在所有环境中管理应用程序的外部属性。客户端和服务器上的概念映射与Spring Environment和PropertySource抽象相同，因此它们与Spring应用程序非常契合，但可以与任何以任何语言运行的应用程序一起使用。随着应用程序通过从开发人员到测试和生产的部署流程，您可以管理这些环境之间的配置，...
Spring Cloud详解
a2285786446的博客
08-29 3万+
微服务架构的提出者：马丁福勒简而言之，微服务架构样式[1]是一种将单个应用程序开发为一组小服务的方法，每个小服务都在自己的进程中运行并与轻量级机制（通常是HTTP资源API）进行通信。这些服务围绕业务功能构建，并且可以由全自动部署机制独立部署。这些服务的集中管理几乎没有，它可以用不同的编程语言编写并使用不同的数据存储技术。1、 微服务架构只是一个样式，一个风格。2、 将一个完成的项目，拆分成多个模块去分别开发。3、 每一个模块都是单独的运行在自己的容器中。4、 每一个模块都是需要相互通讯的。
初识Eureka: 微服务架构的原理与应用
## 1.2 微服务架构的优势与特点 微服务架构是一种以小服务构建大系统的架构模式，它将一个大型应用程序拆分为一系列小型服务，每个服务可以独立开发、部署和扩展。微服务架构具有松耦合、独立部署、技术多样性、弹性...
初识Spring Cloud（一）：Netflix
qq_55081353的博客
06-14 1118
基于Netflix公司组件的微服务系统基础
超详细的SpringCloud底层原理
青藤的博客
05-24 9123
先来个简单的介绍吧！ SpringCloud框架 针对这个架构图我分层介绍一下： 1、是web服务器的选型，这个我选择的是nginx+keepalived，haproxy也是一个选择，但是haproxy在反向代理处理跨域访问的时候问题很多。所以我们nginx有些地方做了keep-alive模式处理，减少了三次握手的次数，提高了连接效率。keepalived做nginx的负载，虚拟一个vip对外，两个nginx做高可用，nginx本身反向代理zuul集群。 2、api gateway，这里的zuu
springcloud eureka服务注册中心 最新版本2.x.x
04-17
springcloud eureka 服务注册中心, 使用最新版本的springcloud eureka 服务注册中心
Spring cloud入门
老猿说说专栏
07-13 1607
spring cloud生态spring cloud 为开发人员提供了快速构建分布式系统的一些工具，包括配置管理、服务发现、断路器、路由、事件总线等等 服务的注册与发现（Eureka）
SrpingCloud系统学习 - 服务注册与发现
蓝星花
12-31 1332
1.什么是Spring Cloud？ ----- Spring提供了一系列工具，可以帮助开发人员迅速搭建分布式系统中的公共组件（比如：配置管理，服务发现，断路器，智能路由，微代理，控制总线，一次性令牌，全局锁，主节点选举， 分布式session, 集群状态）。协调分布式环境中各个系统，为各类服务提供模板性配置。使用Spring Cloud, 开发人员可以搭建实现了这些样板的应用，并且在任何分...
springcloud教程 -- 1.快速搭建入门级demo,看这一篇就够了
叶巨岩的博客
08-01 7万+
废话不多讲，跟紧我，开启你的SpringCloud初体验 首先回顾微服务的基本组成： [图片 here] 生产者：提供服务 消费者：消费服务 服务注册/发现中心：服务注册，发现，监控 所以，首先明白springcloud微服务的架构基础：生产者（client），消费者（client），服务注册/发现中心（server）
SpringCloud：服务注册与发现
令狐姑娘
09-12 723
网络上关于Spring、Spring Boot、Spring Cloud是什么的文章非常多，基本就是一个简化开发者劳动而引申出框架的更新，详细请看《Spring Cloud体系介绍》 《各个组件的介绍》 使用SpringCloud搭建微服务，Eureka作为注册中心 1.新建SpringBoot项目 new—Project—Spring Initializr Cloud Disco...
springCloud的eureka注册发现和ribbon客户端实现负载均衡
qq_18841277的博客
09-08 526
eureka是一个服务注册和发现的组件，eureka分为服务的提供者和服务的发现者和注册中心，接下来我们就来搭建一下。
SpringCloud-Ribbon
wuzj1314的博客
04-14 801
spring-cloud-starter-netflix-eureka-client 3.0以上默认不再集成Ribbon而改为集成spring-cloud-starter-loadbalancer。这里只是简单介绍一下之前的ribbon使用。 1.Ribbon介绍 Ribbon是基于HTTO和TCP协议的，主要功能是实现客户端软件的负载均衡算法。 Spring Cloud中Ribbon就是基于NetFix公司的Ribbon实现的，不需要单独部署，但是却...
Spring Cloud Eureka.Ribbon服务注册与调用实战教程
"本文主要探讨了Spring Cloud Eureka与Ribbon在服务注册发现与调用中的应用，通过一个实例展示了如何在Spring Boot环境下配置和使用这两个组件。" 在分布式系统中，服务治理是至关重要的部分，Spring Cloud Eureka ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值