SpringCloud

源代码

链接：https://pan.baidu.com/s/1W6l_KjrSqVzC3h3a-g_NzA
提取码：obwi

1、微服务概述

1.1、微服务简介

微服务（Microservice Architecture）是近几年流行的一种架构思想

Martin Fowler
于2014年提出的一段话：

原文：https://martinfowler.com/articles/microservices.html
汉化：https://www.cnblogs.com/liuning8023/p/4493156.html

就目前而言，对于微服务，业界并没有一个统一的，标准的定义
但通常而言，微服务架构是一种架构模式，或者说是一种架构风格，它提倡将单一的应用程序划分成一
组小的服务，每个服务运行在其独立的自己的进程内，服务之间互相协调，互相配置，为用户提供最终
价值。服务之间采用轻量级的通信机制互相沟通，每个服务都围绕着具体的业务进行构建，并且能够被
独立的部署到生产环境中，另外，应尽量避免统一的，集中式的服务管理机制，对具体的一个服务而
言，应根据业务上下文，选择合适的语言，工具对其进行构建，可以有一个非常轻量级的集中式管理来
协调这些服务，可以使用不同的语言来编写服务，也可以使用不同的数据存储；

微服务化的核心就是将传统的一站式应用，根据业务拆分成一个一个的服务，彻底地去耦合，每一个微
服务提供单个业务功能的服务，一个服务做一件事情，从技术角度看就是一种小而独立的处理过程，类
似进程的概念，能够自行单独启动或销毁，拥有自己独立的数据库。

1.2、springcloud和springboot的关系

SpringBoot专注于快速方便的开发单个个体微服务。
SpringCloud是关注全局的微服务协调整理治理框架，它将SpringBoot开发的一个个单体微服务整合并
管理起来，为各个微服务之间提供：配置管理，服务发现，断路器，路由，微代理，事件总线，全局
锁，决策竞选，分布式会话等等集成服务。
SpringBoot可以离开SpringClooud独立使用，开发项目，但是SpringCloud离不开SpringBoot，属于依
赖关系
SpringBoot专注于快速、方便的开发单个个体微服务，SpringCloud关注全局的服务治理框架

1.3、springcloud和dubbo的区别

解决的问题域不一样：Dubbo的定位是一款RPC框架，Spring Cloud的目标是微服务架构下的一站式解
决方案

1.4、SpringCloud入门

官网：http://projects.spring.io/spring-cloud/

参考文档：
https://springcloud.cc/spring-cloud-netflix.html
中文API文档：https://springcloud.cc/spring-cloud-dalston.html
SpringCloud中国社区 http://springcloud.cn/
SpringCloud中文网 https://springcloud.cc

2、Rest微服务构建

2.1、springcloud-study

新建父工程Maven项目 springcloud-study

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>

    <groupId>org.example</groupId>
    <artifactId>springcloud-study</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>springcloudapi</module>
        <module>springcloud-provider-dept-8001</module>
        <module>sringcloud-consummer-dept-80</module>
    </modules>
    <!--打包方式-->
    <packaging>pom</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>

    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR4</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- spring-boot-dependencies -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.2.1.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- mysql-connector-java -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
            <!-- druid -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.6</version>
            </dependency>
            <!-- mybatis-spring-boot-starter -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.3.0</version>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.2.3</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>

</project>

创建api公共模块

2.2、springcloudapi

新建springcloudapi模块

编写springcloud-api 的 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>springcloud-study</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloudapi</artifactId>

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

    <!--当前的model自己需要的依赖，如果父依赖中已经配置了版本。这里就不写了-->
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

</project>

创建部门数据库脚本，数据库名：db01

CREATE TABLE dept(
    deptno BIGINT NOT NULL PRIMARY KEY AUTO_INCREMENT,
    dname VARCHAR(60),
    db_source VARCHAR(60)
);
INSERT INTO dept(dname,db_source) VALUES('开发部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('人事部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('财务部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('市场部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('运维部',DATABASE());

编写实体类，注意：实体类都序列化！

package com.lxw.springcloud.pojo;

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

import java.io.Serializable;

@Data
@NoArgsConstructor
@Accessors(chain = true)  //链式写法
public class Dept implements Serializable {

    private Long deptno;
    private String dname;
    private String db_source; //数据库

    public Dept(String dname){
        this.dname = dname;
    }


}

2.3、springcloud-provider-dept-8001

创建provider模块springcloud-provider-dept-8001

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>springcloud-study</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-provider-dept-8001</artifactId>

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

    <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>springcloudapi</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <!-- spring-boot-devtools -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

</project>

编辑 application.yml

server:
  port: 8001
#mybatis的配置
mybatis:
  config-location: classpath:mybatis/mybatis-config.xml
  type-aliases-package: com.lxw.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
#spring的相关配置
spring:
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource # 数据源
    driver-class-name: com.mysql.jdbc.Driver # mysql驱动
    url: jdbc:mysql://localhost:3306/db01?useSSL=false&useUnicode=true&characterEncoding=UTF-8 #数据库名称
    username: root
    password: 123456
    dbcp2:
      min-idle: 5 #数据库连接池的最小维持连接数
      initial-size: 5 #初始化连接数
      max-total: 5 #最大连接数
      max-wait-millis: 200 #等待连接获取的最大超时时间

根据配置新建mybatis-config.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <!--开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
</configuration>

编写部门的dao接口

package com.lxw.springcloud.dao;


import com.lxw.springcloud.pojo.Dept;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Mapper
@Repository
public interface DeptDao {
    public boolean addDept(Dept dept);

    public Dept queryById(Long id);

    public List<Dept> queryAll();
}

接口对应的Mapper.xml文件 mybatis\mapper\DeptMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lxw.springcloud.dao.DeptDao">
    <insert id="addDept" parameterType="com.lxw.springcloud.pojo.Dept">
        insert into db01.dept (dname,db_source) values (#{dname},DATABASE());
    </insert>
    <select id="queryById" resultType="com.lxw.springcloud.pojo.Dept" parameterType="Long">
        select deptno,dname,db_source from db01.dept where deptno = #{deptno};
    </select>
    <select id="queryAll" resultType="com.lxw.springcloud.pojo.Dept">
        select deptno,dname,db_source from db01.dept;
    </select>
</mapper>

创建Service服务层接口DeptService.java

package com.lxw.springcloud.service;

import com.lxw.springcloud.pojo.Dept;

import java.util.List;

public interface DeptService {

    public boolean addDept(Dept dept);

    public Dept queryById(Long id);

    public List<Dept> queryAll();
}

DeptServiceImpl.java

package com.lxw.springcloud.service;

import com.lxw.springcloud.dao.DeptDao;
import com.lxw.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class DetServiceImpl implements DeptService{

    @Autowired
    private DeptDao deptDao;

    @Override
    public boolean addDept(Dept dept) {
        return deptDao.addDept(dept);
    }

    @Override
    public Dept queryById(Long id) {
        return deptDao.queryById(id);
    }

    @Override
    public List<Dept> queryAll() {
        return deptDao.queryAll();
    }
}

DeptController提供REST服务DeptController.java

package com.lxw.springcloud.Controller;

import com.lxw.springcloud.pojo.Dept;
import com.lxw.springcloud.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Controller
public class DeptController {
    @Autowired
    private DeptService deptService;

    @PostMapping("/dept/add")
    @ResponseBody
    public boolean addDept(Dept dept){
        return deptService.addDept(dept);
    }

    @GetMapping("dept/get/{id}")
    @ResponseBody
    public Dept get(@PathVariable("id") Long id){
        return deptService.queryById(id);
    }

    @GetMapping("/dept/list")
    @ResponseBody
    public List<Dept> queryAll(){
        return deptService.queryAll();
    }
}

编写DeptProvider的主启动类

DeptProvider_8001.java

package com.lxw.springcloud;

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

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

启动测试，注意编写细节：

2.4、springcloud-consummer-dept-80

创建consumer模块springcloud-consummer-dept-80

编辑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>springcloud-study</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>sringcloud-consummer-dept-80</artifactId>

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

    <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>springcloudapi</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>
    </dependencies>


</project>

application.yml 配置文件

server:
  port: 80

新建一个ConfigBean包注入 RestTemplate！

package com.lxw.springcloud.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean {

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

创建Controller包，编写DeptConsumerController类

package com.lxw.springcloud.controller;


import com.lxw.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
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 java.util.List;

@RestController
public class DeptConsumerController {
    //理解：消费者，不应该有service层
    // 使用RestTemplate访问restful接口非常的简单粗暴且无脑
    // （url，requestMap，ResponseBean.class） 这三个参数分别代表
    // REST请求地址，请求参数，Http响应转换 被 转换成的对象类型

    @Autowired
    private RestTemplate restTemplate;

    private static final String REST_URL_PREFIX = "http://localhost:8001";

    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept){
        return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,Boolean.class);
    }

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get/"+id,Dept.class);
    }

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);
    }

}

