第三章 spring cloud eureka 配置 2.1.4版本

前言

服务治理

服务治理是微服务中最为核心和基础的模块,主要实现各个微服务的自动化注册和发现;为什么使用服务治理:随着业务的发展,系统功能越来越复杂,相应的微服务也不断增加,那么多的微服务应用当修改服务命名等,如果通过手工维护方式,容易出现命名冲突等问题;
服务注册: 在服务治理框架中,通过创建一个注册中心,每个服务向注册中心注册自己的服务,将端口号,版本号,通讯协议等信息上报注册中心,注册中心按照服务名进行分类,当注册上来后,注册中心会根据心跳方式去检测上报的服务是否存活,如不存活就赐予飞机票;

服务发现

在服务治理框架中,服务调用不是指定具体实例来调用,而是通过请求服务名来调用;服务调用方调用时不知具体服务在何方,而是通过注册中心获取服务清单,当服务调用方发起调用时通过某种轮训机制取出一个服务去掉用;

高可用的注册中心

当注册中心发生故障时候会导致服务群瘫痪,所以需要高可用的注册中心,eureka server支持高可用的配置,在eureka服务治理中,所有节点既是服务提供方也是服务消费方,注册中心也一样;eureka server的高可用实际上将自己当做服务向其他注册中心注册,多个服务相互注册,这样就形成了一组高可用的注册中心,注册中心相互注册获取清单,如果有一个挂了,也不会影响服务群;

高可用比率

通过时间计算;比如:保证一年的可用性为99.99%;

可用时间就是:365 * 24 * 3600 * 99.99%
不可用时间就是:365 * 24 * 3600 * 0.01% = 3153.6s
单台机器不可用比率：1%
两台机器不可用比率：1% * 1%
N 机器不可用比率：1% ^ n

可靠性

一次调用a->b->c 99%->99%->99%=97%
a->b->c->d 99%->99%->99%->99%=96%

总结

增加机器可以提高可用性，增加服务调用会降低可靠性，同时降低了可用性;

spring-cloud-eureka-server

失效剔除

eureka.server.eviction-interval-timer-in-ms: 清理无效节点的时间间隔;
服务如果正常下线,会告知eureka server,eureka server会剔除当前下线的服务,但是如果异常下线,将不会告知eureka server,这时eureka server会启动一个定时任务,默认每个一段时间(60s) 将当前清单中超过一段时间(90s)的没有续约服务剔除

自我保护

eureka.server.enable-self-preservation: 
eureka server 中会出现一个问题,如图
该警告触发Eureka Server 自我保护机制,服务注册到eureka server都会维护一个心跳,告诉eureka server我还活着,eureka server 在运行期间,会统计心跳失败的比例,15分钟之内低于85%;他会保留当前的实例注册信息,让他们不过期,但是调用服务时候会出现调用失败情况,这时候就要有容错机制,请求重试或者断路器等;这个系统默认开启自我保护机制;官方解释https://github.com/Netflix/eureka/wiki/Understanding-Eureka-Peer-to-Peer-Communication 
更多的eureka server配置项查看EurekaServerConfigBean

访问start.spring.io, 引入web,actuator,eureka-server

主程序入口

package cn.cold.springcloudeurekaserver.springcloudeurekaserverdemo;

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

