SpringCloud - Spring Cloud Netflix 之 Eureka服务注册中心，Ribbon负载均衡（三）

Dear 丶 2023-09-28 10:20 162阅读 0赞

#### 阅读本文前可先参考 ####

#### [SpringCloud - Spring Cloud根/父项目，开发准备（二）\_MinggeQingchun的博客-CSDN博客][SpringCloud - Spring Cloud_MinggeQingchun_-CSDN] ####

####  ####

我们首先来看下不需要注册服务中心，服务消费者 直接调用 服务提供者

## 一、服务消费者 直接 访问 服务提供者 ##

### 1、服务提供者 ###

1、新建一个springboot Module（springcloud-1-noregistry-provider），设置父项目（服务提供者）

2、添加 web，mysql，mybatis依赖，以及处理资源resoureces，java等插件

<parent>
            <groupId>com.company</groupId>
            <artifactId>springcloud-demo</artifactId>
            <version>1.0.0</version>
            <relativePath/> 
        </parent>
    
        <groupId>com.company</groupId>
        <artifactId>springcloud-1-noregistry-provider</artifactId>
        <version>1.0.0</version>
    
        <name>springcloud-1-noregistry-provider</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.2.2</version>
            </dependency>
    
        </dependencies>
    
        <build>
    
            
            <resources>
                <resource>
                    <directory>src/main/java</directory>
                    <includes>
                        <include>**/*.xml</include>
                    </includes>
                </resource>
    
                <resource>
                    <directory>src/main/resources</directory>
                    <includes>
                        <include>**/*.*</include>
                    </includes>
                </resource>
            </resources>
    
            <plugins>
                
                <plugin>
                    <groupId>org.mybatis.generator</groupId>
                    <artifactId>mybatis-generator-maven-plugin</artifactId>
                    <version>1.3.6</version>
                    <configuration>
                        
                        <configurationFile>GeneratorMapper.xml</configurationFile>
                        <verbose>true</verbose>
                        <overwrite>true</overwrite>
                    </configuration>
                </plugin>
    
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>

3、application.prperties配置文件中配置访问端口9001，以及 mysql数据库等信息

server.port=9001
    
    #设置mysql数据库连接信息
    spring.datasource.url=jdbc:mysql://localhost:3306/springcloud?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
    spring.datasource.username=root
    spring.datasource.password=admin123456

4、可使用代码自动生成响应的mapper，model，service等包以及响应类

public class Goods {
    
        private Integer goodId;
        private String goodName;
        private String goodNameDesc;
        private BigDecimal goodPrice;
        private String goodImgUrl;
        private Integer goodStore;
        private Date startTime;
        private Date endTime;
    
        public Integer getGoodId() {
            return goodId;
        }
    
        public void setGoodId(Integer goodId) {
            this.goodId = goodId;
        }
    
        public String getGoodName() {
            return goodName;
        }
    
        public void setGoodName(String goodName) {
            this.goodName = goodName;
        }
    
        public String getGoodNameDesc() {
            return goodNameDesc;
        }
    
        public void setGoodNameDesc(String goodNameDesc) {
            this.goodNameDesc = goodNameDesc;
        }
    
        public BigDecimal getGoodPrice() {
            return goodPrice;
        }
    
        public void setGoodPrice(BigDecimal goodPrice) {
            this.goodPrice = goodPrice;
        }
    
        public Integer getGoodStore() {
            return goodStore;
        }
    
        public void setGoodStore(Integer goodStore) {
            this.goodStore = goodStore;
        }
    
        public String getGoodImgUrl() {
            return goodImgUrl;
        }
    
        public void setGoodImgUrl(String goodImgUrl) {
            this.goodImgUrl = goodImgUrl;
        }
    
        public Date getStartTime() {
            return startTime;
        }
    
        public void setStartTime(Date startTime) {
            this.startTime = startTime;
        }
    
        public Date getEndTime() {
            return endTime;
        }
    
        public void setEndTime(Date endTime) {
            this.endTime = endTime;
        }
    