主启动类DeptConsumer_80.java

package com.lxw.springcloud;

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

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

访问测试：

3、Eureka服务注册与发现

3.1、服务构建

建立springcloud-eureka-7001模块

编辑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>springcloud-study</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-eureka-7001</artifactId>

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

    <dependencies>
        <!-- eureka-server服务端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
        <!--热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

</project>

application.yml

server:
  port: 7001

eureka:
  instance:
    hostname: localhost #eureka服务端的实例名称
  client:
    register-with-eureka: false # 表示是否向eureka注册中心注册自己,本身是服务器，无需注册
    fetch-registry: false # false代表自己为注册中心,false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

编写主启动类EurekaServer_7001

package com.lxw.springcloud;


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

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

启动，访问测试：

System Status：系统信息

DS Replicas：服务器副本
Instances currently registered with Eureka：已注册的微服务列表
General Info：一般信息
Instance Info：实例信息

3.2、Service Provider

将 8001 的服务入驻到 7001 的eureka中！

1、修改8001服务的pom文件，增加eureka的支持！

<!--将服务的provider注册到eureka中-->
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/springcloud-starter-eureka -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

2、yaml 中配置 eureka 的支持

#eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka

3、8001 的主启动类注解支持

package com.lxw.springcloud;

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

@SpringBootApplication
@EnableEurekaClient // 本服务启动之后会自动注册进Eureka中！
public class DeptProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8001.class,args);
    }
}

截止目前：服务端也有了，客户端也有了，启动7001，再启动8001，测试访问

3.3、actuator与注册微服务信息完善

在8001的yaml中修改一下配置

#eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    instance-id: springcloud-provider-dept8001 # 重点，和client平级

重新访问：

访问信息有IP信息提示

yaml中在增加一个配置

#eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    instance-id: springcloud-provider-dept8001 # 重点，和client平级
    prefer-ip-address: true # true访问路径可以显示IP地址

修改8001的pom文件，新增依赖！

<!--actuator监控信息完善-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

在总的父工程中修改pom.xml添加build信息【没必要做】

<build>
    <finalName>springcloud</finalName>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
        </resource>
    </resources>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-resources-plugin</artifactId>
            <version>3.2.0</version>
            <configuration>
                <delimiters>
                    <!--以$开头的或者结尾的在src/main/resources路径下的就能读取-->
                    <delimit>$</delimit>
                </delimiters>
            </configuration>
        </plugin>
    </plugins>
</build>

然后回到我们的8001的yaml配置文件中修改增加信息

#info配置
info:
  app.name: lxwname-springcloud
  company.name: www.lxw.com
  build.artifactId: ${project.artifactId}
  build.version: ${project.version}

重启项目测试：7001、8001

3.4、Eureka的自我保护机制

自我保护机制：好死不如赖活着
一句话总结：某时刻某一个微服务不可以用了，eureka不会立刻清理，依旧会对该微服务的信息进行保
存！

3.5、8001服务发现 Discovery

对于注册进eureka里面的微服务，可以通过服务发现来获得该服务的信息。【对外暴露服务】
修改springcloud-provider-dept-8001工程中的DeptController

@GetMapping("/dept/discovery")
@ResponseBody
public Object discovery(){
    //获取微服务列表的清单
    List<String> services = client.getServices();
    System.out.println("discovery=>services:"+services);

    //得到一个具体的微服务信息
    List<ServiceInstance> instances = client.getInstances("springcloud-provider-dept");

    for (ServiceInstance instance : instances) {
        System.out.println(
            instance.getServiceId()+"\t"+
            instance.getHost()+"\t"+
            instance.getPort()+"\t"+
            instance.getUri()
        );
    }
    return this.client;
}

主启动类增加一个注解

package com.lxw.springcloud;

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

@SpringBootApplication
@EnableEurekaClient // 本服务启动之后会自动注册进Eureka中！
@EnableDiscoveryClient
public class DeptProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8001.class,args);
    }
}

启动Eureka服务，启动8001提供者

访问测试 http://localhost:8001/dept/discovery

后台输出：

3.6、consumer访问服务

springcloud-consumer-dept-80
修改DeptConsumerController增加一个方法

@GetMapping("/consumer/dept/discovery")
public Object discovery(){
    return restTemplate.getForObject(REST_URL_PREFIX+"/dept/discovery",Object.class);
}

启动80项目访问：

3.7、集群配置

新建工程springcloud-eureka-7002、springcloud-eureka-7003
按照7001为模板粘贴POM
修改7002和7003的主启动类
修改映射配置 , windows域名映射hosts