@SpringBootApplication
@EnableEurekaServer
public class SpringCloudEurekaServerDemoApplication {

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

properties文件

application-peer1.properties

spring.application.name=spring-cloud-eureka-server
server.port=9090
#是否检索服务
eureka.client.fetch-registry=false
#是否注册到eureka,这里如果配置相互依赖那么必须要设置为true
eureka.client.register-with-eureka=true
#服务注册中心的配置内容，指定服务注册中心的位置
eureka.client.service-url.defaultZone=http://localhost:9091/eureka/

application-peer2.properties

spring.application.name=spring-cloud-eureka-server
server.port=9091
eureka.client.fetch-registry=false
eureka.client.register-with-eureka=true
eureka.client.service-url.defaultZone=http://localhost:9090/eureka/

以上两个就可以构成高可用注册中心,使用命令行进行打包,执行

java -jar spring-cloud-eureka-server-demo-0.0.1-SNAPSHOT.jar --management.endpoints.web.exposure.include=* --eureka.server.enable-self-preservation=false --spring.profiles.active=peer1

java -jar spring-cloud-eureka-server-demo-0.0.1-SNAPSHOT.jar --management.endpoints.web.exposure.include=* --eureka.server.enable-self-preservation=false --spring.profiles.active=peer2

分别启动两个注册中心,让他们相互注册如图:

spring-cloud-eureka-client

start.spring.io,引入web,actuator,eureka discovery 

这里我们将删除src目录,然后添加pom文件中

<packaging>pom</packaging>

然后在当前目录添加maven子项目,如图

创建子项目后,在父项目的pom一定要有

 <modules>
        <module>user-api</module>
        <module>user-consumer</module>
        <module>user-service-provider</module>
 </modules>

目录结构,如图

　　

user-api 

User.java

package cn.cold.user.api.domain;

/*
 * @create 2019-05-07 19:46
 * @Author 江湖人称洗发水
 * @Description //TODO
 **/
public class User {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

UserService.java

package cn.cold.user.api.service;

import cn.cold.user.api.domain.User;

import java.util.List;

/**
 * @author mengll
 * @date 2019/5/7 19:47
 */
public interface UserService {

    boolean save(User user);

    List<User> findAll();
}

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">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>cn.cold</groupId>
    <artifactId>user-api</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>user-api</name>
    <description>Demo project for Spring Boot</description>

</project>

user-service-consumer

UserServiceProxy.java

package cn.cold.user.consumer.service;

import cn.cold.user.api.domain.User;
import cn.cold.user.api.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.List;

/*
 * @create 2019-05-07 19:49
 * @Author 江湖人称洗发水
 * @Description //TODO
 **/
@Service
public class UserServiceProxy implements UserService {

    private static final String PROVIDER_SERVER_URL_PREFIX = "http://user-service-provider";

    @Autowired
    private RestTemplate restTemplate;

    @Override
    public boolean save(User user) {
        //端口会自动加上
        return restTemplate.postForEntity(PROVIDER_SERVER_URL_PREFIX + "/user/save", user, User.class) != null;
    }

    @Override
    public List<User> findAll() {
        return restTemplate.getForObject(PROVIDER_SERVER_URL_PREFIX + "/user/list", List.class);
    }
}

UserRestApiController.java

package cn.cold.user.consumer.web.controller;

import cn.cold.user.api.domain.User;
import cn.cold.user.api.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/*
 * @create 2019-05-07 19:50
 * @Author 江湖人称洗发水
 * @Description //TODO
 **/
@RestController
public class UserRestApiController {

    @Autowired
    private UserService userService;
    @Autowired
    private DiscoveryClient discoveryClient;


    @PostMapping("/save")
    public User save(@RequestParam String name) {
        User user = new User();
        user.setName(name);
        if (userService.save(user)) {
            return user;
        } else {
            return null;
        }
    }

    @GetMapping("/list")
    public List<User> list(){
        System.out.println(discoveryClient.description());
        System.out.println("11111111111111");
        return userService.findAll();
    }
}

主程序

package cn.cold.user.consumer;

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

@SpringBootApplication
@EnableDiscoveryClient
public class UserConsumerApplication {

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

    @Bean
    @LoadBalanced　　//负载均衡
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

application.properties

spring.application.name=user-service-consumer
## 服务消费方端口
server.port=8080
## Eureka Server 服务 URL,用于客户端注册
eureka.client.serviceUrl.defaultZone=\
  http://localhost:9090/eureka,http://localhost:9091/eureka
## Management 安全失效
management.endpoints.web.exposure.include=*

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">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>cn.cold.springcloudeurekaclient</groupId>
        <artifactId>spring-cloud-eureka-client-demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>cn.cold</groupId>
    <artifactId>user-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>user-consumer</name>
    <description>Demo project for Spring Boot</description>