        @Override
        public String toString() {
            return "Goods{" +
                    "goodId=" + goodId +
                    ", goodName='" + goodName + '\'' +
                    ", goodNameDesc='" + goodNameDesc + '\'' +
                    ", goodPrice=" + goodPrice +
                    ", goodStore='" + goodStore + '\'' +
                    ", goodImgUrl='" + goodImgUrl + '\'' +
                    ", startTime=" + startTime +
                    ", endTime=" + endTime +
                    '}';
        }
    }
    
    
    @Mapper
    public interface GoodsMapper {
        List<Goods> selectAllGoods();
    }
    
    
    @Service
    public class GoodsServiceImpl implements GoodsService {
    
        @Autowired
        private GoodsMapper goodsMapper;
    
        public List<Goods> getAllGoods() {
            return goodsMapper.selectAllGoods();
        }
    
        public Goods getGoodsById(Integer goodsId) {
            return goodsMapper.selectByPrimaryKey(goodsId);
        }
    
        public int decrByStore(Integer goodsId, Integer buyNum) {
            return goodsMapper.updateByStore(goodsId, buyNum);
        }
    }

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.company.mapper.GoodsMapper">
        <resultMap id="BaseResultMap" type="com.company.model.Goods">
            <id column="good_id" jdbcType="INTEGER" property="goodId"/>
            <result column="good_name" jdbcType="VARCHAR" property="goodName"/>
            <result column="good_name_desc" jdbcType="VARCHAR" property="goodNameDesc"/>
            <result column="good_price" jdbcType="DECIMAL" property="goodPrice"/>
            <result column="good_img_url" jdbcType="VARCHAR" property="goodImgUrl"/>
            <result column="good_store" jdbcType="INTEGER" property="goodStore"/>
            <result column="start_time" jdbcType="TIMESTAMP" property="startTime"/>
            <result column="end_time" jdbcType="TIMESTAMP" property="endTime"/>
        </resultMap>
        <sql id="Base_Column_List">
            good_id, good_name, good_name_desc, good_price, good_store,good_img_url, start_time, end_time
        </sql>
    
        <select id="selectAllGoods" resultMap="BaseResultMap">
            select
            <include refid="Base_Column_List"/>
            from goods
        </select>
    
        <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
            select
            <include refid="Base_Column_List"/>
            from goods
            where good_id = #{goodId,jdbcType=INTEGER}
        </select>
    
        <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
            delete
            from goods
            where good_id = #{goodId,jdbcType=INTEGER}
        </delete>
    
        <insert id="insert" parameterType="com.company.model.Goods">
            insert into goods (good_id, good_name, good_price,good_store)
            values (#{goodId,jdbcType=INTEGER}, #{goodName,jdbcType=VARCHAR}, #{goodPrice,jdbcType=DECIMAL},
                    #{goodStore,jdbcType=INTEGER})
        </insert>
    
        <insert id="insertSelective" parameterType="com.company.model.Goods">
            insert into goods
            <trim prefix="(" suffix=")" suffixOverrides=",">
                <if test="goodId != null">
                    good_id,
                </if>
                <if test="goodName != null">
                    good_name,
                </if>
                <if test="goodPrice != null">
                    good_price,
                </if>
                <if test="goodStore != null">
                    good_store,
                </if>
            </trim>
            <trim prefix="values (" suffix=")" suffixOverrides=",">
                <if test="goodId != null">
                    #{goodId,jdbcType=INTEGER},
                </if>
                <if test="goodName != null">
                    #{goodName,jdbcType=VARCHAR},
                </if>
                <if test="goodPrice != null">
                    #{goodPrice,jdbcType=DECIMAL},
                </if>
                <if test="goodStore != null">
                    #{goodStore,jdbcType=INTEGER},
                </if>
            </trim>
        </insert>
        <update id="updateByPrimaryKeySelective" parameterType="com.company.model.Goods">
            update goods
            <set>
                <if test="goodName != null">
                    good_name = #{goodName,jdbcType=VARCHAR},
                </if>
                <if test="goodPrice != null">
                    good_price = #{goodPrice,jdbcType=DECIMAL},
                </if>
                <if test="goodStore != null">
                    good_store = #{goodStore,jdbcType=INTEGER},
                </if>
            </set>
            where good_id = #{goodsId,jdbcType=INTEGER}
        </update>
        <update id="updateByPrimaryKey" parameterType="com.company.model.Goods">
            update goods
            set good_name  = #{goodName,jdbcType=VARCHAR},
                good_price = #{goodPrice,jdbcType=DECIMAL},
                good_store = #{goodStore,jdbcType=INTEGER}
            where good_id = #{goodsId,jdbcType=INTEGER}
        </update>
    
        <update id="updateByStore">
            update goods
            set good_store = good_store - #{buyNum,jdbcType=INTEGER}
            where good_id = #{goodsId,jdbcType=INTEGER}
        </update>
    </mapper>

5、创建服务提供者访问方法，基于RESTFUL风格

@RestController
    public class GoodsController {
    
        @Autowired
        private GoodsService goodsService;
    
        @GetMapping(value = "/service/goodList")
        public List<Goods> goodList(){
            List<Goods> goodsList = goodsService.getAllGoods();
    
            System.out.println("查询商品列表成功：");
            for (Goods good:goodsList) {
                System.out.println("查询商品："+ good);
            }
            return goodsList;
        }
    }

6、启动springboot启动类，访问应用，测试能否正常运行

http://localhost:9001/service/goodList

![6ec6aece3c194fd4943f293d53181d9d.png][]

### 2、服务消费者 ###

1、新建一个springboot Module（springcloud-1-noregistry-consumer），设置父项目 （服务消费者）

2、添加 web依赖

3、application.prperties配置文件中配置访问端口8081

4、创建一个RestConfig配置类，创建RestTemplate

#### RestTemplate ####

Spring框架提供的RestTemplate类可用于在应用中调用rest服务，它简化了与http服务的通信方式，统一了RESTful的标准，封装了http链接， 我们只需要传入url及返回值类型即可。相较于之前常用的HttpClient，RestTemplate是一种更优雅的调用RESTful服务的方式

@Configuration
    public class RestConfig {
        @Bean
        public RestTemplate restTemplate () {
            return new RestTemplate();
        }
    }

5、创建服务消费者访问方法，基于RESTFUL风格

@RestController
    public class GoodsController {
        private final String GOODS_SERVICE_URL = "http://localhost:9001/service/goodList";
    
        @Autowired
        private RestTemplate restTemplate;
    
        @GetMapping(value = "/springcloud/goodList")
        public @ResponseBody Object getGoodList(){
            //调用远程的一个controller(Restful风格调用)
            ResponseEntity<Object> responseEntity = restTemplate.getForEntity(GOODS_SERVICE_URL, Object.class);
    
            return responseEntity.getBody();
        }
    }

6、启动springboot启动类，访问应用，测试能否正常运行 http://localhost:8081/springcloud/goodList

![124eac47109843adbe74c94b3a5fab4a.png][]

## 二、Eureka 服务注册中心 ##

通过手动指定每个服务来实现调用，相当低效，当服务接口增多，手动指定接口地址变得难以维护

Spring Cloud（特指 Spring Cloud Netflix） 提供了多种服务注册与发现的实现方式，如：Eureka、Consul、Zookeeper

Spring Cloud（特指 Spring Cloud Netflix）支持得最好的是 Eureka，其次是 Consul，再次是 Zookeeper；当然后续还会说到 Spring Cloud Alibaba的 Nacos

### **服务注册** ###

服务注册：将服务所在主机、端口、版本号、通信协议等信息登记到注册中心上

### **服务发现** ###

服务发现：服务消费者向注册中心请求已经登记的服务列表，然后得到某个服务的主机、端口、版本号、通信协议等信息，从而实现对具体服务的调用；

### Eureka ###

Eureka 是 Netflix 公司开发的一款开源的服务注册与发现组件

> Spring Cloud 将 Eureka 与 Netflix 中的其他开源服务组件（例如 Ribbon、Feign 以及 Hystrix 等）一起整合进 Spring Cloud Netflix 模块中，整合后的组件全称为 Spring Cloud Netflix Eureka。

Eureka 是 Spring Cloud Netflix 模块的子模块，它是 Spring Cloud 对 Netflix Eureka 的二次封装，主要负责 Spring Cloud 的服务注册与发现功能。  
  
Spring Cloud 使用 Spring Boot 思想为 Eureka 增加了自动化配置，开发人员只需要引入相关依赖和注解，就能将 Spring Boot 构建的微服务轻松地与 Eureka 进行整合。

####  ####

### 1、Spring Cloud Netflix 架构图 ###

Service Provider： 暴露服务的服务提供方

Service Consumer：调用远程服务的服务消费方。

EureKa Server： 服务注册中心和服务发现中心

![8aa9ab9acb4b46e8a297bacc3b61fe29.png][]

### 2、Eureka 两大组件 ###

Eureka 采用 CS（Client/Server，客户端/服务器） 架构，它包括以下两大组件：

**Eureka Server**：Eureka 服务注册中心，主要用于提供服务注册功能。当微服务启动时，会将自己的服务注册到 Eureka Server。Eureka Server 维护了一个可用服务列表，存储了所有注册到 Eureka Server 的可用服务的信息，这些可用服务可以在 Eureka Server 的管理界面中直观看到。

**Eureka Client**：Eureka 客户端，通常指的是微服务系统中各个微服务，主要用于和 Eureka Server 进行交互。在微服务应用启动后，Eureka Client 会向 Eureka Server 发送心跳（默认周期为 30 秒）。若 Eureka Server 在多个心跳周期内没有接收到某个 Eureka Client 的心跳，Eureka Server 将它从可用服务列表中移除（默认 90 秒）。

> 注：“心跳”指的是一段定时发送的自定义信息，让对方知道自己“存活”，以确保连接的有效性。大部分 CS 架构的应用程序都采用了心跳机制，服务端和客户端都可以发心跳。通常情况下是客户端向服务器端发送心跳包，服务端用于判断客户端是否在线。

#### 1、Eureka注册服务端 ####

1、新建一个springboot Module（springcloud-3-service-eureka），设置父项目（服务注册中心）

2、添加 web，eureka-server 依赖

添加 eureka server 的依赖！！！**spring-cloud-starter-netflix-eureka-server**

<dependency> 
        <groupId>org.springframework.cloud</groupId> 
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId> 
    </dependency>

3、application.prperties配置文件中配置访问端口8761，以及配置 Eureka服务注册中心信息

#内嵌Tomcat端口
    server.port=8761
    
    #设置该服务注册中心的hostname
    eureka.instance.hostname=localhost
    #由于目前创建的应用是一个服务注册中心，而不是普通应用；默认情况下，这个应用会向注册中心（它自己）注册自己，设置FALSE表示禁止自己向自己注册的默认行为
    eureka.client.register-with-eureka=false
    #表示不去从服务端检索其他服务信息，因为自己就是服务端，服务注册中心本身职责就是维护服务实例，不需要去检索其他服务
    eureka.client.fetch-registry=false
    #指定服务注册中心的位置  eureka.client.service-url.defaultZone=http://localhost:8761/eureka
    eureka.client.service-url.defaultZone=http://localhost:8761/eureka

4、在 Spring Boot 的入口类上添加一个**@EnableEurekaServer** 注解，开启 Eureka 注册中心服务端

import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
    
    @EnableEurekaServer //开启Eureka服务端
    @SpringBootApplication
    public class EurekaApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(EurekaApplication.class, args);
        }
    
    }

