实用篇-Eureka注册中心

一、提供者与消费者

服务提供者：一次业务中，被其他微服务调用的服务。(提供接口给其他微服务)

服务消费者：一次业务中，调用其他微服务的服务。(调用其他微服务提供的接口)

例如前面的案例中，order-service微服务是服务提供者，user-service微服务是服务消费者

思考：

如果服务A调用服务B，服务B调用服务C，那么服务B是什么角色 ?

一个服务既可以是提供者，也可以是消费者。所以服务B相对于服务A而言，服务B是提供者。服务B相对于服务C而言，服务B是消费者

二、Eureka原理分析

以上面的案例为例，order-service微服务和user-service微服务之间，服务调用出现的问题如下:

• order-service去向user-service发送请求，使用的是硬编码，也就是 "http://localhost:8081/user/"+order.getUserId();
• 硬编码每次修改需要重新打包
• 如果user-service微服务(提供者)部署成了多实例，形成集群来应对并发，那么order-service微服务(消费者)硬编码到底是写哪个实例的地址
• 即使你知道这些实例的地址，那么如何挑选其中一台实例来使用呢

Eureka原理

• Eureka架构中，微服务角色有两类，一个是EurekaServer叫做服务端(注册中心)。作用是记录服务信息，心跳监控；一个是EurekaClient叫做客户端，也就是服务的提供者/消费者
• 可以把注册中心理解为Key，我们的微服务项目理解为Value，Eureka理解为字典
• 当微服务项目(例如user-service)启动时，会主动把自己(user-service微服务)的信息注册给注册中心
• 注册到注册中心的微服务会每隔30秒，向注册中心发起心跳，证明自己还在健康运行
• 多个微服务的话，注册中心就会有多个Value，一个Value就是一个微服务的信息，这些Value会放到一个列表里面
• 当其它微服务(例如order-service)要使用某个微服务(例如user-service)时，这个微服务(order-service就会向注册中心去拉取对应微服务(user-service)的信息
• 当注册中心有多个提供者(微服务)，那么消费者是通过负载均衡算法，在注册中心的服务列表中挑选一个

三、搭建Eureka

步骤有三步：

1、搭建注册中心(EurekaServer)。搭建EurekaServer注册中心，也就是创建一个项目(在cloud-demo项目内部创建eureka-server项目)，把这个项目做成注册中心

2、服务注册。将user-service(前面导入的服务拆分Demo)、order-service(前面导入的服务拆分Demo)都注册到eureka

3、服务发现。在order-service中完成服务拉取，然后通过负载均衡挑选一个服务，实现远程调用

1. 搭建EurekaServer注册中心

第一步: 创建一个新的项目，作为独立的微服务，用于搭建Eureka，也就是在cloud-demo工程里面新建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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>cloud-demo</artifactId>
        <groupId>cn.itcast.demo</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>eureka-server</artifactId>

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

    <!--添加注册中心的依赖坐标-->
    <dependencies>
<!--        eureka服务端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

</project>

第三步: 在eureka-server微服务的src/main/java目录新建cn.itcast.eureka.EurekaApplication类，写入如下，注意加上@EnableEurekaServer注解，启动Eureka

package cn.itcast.eureka;


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

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

第四步: 在eureka-server微服务的src/main/resources目录新建File，名字为application.yml，写入如下

server:
  # 服务端口
  port: 8686

spring:
  application:
    # eureka的服务名称，因为eureka自己也是一个服务，也需要注册服务
    name: eurekaserver

eureka:
  client:
    service-url:
      # eureka的服务地址。如果有多个的话，逗号隔开
      defaultZone: http://localhost:8686/eureka

第五步: 启动eureka-server微服务。也就是运行EurekaApplication类，浏览器访问 http://localhost:8686 

2. 服务注册

这里我们实现把user-service和order-service注册到Eureka，只演示user-service

第一步：在user-service项目引入spring-cloud-start-netfix-eureka-client依赖，表示客户端

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

 第二步: 在user-service微服务的application.yml添加如下

spring:
  # Eureka相关配置
  application:
    # user的服务名称。也就是这个user-service注册到Eureka之后，这个user-service会叫什么名字
    name: userservice

eureka:
  client:
    service-url:
      # eureka的服务地址。如果有多个的话，逗号隔开。也就是把当前这个user-service微服务注册给哪个Eureka
      defaultZone: http://localhost:8686/eureka

 添加完后，user-service的application.yml文件如下，注意application是spring下的配置，要写在spring的下面

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/cloud_user?useSSL=false
    username: root
    password:
    driver-class-name: com.mysql.jdbc.Driver
    # Eureka相关配置
  application:
    # user的服务名称。也就是这个user-service注册到Eureka之后，这个user-service会叫什么名字
      name: UserService
mybatis:
  type-aliases-package: cn.itcast.user.pojo
  configuration:
    map-underscore-to-camel-case: true
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS
    
eureka:
  client:
    service-url:
      # eureka的服务地址。如果有多个的话，逗号隔开。也就是把当前这个user-service微服务注册给哪个Eureka
      defaultZone: http://localhost:8686/eureka    

同理，order-service也做相同操作，只是服务名修改一下 

第三步:

启动user-service。也就是运行UserApplication类，浏览器访问 http://localhost:8686，就可以看到user-service已经添加到Eureka里面

启动order-service。也就是运行OrderApplication类，浏览器访问 http://localhost:8686，就可以看到order-service已经添加到Eureka里面

当运行程序出现找不到或无法加载主类，可以尝试install一下maven工程，实在不行就全部删掉重新写一遍

IDEA复制服务实例 

上面我们启动了一个UserService服务实例，那么我们想再启动一个UserService实例，向Eureka注册多个服务，实现如下

第一步：右键服务然后点击复制配置 

第二步：设置服务名称和端口

 第三步：启动服务

第四步：打开Eureka注册中心，看到UserService的服务列表中增加了一个

也就是说，UserService的服务实例可以注册多个，当消费者想要获取服务时，可以通过负载均衡策略向服务实例发起请求 

3. 服务发现

服务发现也叫服务拉取，我们需要在order-service完成服务拉取。服务拉取是基于服务名称获取服务列表，然后再对服务列表做负载均衡

首先回想一下，前面的远程调用，我们实现了在订单项目(也就是现在的order-service微服务)去查询用户项目(也就是现在的user-service微服务)的案例需求

当时是在order-service里面使用url请求ip地址的方式，去请求user-service，从而获取user-service的用户信息

那么，学习了上面的Eureka之后，并且我们已经把order-service和user-service注册到注册中心(eureka-server)了，所以就可以在order-service里面，通过 '服务发现' 去获取user-service里面的用户信息

具体操作也非常简单，也是使用url请求的方式，但请求的路径不是ip，而是服务名称

代码实现

第一步: 在order-server微服务中的src/main/java/cn.itcast.order/service/OrderService类，修改访问的url路径，用服务名代替ip、端口。修改为如下

package cn.itcast.order.service;

import cn.itcast.order.mapper.OrderMapper;
import cn.itcast.order.pojo.Order;
import cn.itcast.order.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.sql.PreparedStatement;

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private RestTemplate restTemplate;

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        //2.利用RestTemplate发起http请求，查询用户
        //2.1 url路径
        String url = "http://UserService:8081/user/" + order.getUserId();
        //这个方法第一个参数是访问路径，第二个参数是把响应得到的Json数据封装成实体类对象
        User user = restTemplate.getForObject(url, User.class);
        //3.封装user到Order
        order.setUser(user);
        // 4.返回
        return order;
    }
}

第二步: 负载均衡。在order-server微服务中的OrderApplication引导类修改为如下，主要是给RestTemplate加上@LoadBalanced注解

package cn.itcast.order;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
public class OrderApplication {

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

    /**
     * 创建RestTemplate并注入Spring容器
     * @return
     */
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

}

第三步: 重新启动在order-server微服务的OrderApplication引导类，浏览器输入

http://localhost:8080/order/101，并向user-service微服务发送多次请求

总结：服务发现，就是将请求url中的ip地址替换成服务名称，然后根据负载均衡策略去调用服务