127.0.0.1  eureka7001.com
127.0.0.1  eureka7002.com
127.0.0.1  eureka7003.com

修改3个EurekaServer的yaml文件夹

7001:

eureka:
  instance:
    hostname: eureka7001.com #eureka服务端的实例名称
  client:
    register-with-eureka: false # 表示是否向eureka注册中心注册自己,本身是服务器，无需注册
    fetch-registry: false # false代表自己为注册中心,false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url:
# 单机     defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

7002:

defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7003.com:7003/eureka/

7003:

defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/

将8001微服务发布到1台eureka集群配置中，发现在集群中的其余注册中心也可以看到，但是平时我们
保险起见，都发布！

defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/

启动集群测试！

3.8、Eureka和Zookeeper区别（CAP原则）

百度百科：https://baike.baidu.com/item/CAP%E5%8E%9F%E5%88%99/5712863

ACID是什么？

A（Atomicity）原子性
C（Consistency）一致性
I （Isolation）隔离性
D（Durability）持久性

CAP是什么？

C（Consistency）强一致性
A（Availability）可用性
P（Partition tolerance）分区容错性

CAP理论的核心
一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求
根据CAP原理，将NoSQL数据库分成了满足CA原则，满足CP原则和满足AP原则三大类：

CA：单点集群，满足一致性，可用性的系统，通常可扩展性较差
CP：满足一致性，分区容错性的系统，通常性能不是特别高
AP：满足可用性，分区容错性的系统，通常可能对一致性要求低一些

Zookeeper保证的是CP；强一致，性能慢
Eureka保证的是AP；高可用，性能快，一致性弱

Zookeeper保证的是CP
当向注册中心查询服务列表时，我们可以容忍注册中心返回的是几分钟以前的注册信息，但不能接受服
务直接down掉不可用。也就是说，服务注册功能对可用性的要求要高于一致性。但是zk会出现这样一种
情况，当master节点因为网络故障与其他节点失去联系时，剩余节点会重新进行leader选举。问题在
于，选举leader的时间太长，30~120s，且选举期间整个zk集群都是不可用的，这就导致在选举期间注
册服务瘫痪。在云部署的环境下，因为网络问题使得zk集群失去master节点是较大概率会发生的事件，
虽然服务最终能够恢复，但是漫长的选举时间导致的注册长期不可用是不能容忍的。

Eureka保证的是AP
Eureka看明白了这一点，因此在设计时就优先保证可用性。Eureka各个节点都是平等的，几个节点挂
掉不会影响正常节点的工作，剩余的节点依然可以提供注册和查询服务。而Eureka的客户端在向某个
Eureka注册时，如果发现连接失败，则会自动切换至其他节点，只要有一台Eureka还在，就能保住注册
服务的可用性，只不过查到的信息可能不是最新的，除此之外，Eureka还有一种自我保护机制，如果在
15分钟内超过85%的节点都没有正常的心跳，那么Eureka就认为客户端与注册中心出现了网络故障，此
时会出现以下几种情况：

Eureka不再从注册列表中移除因为长时间没收到心跳而应该过期的服务
Eureka仍然能够接受新服务的注册和查询请求，但是不会被同步到其他节点上（即保证当前节点依
然可用）
当网络稳定时，当前实例新的注册信息会被同步到其他节点中

结论：因此，Eureka可以很好的应对因网络故障导致部分节点失去联系的情况，而不会像zookeeper那样使整
个注册服务瘫痪

4、Ribbon负载均衡

4.1、Ribbon是什么？

Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。

负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA（高可用）。

简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将NetFlix的
中间层服务连接在一起。Ribbon的客户端组件提供一系列完整的配置项如：连接超时、重试等等。简单
的说，就是在配置文件中列出LoadBalancer（简称LB：负载均衡）后面所有的机器，Ribbon会自动的
帮助你基于某种规则（如简单轮询，随机连接等等）去连接这些机器。我们也很容易使用Ribbon实现自
定义的负载均衡算法！

常见的负载均衡软件有 Nginx，Lvs 等等

负载均衡简单分类：

集中式LB
- 即在服务的消费方和提供方之间使用独立的LB设施
- 如之前学习的Nginx，由该设施负责把访问请求通过某种策略转发至服务的提供方！
进程式LB
- 将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器。
- Ribbon就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址！
  Ribbon的github地址： https://github.com/NetFlix/ribbon

4.2、Ribbon配置初步

复制springcloud-consumer-dept-80工程 springcloud-consumer-dept-ribbon-80
1、主启动类名字修改下，用作区分

DeptConsumerRibbon80

2、修改pom.xml，添加Ribbon相关的配置

<!--Ribbon相关-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/springcloud-starter-ribbon -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-ribbon</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

3、修改application.yml ，追加Eureka的服务注册地址

server:
  port: 80

#Eureka配置
eureka:
  client:
    register-with-eureka: false #false表示不向注册中心注册自己
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

4、对里面的ConfigBean方法加上注解@LoadBalanced在获得Rest时加入Ribbon的配置；

