跟乐乐学微服务!(一) SpringCloud组件Eureka的应用

最新推荐文章于 2022-07-27 11:38:34 发布

君を見つけて

最新推荐文章于 2022-07-27 11:38:34 发布

阅读量853

点赞数

分类专栏： Cloud微服务

本文链接：https://blog.csdn.net/chinatopno1/article/details/111770672

版权

Cloud微服务专栏收录该内容

11 篇文章 0 订阅

订阅专栏

下一篇文章：跟乐乐学微服务!(二) SpringCloud组件负载均衡Ribbon的应用

Eureka介绍

Eureka的意义

在没有注册中心的时候，服务消费者要访问服务提供者的话，服务消费者需要手动地，写死服务提供方的地址才可以。
但假如服务提供方由一个ip地址变为另一个ip地址的话，就又需要去更改。
那么，有了eureka注册中心后，就可以解决这个问题。
为什么呢？因为服务提供方会通过eureka客户端，将自己的服务地址注册在eureka服务端；服务消费端使用eureka客户端，通过访问eureka服务端，再去拉取服务提供方地址。从而不用去写死一个服务提供方的地址。
这和zookeeper作用是一样的，他们都是注册中心。

Eureka的原理

在这里插入图片描述

Eureka：就是服务注册中心（可以是一个集群），对外暴露自己的地址
提供者：启动后向Eureka注册自己信息（地址，提供什么服务）
消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新
心跳(续约)：提供者定期通过http方式向Eureka刷新自己的状态

应用实践一：创建父工程

现在，我们需要实践一下Eureka。为了方便，我们需要先创建一个父工程，Eureka服务端、服务提供方、服务消费方这三个模块都将在该父工程下运行。
SpringBoot版本：2.3.7.RELEASE
SpringCloud版本：Hoxton.SR9

父工程的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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.databasequeryproject</groupId>
    <artifactId>databasequery</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>databasequery</name>
    <description>DatabaseQueryProject</description>
    <packaging>pom</packaging>
    
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-cloud.version>Hoxton.SR9</spring-cloud.version>
    </properties>

    <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.7.RELEASE</version>
    </parent>

    <dependencies>
        <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>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <!-- dependencyManagement标签用于版本管理，锁定依赖的版本。这样以来，dependencies标签下的依赖将无需通过version指定版本，默认使用dependencyManagement标签下指定的版本。 -->
    <dependencyManagement>
        <dependencies>
            <!-- springCloud -->
            <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.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <mainClass>com.databasequeryproject.databasequery.DatabasequeryApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

应用实践二：Eureka单节点

在这里插入图片描述

一.Eureka服务端的配置

我们需要创建一个模块，这个模块专门用来提供Eureka服务端服务。
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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
	<!-- 继承父工程 -->
    <parent>
        <groupId>com.databasequeryproject</groupId>
        <artifactId>databasequery</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <artifactId>eureka-server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>eureka-server</name>
    <description>Demo project for Spring Boot</description>

  <dependencies>
  	<!-- 引入Eureka服务端依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            <version>2.2.7.RELEASE</version>
        </dependency>
    </dependencies>

</project>

配置文件如下：

server:
  port: 2001
# 应用名称
spring:
  application:
    name: eureka-server-application

eureka:
  client:
    service-url: # 作为Eureka服务端，如果你要实现集群，则下面只能填写其它Eureka服务端地址。如果不是集群，则只填写自己本机地址。
      defaultZone: http://127.0.0.1:2001/eureka
      # 作为Eureka服务端，且是Eureka单节点的情况下，自身将不提供服务，因此不应将自己注册。
    register-with-eureka: false
    # 作为Eureka服务端，，且是Eureka单节点的情况下，自身不需要消费服务，所以不应拉取服务。
    fetch-registry: false

启动类如下：

package com.databasequeryproject.eurekaserver;

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

@SpringBootApplication
@EnableEurekaServer //通过该注解表示该项目或模块用于Eureka服务端。
public class EurekaServerApplication {

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

}

二.服务提供方配置