5、启动 SpringBoot 程序，main 方法运行，浏览器输入访问

http://localhost:8761/

Eureka控制面板界面如下

![b9690283366648339eb8bf4c4f9e0c27.png][]

Eureka控制面板界面详细参数可参考 [https://blog.csdn.net/MinggeQingchun/article/details/125261048][https_blog.csdn.net_MinggeQingchun_article_details_125261048]

####  ####

#### 2、Eureka注册服务提供者 ####

1、新建一个springboot Module（springcloud-3-service-eureka-provider），设置父项目（服务提供者）

2、添加 web，mysql，mybatis，springcloud的common公共服务，springboot自动热部署，spring-cloud-starter-netflix-eureka-client等 依赖，以及处理资源resoureces,java等插件

eureka 客户端的依赖！！！**spring-cloud-starter-netflix-eureka-client**

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>

<parent>
            <groupId>com.company</groupId>
            <artifactId>springcloud-demo</artifactId>
            <version>1.0.0</version>
            <relativePath/> 
        </parent>
    
        <groupId>com.company</groupId>
        <artifactId>springcloud-3-service-eureka-provider</artifactId>
        <version>1.0.0</version>
    
        <name>springcloud-3-service-eureka-provider</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.2.2</version>
            </dependency>
    
            
            <dependency>
                <groupId>com.company</groupId>
                <artifactId>springcloud-2-service-common</artifactId>
                <version>1.0.0</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <optional>true</optional>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
    
        </dependencies>
    
        <build>
    
            
            <resources>
                <resource>
                    <directory>src/main/java</directory>
                    <includes>
                        <include>**/*.xml</include>
                    </includes>
                </resource>
    
                <resource>
                    <directory>src/main/resources</directory>
                    <includes>
                        <include>**/*.*</include>
                    </includes>
                </resource>
            </resources>
    
            <plugins>
    
                
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>

3、application.prperties配置文件中配置访问端口9001，mysql数据库，以及 服务名称 和 eureka注册中心 等信息

server.port=9001
    
    #设置应用名称，对应Eureka控制台下 DS Replicas 的 Application
    spring.application.name=springcloud-3-service-eureka-provider
    
    #设置mysql数据库连接信息
    spring.datasource.url=jdbc:mysql://localhost:3306/springcloud?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
    spring.datasource.username=root
    spring.datasource.password=admin123456
    
    #每间隔5s，向Eureka服务注册中心发送一次心跳，证明服务是否依然“存活”
    eureka.instance.lease-renewal-interval-in-seconds=5
    #告诉服务端，如果10s之内没有发送心跳，就代表故障，将本服务踢出
    eureka.instance.lease-expiration-duration-in-seconds=10
    #告诉服务端，服务实例以IP作为链接，不是取机器名
    eureka.instance.prefer-ip-address=false
    
    #注册服务实例名称
    eureka.instance.instance-id=springcloud-3-service-eureka-provider
    #注册中心的链接地址
    eureka.client.service-url.defaultZone=http://localhost:8761/eureka

注：

这里需要配置一下应用名称，对应Eureka控制台下 DS Replicas 的 Application

#设置应用名称，对应Eureka控制台下 DS Replicas 的 Application
    spring.application.name=springcloud-3-service-eureka-provider

如果没设置

![ce6c54d161ad490d816c8a0df20c981d.png][]

设置了应用名称

![6420d8c0233340aa9eb5dafe1b9e6af3.png][]

4、在 Spring Boot 的启动类中，添加**@EnableEurekaClient** 注解，表明是一个 eureka 客户端，让服务提供者可以连接 eureka 注册中心

@EnableEurekaClient  //开启 Eureka client服务
    @SpringBootApplication
    public class Eureka3ProviderApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(Eureka3ProviderApplication.class, args);
        }
    
    }

