使用Eureka搭建单击模拟到集群模拟

cra风

已于 2023-02-14 15:30:50 修改

阅读量475

点赞数 2

文章标签： spring tomcat maven spring cloud mybatis Powered by 金山文档

于 2023-02-13 15:35:06 首次发布

本文链接：https://blog.csdn.net/weixin_61189391/article/details/129007731

版权

首先讲讲什么是Eureka:

1.Eureka是Netflix的子模块，同样也是核心模块之一，Eureka是基于REST的服务，用于定位服务，以实现云端中间件层服务发现和故障转移，服务注册与发现对于微服务来说是非常重要的，有了服务注册于发现，只需要使用服务的标识符，就可以访问到服务，而不需要服务调用的配置文件了，功能类似于Dubbo的注册中心，比如zookeeper。

讲讲Eureka基本的架构：

SpringCloud封装了Nerflix公司开发的Eureka模块来实现服务注册与发现。

Eureka采用了C-S的架构设计，EurekaService作为服务注册功能的服务器，它是服务注册中心。

而系统中的其他微服务，使用Eureka的客户连接到EurekaService并维持心跳连接，这样系统的维护人员就可以通过EurekaService来监控这样中各个微服务是否正常运行，SpringCloud的一些其他模块（比如Zuul）就可以通过EurekaService来发现系统中的其他微服务，并且执行相关的逻辑。

Eureka包含两个组件：Eureka Server和Eureka Client。

EurekaService提供服务器注册，各个结点启动后，会在EurekaServer中进行注册，这样Eureka Service中的服务器注册表中将会存储所有可用服务结点的信息，服务结点的信息可以在界面中直观的看到。

Eureka Client是一个Java客户端，用于简化EurekaServer的交互，客户端同时也具备一个内置的，使用轮询负载算法的负载均衡器，在应用启动后，将会向EurekaServer发送心跳（默认周期为30秒），如果Eureka Server多个心跳周期内没有接受到某个结点的心跳，EurekaServer将会从服务注册表中把这个服务结点移除掉（默认周期为90秒）。

Eureka的三大角色

Eureka Server:提供服务的注册与发现。

Service Provider：服务生成方，将自身服务注册到Eureka中，从而使服务消费方能够找到。

Service Consumer：服务消费方，从Eureka中获取注册服务列表，从而找到消费服务。

首先我们先说一下生成者与消费者之间的关系，并且代码演示：

我们需要创建一个普通的maven项目，创建步骤如下：

创建好项目(springcloud-api)之后，导入相应的maven坐标依赖：

<?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>

    <groupId>org.example</groupId>
    <artifactId>springcloud</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>springcloud-api</module>
        <module>springcloud-provider-dept-9999</module>
        <module>springcloud-consumer-dept-80</module>
    </modules>
    <!--   打包方式-->
    <packaging>pom</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.13</junit.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!--        springCloud的依赖-->
            <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-dependencies -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.SR3</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
<!--            springboot-->
            <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-dependencies -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.1.9.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--                springboot启动器-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.1.4</version>
            </dependency>
            <!--        lo4g-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                //这里使用表达式接受的原因是因为上面的properties标签定义了直接获取即可
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
            <!--        lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.16</version>
            </dependency>

            <!--        数据库-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.46</version>
            </dependency>
            <!--        连接池-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.16</version>
            </dependency>
<!--            日志测试-->
            <!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-core -->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.2.3</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

在编写对应的java代码，编写了了一个部门实体类，首先要创建数据库

看着这个结构我相信你可以写出来的，不然怎么可能刷到这篇文章。

对应插入数据表如上，这个存db_source使用的是DATABASE()可以直接获取数据的名字。

那么对应的pojo实体类就是如下图片：

package com.cra.pojo;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.io.Serializable;

@Data
@NoArgsConstructor
@Accessors(chain = true)//链式写法
public class Dept implements Serializable {
    private static final long serialVersionUID = 1827876342325740694L;
    private Long deptno;
    private String dname;
    //这个数据库存在那个数据库的字段 微服务， 一个服务对应一个数据库
    //同一个信息可能存在不同的数据库
    private String db_source;

    public Dept(String dname) {
        this.dname = dname;
    }

