Springcloud netfix相关知识点

一.SpringCloud

1. Spring Cloud Netflix —一站式解决方案！（停更）

   api网关：zuul组件

   Feign ----HttpClient — Http通信方式，同步 阻塞

   注册服务发现：Eureka

   熔断机制：Hystrix

2. Apache Dubbo Zookeeper 半自动，需要整合别人的

   API：没有，找第三方组件，或自己实现

   Dubbo ：基于java的RPC通信框架

   Zookeeper：可以提供注册与发现

   没有：借助于 Hystrix

​ Doubbo这个方案不完善

3.Spring Cloud Alibaba —一站式解决方案！ 更简单

​

新概念：服务网格-- Server Mesh

​ istio

万变不离其宗：

​ 1.API

​ 2.HTTP RPC

​ 3.注册和发现

​ 4.熔断机制

​

二.微服务

1.什么是微服务？（灵活，方便）

微服务架构是一种架构模式，或者说是一种架构风格，它提倡将一种单一的应用程序划分成一组小的服务，（模块化）

每个服务运行在其独立的自己的进程中，服务之间互相协调，互相配置，为用户提供最终价值。

服务之间采用轻量级的通信机制互相沟通，每个服务都围绕着具体的业务进行构建，并且能够独立的部署到生产环境中

另外，应尽量避免统一的，集中式的服务管理机制，对具体的一个服务而言，应根据业务上下文，选择合适的语言，工具（maven）进行构建，可以有一个非常轻量级的集中式管理来协调这些服务，可以使用不同的语言来编写服务，也可以用不同的数据存储。

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

2.springboot和springcloud的关系

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

几个常用网站：

• springCloud中文网:https://www.springcloud.cc/

• https://www.springcloud.cc/spring-cloud-netflix.html

• 中文API官网：https://www.springcloud.cc/spring-cloud-dalston.html

• springCloud中国社区：https://www.springcloud.cn/

三.Eureka

1.包含两个组件：Eureka Server 和 Eureka Client.

2.Eureka Server 提供服务注册服务，各个节点启动后，会在EurekaServer中进行注册，这样Eureka Server 中的服务注册表中就会所有可用的服务节点的信息，服务节点的信息可以再界面中看到；

3.Eureka Client是一个java客户端，用于简化EurekaServer的交互，客户端同时也具备一个内置的，使用轮询负载算法的负载均衡器，，在应用启动后，将会向EurekaServer发送心跳（默认周期为30s）,如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer就会从服务注册表中把这个服务节点移除掉（默认周期为90秒）。

• 三大角色
  • Eureka Server: 提供服务的注册与发现， zookeeper
  • Service Provider:将自身服务注册到Eureka中，从而使消费方可以找到
  • Service Consumer:服务消费方从Eureka中获取注册服务列表，从而找到消费服务。

4.自我保护机制：好死不如赖活着

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ueAQgelS-1684541273806)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1673958887089.png)]

某时刻某一个服务不可以用了，Eureka不会立刻清理，依旧会对该微服务的信息进行保存！

• 宁可保留所有的服务，也不注销任何服务
• 自我保护机制是一种应对网络异常的安全保护机制，可以让Eureka集群更加健壮和稳定。
• 在springcloud中，可以使用eureka.server.enable-self-preservation = false 禁用自我保护机制（设置之后，服务崩了就是崩了，不再保护了！）

四.CAP原则

RDBMS(Mysql Oracle、SqlServer) ====>ACID

NoSQL(redis,mongdb) ===>CAP

ACID是什么？

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

CAP是什么？

• C(Consistency) 强一致性
• A(Avaliablity) 可用性
• P(Partition tolerance) 分区容错性

CAP的三进二：CA, CP, AP

指的是在一个分布式系统中，[一致性]（Consistency）、[可用性]（Availability）、[分区容错性]（Partition tolerance）。CAP 原则指的是，这三个[要素]最多只能同时实现两点，不可能三者兼顾。

作为服务注册中心，Eureka和zookeeper好在哪里？

• zookeeper保证的是CP

