Spring Cloud 实战: 手把手带你用 Netflix Eureka 实现微服务注册/发现（Service Discovery）

最新推荐文章于 2024-09-02 01:03:39 发布
最新推荐文章于 2024-09-02 01:03:39 发布
阅读量324 收藏
点赞数 1
分类专栏： Spring 文章标签： spring cloud eureka discovery microservice spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44691608/article/details/111282991
版权

Spring Cloud 实战: 手把手带你用 Netflix Eureka 实现微服务注册/发现（Service Discovery）

文章目录

简介

前一篇：Spring Cloud: Overview 概述，对 Spring Cloud 的所有成员有大概的说明。

本篇将要来实现第一个 Spring Cloud 模块：使用 Spring Cloud Netflix Eureka 实现 Service Discovery

参考

Eureka 概念https://blog.csdn.net/u013084266/article/details/100105965
Spring Cloud 入门教程(一): 服务注册https://www.cnblogs.com/chry/p/7248947.html
idea创建springcloud项目图文教程(EurekaServer注册中心)（六）https://blog.csdn.net/hcmony/article/details/77855158
idea创建springcloud项目图文教程(创建服务提供者)（七）https://blog.csdn.net/hcmony/article/details/77855843
idea创建springcloud项目图文教程(创建消费者)（八）https://blog.csdn.net/hcmony/article/details/77855903

正文

Service Discovery 回顾

首先我们先来回顾一下微服务的服务注册/发现(Service Discovery)功能

当我们将服务拆分成一个个微服务(MicroService)时我们可以建立一个注册中心(Register Center)，之后所有服务启动时都需要向注册中心注册(Register)自己的服务，其他微服务想要调用时就可以从注册中心获取可用的服务信息。

Netflix Eureka 架构

为了实现服务注册的特性，本篇采用 Spring Cloud Netflix Eureka 依赖来达成整个目标。

与我们前面提到的类似，Eureka 的注册中心(Register Server)称为一个 Eureka Server，其他每一个微服务(MicroService)则被视为一个 Eureka Client。

当然我们也可以修改配置后启动多个 Eureka Server 并互相发现，实现注册中心的高可用性

实现细节像是什么续约啊、心跳检测啥的用于保证服务持续可用啥的这边就不过多说明了，可以查看参考链接或是自行找寻相关材料吧，这边主要专注在实现上。

项目启动

接下来我们就手把手 使用 Netflix Eureka 带你实现一个简单的微服务注册项目

项目结构

首先先给出项目的目标架构图

此次实践中我们将构建一个 Eureka Server 和两个 Eureka Client（分别是 provider 和 consumer），同时 consumer 将透过 restTemplate 向 provider 请求服务。

  • 架构缺陷

这边的实践存在一个瑕疵：consumer 向 provider 请求服务时仅仅只是简单的 HTTP 请求，与外部的一般调用者无意，也就是说我们还没有用到 Eureka Server 提供的服务发现(Discovery)，而仅仅实现了向 Eureka Server 注册服务(Register)的部分。下一篇我们将使用 Feign 来真正利用 Eureka Server 带来的服务发现功能。

搭建项目外壳

搭建空项目

接下来我们就开始搭建项目内容了。首先先利用 IDEA 创建空的项目，详细步骤如下：

  1. 点击 New Project 创建新的项目

  1. 选择 Empty Project 创建一个空项目，接下来所有微服务都放在该目录之下

  1. 输入项目名称 spring_cloud_eureka（可自定）

Eureka Server 注册中心

创建 Eureka Server 注册中心

  1. 选择 File -> New -> Module 新增模块

  1. 使用 Spring Initializr 创建 Spring 项目（IDEA 新的插件好像是叫 Spring Assistant，一个东西）

  1. 输入一些 maven 项目配置信息（项目名称、Java 版本、包结构等）

  1. 选择 Spring 依赖，选 Spring Cloud Discovery -> Eureka Server

  1. 项目路径就放在刚刚创建的空项目之下就行了：/spring_cloud_eureka/eureka-server

如果建好项目之后看到下面长成这幅德行