5、可使用代码自动生成响应的mapper，model，service等包以及响应类（可放在公共服务Module common中）

6、创建服务提供者访问方法，基于RESTFUL风格

@RestController
    public class GoodsController {
    
        @Autowired
        private GoodsService goodsService;
        
        @GetMapping(value = "/eureka/service/goodList")
        public List<Goods> goodList(){
            List<Goods> goodsList = goodsService.getAllGoods();
    
            System.out.println("查询商品列表成功：");
            for (Goods good:goodsList) {
                System.out.println("查询商品："+ good);
            }
            return goodsList;
        }
    }

7、启动springboot启动类，访问应用，再去查看 Eureka 控制中心控制台服务 http://localhost:9001/eureka/service/goodList

http://localhost:8761/

![7fc8adc7757e4435b8af8aa001a619a7.png][]

#### 3、Eureka注册服务消费者 ####

1、新建一个springboot Module（springcloud-3-service-eureka-consumer），设置父项目 （服务消费者）

2、添加 web依赖，springcloud的common公共服务，springboot自动热部署，spring-cloud-starter-netflix-eureka-client 客户端支持

eureka 客户端的依赖！！！**spring-cloud-starter-netflix-eureka-client**

3、application.prperties配置文件中配置访问端口8081

server.port=8081
    
    #设置应用名称，对应Eureka控制台下 DS Replicas 的 Application
    spring.application.name=springcloud-3-service-eureka-consumer
    
    #每间隔5s，向Eureka服务注册中心发送一次心跳，证明服务是否依然“存活”
    eureka.instance.lease-renewal-interval-in-seconds=30
    #告诉服务端，如果10s之内没有发送心跳，就代表故障，将本服务踢出
    eureka.instance.lease-expiration-duration-in-seconds=60
    #告诉服务端，服务实例以IP作为链接，不是取机器名
    eureka.instance.prefer-ip-address=false
    
    #注册服务实例名称
    eureka.instance.instance-id=springcloud-3-service-eureka-consumer
    #注册中心的链接地址
    eureka.client.service-url.defaultZone=http://localhost:8761/eureka

