SpringCloud学习记录（三）——注册中心Eureka基础（一）

---

前言

本篇记录学习Eureka注册中心的学习记录，代码位置

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、Eureka简介

1.1 Eureka能做什么，

• Eureka可以管理、记录服务提供者的信息，服务调用者无需自己寻找服务，而是把自己的需求告诉Eureka，然后Eureka把符合你需求的服务告诉你。
• 同时，服务提供方与Eureka之间通过 “心跳” 机制进行监控，当某个服务提供方出现问题，Eureka自然会把它从服务列表中剔除。
  这就实现了服务的自动注册、发现、状态监控。

1.2 原理图

0：实例化服务        1：将服务注册到Eureka
2：记录服务信息     3：从Eureka定期获取服务列表
4：基于负载均衡算法，从服务地址列表中选择一个地址调用服务
5：定期想EurekaServer发送心跳（续约）信号
6：检查没有定期发送心跳（续约）信号的服务，将其在一定时间内，从服务	     列表中剔除

二、入门案例

简单的入门案例只有三部分，EurekaServer（注册中心）、UserService（服务提供者）、ConsumerService（服务消调用者）；
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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.kaikeba</groupId>
    <artifactId>spring-cloud01</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>sc-eureka</module>
        <module>user-service</module>
        <module>consumer-service</module>
    </modules>

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

    <!-- 版本管理 -->
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud-version>Greenwich.SR1</spring-cloud-version>
        <tk-mybatis.version>2.1.5</tk-mybatis.version>
        <mysql-connection-version>8.0.25</mysql-connection-version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- spring cloud-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud-version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- tk mybatis -->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper-spring-boot-starter</artifactId>
                <version>2.1.5</version>
            </dependency>

            <!-- mysql驱动 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql-connection-version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2.1 注册中心——EurekaServer

注册中心重点是

1. eureka.client.service-url.defaultZone 这里配置的地址是给其他服务注册使用url；
2. 启动类上“标记当前服务室Eureka服务”的注解@EnableEurekaServer
   
   
   配置文件application.yml

server:
  port: 8080

spring:
  application:
    name: eureka-server
eureka:
    client:
      # eureka服务地址 若是集群 就需要指定其他eureka的地址
      service-url:
        defaultZone: http://127.0.0.1:8080/eureka
      # 不注册自己
      register-with-eureka: false
      # 不拉取服务
      fetch-registry: false

启动类ScEurekaApplication

package com.kaikeba;

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

/**
 * Eureka-server 服务的注册与发现
 */
@SpringBootApplication
@EnableEurekaServer   // 声明当前应用时Eureka服务
public class ScEurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(ScEurekaApplication.class, args);
    }
}

2.2 服务提供者

我们模拟的服务提供者是User信息：


服务提供者要注意的是：

1. eureka.client.service-url.defaultZone 这里配置的是上面注册中心配置的地址值；
2. 同时启动类上的注解和Eureka上的是不一样的：使用的是 @EnableEurekaClient

2.2.1 application.yml

server:
  port: 8081

spring:
  application:
    name: user-service
  datasource:
    password: root
    username: root
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springcloud
mybatis:
  base-packages: com.kaikeba.com.kaikeba.entity

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8080/eureka

2.2.2 User

package com.kaikeba.entity;

import lombok.Data;
import lombok.experimental.Accessors;

import javax.persistence.*;
import java.util.Date;

@Data
@Accessors(chain = true)
@Table(name = "tb_user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column(name = "user_name")
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private Integer sex;
    private Date birthday;
    private Date created;
    private Date updated;
    private String note;
}

2.2.3 UserMapper

package com.kaikeba.mapper;


import com.kaikeba.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends tk.mybatis.mapper.common.Mapper<User> {
}

2.2.4 UserService

UserService

package com.kaikeba.service;

import com.kaikeba.entity.User;

public interface UserService {
    /**
     * 根据id查询
     */
    User findById(Integer id);
}

UserServiceImpl

package com.kaikeba.service.impl;

import com.kaikeba.entity.User;
import com.kaikeba.mapper.UserMapper;
import com.kaikeba.service.UserService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class UserServiceImpl implements UserService {
    @Resource
    private UserMapper userMapper;

    public User findById(Integer id) {
        return userMapper.selectByPrimaryKey(id);
    }
}

2.2.5 UserController

package com.kaikeba.controller;

import com.kaikeba.entity.User;
import com.kaikeba.service.UserService;
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 javax.annotation.Resource;

@RestController
@RequestMapping("/user")
public class UserController {

    @Resource
    private UserService userService;

    @GetMapping("/{id}")
    public User searchById(@PathVariable("id") Integer id) {
        return  userService.findById(id);
    }
}

2.3 服务调用者

我们模拟的服务调用者是Consumer-Service

• 调用者要注意的事项也是配置文件中的defaultZone和启动类上的注解

2.3.1 application.yml

server:
  port: 8082

spring:
  application:
    name: consumer-service

eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:8080/eureka

2.3.2 User

这里的User是为了接收UserService返回的结果的所以，可以没有那些持久层相关的注解；

package com.kaikeba.entity;

import lombok.Data;

import java.util.Date;

@Data
public class User {
    private Integer id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private Integer sex;
    private Date birthday;
    private Date created;
    private Date updated;
    private String note;
}

2.3.2 ConsumerController

package com.kaikeba.controller;

import com.kaikeba.entity.User;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
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 javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/consumer")
public class ConsumerController {
    @Resource
    private RestTemplate restTemplate;

    @Resource
    private DiscoveryClient discoveryClient;

    @RequestMapping("/{id}")
    public User searchById(@PathVariable("id") Integer id) {
        List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
        ServiceInstance serviceInstance = instances.get(0);
        String url = "http://" + serviceInstance.getHost() + ":" + serviceInstance.getPort() + "/user/" + id;

        User user = restTemplate.getForObject(url, User.class);

        return user;
    }
}

2.3.4 启动类

package com.kaikeba;

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 // Eureka 发现功能
@SpringBootApplication
public class ConsumerServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerServiceApplication.class);
    }

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

2.4 测试结果

2.4.1 Eureka启动

2.4.2 UserService启动

2.4.3 Consumer启动

2.4.4 接口调用