这个服务提供方将暴露一个查询接口，给消费方去请求。
作为服务提供方，我们需要将自己这个服务通过Eureka客户端注册到Eureka服务端。
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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.databasequeryproject</groupId>
        <artifactId>databasequery</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <artifactId>providerofdatabasequery</artifactId>
    <name>providerofdatabasequery</name>
    <description>providerOfDatabaseQueryProject</description>


    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    </properties>

    <dependencies>

        <!-- Eureka客户端依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.2.7.RELEASE</version>
        </dependency>

        <!-- mybatis依赖 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>

        <!-- mysql依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

</project>

配置文件如下：

server:
  port: 8081 # 服务提供者端口

eureka:
  client:
    service-url: # 作为eureka客户端，你需要填写eureka服务端的地址。如果存在eureka服务端集群，则需要将这些集群地址全部写上去。
      defaultZone: http://127.0.0.1:2001/eureka
      # 作为服务提供者，通过register-with-eureka，来表示使用本eureka客户端向eureka服务端去注册服务。
    register-with-eureka: true
    # 作为服务提供者，本eureka客户端不应该从eureka服务端拉取服务。因此fetch-registry设为false.
    fetch-registry: false
#  instance:
#    prefer-ip-address: true # 是否将本服务以ip注册到eureka服务端中，而非是主机名?
#    ip-address: 127.0.0.1 # 本服务的ip地址。

spring:
  application:
    name: database-provider-service # 给服务起个名。
    # 数据库驱动：
  datasource: # 配置多个数据源
    db-mydatabase: # 存放信息数据的数据源
      type: com.zaxxer.hikari.HikariDataSource # 指定数据源所用连接池为hikari
      driver-class-name: com.mysql.cj.jdbc.Driver
      name: defaultDataSource # 数据源名称，该数据源用于存放信息数据
      jdbc-url: jdbc:mysql://localhost:3306/qq_phoneNumber?serverTimezone=UTC # jdbc:mysql://localhost:3306/qq_phoneNumber?serverTimezone=UTC
      username: root
      password: root