package com.lxw.springcloud.config;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean {

    @Bean
    @LoadBalanced ////Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

6、修改DeptConsumerController客户端访问类，之前的写的地址是写死的，现在需要变化！

7、先启动3个Eureka集群后，在启动springcloud-provider-dept-8001并注册进eureka，再启动 DeptConsumerRibbon80

8、测试http://localhost/consumer/dept/list

9、小结：Ribbon和Eureka整合后Consumer可以直接调用服务而不用再关心地址和端口号！

4.3、Ribbon负载均衡

新建db02/db03数据库，各自微服务分别连接各自的数据库，复制DB1！

修改8002/8003各自的yml文件

端口
数据库连接
实例名也需要修改

instance:
	instance-id: springcloud-provider-dept8003

对外暴露的统一的服务实例名【三个服务名字必须一致！】

application:
	name: springcloud-provider-dept

启动3个Eureka集群配置区

启动3个Dept微服务并都测试通过
http://localhost:8001/dept/list
http://localhost:8002/dept/list
http://localhost:8003/dept/list

启动springcloud-consumer-dept-ribbon-80

客户端通过Ribbon完成负载均衡并访问上一步的Dept微服务
http://localhost/consumer/dept/list
多刷新几次注意观察结果！

第一次访问

第二次访问

第三次访问

4.4、Ribbon核心组件IRule

IRule：根据特定算法从服务列表中选取一个要访问的服务！

RoundRobinRule【轮询】
RandomRule【随机】
AvailabilityFilterRule【会先过滤掉由于多次访问故障而处于断路器跳闸的服务，还有并发的连接数量超过阈值的服务，然后对剩余的服务列表按照轮询策略进行访问】
WeightedResponseTimeRule【根据平均响应时间计算所有服务的权重，响应时间越快服务权重越大，被选中的概率越高，刚启动时如果统计信息不足，则使用RoundRobinRule轮询策略，等待统计信息足够，会切换到WeightedResponseTimeRule】
RetryRule【先按照RoundRobinRule轮询的策略获取服务，如果获取服务失败，则在指定时间内会进行重试，获取可用的服务】
BestAvailableRule【会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，然后选择一个并发量最小的服务】
ZoneAvoidanceRule【默认规则，复合判断server所在区域的性能和server的可用性选择服务器】

查看分析源码：

可以切换为随机策略实现试试，在ConfigBean中添加方法

@Bean
public IRule myRule(){
	//使用我们重新选择的随机算法，替代默认的轮询！
	return new RandomRule();
}

4.5、自定义Ribbon

修改springcloud-consumer-dept-ribbon-80
主启动类添加@RibbonClient注解
在启动该微服务的时候就能去加载我们自定义的Ribbon配置类，从而使配置类生效，例如:

@RibbonClient(name="SPRINGCLOUD-PROVIDERDEPT",configuration=MySelfRule.class)

官方文档明确给出了警告：
这个自定义配置类不能放在@ComponentScan所扫描的当前包以及子包下，否则我们自定义的这个配置
类就会被所有的Ribbon客户端所共享，也就是说达不到特殊化定制的目的了！

1.由于有以上配置细节原因，我们建立一个包 com.lxw.myrule

2.在这里新建一个自定义规则的Rubbion类

package com.lxw.myrole;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class LxwRule {
    @Bean
    public IRule myRule(){
        return new RandomRule(); //Ribbon默认是轮询，我们自定义为随机算法
    }
}

3.在主启动类上配置我们自定义的Ribbon

package com.lxw.springcloud;

import com.lxw.myrole.LxwRule;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name="SPRINGCLOUD-PROVIDER-DEPT",configuration= LxwRule.class)
public class DeptConsumerRibbon80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumerRibbon80.class,args);
    }
}

4.启动所有项目，访问测试，看看我们编写的随机算法，现在是否生效！

访问测试http://localhost/consumer/dept/list，确实变成随机的了

自定义规则深度解析
1、问题：依旧轮询策略，但是加上新需求，每个服务器要求被调用5次，就是以前每一个机器一次，现
在每个机器5次；
2、解析源码：RandomRule.java ， IDEA直接点击进去，复制出来，变成我们自己的类
LxwRondomRule

源码：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.netflix.loadbalancer;

import com.netflix.client.config.IClientConfig;
import edu.umd.cs.findbugs.annotations.SuppressWarnings;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

public class RandomRule extends AbstractLoadBalancerRule {
    public RandomRule() {
    }

    @SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        } else {
            Server server = null;

            while(server == null) {
                if (Thread.interrupted()) {
                    return null;
                }

                List<Server> upList = lb.getReachableServers();
                List<Server> allList = lb.getAllServers();
                int serverCount = allList.size();
                if (serverCount == 0) {
                    return null;
                }

                int index = this.chooseRandomInt(serverCount);
                server = (Server)upList.get(index);
                if (server == null) {
                    Thread.yield();
                } else {
                    if (server.isAlive()) {
                        return server;
                    }

                    server = null;
                    Thread.yield();
                }
            }

            return server;
        }
    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

    public Server choose(Object key) {
        return this.choose(this.getLoadBalancer(), key);
    }

    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

参考源码修改为我们需求要求的LxwRondomRule.java

package com.lxw.myrole;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;

import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

public class LxwRondomRule extends AbstractLoadBalancerRule {
    // total = 0 当total数等于5以后，我们指针才能往下走
    // index = 0 当前对外提供服务的服务器地址
    // 如果total等于5，则index+1，将total重置为0即可！
    // 问题：我们只有3台机器，所有total>3 则将total置为0；
    private int total = 0; //总共被调用的次数
    private int currentIndex = 0; //当前提供服务的机器序号！
    // ILoadBalancer选择的随机算法
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;
        while (server == null) {
            //查看线程是否中断了
            if (Thread.interrupted()) {
                return null;
            }
            //Reachable： 可及；可到达；够得到
            List<Server> upList = lb.getReachableServers(); //活着的服务
            List<Server> allList = lb.getAllServers(); //获取所有的服务
            int serverCount = allList.size();
            if (serverCount == 0) {
                return null;
            }
            // int index = chooseRandomInt(serverCount); //生成区间随机数！
            // server = upList.get(index); //从活着的服务中，随机取出一个
            //+=====================================
            if (total<5){
                server = upList.get(currentIndex);
                total++;
            }else {
                total = 0;
                currentIndex++;
                if (currentIndex>=upList.size()){
                    currentIndex = 0;
                }
                server = upList.get(currentIndex);
            }
            //+=====================================
            if (server == null) {
                Thread.yield();
                continue;
            }
            if (server.isAlive()) {
                return (server);
            }
            server = null;
            Thread.yield();
        }
        return server;
    }
    //随机
    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }
    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }

}

调用，在我们自定义的LxwRole方法中返回刚才我们写好的随机算法类

package com.lxw.myrole;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class LxwRule {
    @Bean
    public IRule myRule(){
//        return new RandomRule(); //Ribbon默认是轮询，我们自定义为随机算法
        return new LxwRondomRule(); //改成我们自定义的算法
    }

}

重启测试

5、Feign负载均衡

5.1、Feign简介

feign是声明式的web service客户端，它让微服务之间的调用变得更简单了，类似controller调用
service。
Spring Cloud集成了Ribbon和Eureka，可在使用Feign时提供负载均衡的http客户端。
只需要创建一个接口，然后添加注解即可！

调用微服务访问两种方法

微服务名字【ribbon】
接口和注解【feign 】

5.2、Feign能干什么？

Feign旨在使编写Java Http客户端变得更容易
前面在使用Ribbon + RestTemplate时，利用RestTemplate对Http请求的封装处理，形成了一套模
板化的调用方法。但是在实际开发中，由于对服务依赖的调用可能不止一处，往往一个接口会被多
处调用，所以通常都会针对每个微服务自行封装一些客户端类来包装这些依赖服务的调用。所以，
Feign在此基础上做了进一步封装，由他来帮助我们定义和实现依赖服务接口的定义，在Feign的实
现下，我们只需要创建一个接口并使用注解的方式来配置它（类似于以前Dao接口上标注Mapper
注解，现在是一个微服务接口上面标注一个Feign注解即可。）即可完成对服务提供方的接口绑
定，简化了使用Spring Cloud Ribbon时，自动封装服务调用客户端的开发量。

5.3、Feign使用步骤