那就到 File -> Project Structure -> Module 将 src/main/java 指定为 Sources 就好了

修改依赖配置 pom.xml

  1. 建好项目之后第一件事先来修改 pom.xml 的配置信息（最后会附上详细文件内容）

  • Spring Boot 版本：2.3.2.RELEASE
  • Spring Cloud 版本：Hoxton.SR6

修改入口类

  1. 在入口类 EurekaServerApplication 添加 @EnableEurekaServer，声明为一个注册中心

修改项目配置 application.yml

  1. 将 application.properties 改名为 application.yml 并填入配置信息

server:
  port: 8800 # 启动端口

eureka:
  client:
    register-with-eureka: false # 不向 eureka 注册
    fetch-registry: false # 表明自己就是 eureka server
  instance:
    secure-port-enabled: false

启动并查看可视化界面

  1. 直接在 IDEA 启动项目之后可以访问 http://localhost:8800 查看可视化界面

到此我们的 Eureka Server 就创建完毕啦，不过后面的路还长着呢hhh

Provider 微服务

接下来我们要创建第二个模块：Provider 微服务，基本上与前面创建 Eureka Server 模块的顺序几乎一样（实在是不想再截一轮了就不放图了），不同的之处就用表格列出吧：

对应步骤属性值
3(maven 配置)Artifact Ideureka-service-provider
Project nameeureka-service-provider
Package namecom.example.provider
4(Spring 依赖选择)Eureka Client 依赖Spring Cloud Discovery.Eureka Discovery Client
5(项目路径位置)Module nameeureka-service-provider
Content rootxxx/spring_cloud_eureka/eureka-service-provider
Module file locationxxx/spring_cloud_eureka/eureka-service-provider
6(依赖配置 pom.xml)Eureka Client 依赖(不用修改)使用了 spring-cloud-starter-netflix-eureka-client 依赖
Web 项目依赖新增 spring-boot-starter-web 依赖
7(入口类声明)Annotation改为添加 @EnableEurekaClient 注释，声明为 Eureka Client

第 8 步开始来加入 Provider 的服务内容

Provider 服务 & 配置

  1. 首先我们先创立一个实体类 User
  • User.java
package com.example.provider;

public class User {

    private static int count = 0;
    private Integer id;
    private String name;
    private String password;

    public User() {
        id = count++;
    }

    public User(String name, String password) {
        id = count++;
        this.name = name;
        this.password = password;
    }
    // 省略 id 的 getter
    // 省略 name、password 的 getter/setter
}
  1. 接下来我们建立 ProviderController 并加入我们的服务接口
  • ProviderController.java
package com.example.provider;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@RestController // 声明为 Controller 类
public class ProviderController {

    // 获取配置信息的端口
    @Value("${server.port}")
    private String port;

    // 记录接下来的用户信息（没有持久化）
    private Map<String, User> userTable = new HashMap<>();

    // 默认路由
    @GetMapping("/")
    public String info() {
        return "Default route from port: " + port;
    }

    // 查看所有组册用户
    @GetMapping("/users")
    public Map<String, User> getUserTable() {
        return userTable;
    }

    // 注册接口
    @GetMapping("/register")
    public String register(String name, String password) {
        // 检查参数
        if (name.length() == 0) {
            return "User name is required.";
        }
        if (password.length() == 0) {
            return "User password is required.";
        }
        // 用户名查重
        if (userTable.containsKey(name)) {
            return "User " + name + " is already exist.";
        }
        // 建立并加入用户
        User user = new User(name, password);
        userTable.put(user.getName(), user);
        return "Register success with id: " + user.getId() + ".";
    }

    // 登入接口
    @GetMapping("/login")
    public String login(String name, String password) {
        if (!userTable.containsKey(name)) {
            return "User " + name + " didn't exist.";
        }
        User user = userTable.get(name);
        if (!user.getPassword().equals(password)) {
            return "Incorrect password.";
        }
        return "Login success with user id: " + user.getId() + ".";
    }
}
  1. 最后一样需要将 application.properties 改名为 application.yml 并填入配置信息
server:
  port: 8801 # 启动端口