4、Springboot启动类上添加**@EnableEurekaClient** 注解，表明是一个 eureka 客户端，让服务消费者可以使用 eureka 注册中心

@EnableEurekaClient  //开启 Eureka client服务
    @SpringBootApplication
    public class Eureka3ConsumerApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(Eureka3ConsumerApplication.class, args);
        }
    
    }

5、创建一个RestConfig配置类，创建RestTemplate；使用Ribbon调用（服务的发现由 eureka 客户端实现，而服务的消费由 Ribbon 实现）

注：

**服务的发现由 eureka 客户端实现，而服务的消费由 Ribbon 实现**，因此服务的调用需要 eureka 客户端和 Ribbon，两者配合起来才能实现；

Eureka 客户端是一个 Java 客户端，用来连接 Eureka 服务端，与服务端进行交互、负载均衡，服务的故障切换等；

Ribbon 是一个基于 HTTP 和 TCP 的客户端负载均衡器，当使用 Ribbon 对服务进行访问的时候，它会扩展 Eureka 客户端的服务发现功能，实现从Eureka 注册中心中获取服务端列表，并通过 Eureka 客户端来确定服务端是否己经启动。

Ribbon 在 Eureka 客户端服务发现的基础上，实现了对服务实例的选择策略，从而实现对服务的负载均衡消费。