1、参考springcloud-consumer-dept-ribbon-80
2、新建springcloud-consumer-dept-feign-80
修改主启动类名称
将springcloud-consumer-dept-80的内容都拷贝到 feign项目中
删除myrule文件夹
修改主启动类的名称为 DeptConsumerFeign80

3、springcloud-consumer-dept-feign-80修改pom.xml ，添加对Feign的支持

<!--Feign相关-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-feign</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

4、修改springcloudapi工程

pom.xml添加feign的支持

新建一个Service包com.lxw.springcloud.service

编写接口 DeptClientService，并增加新的注解@FeignClient。

package com.lxw.springcloud.service;

import com.lxw.springcloud.pojo.Dept;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;

import java.util.List;
@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")
public interface DeptClientService {

    @GetMapping("/dept/get/{id}")
    public Dept queryById(@PathVariable("id") Long id);

    @GetMapping("/dept/list")
    public List<Dept> queryAll();

    @PostMapping(value = "/dept/add")
    public boolean addDept(Dept dept);

}

5、springcloud-consumer-dept-feign-80工程修改Controller，添加上一步新建的DeptClientService

package com.lxw.springcloud.controller;


import com.lxw.springcloud.pojo.Dept;
import com.lxw.springcloud.service.DeptClientService;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class DeptConsumerController {
    
    @Autowired
    private DeptClientService deptClientService = null;

    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept){
        return this.deptClientService.addDept(dept);
    }

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
        return this.deptClientService.queryById(id);
    }

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){
        return this.deptClientService.queryAll();
    }

}

6、springcloud-consumer-dept-feign-80工程修改主启动类，开启Feign使用！

package com.lxw.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients(basePackages = {"com.lxw.springcloud"} )
//@RibbonClient(name="SPRINGCLOUD-PROVIDER-DEPT",configuration= LxwRule.class)
public class DeptConsumerFeign80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumerFeign80.class,args);
    }
}

7、测试

启动eureka集群7001.7002.7003

启动8001，8002，8003

启动feign客户端

测试： http://localhost/consumer/dept/list

结论：Feign自带负载均衡配置项

5.4、小结

Feign通过接口的方法调用Rest服务 ( 之前是Ribbon+RestTemplate )
该请求发送给Eureka服务器（http://MICROSERVICECLOUD-PROVIDER-DEPT/dept/list）
通过Feign直接找到服务接口，由于在进行服务调用的时候融合了Ribbon技术，所以也支持负载均衡作
用！
feign其实不是做负载均衡的,负载均衡是ribbon的功能,feign只是集成了ribbon而已,但是负载均衡的功能
还是feign内置的ribbon再做,而不是feign。
feign的作用的替代RestTemplate,性能比较低，但是可以使代码可读性很强。

6、Hystrix断路器

6.1、分布式系统问题概述

分布式系统面临的问题
复杂分布式体系结构中的应用程序有数十个依赖关系，每个依赖关系在某些时候将不可避免的失败！

服务雪崩
多个微服务之间调用的时候，假设微服务A调用微服务B和微服务C，微服务B 和微服务C又调用其他的微
服务，这就是所谓的 “扇出”、如果扇出的链路上某个微服务的调用响应时间过长或者不可用，对微服务A
的调用就会占用越来越多的系统资源，进而引起系统崩溃，所谓的 “雪崩效应”。

对于高流量的应用来说，单一的后端依赖可能会导致所有服务器上的所有资源都在几秒中内饱和。比失
败更糟糕的是，这些应用程序还可能导致服务之间的延迟增加，备份队列，线程和其他系统资源紧张，
导致整个系统发生更多的级联故障，这些都表示需要对故障和延迟进行隔离和管理，以便单个依赖关系
的失败，不能取消整个应用程序或系统。

我们需要 ·弃车保帅·

6.2、什么是Hystrix

Hystrix是一个用于处理分布式系统的延迟和容错的开源库，在分布式系统里，许多依赖不可避免的会调
用失败，比如超时，异常等，Hystrix能够保证在一个依赖出问题的情况下，不会导致整体服务失败，避
免级联故障，以提高分布式系统的弹性。
“断路器” 本身是一种开关装置，当某个服务单元发生故障之后，通过断路器的故障监控（类似熔断保险
丝），向调用方返回一个服务预期的，可处理的备选响应（FallBack），而不是长时间的等待或者抛出
调用方法无法处理的异常，这样就可以保证了服务调用方的线程不会被长时间，不必要的占用，从而避
免了故障在分布式系统中的蔓延，乃至雪崩.

能干嘛

服务降级
服务熔断
服务限流
接近实时的监控
....

官网资料
https://github.com/Netflix/Hystrix/wiki

6.3、服务熔断

是什么
熔断机制是对应雪崩效应的一种微服务链路保护机制。
当扇出链路的某个微服务不可用或者响应时间太长时，会进行服务的降级，进而熔断该节点微服务的调
用，快速返回错误的响应信息。当检测到该节点微服务调用响应正常后恢复调用链路。在SpringCloud
框架里熔断机制通过Hystrix实现。Hystrix会监控微服务间调用的状况，当失败的调用到一定阈值，缺省
是5秒内20次调用失败就会启动熔断机制。
熔断机制的注解是 @HystrixCommand。

实现：

1.参考springcloud-provider-dept-8001
新建springcloud-provider-dept-hystrix-8001
将之前8001的所有东西拷贝一份

2.修改pom.xml，添加Hystrix的依赖

<!--Hystrix-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

3.修改yml

修改eureka实例的id

instance-id: springcloud-provider-dept8001-hystrix

4.修改DeptController

package com.lxw.springcloud.Controller;

import com.lxw.springcloud.pojo.Dept;
import com.lxw.springcloud.service.DeptService;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@Controller
public class DeptController {

    @Autowired
    private DeptService service;

    //一旦调用服务方法失败并抛出了错误信息后
// 会自动调用HystrixCommand标注好的fallbackMethod调用类中指定方法
    @GetMapping("/dept/get/{id}")
    @HystrixCommand(fallbackMethod = "processHystrix_Get")
    public Dept get(@PathVariable("id") Long id) {
        Dept dept = service.queryById(id);
        if (dept == null) {
            throw new RuntimeException("该id：" + id + "没有对应的的信息");
        }
        return dept;
    }

    public Dept processHystrix_Get(@PathVariable("id") Long id) {
        return new Dept().setDeptno(id)
                .setDname("该id：" + id + "没有对应的信息，null--@HystrixCommand")
                .setDb_source("no this database in MySQL");

    }
}

5.修改主启动类添加新注解 @EnableCircuitBreaker

package com.lxw.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient // 本服务启动之后会自动注册进Eureka中！
@EnableDiscoveryClient
@EnableCircuitBreaker  //对hystrix 熔断机制的支持 【==========new=======】
public class DeptProviderHystrix8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProviderHystrix8001.class,args);
    }
}