eureka:
  instance:
    appname: service-provider # 实例名称
  client:
    service-url:
      defaultZone: http://localhost:8800/eureka/ # 注册中心

spring:
  application:
    name: service-provider # 服务名称

这边不同的地方在于我们透过设置 eureka.client.service-url.defaultZone 来指定注册中心，接下来我们就可以在浏览器访问服务了

测试

  1. 我们先启动前面的 Eureka Server 然后启动我们的 Provider，并访问 http://localhost:8800 查看我们的注册中心

  1. 接下来我们分别测试 Provider 的四个接口是否正确生效
  • http://localhost:8801

  • http://localhost:8801/register?name=user1&password=123

  • http://localhost:8801/register?name=user2&password=456

  • http://localhost:8801/users

  • http://localhost:8801/login?name=user1&password=123

确定好 Provider 服务可以了之后，接下来轮到 Consumer 服务

Consumer 微服务

第三个模块是 Consumer 服务，与前两个一样，也是经过 File -> New -> Module -> ... 等一系列步骤创建，详细步骤就不展开了，一样给出配置信息：

StagePropertyValue / Action
3(maven 配置)Artifact Ideureka-service-consumer
Project nameeureka-service-consumer
Package namecom.example.consumer
4(Spring 依赖选择)Eureka Client 依赖Spring Cloud Discovery.Eureka Discovery Client
5(项目路径位置)Module nameeureka-service-consumer
Content rootxxx/spring_cloud_eureka/eureka-service-consumer
Module file locationxxx/spring_cloud_eureka/eureka-service-consumer
6(依赖配置 pom.xml)Eureka Client 依赖(不用修改)使用了 spring-cloud-starter-netflix-eureka-client 依赖
Web 项目依赖新增 spring-boot-starter-web 依赖
7(入口类声明)Annotation改为添加 @EnableEurekaClient 注释，声明为 Eureka Client

我们一样从第 8 步开始

Consumer 服务 & 配置

在 Consumer 我们打算的事不太多，直接代理 Provider 提供的服务就行了

  1. 创建实体类 User（内容与 Provider 的相仿，用于接受请求结果）
  • User.java
package com.example.consumer;

public class User {

    private Integer id;
    private String name;
    private String password;
    // 省略 id、name、password 的 getter
}
  1. 接下来我们在主入口 EurekaServiceConsumerApplication.main 的下方注入一个 RestTemplate，等下请求 Provider 服务会用到
  • EurekaServiceConsumerApplication.java
package com.example.consumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@EnableEurekaClient
@SpringBootApplication
public class EurekaServiceConsumerApplication {

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

    // 注入一个 RestTemplate 的 Bean
	@Bean
	public RestTemplate restTemplate() {
		return new RestTemplate();
	}
}
  1. 再来我们创建 ConsumerController 来定义我们的接口
package com.example.consumer;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.Map;

@RestController
public class ConsumerController {

    // 配置文件中的端口
    @Value("${server.port}")
    private String port;

    // 自动装配刚刚注入的 RestTemplate
    @Autowired
    private RestTemplate restTemplate;

    // Provider 的路由
    private String providerUrl = "http://localhost:8801";

    @GetMapping("/")
    public String info() {
        return "Default route from port: " + port;
    }

    /* 
        下面三个方法都是直接代理 Provider 的服务
     */
    @GetMapping("/users")
    public Map<String, User> users() {
        String url = providerUrl + "/users";
        // 使用 getForObject 快速发起 GET 请求并获取 body
        Map<String, User> res = restTemplate.getForObject(url, Map.class);
        return res;
    }

    @GetMapping("/register")
    public String register(String name, String password) {
        String url = providerUrl + "/register?name=" + name + "&password=" + password;
        String res = restTemplate.getForObject(url, String.class);
        return "Proxy from " + port + ": " + res;
    }

    @GetMapping("/login")
    public String login(String name, String password) {
        String url = providerUrl + "/login?name=" + name + "&password=" + password;
        String res = restTemplate.getForObject(url, String.class);
        return "Proxy from " + port + ": " + res;
    }
}
  1. 最后的最后一样要配置一下 application.yml
  • application.yml
server:
  port: 8802 # 启动端口