    /**
     * 链式写法
     * Dept dept =new Dept();
     * dept.setDeptNo(11).setDnmae('ss').setDb_source('001');
     */
}

接下来创建另外一个项目那就是生成者的：创建项目的过程和上面一样的，也就是在创建时选择父类的时候，选你第一个创建的项目（springcloud-api）。

创建好第二个项目命名为springcloud-provider-dept-9999，搭建maven环境

<?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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-provider-dept-9999</artifactId>

    <dependencies>
<!--        我们需要拿到实体类 所以要配置api module 服务拆分-->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
<!--        springtest-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
<!--        jetty-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
<!--        热部署工具-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
<!--        eureka-->
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.5.RELEASE</version>
        </dependency>
<!--        actuator完善监控信息-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>

</project>

server:
  port: 8001
#mybatis配置
mybatis:
  type-aliases-package: com.cra.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml

#spring的配置
spring:
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: org.gjt.mm.mysql.Driver
    url: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: rxxcwyzxg.

#eureka的配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/,http:127.0.0.1:7002/eureka/,http:10.11.32.46:7003/eureka/
  instance:
    instance-id: springcloud-provider-dept8001 #修改eureka的status的状态名称
#info配置
info:
  app.name: cra-springcloud
  company.name: https://blog.csdn.net/weixin_61189391?type=blog

搭建好maven环境和application.yml后，创建对应的Controller包，并且创建类

package com.cra.controller;

import com.cra.pojo.Dept;
import com.cra.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

//提供Restful服务
@RestController
public class DeptController {
    @Autowired
    private DeptService deptService;
    @PostMapping("/dept/add")
    public boolean addDept(Dept dept){
        return deptService.addDept(dept);
    }

    @GetMapping("/dept/get/{id}")
    public Dept queryOne(@PathVariable("id") Long id) {
        return deptService.queryById(id);
    }

    @GetMapping("/dept/list")
    public List<Dept> queryAll(){
        return deptService.queryAll();
    }

}

创建好对应的dao层，以及myabtis配置和增删改代码

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
<!--        开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
</configuration>

package com.cra.dao;

import com.cra.pojo.Dept;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Mapper
@Repository
public interface DeptDao {
    /**
     * 添加部门
     * @param dept
     * @return
     */
    public boolean addDept(Dept dept);

    /**
     * 查询一个部门
     * @param id
     * @return
     */
    public Dept queryById(Long id);

    /**
     * 查询所有部门
     * @return
     */
    public List<Dept> queryAll();
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cra.dao.DeptDao">
    <insert id="addDept" parameterType="dept">
        insert into db01.dept(dname, db_source)
        values (#{dname},DATABASE());
    </insert>
    <select id="queryById" resultType="dept" parameterType="long">
        select * from db01.dept where deptno=#{deptno};
    </select>
    
    <select id="queryAll" resultType="dept">
        select * from dept;
    </select>
</mapper>

创建service生产者启动类

package com.cra;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
//启动类
@SpringBootApplication
@EnableEurekaClient //在服务启动后自动注册到eureka中！
@EnableDiscoveryClient //服务发现
public class DeptProvider_9999 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8001.class,args);
    }
}

接下来创建消费者的项目，项目名字为springcloud-consumer-dept-80

创建好项目之后，导入对应的maven坐标

<?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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-consumer-dept-80</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
<!--    实体类+web-->
    <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

</project>

maven坐标导入之后，配置以先application.yml

server:
  port: 80

接下来创建controller，和对应的类

package com.cra.controller;

import com.cra.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class DeptConsumerController {
    //理解：消费者，不应该有service层
    //restfulTemplate .... 供我们直接调用就可以了! 注册到spring中
    //(url,实体：map,Class<T> responseType)
    @Autowired
    private RestTemplate restTemplate;//提供多种便捷访问远程http服务的方法，简单的restful服务模板

    //http://localhost:8001/dept/list
    private static final String REST_URL_PREFIX="http://localhost:8001";

    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept){
        return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,Boolean.class);
    }

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get/"+id,Dept.class);
    }

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);
    }
}

创建config包，在创建对应的类