测试
1、启动Eureka集群
2、启动主启动类 DeptProviderHystrix8001

3、启动客户端 springcloud-consumer-dept-80

4、访问 http://localhost/consumer/dept/get/1

访问不存在的：http://localhost/consumer/dept/get/8

6.4、服务降级

是什么
整体资源快不够了，忍痛将某些服务先关掉，待渡过难关，再开启回来。

服务降级处理是在客户端实现完成的，与服务端没有关系
修改springcloud-api工程，根据已经有的DeptClientService接口新建一个实现了FallbackFactory接
口的类DeptClientServiceFallbackFactory
【注意：这个类上需要@Component注解！！！】

package com.lxw.springcloud.service;

import com.lxw.springcloud.pojo.Dept;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;

import java.util.List;

@Component //千万不要忘记
public class DeptClientServiceFallbackFactory implements
        FallbackFactory<DeptClientService> {
    @Override
    public DeptClientService create(Throwable throwable) {
        return new DeptClientService() {
            @Override
            public Dept queryById(Long id) {
                return new Dept().setDeptno(id)
                        .setDname("该id："+id+"没有对应的信息，Consumer客户端提供 的降级信息，此刻服务Provider已经关闭")
                                        .setDb_source("no this database in MySQL");
            }
            @Override
            public List<Dept> queryAll() {
                return null;
            }
            @Override
            public boolean addDept(Dept dept) {
                return false;
            }
        };
    }
}

修改springcloud-api工程，DeptClientService接口在注解 @FeignClient中添加fallbackFactory属
性值

package com.lxw.springcloud.service;

import com.lxw.springcloud.pojo.Dept;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;

import java.util.List;
@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT",fallbackFactory = DeptClientServiceFallbackFactory.class)
public interface DeptClientService {

    @GetMapping("/dept/get/{id}")
    public Dept queryById(@PathVariable("id") Long id);

    @GetMapping("/dept/list")
    public List<Dept> queryAll();

    @PostMapping(value = "/dept/add")
    public boolean addDept(Dept dept);

}

springcloud-consumer-dept-feign-80工程修改YML

server:
  port: 80

feign:
  hystrix:
    enabled: true

#Eureka配置
eureka:
  client:
    register-with-eureka: false #false表示不向注册中心注册自己
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

测试

启动eureka集群
启动 springcloud-provider-dept-hystrix-8001
启动 springcloud-consumer-dept-feign-80
正常访问测试
http://localhost/consumer/dept/get/1

故意关闭微服务启动 springcloud-provider-dept-hystrix-8001
客户端自己调用提示
http://localhost/consumer/dept/get/1

此时服务端provider已经down了，但是我们做了服务降级处理，让客户端在服务端不可用时
也会获得提示信息而不会挂起耗死服务器。

6.5、小结

**服务熔断：**一般是某个服务故障或者异常引起，类似现实世界中的 “保险丝” ，当某个异常条件被触发，
直接熔断整个服务，而不是一直等到此服务超时！
**服务降级：**所谓降级，一般是从整体负荷考虑，就是当某个服务熔断之后，服务器将不再被调用，此时
客户端可以自己准备一个本地的fallback回调，返回一个缺省值。这样做，虽然服务水平下降，但好歹可
用，比直接挂掉要强。

6.6、服务监控

服务监控 hystrixDashboard
除了隔离依赖服务的调用以外，Hystrix还提供了准实时的调用监控（Hystrix Dashboard），Hystrix会
持续地记录所有通过Hystrix发起的请求的执行信息，并以统计报表和图形的形式展示给用户，包括每秒
执行多少请求，多少成功，多少失败等等。
Netflix通过hystrix-metrics-event-stream项目实现了对以上指标的监控，SpringCloud也提供了Hystrix
Dashboard的整合，对监控内容转化成可视化界面！

新建工程springcloud-consumer-hystrix-dashboard-9001
Pom.xml
复制之前80项目的pom文件，新增以下依赖！

<!--Hystrix-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

application.yaml配置

server:
  port: 9001

主启动类改名 + 新注解@EnableHystrixDashboard

所有的Provider微服务提供类(8001/8002/8003) 都需要监控依赖配置

<!--actuator监控信息完善-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

启动springcloud-consumer-hystrix-dashboard-9001该微服务监控消费端

http://localhost:9001/hystrix

测试一

启动eureka7001.7002.7003集群
启动springcloud-consumer-hystrix-dashboard-9001

在 springcloud-provider-dept-hystrix-8001 启动类中增加一个bean

@Bean
public ServletRegistrationBean hystrixMetricsStreamServlet() {
    ServletRegistrationBean registration = new ServletRegistrationBean(new HystrixMetricsStreamServlet());
    registration.addUrlMappings("/actuator/hystrix.stream");
    return registration;
}

启动 springcloud-provider-dept-hystrix-8001
1. http://localhost:8001/dept/get/1
2. http://localhost:8001/actuator/hystrix.stream 【查看1秒一动的数据流】
监控测试
多次刷新 http://localhost:8001/dept/get/1

观察监控窗口，就是那个豪猪页面

Delay : 该参数用来控制服务器上轮询监控信息的延迟时间，默认为2000毫秒，可以通过配置
该属性来降低客户端的网络和CPU消耗
Title ：该参数对应了头部标题HystrixStream之后的内容，默认会使用具体监控实例URL，可
以通过配置该信息来展示更合适的标题。

如何看监控图

7色

一圈

实心圆：公有两种含义，他通过颜色的变化代表了实例的健康程度
它的健康程度从绿色<黄色<橙色<红色递减
该实心圆除了颜色的变化之外，它的大小也会根据实例的请求流量发生变化，流量越大，该实心圆就越大，所以通过该实心圆的展示，就可以在大量的实例中快速发现故障实例和高压力实例。

一线

曲线：用来记录2分钟内流量的相对变化，可以通过它来观察到流量的上升和下降趋势！

整图说明

7、Zuul路由网关

7.1、概述

什么是Zuul？

Zuul包含了对请求的路由和过滤两个最主要的功能：

其中路由功能负责将外部请求转发到具体的微服务实例上，是实现外部访问统一入口的基础，而过滤器功能则负责对请求的处理过程进行干预，是实现请求校验，服务聚合等功能的基础。Zuul和Eureka进行整合，将Zuul自身注册为Eureka服务治理下的应用，同时从Eureka中获得其他微服务的消息，也即以后的访问微服务都是通过Zuul跳转后获得。
注意：Zuul服务最终还是会注册进Eureka
提供：代理 + 路由 + 过滤三大功能！

Zuul能干嘛？
路由
过滤

官网文档：https://github.com/Netflix/zuul