eureka:
  instance:
    appname: service-consumer # 实例名称
  client:
    service-url:
      defaultZone: http://localhost:8800/eureka/ # 注册中心

spring:
  application:
    name: service-consumer # 服务名称

这边基本跟 Provider 一致（同为 Eureka Client），只需要修改端口(port)和服务名称(application.name、instance.appname)就好了

启动 & 测试

  1. 接下来跟测试 Provider 的时候一样，先分别启动 Eureka Server、Provider、Consumer，然后到 8800 查看 Eureka Server 的注册情形

我们可以看到 Provider 跟 Consumer 都正确的注册到 Eureka Server 了

  1. 最后简单测试一下 Consumer 的接口
  • http://localhost:8802

  • http://localhost:8802/register?name=user1&password=123

  • http://localhost:8801/register?name=user2&password=456

  • http://localhost:8802/users

由于 Consumer 只是代理 Provider 的操作，所以不论是 8801 或是 8802 注册的用户都保存在 Provider 的 userTable 中

  • http://localhost:8802/login?name=user1&password=123

完整项目内容

最后给出最终版本的项目完整内容

最终项目结构 & 配置信息 & 接口信息

最终项目结构

/spring_cloud_eureka
├── eureka-server
│   ├── pom.xml
│   └── src
│       ├── main
│       │   ├── java
│       │   │   └── com
│       │   │       └── example
│       │   │           └── server
│       │   │               └── EurekaServerApplication.java
│       │   └── resources
│       │       └── application.yml
│       └── test // 省略
├── eureka-service-consumer
│   ├── pom.xml
│   └── src
│       ├── main
│       │   ├── java
│       │   │   └── com
│       │   │       └── example
│       │   │           └── consumer
│       │   │               ├── ConsumerController.java
│       │   │               ├── EurekaServiceConsumerApplication.java
│       │   │               └── User.java
│       │   └── resources
│       │       └── application.yml
│       └── test // 省略
└── eureka-service-provider
    ├── pom.xml
    └── src
        ├── main
        │   ├── java
        │   │   └── com
        │   │       └── example
        │   │           └── provider
        │   │               ├── EurekaServiceProviderApplication.java
        │   │               ├── ProviderController.java
        │   │               └── User.java
        │   └── resources
        │       └── application.yml
        └── test // 省略

服务端口信息

ServicenamePort
Eureka Servereureka-server8800
Providereureka-service-provider8801
Consumereureka-service-consumer8802

接口信息

ServiceAPIUsage
默认1localhost:8801Provider 的默认端口
默认2localhost:8802Consumer 的默认端口
注册1localhost:8801/register在 Provider 注册用户
注册2localhost:8802/register代理 Provider 的注册接口
登陆1localhost:8801/login在 Provider 登陆
登陆2localhost:8802/login代理 Provider 的登陆接口
用户列表1localhost:8801/users查看 Provider 上的所有用户信息
用户列表2localhost:8802/users查看 Provider 上的所有用户信息

Eureka Server（eureka-server 模块）

pom.xml

