《SpringCloud篇：001Eureka服务的注册与发现入门篇》

2.1.9  -  G-SR6

微服务架构的提出者：马丁福勒

简而言之，微服务架构样式[1]是一种将单个应用程序开发为一组小服务的方法，
每个小服务都在自己的进程中运行并与轻量级机制（通常是HTTP资源API）进行
通信。这些服务围绕业务功能构建，并且可以由全自动部署机制独立部署。这些
服务的集中管理几乎没有，它可以用不同的编程语言编写并使用不同的数据存储
技术。

1、 微服务架构只是一个样式，一个风格。

2、 将一个完成的项目，拆分成多个模块去分别开发。

3、 每一个模块都是单独的运行在自己的容器中。

4、 每一个模块都是需要相互通讯的。 Http，RPC，MQ。

5、 每一个模块之间是没有依赖关系的，单独的部署。

6、 可以使用多种语言去开发不同的模块。

7、 使用MySQL数据库，Redis，ES去存储数据，也可以使用多个MySQL数据库。

总结：将复杂臃肿的单体应用进行细粒度的划分，每个拆分出来的服务各自打包部署。

- SpringCloud是微服务架构落地的一套技术栈。
- SpringCloud中的大多数技术都是基于Netflix公司的技术进行二次研发。
- SpringCloud的中文社区网站：http://springcloud.cn/
- SpringCloud的中文网：http://springcloud.cc/
- 八个技术点：
  - Eureka - 服务的注册与发现
  - Ribbon - 服务之间的负载均衡
  - Feign - 服务之间的通讯
  - Hystrix - 服务的线程隔离以及断路器
  - Zuul - 服务网关
  - Stream - 实现MQ的使用
  - Config - 动态配置
  - Sleuth - 服务追踪
  - SpringBoot对应SpringCloud版本：https://start.spring.io/actuator/info

- 服务的调用方需要维护大量服务提供方的地址信息，维护成本是很高的。
- 如果服务提供方出现了宕机等问题，服务调用方无法感知。
- 使用Eureka来管理所有服务的地址信息以及是否存活，服务的注册与发现

<?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>
    <modules>
        <module>01-eureka</module>
        <module>02-provider</module>
        <module>03-consumer</module>
        <module>04-eureka-replicas</module>
        <module>05-provider</module>
        <module>06-zuul</module>
        <module>08-sidecar</module>
        <module>09-stream-send</module>
        <module>10-stream-listen</module>
    </modules>


    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <!-- 修改packaging为pom ,删除src整个目录-->
    <packaging>pom</packaging>

    <groupId>com.qf</groupId>
    <artifactId>springcloud</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springcloud</name>
    <description>Demo project for Spring Boot</description>

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

    <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>

</project>

package com.qf.springcloud.eurekaserver;

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

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerStarterApp {

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

}

server:
  port: 8761

eureka:
  client:
    # 不让当前eurekaServer尝试注册到其他Eureka,(单机版)
    fetch-registry: false
    register-with-eureka: false
    # 指定当前服务需要注册已经拉取信息的Eureka地址，默认就是http://localhost:8761/eureka/配置
    service-url:
      defaultZone: http://localhost:8761/eureka/

<?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>springcloud</artifactId>
        <groupId>com.qf</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>02-provider</artifactId>


    <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>
    </dependencies>

</project>

package com.qf.springcloud.provider;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
//@EnableEurekaClient         // 代表要注册到Eureka的注册中心
//@EnableDiscoveryClient      // 代表要注册到注册中心上,可能是其他注册中心,Zookeeper,Nacos,Console,Redis , 服务的注册与发现
public class ProviderStarterApp {

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

}

spring:
  application:
    # 指定服务名称
    name: provider


#eureka:
#  client:
#    service-url:
      # 指定注册到的eureka的地址信息
#      defaultZone: http://admin:admin@localhost:8761/eureka/,http://admin:admin@localhost:8762/eureka/