7.2、路由的基本配置

新建Module模块springcloud-zuul-gateway-9527

pom.xml文件
添加Eureka和zuul的配置

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-zuul</artifactId>
        <version>1.4.7.RELEASE</version>
    </dependency>
    <!--eureka相关-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
        <version>1.4.7.RELEASE</version>
    </dependency>

</dependencies>

application.yaml配置

server:
  port: 9527
#spring的相关配置
spring:
  application:
    name: springcloud-zuul-gateway
#eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: gateway9527.com
    prefer-ip-address: false #true访问路径可以显示IP地址
#info配置
info:
  app.name: lxw-springcloud
  company.name: www.lxw.com
  build.artifactId: ${project.artifactId}
  build.version: ${project.version}

hosts修改

127.0.0.1 myzuul.com

主启动类SpringCloudZuulApp9527

package com.lxw.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

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

启动
Eureka集群7001.7002.7003
一个服务提供类：springcloud-provider-dept-hystrix-8001
zuul路由
访问：http://localhost:7001/

测试
不用路由：http://localhost:8001/dept/get/2

使用路由：http://myzuul.com:9527/springcloud-provider-dept/dept/get/2
网关 / 微服务名字 / 具体的服务

7.3、路由访问映射规则

问题：http://myzuul.com:9527/springcloud-provider-dept/dept/get/2 这样去访问的话，就暴露了我们真实微服务的名称！这不是我们需要的！怎么处理呢?

修改：springcloud-zuul-gateway-9527 工程

代理名称
yml配置修改，增加Zuul路由映射！