<?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.3.2.RELEASE</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>Hoxton.SR6</spring-cloud.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-server</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>${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>

	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
		</repository>
	</repositories>

</project>

application.yml

server:
  port: 8800 # 启动端口

eureka:
  client:
    register-with-eureka: false # 不向 eureka 注册
    fetch-registry: false # 表明自己就是 eureka server
  instance:
    secure-port-enabled: false

EurekaServerApplication.java

package com.example.server;

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

@EnableEurekaServer
@SpringBootApplication
public class EurekaServerApplication {

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

}

Provider（eureka-service-provider 模块）

pom.xml

<?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.3.2.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>eureka-service-provider</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>eureka-service-provider</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Hoxton.SR6</spring-cloud.version>
	</properties>

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

	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
		</repository>
	</repositories>

</project>

application.yml

server:
  port: 8801 # 启动端口

eureka:
  instance:
    appname: service-provider # 实例名称
  client:
    service-url:
      defaultZone: http://localhost:8800/eureka/ # 注册中心

spring:
  application:
    name: service-provider # 服务名称

EurekaServiceProviderApplication.java

package com.example.provider;

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

@EnableEurekaClient
@SpringBootApplication
public class EurekaServiceProviderApplication {

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

}

ProviderController.java

package com.example.provider;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@RestController
public class ProviderController {

    @Value("${server.port}")
    private String port;

    private Map<String, User> userTable = new HashMap<>();

    @GetMapping("/")
    public String info() {
        return "Default route from port: " + port;
    }

    @GetMapping("/users")
    public Map<String, User> getUserTable() {
        return userTable;
    }

    @GetMapping("/register")
    public String register(String name, String password) {
        if (name.length() == 0) {
            return "User name is required.";
        }
        if (password.length() == 0) {
            return "User password is required.";
        }
        if (userTable.containsKey(name)) {
            return "User " + name + " is already exist.";
        }
        User user = new User(name, password);
        userTable.put(user.getName(), user);
        return "Register success with id: " + user.getId() + ".";
    }

    @GetMapping("/login")
    public String login(String name, String password) {
        if (!userTable.containsKey(name)) {
            return "User " + name + " didn't exist.";
        }
        User user = userTable.get(name);
        if (!user.getPassword().equals(password)) {
            return "Incorrect password.";
        }
        return "Login success with user id: " + user.getId() + ".";
    }
}

User.java

package com.example.provider;

public class User {

    private static int count = 0;
    private Integer id;
    private String name;
    private String password;

    public User() {
        id = count++;
    }

    public User(String name, String password) {
        id = count++;
        this.name = name;
        this.password = password;
    }

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

Consumer（eureka-service-consumer 模块）

pom.xml

<?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.3.2.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>eureka-service-consumer</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>eureka-service-consumer</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Hoxton.SR6</spring-cloud.version>
	</properties>

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

	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
		</repository>
	</repositories>

</project>

application.yml

server:
  port: 8802 # 启动端口

eureka:
  instance:
    appname: service-consumer # 实例名称
  client:
    service-url:
      defaultZone: http://localhost:8800/eureka/ # 注册中心

spring:
  application:
    name: service-consumer # 服务名称

EurekaServiceConsumerApplication.java

package com.example.consumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@EnableEurekaClient
@SpringBootApplication
public class EurekaServiceConsumerApplication {

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

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

ConsumerController.java

package com.example.consumer;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.Map;

@RestController
public class ConsumerController {

    @Value("${server.port}")
    private String port;

    @Autowired
    private RestTemplate restTemplate;

    private String providerUrl = "http://localhost:8801";

    @GetMapping("/")
    public String info() {
        return "Default route from port: " + port;
    }

    @GetMapping("/users")
    public Map<String, User> users() {
        String url = providerUrl + "/users";
        Map<String, User> res = restTemplate.getForObject(url, Map.class);
        return res;
    }

    @GetMapping("/register")
    public String register(String name, String password) {
        String url = providerUrl + "/register?name=" + name + "&password=" + password;
        String res = restTemplate.getForObject(url, String.class);
        return "Proxy from " + port + ": " + res;
    }

    @GetMapping("/login")
    public String login(String name, String password) {
        String url = providerUrl + "/login?name=" + name + "&password=" + password;
        String res = restTemplate.getForObject(url, String.class);
        return "Proxy from " + port + ": " + res;
    }
}

User.java

package com.example.consumer;

public class User {

    private Integer id;
    private String name;
    private String password;

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getPassword() {
        return password;
    }
}

结语

呼！终于结束了，其实整个服务也没啥内容，光是配置就弄了好久，而且好像该弄个代码仓库了，这样一个个复制贴上也不是办法hhh。

下一篇将带来使用 Feign 实现根据 Eureka Server 注册中心中的服务注册信息来实现内部的服务间调用(service-to-service calls)。

超悠閒
关注
专栏目录
SpringCloud学习之手把手教你用IDEA搭建入门项目（二）
易雪寒的博客
10-26 695
本篇博客是承接上一篇《手把手教你用IDEA搭建SpringCloud入门项目（一）》，不清楚的请到我的博客空间查看后再看本篇博客 1）先创建一个Eureka服务注册中心模块，用来作为服务的注册中心，点击项目右键，创建一个新的module 2)SpringCloud是基于SpringBoot的，所以这里选择Spring Initializer创建一个新的SpringBoot模块...
spring-cloud-starter-netflix-eureka-server-1.4.5.RELEASE.jar
02-21
spring-cloud-starter-netflix-eureka-server-1.4.5.RELEASE.jar
无法解析 org.springframework.cloud:spring-cloud-starter-netflix-eureka-serve
城南蝈蝈
10-07 1522
需要注意的是你用的spring-cloud是netflix还是alibaba的，他们之间的版本不完全相同。这里面的Greenwich是spring-cloud当前版本的别称，这个别称没有查到在哪里查，只查到了下面的这个表格。最好看官网的：https://spring.io/projects/spring-cloud#learn。然后往下拉，看到当前对应的spring-cloud-netflix的版本是 4.0.4-SNAPSHOT。我们点开其中一个，可以看到当前版本支持spring boot是3.0.9。
【Eureka】搭建Eureka Server，实现服务注册和服务发现
最新发布
qq_45875349的博客
09-02 1651
Eureka的使用详解，一篇带你理解什么是Eureka该怎么配置和使用。
构建springCloud微服务时，spring-cloud-starter-netflix-eureka-server ，springboot 版本兼容问题
IT_hot_pot的博客
08-13 4782
构建springCloud微服务时,版本对应 今天在公司构建springcould微服务时，刚开始构建项目，导入maven依赖，构建立马报错！ 一开始没在意以为只是依赖还在加载，等了几分钟，结果还是一样，应该是出问题了，于是自己对应着springboot， spring-cloud-starter-netflix-eureka-server 服务器版本查找，断定应该是版本不一致问题 问题截图 于是改对应的版本，虽然不是最新的但是，是对应得版本，有需要得可以对应的改. Release Train Ver
实战·Spring Cloud Netflix Eureka Server构建
JavaUpgrade
02-22 174
实战·Spring Cloud Netflix Eureka Server构建一.环境二.创建项目三.配置application.properties3.1 修改端口3.2 修改配置四.查看EureKa控制台 一.环境 jdk 1.8 Maven 3.2.6 Mac系统 二.创建项目 https://start.aliyun.com,因为这个是国内的镜像，速度快很多 三个依赖包 Spring Boot DevTools Lombok Eureka Server 其实，只用Eureka也可以
SpringBoot 2.0 +SpringCloud 实现服务注册与发现
boom_boom_booms的博客
04-04 416
1.创建 SpringBoot 项目 修改pom.xml 文件 添加springcloud依赖 <?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-instan...
SpringCloud微服务第1章之项目搭建
热门推荐
qq_57756904的博客
06-10 1万+
高可用：与传统的单机系统比，它的可用性高。举个例子说明下：单机系统如果挂了，那么整个系统的服务就不能提供服务了，这给使用它的商家带来很大的经济损失。而微服务不同，某个服务挂了，可能并不会影响其它微服务继续对外提供服务。而且新开发的功能点或更改的功能点集中在一个服务上面，即使部署上线出了问题，也不会影响其它服务的业务。 松耦合：无论是在开发阶段或部署阶段都是独立的，富有单一职责原则之称，从而保障高可用。 模块化：它将一个整体应用程序分解成一系列服务，每个模块都有它相应的职责，提高了维护与扩展性。在分工方面也有
SpringCloud 服务治理：Eureka、Consul、Nacos
「 虚幻私塾」
06-05 541
目录* 1. Eureka + 1.1 Eureka 介绍 + 1.2 Eureka 入门案例 - 父工程 - Eureka Server（子工程） * pom.xml * 启动类 * application.yml * Eureka 控制台 - 服务提供者（子工程） * pom.xml * 启动类 * application.yml * domain * controller * service * dao - 服务调用者（子工程） * pom.xml * 启动类 * application.yml *
手把手教你整合SpringCloud微服務框架-dubbo框架+zookeeper服务的注册发现+druid数据源管理
撸起袖子加油干
07-21 586
一、前言： 技术架构，芸芸众生，没有最好的，只有最适用的，作为程序猿的你，如同修炼绝世武功的侠客，唯有BAT，才能练就绝世武功；这些企业的特征：20%的企业覆盖并占据了80%的互联网流量。 在这样的企业中，想怂都难，估计271末尾淘汰的员工，去一些传统行业都可以称霸一方。 springcloud、dubbo都是微服务框架中的佼佼者，不妨来一次强强联合，咱们先来分析一下各自的优劣势： 功能名称 Dubbo Spring Cloud 服务注册中心 ZooKeeper Spr.
手把手教你，从零开始搭建 Spring Cloud Alibaba、这份笔记太牛了
m0_74931226的博客
11-27 231
Spring Cloud Netflix 项目进入维护模式，将不再开发新的组件，SpringCloud 性能上不 能满足互联企业的发展需求。但互联网发展又迫切需要解决微服务的方案，因此龙头企业阿里应运而生推出了 Spring Cloud Alibaba 新一代的微服务架构解决方案。如果你还没有掌握这套主流技术，现在想要在最短的时间里吃透它。那么这份 SpringCloud Alibaba 实战笔记你一定不能错过！（还有一份 SpringCloud Alibaba 理论知识笔记同步打包分享）
spring-cloud-starter-eureka-server 和 spring-cloud-starter-netflix-eureka-server的区别
旷野历程
07-19 7652
在学习spring cloud时发现有的引入了spring-cloud-starter-eureka-server，有的引入了spring-cloud-starter-netflix-eureka-server。刚开始还看不懂，特意去查了一下做下总结： springcloud更新换代比较快； spring-cloud-starter-eureka-server是1.5才前的版本依赖； spring-cloud-starter-netflix-eureka-server是最新版本的依赖（推荐）...
SpringCloud中集成Eureka时通过Discovery实现服务发现
BADAO_LIUMANG_QIZHI的博客
05-12 361
场景 SpringCloud中集成Eureka实现服务注册(单机Eureka构建)： SpringCloud中集成Eureka实现服务注册(单机Eureka构建)_霸道流氓气质的博客-CSDN博客 SpringCloud中集成Eureka实现集群部署服务注册与服务提供者： SpringCloud中集成Eureka实现集群部署服务注册与服务提供者_霸道流氓气质的博客-CSDN博客 在上面实现服务注册单机与集群的基础上，怎样去进行服务发现。 注： 博客：霸道流氓气质的博客_CSDN博客-C#,架构
Netflix SpringCloud-Eureka
CaBCo的博客
07-27 534
Eureka 发现了，找到了！
一、SpringCloud-Netflix-Eureka
m0_50820806的博客
07-21 565
Eureka简单使用
一站式微服务架构SpringCloud-Netflix注册中心Eureka
桀骜浮沉的博客
06-23 204
一站式微服务架构SpringCloud-Netflix注册中心Eureka
SpringCloud五大组件之服务发现-Netflix Eureka
LeungChunwai的博客
02-01 1484
SpringCloud五大组件之服务发现-Netflix Eureka 本文主要介绍服务注册发现的基本用法和集成 SpringCloud五大常用组件: 服务注册发现——Netflix Eureka 客服端负载均衡——Netflix Ribbon 断路器——Netflix Hystrix 服务网关——Netflix Zuul 分布式配置——Spring Cloud Config 分布式服务必然要面临的几大主要问题： 1.服务管理 2.如何自动注册和发现 3.如何实现状态监管 4.如何实现动态
spring服务注册和发现的实现springCloudStarterNetflixEurekaServer
keny-大成的博客
04-06 665
1.spring服务注册和发现 2.编译条件 JDK 1.8or later Gradle 4+orMaven 3.2+ 3.代码格式 3.1 service目录 3.2 client的目录 4.POM.xml的文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http...
SpringCloud实战：Eureka服务注册与发现详解
"本文将详细介绍如何使用Spring Cloud Eureka构建服务注册中心，以及Eureka在Spring Cloud生态中的重要地位和作用。" Spring Cloud Eureka是Netflix公司开源的一个服务注册与发现的组件，它在Spring Cloud框架中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值