@Configuration
    public class RestConfig {
    
        //使用Ribbon实现负载均衡的调用
        @LoadBalanced
        @Bean
        public RestTemplate restTemplate () {
            return new RestTemplate();
        }
    }

6、创建服务消费者访问方法，基于RESTFUL风格

@RestController
    public class GoodsController {
        private final String GOODS_SERVICE_URL = "http://localhost:9001/service/goodList";
    
        private final String GOODS_SERVICE_EUREKA_URL = "http://springcloud-3-service-eureka-provider/eureka/service/goodList";
    
        @Autowired
        private RestTemplate restTemplate;
    
        @GetMapping(value = "/springcloud/eureka/goodList")
        public @ResponseBody Object getGoodList(){
            //调用远程的一个controller(Restful风格调用)
            ResponseEntity<Object> responseEntity = restTemplate.getForEntity(GOODS_SERVICE_EUREKA_URL, Object.class);
    
            return responseEntity.getBody();
        }
    }

7、启动springboot启动类，访问应用，测试能否正常运行 http://localhost:8081/springcloud/eureka/goodList

![0d1b037e770241f8ba223a2b226c2a44.png][]

这时再去访问 Eureka 控制台，就会发现一个服务提供者，和一个服务消费者

![b994b0a84ed24e218376e89703e3a20c.png][]

[SpringCloud - Spring Cloud_MinggeQingchun_-CSDN]: https://blog.csdn.net/MinggeQingchun/article/details/125273584?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22125273584%22%2C%22source%22%3A%22MinggeQingchun%22%7D&ctrtid=LyK5x
[6ec6aece3c194fd4943f293d53181d9d.png]: https://img-blog.csdnimg.cn/6ec6aece3c194fd4943f293d53181d9d.png
[124eac47109843adbe74c94b3a5fab4a.png]: https://img-blog.csdnimg.cn/124eac47109843adbe74c94b3a5fab4a.png
[8aa9ab9acb4b46e8a297bacc3b61fe29.png]: https://img-blog.csdnimg.cn/8aa9ab9acb4b46e8a297bacc3b61fe29.png
[b9690283366648339eb8bf4c4f9e0c27.png]: https://img-blog.csdnimg.cn/b9690283366648339eb8bf4c4f9e0c27.png
[https_blog.csdn.net_MinggeQingchun_article_details_125261048]: https://blog.csdn.net/MinggeQingchun/article/details/125261048
[ce6c54d161ad490d816c8a0df20c981d.png]: https://img-blog.csdnimg.cn/ce6c54d161ad490d816c8a0df20c981d.png
[6420d8c0233340aa9eb5dafe1b9e6af3.png]: https://img-blog.csdnimg.cn/6420d8c0233340aa9eb5dafe1b9e6af3.png
[7fc8adc7757e4435b8af8aa001a619a7.png]: https://img-blog.csdnimg.cn/7fc8adc7757e4435b8af8aa001a619a7.png
[0d1b037e770241f8ba223a2b226c2a44.png]: https://img-blog.csdnimg.cn/0d1b037e770241f8ba223a2b226c2a44.png
[b994b0a84ed24e218376e89703e3a20c.png]: https://img-blog.csdnimg.cn/b994b0a84ed24e218376e89703e3a20c.png