一个节点down掉，其他节点选取leader，但时间会过长，导致整个集群都是不可用的，，这就导致在选举期间注册服务瘫痪，在云部署的环境下，因为网络问题使得zk集群失去master节点是较大概率会发生的事件，虽然服务最终能够恢复，但是漫长的选举时间导致的 注册长期不可用是不能容忍的。

• eureka保证的是AP

Eureka各个节点都是平等的，几个节点挂掉不会影响其他节点的工作，剩余的节点仍然可以提供注册与查询服务，而eureka客户端在向某个eureka注册时，如果发现连接失败，则会自动切换至其他节点。只要有一台eureka还在，就能保证注册服务的可用性，只不过查到的信息可能不是最新的（不保证一致性的原因）。

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

五.Ribbon

1.是什么？

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

2.能干嘛？

• 将用户的请求平摊的分配到多个服务上，从而达到系统的HA(高可用)
• 常见的负载均衡软件有Nginx，Lvs（Linux Virtual Server Linux虚拟服务器）等
• Dubbo，springcloud中均给我们提供了负载均衡，springcloud的负载均衡算法可以自定义。

3.负载均衡简单理解[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MXg3sqFx-1684541273813)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1674271459034.png)]

客户端从eureka集群中获取可用的列表，然后通过列表实现负载均衡，去判断自己要去连哪一个服务。

4.自定义负载均衡算法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1aaeWYMn-1684541273815)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1674271666336.png)]

package com.kuang.myrule;

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

@Configuration
public class MyRule {

    @Bean
    public IRule myRule(){
        return new KuangRandomRule();//默认是轮询，现在是自定义为KuangRandomRule
    }

}

KuangRandomRule.java

package com.kuang.myrule;

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;
//每个服务，访问5次，换下一个服务（3个）
//total=0,默认为0，如果=5，我们指向下一个服务节点
//index=0,默认为0，如果total=5，index+1、

public class KuangRandomRule extends AbstractLoadBalancerRule {

    private int total = 0;//被调用的次数
    private int currentIndex = 0;//当前是谁在提供服务

    public KuangRandomRule() {
    }

    @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(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();
                } 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) {
    }
}

application.yml

server:
  port: 80


#Eureka配置
eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

ConfigBean.java

package com.kuang.springcloud.config;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
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 {

    //配置负载均衡实现RestTemplate
    //IRule
    //RoundRobinRule轮询
    //RandomRule随机
    //AvailabilityFilteringRule:会先过滤掉，跳闸，访问故障的服务，对剩下的进行轮询
    //RetryRule:会先按照轮询获取服务，如果服务获取失败，则会在指定的时间内进行重试
    @Bean
    @LoadBalanced //Ribbon
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }

}

DeptConsumerController.java

package com.kuang.springcloud.controller;

import com.kuang.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...供我们直接调用就可以了，注册到spring中
    //(url,实体：Map,Class<T> responseType)
    @Autowired
    private RestTemplate restTemplate;//提供多种便捷访问远程http服务的方法，简单的restful服务模板

    private static final String REST_URL_PREFIX = "http://springcloud-provide-dept";

    @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);
    }

}

六.Feign负载均衡

1.简介

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

2.feign，主要是社区，大家都习惯面向接口编程，这个是很多开发人员的规范，调用微服务访问两种方法

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

3.Feign能干什么？

• Feign旨在使编写java Http客户端变得更容易
• Feign集成了ribbon

4.Ribbon和Feign的区别：

• Ribbon通过微服务的名字调用，而Feign是通过接口调用。

Feign的调用：（社区版，接口）

package com.kuang.springcloud.controller;

import com.kuang.springcloud.pojo.Dept;
import com.kuang.springcloud.service.DeptClientService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
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 service = null;

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

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

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

}

Ribbon的调用（微服务的名字调用）

package com.kuang.springcloud.controller;

import com.kuang.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...供我们直接调用就可以了，注册到spring中
    //(url,实体：Map,Class<T> responseType)
    @Autowired
    private RestTemplate restTemplate;//提供多种便捷访问远程http服务的方法，简单的restful服务模板

    private static final String REST_URL_PREFIX = "http://springcloud-provide-dept";

    @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);
    }

}