#Zuul路由映射
zuul:
  routes:
    mydept.serviceId: springcloud-provider-dept
    mydept.path: /mydept/**

配置前访问：http://myzuul.com:9527/springcloud-provider-dept/dept/get/2

配置后访问：http://myzuul.com:9527/mydept/dept/get/2

问题，现在访问原路径依旧可以访问！这不是我们所希望的！

原真实服务名忽略

#Zuul路由映射
zuul:
  ignored-services: springcloud-provider-dept # 不能再使用这个服务名访问；
  routes:
    mydept.serviceId: springcloud-provider-dept
    mydept.path: /mydept/**

测试：现在访问http://myzuul.com:9527/springcloud-provider-dept/dept/get/2 就访问不了了

上面的例子中，我们只写了一个，那要是有多个需要隐藏，怎么办呢?

#Zuul路由映射
zuul:
	ignored-services: "*" # 通配符 * ， 隐藏全部的！
	routes:
		mydept.serviceId: springcloud-provider-dept
		mydept.path: /mydept/**

设置统一公共前缀

#Zuul路由映射
zuul:
	prefix: /kuang
	ignored-services: springcloud-provider-dept
	routes:
		mydept.serviceId: springcloud-provider-dept
		mydept.path: /mydept/**

访问：http://myzuul.com:9527/kuang/mydept/dept/get/2 ，加上统一的前缀！kuang，否则，就访问不了了！

8、SpringCloud Config

8.1、git环境搭建

1.下载git工具安装，一路next

2.右键git bash here

3.配置用户信息

git config --list
git config --global user.name="badwei"
git config --global user.email="1211304872@qq.com"

4.下载

git clone https://gitee.com/badwei/springcloud-config.git

5.上传

git add .
git status
git commit -m "my first commit"
git push origin master

上传文件为application.yml【注意不要漏掉---】

spring:
  profiles:
    active: dev

---
spring:
  profiles: dev
  application:
    name: springcloud-config-dev

---
spring:
  profiles: test
  application:
    name: springcloud-config-test

8.2、服务端：

新建springcloud-config-server-3344模块导入pom.xml依赖

<dependencies>
    <!--web-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--config-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-config-server</artifactId>
        <version>2.1.1.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
        <version>1.4.7.RELEASE</version>
    </dependency>
</dependencies>

resource下创建application.yml配置文件，Spring Cloud Config服务器从git存储库（必须提供）为远程客户端提供配置：

server:
  port: 3344

spring:
  application:
    name: springcloud-config-server
  # 连接码云远程仓库
  cloud:
    config:
      server:
        git:
          # 注意是https的而不是ssh
          uri: https://gitee.com/cao_shi_peng/springcloud-config.git 
            # 通过 config-server可以连接到git，访问其中的资源以及配置~

# 不加这个配置会报Cannot execute request on any known server 这个错：连接Eureka服务端地址不对
# 或者直接注释掉eureka依赖 这里暂时用不到eureka
eureka:
  client:
    register-with-eureka: false
    fetch-registry: false

主启动类

package com.lxw.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

@EnableConfigServer // 开启spring cloud config server服务
@SpringBootApplication
public class Config_server_3344 {
    public static void main(String[] args) {
        SpringApplication.run(Config_server_3344.class,args);
    }
}

HTTP服务具有以下格式的资源：

/{application}/{profile}[/{label}]
/{application}-{profile}.yml
/{label}/{application}-{profile}.yml
/{application}-{profile}.properties
/{label}/{application}-{profile}.properties

其中“应用程序”作为SpringApplication中的spring.config.name注入（即常规的Spring Boot应用程序中通常是“应用程序”），“配置文件”是活动配置文件（或逗号分隔列表的属性），“label”是可选的git标签（默认为“master”）。

启动访问测试：http://localhost:3344/application-dev.yml

测试：http://localhost:3344/application-test.yml

测试访问 http://localhost:3344/application/test/master

测试访问 http://localhost:3344/master/application-dev.yml

如果测试访问不存在的配置则不显示如：http://localhost:3344/master/application-aaa.yml

8.3、客户端

将本地git仓库springcloud-config文件夹下新建的config-client.yml提交到码云仓库：

spring:
  profiles:
    active: dev

---
server:
  port: 8201
spring:
  profiles: dev
  application:
    name: springcloud-provider-dept

eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/

---
server:
  port: 8202
spring:
  profiles: test
  application:
    name: springcloud-provider-dept

eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka

新建一个springcloud-config-client-3355模块，并导入依赖

<!--config-->
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-start -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
    <version>2.1.1.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

resources下创建application.yml和bootstrap.yml配置文件

bootstrap.yml 是系统级别的配置

# 系统级别的配置
spring:
  cloud:
    config:
      name: config-client # 需要从git上读取的资源名称，不要后缀
      profile: dev
      label: master
      uri: http://localhost:3344

application.yml 是用户级别的配置

# 用户级别的配置
spring:
  application:
    name: springcloud-config-client

创建controller包下的ConfigClientController.java 用于测试

package com.lxw.springcloud.controller;

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

@RestController
public class ConfigClientController {

    @Value("${spring.application.name}")
    private String applicationName; //获取微服务名称

    @Value("${eureka.client.service-url.defaultZone}")
    private String eurekaServer; //获取Eureka服务

    @Value("${server.port}")
    private String port; //获取服务端的端口号


    @RequestMapping("/config")
    public String getConfig() {
        return "applicationName:" + applicationName +
                "eurekaServer:" + eurekaServer +
                "port:" + port;
    }

}

主启动类

package com.lxw.springcloud;

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

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

测试：

启动服务端Config_server_3344 再启动客户端ConfigClient_3355

访问：http://localhost:8201/config/

8.4、小案例

本地新建config-dept.yml和config-eureka.yml并提交到码云仓库

config-dept.yml 参考8001

spring:
  profiles:
  active: dev

---
server:
  port: 8001
#mybatis的配置
mybatis:
  config-location: classpath:mybatis/mybatis-config.xml
  type-aliases-package: com.lxw.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
#spring的相关配置
spring:
  profiles: dev
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource # 数据源
    driver-class-name: com.mysql.jdbc.Driver # mysql驱动
    url: jdbc:mysql://localhost:3306/db01?useSSL=false&useUnicode=true&characterEncoding=UTF-8 #数据库名称
    username: root
    password: 123456
    dbcp2:
      min-idle: 5 #数据库连接池的最小维持连接数
      initial-size: 5 #初始化连接数
      max-total: 5 #最大连接数
      max-wait-millis: 200 #等待连接获取的最大超时时间
#eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/
  instance:
    instance-id: springcloud-provider-dept8001 # 重点，和client平级
    prefer-ip-address: true # true访问路径可以显示IP地址

#info配置
info:
  app.name: lxwname-springcloud
  company.name: www.lxw.com
  build.artifactId: ${project.artifactId}
  build.version: ${project.version}
  

---
server:
  port: 8001
#mybatis的配置
mybatis:
  config-location: classpath:mybatis/mybatis-config.xml
  type-aliases-package: com.lxw.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
#spring的相关配置
spring:
  profiles: test
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource # 数据源
    driver-class-name: com.mysql.jdbc.Driver # mysql驱动
    url: jdbc:mysql://localhost:3306/db02?useSSL=false&useUnicode=true&characterEncoding=UTF-8 #数据库名称
    username: root
    password: 123456
    dbcp2:
      min-idle: 5 #数据库连接池的最小维持连接数
      initial-size: 5 #初始化连接数
      max-total: 5 #最大连接数
      max-wait-millis: 200 #等待连接获取的最大超时时间
#eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/
  instance:
    instance-id: springcloud-provider-dept8001 # 重点，和client平级
    prefer-ip-address: true # true访问路径可以显示IP地址

#info配置
info:
  app.name: lxwname-springcloud
  company.name: www.lxw.com
  build.artifactId: ${project.artifactId}
  build.version: ${project.version}

config-eureka.yml 参考7001

spring:
  profiles:
  active: dev

---
server:
  port: 7001
 
spring:
  profiles: dev
  application:
    name: springcloud-config-eureka

eureka:
  instance:
    hostname: eureka7001.com #eureka服务端的实例名称
  client:
    register-with-eureka: false # 表示是否向eureka注册中心注册自己,本身是服务器，无需注册
    fetch-registry: false # false代表自己为注册中心,false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url:
# 单机     defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

---
server:
  port: 7001
 
spring:
  profiles: test
  application:
    name: springcloud-config-eureka

eureka:
  instance:
    hostname: eureka7001.com #eureka服务端的实例名称
  client:
    register-with-eureka: false # 表示是否向eureka注册中心注册自己,本身是服务器，无需注册
    fetch-registry: false # false代表自己为注册中心,false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url:
# 单机     defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

新建springcloud-config-eureka-7001模块，并将原来的springcloud-eureka-7001模块下的内容拷贝的该模块。

1.清空该模块的application.yml配置，并新建bootstrap.yml连接远程配置

bootstrap.yml

spring:
  cloud:
    config:
      name: config-eureka # 仓库中的配置文件名称
      label: master
      profile: dev
      uri: http://localhost:3344

application.yml

spring:
  application:
    name: springcloud-config-erueka-7001

2.在pom.xml中添加spring cloud config依赖

<!--config-->
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-config -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
    <version>2.1.1.RELEASE</version>
</dependency>

3.测试

第一步：启动 Config_Server_3344，并访问 http://localhost:3344/master/config-eureka-dev.yml 测试

第二步：启动ConfigEurekaServer_7001，访问 http://localhost:7001/ 测试

同样的我们新建8001：

新建springcloud-config-dept-8001模块并拷贝springcloud-provider-dept-8001的内容

同理导入spring cloud config依赖、清空application.yml 、新建bootstrap.yml配置文件并配置

bootstrap.yml

spring:
  cloud:
    config:
      name: config-dept
      label: master
      profile: dev
      uri: http://localhost:3344

application.yml

spring:
  application:
    name: springcloud-config-dept-8001

导包

<!--config-->
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-config -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
    <version>2.1.1.RELEASE</version>
</dependency>

测试：http://localhost:7001

再测试http://localhost:8001/dept/get/1

数据库为db02

我们修改远程配置后重启项目测试http://localhost:8001/dept/get/1

数据库换成了db01

9、回顾

导入依赖--编写配置--开启Enable

该往SpringCloud Alibaba学了，阿巴阿巴

SpringCloud

SpringCloud

1、微服务概述

1.1、微服务简介

1.2、springcloud和springboot的关系

1.3、springcloud和dubbo的区别

1.4、SpringCloud入门

2、Rest微服务构建

2.1、springcloud-study

2.2、springcloudapi

2.3、springcloud-provider-dept-8001

2.4、springcloud-consummer-dept-80

3、Eureka服务注册与发现

3.1、服务构建

3.2、Service Provider

3.3、actuator与注册微服务信息完善

3.4、Eureka的自我保护机制

3.5、8001服务发现 Discovery

3.6、consumer访问服务

3.7、集群配置

3.8、Eureka和Zookeeper区别（CAP原则）

4、Ribbon负载均衡

4.1、Ribbon是什么？

4.2、Ribbon配置初步

4.3、Ribbon负载均衡

4.4、Ribbon核心组件IRule

4.5、自定义Ribbon

5、Feign负载均衡

5.1、Feign简介

5.2、Feign能干什么？

5.3、Feign使用步骤

5.4、小结

6、Hystrix断路器

6.1、分布式系统问题概述

6.2、什么是Hystrix

6.3、服务熔断

6.4、服务降级

6.5、小结

6.6、服务监控

7、Zuul路由网关

7.1、概述

7.2、路由的基本配置

7.3、路由访问映射规则

8、SpringCloud Config

8.1、git环境搭建

8.2、服务端：

8.3、客户端

8.4、小案例

9、回顾

评论区