<?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>springcloud</artifactId>
        <groupId>com.qf</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>03-consumer</artifactId>

    <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.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
        </dependency>
    </dependencies>

</project>

package com.qf.springcloud.consumer;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableFeignClients
@EnableCircuitBreaker
@EnableHystrixDashboard
@ServletComponentScan(basePackages = "com.qf.springcloud.consumer")
public class ConsumerStarterApp {

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


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


//    @Bean
//    public IRule randomRule(){
//        return new RandomRule();
//    }
}

package com.qf.springcloud.consumer.controller;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import com.qf.springcloud.consumer.client.ProviderClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

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

@RestController
public class ConsumerController {

    /*@Autowired
    private EurekaClient eurekaClient;*/

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private ProviderClient providerClient;

    @GetMapping("/consumer/test")
    public String test() throws InterruptedException {
        /*//1. 通过Eureka获取PROVIDER服务的ip和port
        InstanceInfo provider = eurekaClient.getNextServerFromEureka("PROVIDER", false);
        String ip = provider.getIPAddr();
        int port = provider.getPort();

        //2. 通过RestTemplate调用provider的/provider/test
        String result = restTemplate.getForObject("http://" + ip + ":" + port + "/provider/test", String.class);*/

        /*
        //1. 访问目标服务
        String result = restTemplate.getForObject("http://PROVIDER/provider/test", String.class);
        */
        Thread.sleep(2000);
        System.out.println("test:" + Thread.currentThread().getName());
        String result = providerClient.test();
        //3. 返回结果
        return result;
    }


    @GetMapping("/param/test/{type}")
    /*
    @HystrixCommand(fallbackMethod = "paramTestFallback",commandProperties = {
            @HystrixProperty(name = "circuitBreaker.enabled",value = "true"),
            @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold",value = "20"),
            @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds",value = "30000"),
            @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage",value = "10")

    })
    */
    public Map paramTest(@PathVariable Integer type) throws InterruptedException {
        System.out.println("paramTest:" + Thread.currentThread().getName());
        if (type == 1){
            // path
            return providerClient.path(123);
        }else if (type == 2){
            int i = 1 / 0;
            // param
            return providerClient.param("张老三",233);
        }else{
            // body
            Map map = new HashMap();
            map.put("abcdefg","hijklmn");
            return providerClient.body(map);
        }
    }


    public Map paramTestFallback(Integer type){
        System.out.println("paramTestFallback:" + Thread.currentThread().getName());
        Map map = new HashMap();
        map.put("msg","我的Consumer自己出现了问题");
        return map;
    }
}

@EnableWebSecurity
class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().ignoringAntMatchers("/eureka/**");
        super.configure(http);
    }
}

spring:
  application:
    name: eureka
#  security:
#    user:
#      name: admin
#      password: admin

EurekaServer如何和EurekaClient进行通讯：EurekaClient会每隔30s向
EurekaServer发送、拉取一次心跳请求，告诉EurekaServer我当前服务的生存情况
，配置方式：lease-renewal-interval-in-seconds

EurekaServer如何确定一个服务已经宕机，并从注册信息列表中移除：如果
EurekaClient90s还没有正常的发送心跳请求，EurekaServer把当前服务从
注册列表中移除，配置方式：lease-expiration-duration-in-seconds

Eureka的自我保护机制：15min内，超过85%的心跳请求不正常，EurekaServer
会认为自己出现了问题，EurekaServer就会开启自我保护机制，不会从注册列表
上删除任何一个服务，直到网络恢复正常，才会关闭自我保护机制，并且从其他
Eureka上同步数据。

- C：一致性（保证多个节点之间数据一致后，才会对外提供功能）
- A：可用性（一定会对外提供功能，但是不保证数据的一致性）
- P：分区容错性（在分布式系统中，分区容错性是必须容忍的）

Eureka是很标准的AP
Zookeeper是很标准的CP