七.Hystrix:服务熔断&服务降级

是什么？

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

服务降级和服务熔断的区别：

1、服务降级（客户端）：当服务调用出现响应时间过长或者运行出差或者宕机，就会调用服务降级方法快速响应。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7GUn6M2J-1684541273820)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1675253623941.png)]

package com.kuang.springcloud.service;

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

import java.util.List;

@Component
public class DeptClientServiceFallbackFactory implements FallbackFactory {
    @Override
    public DeptClientService create(Throwable throwable) {
        return new DeptClientService() {
            @Override
            public Dept queryById(Long id) {
                return new Dept()
                        .setDeptno(id)
                        .setDname("id=>"+id+"没有对应的信息，客户端提供了降级的信息，这个服务现在已经被关闭")
                        .setDb_source("没有数据~");
            }

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

            @Override
            public Boolean addDept(Dept dept) {
                return false;
            }
        };
    }
}

2、服务熔断（服务器端），只有在一定时间内服务调用失败（报错、超时、宕机）达到一定次数，才会启动服务熔断，进而调用服务降级方法快速响应。

package com.kuang.springcloud.controller;

import com.kuang.springcloud.pojo.Dept;
import com.kuang.springcloud.service.DeptService;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import lombok.val;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
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 java.util.List;

//提供restful服务！！
@RestController
public class DeptController {

    @Autowired
    private DeptService deptService;


    @HystrixCommand(fallbackMethod = "hystrixGet")
    @GetMapping("/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
        Dept dept = deptService.queryById(id);
        if (dept == null){
            throw new RuntimeException("id=>"+id+",不存在该用户，或者信息无法找到！！");
        }
        return dept;
    }

    //备选方案
    public Dept hystrixGet(@PathVariable("id") Long id){
        return new Dept()
                    .setDeptno(id)
                    .setDname("id=>"+id+"没有对应的信息，null--@Hystrix")
                    .setDb_source("no this database in Mysql");
    }
}

3、服务降级每次都会先调用原服务方法，调用失败才会执行服务降级方法；服务熔断状态会直接调用服务降级方法。

Hystrix：Dashboard流监控

在Hystrix服务端添加流监控并将服务注册到eureka中，客户端访问数据时会有流监控。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KqvPJ4lA-1684541273827)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1675299326292.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fF4hJbQB-1684541273831)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1675299402353.png)]

package com.kuang.springcloud;


import com.netflix.hystrix.contrib.metrics.eventstream.HystrixMetricsStreamServlet;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;

//启动类
@SpringBootApplication
@EnableEurekaClient //在服务启动后自动注册到Eureka中！
@EnableDiscoveryClient //服务发现
//添加对熔断的支持
@EnableCircuitBreaker
public class DeptProviderHstrix_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProviderHstrix_8001.class,args);
    }

    //增加一个servlet
    @Bean
    public ServletRegistrationBean a(){
        ServletRegistrationBean  registrationBean = new ServletRegistrationBean(new HystrixMetricsStreamServlet());
        registrationBean.addUrlMappings("/actuator/hystrix.stream");
        return registrationBean;
    }
}

八.Zuul路由网关

什么是Zuul？

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

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

注意：Zuul服务最终还是会注册进Eureka

提供：代理+路由+过滤三大功能！

Zuul能干嘛？

• 路由
• 过滤

server:
  port: 9527

spring:
  application:
    name: springcloud-zuul

eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: zuul9527.com
    prefer-ip-address: true

info:
  app.name: kuang-springcloud
  company.name: blog-kuangstudy.com