#下面这些内容是为了让MyBatis映射
#指定Mybatis的Mapper文件
mybatis:
  mapper-locations: classpath:mapper/*xml # 因为要配置多数据源，所以这里注释掉。无用了
  #指定Mybatis的实体目录
  type-aliases-package: com.databasequeryproject.providerofdatabasequery.pojo
  configuration: # 开启sql文打印
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

启动类如下：

package com.databasequeryproject.providerofdatabasequery;

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


@SpringBootApplication
@EnableTransactionManagement
@EnableDiscoveryClient// 表示这个工程使用Eureka客户端。将使用客户端的服务注册/服务拉取功能
public class ProviderofdatabasequeryApplication {

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

}

controller如下：

@RestController
@RequestMapping(value = "query")
public class QueryController {

    @Autowired
    private QueryService queryService;

    @GetMapping("qq/{qqnum}")
    public QueryResult qqQueryMethod(@PathVariable("qqnum") String qqnum){
        QueryResult query = queryService.query(qqnum);
        return query;
    }

}

此处我们省略了service层和dao层的代码。只需要知道controller暴露的是一个查询业务的接口就是了。
启动了服务提供方后，服务提供方就会将自身服务注册到eureka服务端。
我们访问eureka服务端地址：http://127.0.0.1:2001 来查看一下。
在这里插入图片描述
可以看到，已经存在了一个服务名为’DATABASE-PROVIDER-SERVICE‘的实例，它的服务地址是DESKTOP-TPILP2U:8081（可以
配置prefer-ip-address为true来显示ip）

三.服务消费方配置

服务消费方将使用eureka客户端，从eureka服务端拉取一个服务（提供方的）地址，然后访问这个服务地址的接口。
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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!-- 继承父工程 -->
    <parent>
        <groupId>com.databasequeryproject</groupId>
        <artifactId>databasequery</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>


    <artifactId>database-query-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>database-query-consumer</name>
    <description>Demo project for Spring Boot</description>


    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
    </properties>

    <dependencies>
	<!-- 引用eureka依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.2.7.RELEASE</version>
        </dependency>

    </dependencies>

</project>

配置文件如下：

server:
  port: 8082 # 服务消费者端口

# 应用名称
spring:
  application:
    name: database-consumer-service
eureka:
  client:
    service-url: # 作为eureka客户端，你需要填写eureka服务端的地址。如果存在eureka服务端集群，则需要将这些集群地址全部写上去。
      defaultZone: http://127.0.0.1:2001/eureka
      # 作为服务消费者，我们是要消费的，所以不应将自身服务注册在eureka服务端。因此register-with-eureka为false
    register-with-eureka: false
    # 作为服务提供者，我们需要从eureka服务端拉取服务提供者。因此fetch-registry为true
    fetch-registry: true

启动类如下：

package com.databasequery.databasequeryconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableDiscoveryClient// 表示这个工程使用Eureka客户端。将使用客户端的服务注册/服务拉取功能
public class DatabaseQueryConsumerApplication {

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

    @Bean//创建RestTemplate对象，通过Bean注解交由SpringIOC容器，以便可以用Autowired注入。
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

controller如下：

package com.databasequery.databasequeryconsumer.controller;

import com.databasequery.databasequeryconsumer.pojo.QueryResult;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import java.util.List;

@RestController
@RequestMapping(value = "query")
public class QueryController {

    // restTemplate用于访问服务提供方暴露的接口。
    @Autowired
    private RestTemplate restTemplate;

    // discoveryClient用于通过Eureka注册中心，来访问服务提供方。
    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("qq/{qqNumber}")
    public QueryResult qqQuery(@PathVariable("qqNumber") String qqNumber){
        //根据服务名称从Eureka服务端拉取该服务。
        List<ServiceInstance> serviceInstanceList = discoveryClient.getInstances("database-provider-service");
        ServiceInstance serviceInstance = serviceInstanceList.get(0);
        String url = "http://"+serviceInstance.getHost()+":"+serviceInstance.getPort()+"/query/qq/"+qqNumber;
        QueryResult qr =   restTemplate.getForObject(url, QueryResult.class);
       return qr;
    }
}

应用实践三：Eureka集群

背景

在这里插入图片描述

问题说明：
单节点的 Eureka Server 虽然能够实现基础功能，但是存在单点故障的问题，不能实现高可用。因为 Eureka Server 中存储了整个系统中所有的微服务的元数据信息，单节点一旦挂了，所有的服务信息都会丢失，造成整个系统的瘫痪。

解决办法：搭建 Eureka Server 集群，让各个 Server 节点之间互相注册，从而实现微服务元数据的复制/备份，即使单个节点失效，其他的 Server 节点仍可以继续提供服务

注意:eureka相互注册实现高可用，是eureka服务端的相互注册，而不是eureka客户端的相互注册

一.编辑Eureka服务端的配置

# 通过SpringCloud的单一文件多个配置的特性，我们在自己这一台电脑上模拟多个eureka服务端，进行Eureka集群。

# 第一个Eureka服务端服务配置
server:
  port: 2001
# 应用名称
spring:
  application:
    name: eureka-server-application
  profiles: eurekaConfig1 # 为该配置起个名，以便启动时进行指定。
eureka:
  client:
    service-url: # 作为Eureka服务端，且需要实现Eureka集群，则下面只能填写其它Eureka服务端地址。
      defaultZone: http://127.0.0.1:2002/eureka,http://127.0.0.1:2003/eureka
      # 作为Eureka服务端，在需要实现Eureka集群的情况下，需要将自己这个服务端注册到其它Eureka服务端上。
    register-with-eureka: true
    # 作为Eureka服务端，在需要实现Eureka集群的情况下，需要从其它Eureka服务端拉取服务信息，以便实现Eureka服务端之间的数据元共享与备份。
    fetch-registry: true


---
# 第二个Eureka服务端服务配置
server:
  port: 2002
spring:
  application:
    name: eureka-server-application
  profiles: eurekaConfig2
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:2001/eureka,http://127.0.0.1:2003/eureka
    register-with-eureka: true
    fetch-registry: true

---
# 第三个Eureka服务端服务配置
server:
  port: 2003
spring:
  application:
    name: eureka-server-application
  profiles: eurekaConfig3
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:2001/eureka,http://127.0.0.1:2002/eureka
    register-with-eureka: true
    fetch-registry: true

二.编辑服务提供方配置

在这里插入图片描述

server:
  port: 8081 # 服务提供者端口

eureka:
  client:
    service-url: # 作为eureka客户端，你需要填写eureka服务端的地址。如果存在eureka服务端集群，则需要将这些集群地址全部写上去。
      defaultZone: http://127.0.0.1:2001/eureka,http://127.0.0.1:2001/eureka,http://127.0.0.1:2002/eureka,http://127.0.0.1:2003/eureka
      # 作为服务提供者，通过register-with-eureka，来表示使用本eureka客户端向eureka服务端去注册服务。
    register-with-eureka: true
    # 作为服务提供者，本eureka客户端不应该从eureka服务端拉取服务。因此fetch-registry设为false.
    fetch-registry: false
#  instance:
#    prefer-ip-address: true # 是否将本服务以ip注册到eureka服务端中，而非是主机名?
#    ip-address: 127.0.0.1 # 本服务的ip地址。

spring:
  application:
    name: database-provider-service # 给服务起个名。
    # 数据库驱动：
  datasource: # 配置多个数据源
    db-mydatabase: # 存放信息数据的数据源
      type: com.zaxxer.hikari.HikariDataSource # 指定数据源所用连接池为hikari
      driver-class-name: com.mysql.cj.jdbc.Driver
      name: defaultDataSource # 数据源名称，该数据源用于存放信息数据
      jdbc-url: jdbc:mysql://localhost:3306/qq_phoneNumber?serverTimezone=UTC # jdbc:mysql://localhost:3306/qq_phoneNumber?serverTimezone=UTC
      username: root
      password: root
      
#下面这些内容是为了让MyBatis映射
#指定Mybatis的Mapper文件
mybatis:
  mapper-locations: classpath:mapper/*xml # 因为要配置多数据源，所以这里注释掉。无用了
  #指定Mybatis的实体目录
  type-aliases-package: com.databasequeryproject.providerofdatabasequery.pojo
  configuration: # 开启sql文打印
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

四.编辑服务消费方配置

在这里插入图片描述

server:
  port: 8082 # 服务消费者端口

# 应用名称
spring:
  application:
    name: database-consumer-service
eureka:
  client:
    service-url: # 作为eureka客户端，你需要填写eureka服务端的地址。如果存在eureka服务端集群，则需要将这些集群地址全部写上去。
      defaultZone: http://127.0.0.1:2001/eureka,http://127.0.0.1:2002/eureka,http://127.0.0.1:2003/eureka
      # 作为服务消费者，我们是要消费的，所以不应将自身服务注册在eureka服务端。因此register-with-eureka为false
    register-with-eureka: false
    # 作为服务提供者，我们需要从eureka服务端拉取服务提供者。因此fetch-registry为true
    fetch-registry: true

五.通过IDEA进行Eureka服务集群启动。

由于我们在Eureka服务端模块的配置文件中进行了多个eureka服务端配置。
所以启动eureka服务端模块时，需要通过idea来指定选用哪个配置。

首先，点击右上角的web服务配置栏，选择’Edit Configurations’

在这里插入图片描述

复制多个’EurekaServerApplication‘WEB服务，因为配置文件中配置了三个服务，所以复制三个。

在这里插入图片描述

在’Program
arguments’这一栏，通过’–spring.profiles.active=配置名'参数，使IDEA根据配置文件中的配置名来启动服务。
当启动三个eureka服务端模块后，我们访问其中一个会发现，三个eureka服务端已经全部注册了。

在这里插入图片描述

我们再来启动服务提供方‘DATABASE-PROVIDER-SERVICE’，服务提供方会将自己注册在eureka服务端集群，此时就会显示‘DATABASE-PROVIDER-SERVICE’服务有一个节点存在。

在这里插入图片描述

君を見つけて

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
跟乐乐学微服务!(一) SpringCloud组件Eureka的应用

问题说明：单节点的 Eureka Server 虽然能够实现基础功能，但是存在单点故障的问题，不能实现高可用。因为 Eureka Server 中存储了整个系统中所有的微服务的元数据信息，单节点一旦挂了，所有的服务信息都会丢失，造成整个系统的瘫痪。解决办法：搭建 Eureka Server 集群，让各个 Server 节点之间互相注册，从而实现微服务元数据的复制/备份，即使单个节点失效，其他的 Server 节点仍可以继续提供服务示例：spring: application:
复制链接

扫一扫