    <dependencies>
        <dependency>
            <groupId>cn.cold</groupId>
            <artifactId>user-api</artifactId>
            <version>${project.version}</version>
        </dependency>
    </dependencies>

</project>

 

user-service-provider

UserRepository.java

package cn.cold.user.service.provider.repository;

import cn.cold.user.api.domain.User;
import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

/*
 * @create 2019-05-07 20:17
 * @Author 江湖人称洗发水
 * @Description //TODO
 **/
@Repository
public class UserRepository {

    private List<User> repository = new ArrayList<>();

    private static final AtomicInteger idGenerator =
            new AtomicInteger(0);

    public List<User> findAll() {
        return repository;
    }

    public boolean save(User user) {
        Integer id = idGenerator.incrementAndGet();
        user.setId(id);
        return repository.add(user);
    }
}

UserServiceImpl.java

package cn.cold.user.service.provider.service;

import cn.cold.user.api.domain.User;
import cn.cold.user.api.service.UserService;
import cn.cold.user.service.provider.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/*
 * @create 2019-05-07 20:16
 * @Author 江湖人称洗发水
 * @Description //TODO
 **/
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public boolean save(User user) {
        return userRepository.save(user);
    }

    @Override
    public List<User> findAll() {
        return userRepository.findAll();
    }
}

UserServiceProviderRestApiController.java

package cn.cold.user.service.provider.web.controller;

import cn.cold.user.api.domain.User;
import cn.cold.user.api.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/*
 * @create 2019-05-07 20:14
 * @Author 江湖人称洗发水
 * @Description //TODO
 **/
@RestController
public class UserServiceProviderRestApiController {
    @Autowired
    private UserService userService;

    @PostMapping("/user/save")
    public User saveUser(@RequestBody User user) {
        if (userService.save(user)) {
            System.out.println("UserService 服务方：保存用户成功！" + user);
            return user;
        } else {
            return null;
        }
    }

    @GetMapping("/user/list")
    public List<User> list() {
        return userService.findAll();
    }
}

主程序

package cn.cold.user.service.provider;

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

@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceProviderApplication {

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

}

application.properties

更多的eureka client配置项可以查看EurekaInstanceConfigBean和EurekaClientConfigBean;
org.springframework.cloud.spring-cloud-netflix-eureka-client.2.1.1.RELEASE.spring-cloud-netflix-eureka-client-2.1.1.RELEASE.jar!\META-INF\spring-configuration-metadata.json;这个json也有比较详细描述
其他配置可在spring-configuration-metadata.json找到这里就不一一举例了;

spring.application.name=user-service-provider
## 服务消费方端口
server.port=7071
## Eureka Server 服务 URL,用于客户端注册
eureka.client.serviceUrl.defaultZone=\
  http://localhost:9090/eureka,http://localhost:9091/eureka
## Management 安全失效
management.endpoints.web.exposure.include=*
# 心跳时间，即服务续约间隔时间（缺省为30s）
eureka.instance.lease-renewal-interval-in-seconds=5
# 即服务续约到期时间（缺省为90s）
eureka.instance.lease-expiration-duration-in-seconds=15  

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">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>cn.cold.springcloudeurekaclient</groupId>
        <artifactId>spring-cloud-eureka-client-demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>cn.cold</groupId>
    <artifactId>user-service-provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>user-service-provider</name>
    <description>Demo project for Spring Boot</description>
    <dependencies>
        <dependency>
            <groupId>cn.cold</groupId>
            <artifactId>user-api</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

以上就是eureka client的代码;这里启动一个consumer,然后启动两个provider, 这里consumer和一个provider用idea,另外一个provider用命令行启动

 java -jar user-service-provider-0.0.1-SNAPSHOT.jar --server.port=7070

注册好了如图:

 

测试

这里再次访问http://localhost:8080/list ,一会有值,一会没值,这里因为是两个服务,没有做数据同步,所以出现该情况,但是也证明了@LoadBalanced确实负载均衡了;

由于篇幅原因,配置的就到此为止,后期会补一些Netflix Ribbon和RestTemplate,还有一些eureka 分析