zuul:
  routes:
    mydept.serviceId: springcloud-provide-dept
    mydept.path: /mydept/**
  ignored-services: "*" #不能再使用这个路径访问了，ignored   http://www.kuangstudy.com:9527/mydept/dept/get/2
  prefix: /kuang #设置公共的前缀 http://www.kuangstudy.com:9527/kuang/mydept/dept/get/2

九.SpringCloud config分布式配置中心

1.git 相关操作及环境搭建：

• 从远程仓库克隆到本地
  • git clone git@gitee.com:xiaofeng-22/springcloud-config.git
• 本地文件修改后通过以下四步操作实现文件提交到远程仓库
  • git add .
  • git status
  • git commit -m “first commit”
  • git push origin master

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eQomPplc-1684541273834)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1675394422596.png)]

git pull origin master --allow-unrelated-histories

2.config客户端连接服务端访问

服务端：（springcloud-config-server-3344）

1.导入依赖

<?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.kuang</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-config-server-3344</artifactId>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
            <version>2.1.1.RELEASE</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>
    </dependencies>

</project>

2.编写配置

server:
  port: 3344

spring:
  application:
    name: springcloud-config-server
    #连接远程仓库
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/xiaofeng-22/springcloud-config.git #https ,不是git

3.编写启动类：

package com.kuang.springcloud;

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

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

客户端（springcloud-config-client-3355）

1.导入依赖：

<?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.kuang</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-config-client-3355</artifactId>

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

    <dependencies>
        <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>


</project>

2.配置文件（application.yml)和（bootstrap.yml）

application.yml

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

bootstrap.yml

#系统级别的配置
spring:
  cloud:
    config:
      name: config-client #从git上读取的文件名称，不需要后缀
      profile: dev
      label: master
      uri: http://localhost:3344  #等价为仓库的地址           http://localhost:3344/config-client-dev.yml为对应的配置文件的位置。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oxJFT6uI-1684541273840)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1675491494900.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZBOxG18N-1684541273843)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1675491528356.png)]

3.写测试，检测是否可以拿到数据

package com.kuang.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 ConfigController {

    @Value("${spring.application.name}")
    private String applicationName;
    @Value("${eureka.client.service-url.defaultZone}")
    private String eurekaServer;

    @Value("${server.port}")
    private String port;


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

    }
}

成功通过端口8201拿到数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VGV9YLIn-1684541273846)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1675491703442.png)]

总结：服务端连接远程仓库，客户端连接服务端，将配置放入远程仓库，通过客户端编写代码可以连接服务端继而拿到远程仓库数据，实现配置与代码解耦。

优点：

• 配置放入远程仓库，便可以在远程仓库中修改配置。
• 本地需要写的配置代码不需要很多，同时在远程仓库的配置代码也能生效。

十.各注解的含义

@EnableEurekaServer //EnableEurekaServer 服务端的启动类，可以接受别人注册进来（springcloud-eureka-7001）

@EnableEurekaClient //在服务启动后自动注册到Eureka中！
@EnableDiscoveryClient //服务发现（springcloud-provider-dept-8001）

@EnableEurekaClient（springcloud-consumer-dept-80）

@EnableConfigServer（springcloud-config-server-3344）

十一.总结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kbqwtoNf-1684541273849)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1675571312374.png)]

1.导入依赖

2.编写配置

3.@EnableXXX

面试题：

@Value("${server.port}")
private String port;


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

}

}

成功通过端口8201拿到数据

[外链图片转存中...(img-VGV9YLIn-1684541273846)]



总结：服务端连接远程仓库，客户端连接服务端，将配置放入远程仓库，通过客户端编写代码可以连接服务端继而拿到远程仓库数据，实现配置与代码解耦。

优点：

- 配置放入远程仓库，便可以在远程仓库中修改配置。
- 本地需要写的配置代码不需要很多，同时在远程仓库的配置代码也能生效。



# 十.各注解的含义

@EnableEurekaServer  //EnableEurekaServer 服务端的启动类，可以接受别人注册进来（springcloud-eureka-7001）



@EnableEurekaClient //在服务启动后自动注册到Eureka中！
@EnableDiscoveryClient //服务发现（springcloud-provider-dept-8001）



@EnableEurekaClient（springcloud-consumer-dept-80）



@EnableConfigServer（springcloud-config-server-3344）

# 十一.总结

[外链图片转存中...(img-kbqwtoNf-1684541273849)]

1.导入依赖

2.编写配置

3.@EnableXXX



面试题：