package com.cra.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean {//@Configuration -- spring applationContext.xml
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

创建消费者启动类

package com.cra;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

上面的步骤完成之后启动生成者类，在启动消费者类，就可以进行访问了，也就相对于用户访问你的服务器一样。

当然你访问9999端口也是可以访问的，也就是相对于访问自己。

接下来我们讲一下集群模拟

在前面的基础上我们建立了，生成模式和消费模式的项目，现在我们需要建立注册中心，注册中心的数量为3个，分别是springcloud-eureka-7001，springcloud-eureka-7002,springcloud-eureka-7003,它们对应的域名为localhost,127.0.0.1,10.11.32.46,在每一个的application.yml中也有配置。

创建步骤也是同上(也就是第一个项目创建maven的方式)，创建普通的maven项目

创建好项目之后，在maven添加对应的坐标

<?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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-eureka-7001</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

<!--    导包-->
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
            <version>1.4.5.RELEASE</version>
        </dependency>

    </dependencies>

</project>

添加好maven坐标之后，创建项目的启动类

package com.cra;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
//启动之后，访问http://localhost:7001/
@SpringBootApplication
@EnableEurekaServer //eureka服务端的启动类，可以接受别人注册进来
public class EurekaServer_7001 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServer_7001.class,args);
    }
}

接下来配置application.yml文件

server:
  port: 7001

#Eureka配置
eureka:
  instance:
    hostname: localhost #Eureka服务器的实例名称
  client:
    register-with-eureka: false #表示是否向eureka注册中心注册自己
    fetch-registry: false #fetch-register如果为false，则表示自己为注册中心
    service-url: #监控页面
      #单击：defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      #集群(关联)：
      defaultZone: http://127.0.0.1:7002/eureka/,http://10.11.32.46:7003/eureka/

同理另外连个Erueka Server也是这样子创建

创建第二个服务器 springcloud-erueka-7002项目

创建好之后添加maven环境，如下

<?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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-eureka-7002</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <!--    导包-->
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
            <version>1.4.5.RELEASE</version>
        </dependency>

    </dependencies>

</project>

添加好maven环境之后，创建项目的启动类

package com.cra;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

//启动之后，访问http://localhost:7001/
@SpringBootApplication
@EnableEurekaServer //eureka服务端的启动类，可以接受别人注册进来
public class EurekaServer_7002 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServer_7002.class,args);
    }
}

配置application.yml，如下:

server:
  port: 7002

#Eureka配置
eureka:
  instance:
    hostname: 127.0.0.1 #Eureka服务器的实例名称
  client:
    register-with-eureka: false #表示是否向eureka注册中心注册自己
    fetch-registry: false #fetch-register如果为false，则表示自己为注册中心
    service-url: #监控页面
      defaultZone: http://localhost:7001/eureka/,http://10.11.32.46:7003/eureka/

创建第三个Eureka Server服务器 springcloud-eureka-7003

创建好项目之后添加maven坐标环境

<?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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-eureka-7003</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <!--    导包-->
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
            <version>1.4.5.RELEASE</version>
        </dependency>

    </dependencies>

</project>

添加好maven环境之后，创建项目的启动类

package com.cra;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

//启动之后，访问http://localhost:7001/
@SpringBootApplication
@EnableEurekaServer //eureka服务端的启动类，可以接受别人注册进来
public class EurekaServer_7003 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServer_7003.class,args);
    }
}

创建好启动类之后，配置application.yml文件

server:
  port: 7003

#Eureka配置
eureka:
  instance:
    hostname: 10.11.32.46 #Eureka服务器的实例名称
  client:
    register-with-eureka: false #表示是否向eureka注册中心注册自己
    fetch-registry: false #fetch-register如果为false，则表示自己为注册中心
    service-url: #监控页面
      defaultZone: http://localhost:7001/eureka/,http://127.0.0.1:7002/eureka/

这就是修改statues状态名称的代码

如果你想了解更多请到b站看狂神😃

cra风

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
2
评论
使用Eureka搭建单击模拟到集群模拟

1.Eureka是Netflix的子模块，同样也是核心模块之一，Eureka是基于REST的服务，用于定位服务，以实现云端中间件层服务发现和故障转移，服务注册与发现对于微服务来说是非常重要的，有了服务注册于发现，只需要使用服务的标识符，就可以访问到服务，而不需要服务调用的配置文件了，功能类似于Dubbo的注册中心，比如zookeeper。
复制链接

扫一扫