SpringCloud 学习笔记

SpringCloud

这个阶段该如何学

三层架构

框架:
	Spring IOC AOP
	
	SpringBoot, 新一代的JavaEE开发标准,自动装配
	
	模块化~  all in one
	
	模块化的开发
 
 微服务架构4个核心问题?
 	1. 服务很多,客户端该怎么访问? api网关
 	2. 这么多服务? 服务之间如何通信? http,rpc
 	3. 这么多服务? 如何治理?	服务注册与发现机制使用注册中心zookeeper,Eureka
 	4. 服务挂了怎么办? 水平拆分,垂直拆分,熔断机制,服务降级,
 	
 解决方案:
 	Spring Cloud 生态!	
 	
 	1. Spring Cloud NetFlix 一站式解决方案!
 		api网关, zuul组件
 		Feugn, --HttpCLient-- http通信方式 同步阻塞
 		服务组测与发现: Eureka
 		熔断机制: Hystrix
 	
 	2. Apache Dubbo Zookeeper 半自动,需要整合别人的!
 		api网关: 没有,找第三方组件或者自己实现
 		Dubbo RPC 异步不阻塞
 		Zookeeper 
 		熔断机制:没有 借助第三方组件
 		
 	3. Spring Cloud Alibaba 一站式解决方案! 更简单
 		
 
 新概念: 服务网格~ Server Mesh
 	istio
 	
 万变不离其宗
 	1. api
 	2. http ,rpc
 	3. 注册和发现
 	4. 熔断机制

目录

• 带着问题走进微服务
• 微服务概述
  • 什么是微服务
  • 微服务的优缺点
  • 微服务技术栈有哪些
  • 为什么选择SpringCloud作为微服务架构
    • 选型依据
    • 当前各大IT公司用的微服务架构有哪些
    • 各微服务框架对比
• SpringCloud入门概述
  • springCloud是什么
  • springCloud和SpringBoot关系
  • Dubbo和SpringCloud技术选型
    • 分布式+服务治理Dubbo
    • SpringCloud如何实现通信(http通信)
    • Dubbo+Zookeeper实现通信(RPC异步通信)
• Eureka服务注册与发现(和zookeeper对比)
  • 什么是Eureka
  • 原理讲解
  • 如何使用
  • 自我保护机制
  • CAP原则Eureka对比Zookeeper
  • 作为服务注册中心,Eureka比Zookeeper好在哪里
• ribbon负载均衡
  • ribbon是什么
  • ribbon能干嘛
• Feign负载均衡
  • 简介
• Hystrix 服务熔断
• Dashboard流监控
• Zuul路由网关
• SpringCloud config分布式配置
• 总结

带着问题走进微服务

1.1 什么是微服务?

微服务架构风格是一种将单个应用程序作为一套小型服务开发的方法，每种应用程序都在自己的进程中运行，并与轻量级机制（通常是HTTP资源API）进行通信。 

1.2 微服务之间如何进行通讯?

​ 使用http或者rpc

1.3 SpringCloud和Dubbo有哪些区别?

Dubbo和Spring Cloud并不是完全的竞争关系，两者所解决的问题域不一样：Dubbo的定位始终是一款RPC框架，而Spring Cloud的目的是微服务架构下的一站式解决方案。

1.4 springBoot和SpringCloud,请谈谈对他们的理解

1、SpringBoot：是一个快速开发框架，通过用MAVEN依赖的继承方式，帮助我们快速整合第三方常用框架，完全采用注解化（使用注解方式启动SpringMVC），简化XML配置，内置HTTP服务器（Tomcat，Jetty），最终以Java应用程序进行执行。

2、SpringCloud： 是一套目前完整的微服务框架，它是是一系列框架的有序集合。它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过SpringBoot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用SpringBoot的开发风格做到一键启动和部署。

1.5 什么是服务熔断?什么是服务降级?

1.6微服务的优缺点分别是什么?说下你在项目开发中遇到的坑

1.7你所知道的微服务技术栈有哪些?请列举一二

1.8eureka和zookeeper都可以提供服务注册与发现的功能,请说说两个的区别

2. 微服务概述

2.1 什么是微服务

**微服务架构: **把一个大型的单个应用程序和服务拆分为数个甚至数十个的支持微服务，它可扩展单个组件而不是整个的应用程序堆栈，从而满足服务等级协议。

**微服务:**微服务是由单一应用程序构成的小服务，拥有自己的进程与轻量化处理，服务依业务功能设计，以全自动的方式部署，与其他服务使用 HTTP API 通讯。同时，服务会使用最小规模的集中管理 （例如 Docker）技术，服务可以用不同的编程语言与数据库等。

微服务的优缺点:

优点

• 每个微服务都很小，这样能聚焦一个指定的业务功能或业务需求。
• 微服务能够被小团队单独开发，这个小团队是2到5人的开发人员组成。
• 微服务是松耦合的，是有功能意义的服务，无论是在开发阶段或部署阶段都是独立的。
• 微服务能使用不同的语言开发。
• 微服务易于被一个开发人员理解，修改和维护，这样小团队能够更关注自己的工作成果。无需通过合作才能体现价值。
• 微服务允许你利用融合最新技术。
• 微服务只是业务逻辑的代码，不会和HTML,CSS 或其他界面组件混合。

缺点

• 微服务架构可能带来过多的操作。

• 需要DevOps技巧 (http://en.wikipedia.org/wiki/DevOps)。

• 可能双倍的努力。

• 分布式系统可能复杂难以管理。

• 因为分布部署跟踪问题难。

• 当服务数量增加，管理复杂性增加。

• 服务之间通信成本增加

• 数据一致性

• 性能监控

2.2 微服务技术栈有哪些?

微服务条目	落地技术
服务开发	SpringBoot,Spring,SpringMVC
服务配置与管理	Netfilx公司的Archaius,阿里的Diamond等
服务注册与发现	EureKa,Consul,zookeeper等
服务调用	Rest,RPC,gRPC
服务熔断器	Hystrix,Envoy等
负载均衡	RIbbon,Nginx等
服务接口调用	Feign等
消息队列	kafka,RabbitMQ,ActiveMQ等
服务配置中心管理	SpringCloudConfig,Chef等
服务路由(API网关)	Zuul等
服务监控	Zabbix,Nagios,Metrics,Specateator等
全链路追踪	Zipkin,Brave,Dapper等
服务部署	Docker,OpenStack,Kubernetes等
数据流操作开发包	SpringCloud Stream(封装与Redis,Rabbit,Kafka等发送接受消息)
事件消息总线	SpringCloud Bus

2.3 为什么选择SpringCloud作为微服务架构

1.选型依据

• 整体解决方案和框架成熟度
• 社区热度
• 可维护性
• 学习曲线

2. 当前各大IT公司用的微服务架构有哪些?

• 阿里: dubbo+HFS
• 京东: JSF
• 新浪: Motan
• 当当网: Dubbox

3. 各微服务框架对比

3. SpringCloud入门概述

3.1 springCloud是什么

SpringCloud,基于SpringBoot提供了一套微服务解决方案,包括服务注册与发现,配置中心,全链路监控,服务网关,负载均衡,熔断器等组件,除了基于NetFlix的开源组件做高度抽象封装之外,还有一些选型中立的开源组件

SpringCloud利用SpringBoot的开发的便利性,巧妙地简化了分布式系统基础设施的开发,springCloud为开发人员提供了快速构建分布式系统的一些工具,包括配置管理,服务发现,断路器,路由,微代理,事件总线,全局锁,决策竞选,分布式会话等等,他们都可以用SpringBoot的开发风格做到一键化部署

springCloud并没有重复造轮子,他只是将目前各家公司开发的比较成熟,经得起实际考核的服务框架组合起来,通过SpringBoot风格进行再次封装,屏蔽掉了复杂的配置和实现原理,最终给开发者留出了一套简单易懂的,易部署,和易维护的分布式系统开发工具包

SpringCloud是分布式微服务架构下的一站式解决方案,是各个微服务架构落地技术的集合体,俗称微服务全家桶

3.2 springCloud和SpringBoot关系

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

3.3 Dubbo和SpringCloud技术选型

1.分布式+服务治理Dubbo

应用服务话拆分+ 消息中间件

Dubbo和SpringCloud对比

最大区别: SpringCloud抛弃了Dubbo的RPC通信,采用的是基于HTTP的REST方式

SpringCloud如何实现通信(http通信)

使用restTemplate实现,该类springBoot只提供了实现,注入需要我们手动配置

    <dependencyManagement>
        <dependencies>
		
        
            <dependency>
                <groupId>org.springframework.cloudgroupId>
                <artifactId>spring-cloud-dependenciesartifactId>
                <version>${spring-cloud-release.version}version>
                <type>pomtype>
                <scope>importscope>
            dependency>
        dependencies>
    dependencyManagement>

Dubbo+Zookeeper实现通信(RPC异步通信)

导入相关依赖,配置zookeeper地址,并将dubbo服务者和消费者注册到zookeeper中,在需要提供服务的类上添加@service(dubbo提供的注解)和@service(将该类交由spring管理),在消费者上添加@@Reference注解注入此类型(需要在maven中导入服务者的坐标)

4.Eureka服务注册与发现(和zookeeper对比)

4.1 什么是Eureka

• Eureka 遵从AP原则
• Eureka是NetFlix的一个子模块,也是核心模块之一,Eureka是一个基于REST的服务,用于定位服务,以实现云端中间层服务发现和故障转移.服务注册与发现对于微服务来说是非常重要的,有了服务注册与发现,只需要使用云端的服务标识符,就可以使用云端服务,而不需要修改服务调用的配置文件了,功能类似于Dubbo的注册中心,例如zookeeper

4.2 原理讲解

• Eureka基本架构

• SPringCloud封装了NetFlix公司开发的Eureka模块来实现服务注册与发现

• 采用C/S架构设计,EurekaServer作为服务注册功能的服务器,它是服务注册中心

• 系统中的其他微服务使用EurekaClient连接到EurekaServer并维持心跳连接(什么是心跳连接),这样系统的为湖人员就可以通过EurekaServer监控系统的服务运行状态,(如何监控采用Zuul等技术)

• 三大角色

  • Eureka Server : 提供服务的注册与发现
  • Server Provider: 将自身服务注册到Eureka中,从而使消费方能够找到
  • Server Consumer: 服务消费方从Eureka中获取注册服务列表,从而找到消费服务

如何使用

Eureka服务注册端

导入依赖

   
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-eureka-serverartifactId>
            <version>1.4.7.RELEASEversion>
        dependency>

配置eureka

server:
  port: 7001

#Eureka配置
eureka:
  instance:
    hostname: localhost #eureka服务端的名字
  client:
    register-with-eureka: false # 表示是否向eureka注册中心注册自己
    fetch-registry: false #如果为false,则表示自己为注册中心
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

在启动类上标注开启注解

访问7001端口

Eureka(服务提供者)

导入依赖

 
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-eurekaartifactId>
            <version>1.4.7.RELEASEversion>
            <classifier>sourcesclassifier>
            <type>java-sourcetype>
        dependency>
   
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>

配置client

#Eureka服务提供者配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    instance-id: ${spring.application.name}
#监控配置
info: #其实就是一个map存放kv键值对当访问/actuator/info时以json字符串返回
  app.name: provider-springcloud
  company.name: czp
  message: eureka学习    

开启注解@enableeurekaclient

在controller中配置

//访问这个页面可以查看微服务的一些信息  
@GetMapping("/dept/discovery")
    public Object discovery(){
        List<String> services = discoveryClient.getServices();
        System.out.println("discovery=>services:" + services);
        //得到一个具体的微服务信息,通过具体的微服务id,
        List<ServiceInstance> provider = discoveryClient.getInstances("provider");
        for (ServiceInstance serviceInstance : provider) {
            System.out.println("----------------------------------------");
            System.out.println("主机ip:" + serviceInstance.getHost());
            System.out.println("主机端口" + serviceInstance.getPort());
            System.out.println("url地址" + serviceInstance.getUri());
            System.out.println("服务名称" + serviceInstance.getServiceId());
        }
        return this.discoveryClient;
    }

需要添加@EnableDiscoveryClient //开启服务注册发现注解

Eureka(服务消费者)

导入依赖

 
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-eurekaartifactId>
            <version>1.4.7.RELEASEversion>
            <classifier>sourcesclassifier>
            <type>java-sourcetype>
        dependency>

对其进行配置

#eureka服务消费者配置
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
    register-with-eureka: false # 不向eureka中注册自己

将restTemplate中url的前缀该为服务提供者的id

private static final String REST_URL_PREFIX = "http://PROVIDER";

使用restTemplate对其进行访问传输即可

Eureka集群

创建多个EurekaServer,在每个EurekaServer中配置

service-url:
#单个关注自己 http://${eureka.instance.hostname}:${server.port}/eureka/
      defaultZone: #多个关注其他EurekaServer地址

EurekaClient(服务注册者在注册时三个都要进行登记注册)

访问7001

服务注册成功

自我保护机制

CAP原则Eureka对比Zookeeper

CAP原则

RDBMS (关系型数据库) 遵从ACID原则

NoSQL(非关系型数据库)遵从CAP原则

ACID原则是什么

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

CAP是什么

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

CAP的三进二: CA,AP,CP

CAP理论的核心

• 一个分布式系统不可能同时很好的满足一致性,可用性和分区容错性这三个需求

• 根据CAP原理NoSQL数据库分成了满足CA原则,满足CP原则和满足AP原则三大类

  • CA:单点集群,满足强一致性和可用性的系统,通常可扩展性较差

  • CP: 满足一致性,分区容错性的系统,通常性能不是特别高

  • AP: 满足可用性和分区容错性的系统,通常可能对一致性的要求低一些

作为服务注册中心,Eureka比Zookeeper好在哪里?

著名的CAP理论指出,一个分布式系统不可能同时满足C(一致性),A(可用性),P(容错性)

由于分区容错性P在分布式系统中是必须要保证的,因此我们只能在A和C之间进行权衡

• Zookeeper保证的是CP;
• Eureka保证的是AP;

Zookeeper保证的是CP

Eureka保证的是AP

5.ribbon负载均衡

ribbon是什么?

• Spring Cloud ribbon是基于NetFlix Ribbon实现的一套客户端负载均衡的工具
• 简单来说,Ribbon是NetFlix发布的开源项目,主要功能是提供客户端的软件均衡算法,将NetFlix的中间件服务连接在一起,Ribbon的客户端组件提供一系列完整的配置项,如连接超时,重试等等,简单的来说,就是在配置文件中列出LoadBalancer(简称LB: 负载均衡)后面所有的机器,RIbbon会自动地帮助你基于某种规则(简单轮询,随即链接等等)去连接这些机器,我们也很容易使用Ribbon实现自定义的负载均衡算法!

ribbon能干嘛?

• LB, 负载均衡,在微服务或者是分布式集群中经常用的一种应用
• 负载均衡简单的来说就是将用户的请求平摊的分配到多个服务上,从而达到系统的HA(high a[CAP中的A 高可用])
• 常见的负载均衡软件有Nginx,lVS等等
• dubbo,springcloud中军给我们提供了负载均衡SpringCloud的负载均衡算法可以自定义
• 负载均衡简单分类
  • 集中式LB
    • 即在服务的消费方和提供方之间使用独立的LB(负载均衡)设施,如Nginx,由该设施负责将访问请求通过某种策略转发至服务的提供方
  • 进程式LB
    • 将LB逻辑集成到消费方,消费方从服务注册中心获知有哪些地址可用,然后自己再从这些地址中选出一个合适的服务器
    • RIbbon就属于进程内LB,他只是一个类库,集成于消费方进程,消费方通过它来获取到服务提供方的地址

如何使用ribbon

导入依赖

   
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-ribbonartifactId>
            <version>1.4.7.RELEASEversion>
        dependency>

在restTemplate上添加@LoadBalanced //Ribbon即可(使用默认的轮播分发模式)

自定义Ribbon算法

将实现iRule的接口实现类注入

iRule算法策略

/**
     *  iRule
     *     AvailabilityFilteringRule : 会先过滤掉跳闸,无法访问的服务;对剩下的进行轮询
     *     RoundRobinRule: 轮询
     *     RandomRule: 随机
     *     RetryRule: 重试 会按照轮询获取服务~,
     *          如果服务获取失败,则会在指定的时间内进行重试
     *     WeightedResponseTimeRule: 30秒计算一次服务器响应时间，
     *          以响应时间作为权重，响应时间越短的服务器被选中的概率越大。
     *     ClientConfigEnabledRoundRobinRule内部定义了RoundRobinRule，
     *          choose方法还是采用了RoundRobinRule的choose方法，所以它的选择策略和RoundRobinRule的选择策略一致，
     *     PredicateBasedRule PredicateBasedRule是ClientConfigEnabledRoundRobinRule的一个子类，
     *          它先通过内部定义的一个过滤器过滤出一部分服务实例清单，
     *          然后再采用线性轮询的方式从过滤出来的结果中选取一个服务实例。
     *     ZoneAvoidanceRule ZoneAvoidanceRule中的过滤条件是以
     *          ZoneAvoidancePredicate为主过滤条件和以AvailabilityPredicate为
     *          次过滤条件组成的一个叫做CompositePredicate的组合过滤条件，过滤成功之后，
     *          继续采用线性轮询的方式从过滤结果中选择一个出来。
     * @return
     */

name: 指定要调用的服务

6.Feign负载均衡

6.1简介

feign是声明式的web service客户端,它让微服务之间的调用变得更简单了,类似controller调用service,springcloud集成了Ribbon和Eureka,可在使用feign时提供负载均衡的http客户端

只需要创建一个接口,然后添加注解即可

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

1. 微服务名字[ribbon]
2. 接口和注解[feign]

feign能干什么?

feign集成了Ribbon

服务降级

在API层为service接口编写一个服务访问错误类(继承FallbackFactory)

例如:

//接口类
//配置微服务的名字
@FeignClient(value = "PROVIDER", fallbackFactory = DeptClientServiceFallBackFactory.class)
public interface DeptService {

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

    @GetMapping("/dept/get/{id}")
    Dept queryById(@PathVariable("id") long deptno);

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

//服务访问错误类
public class DeptClientServiceFallBackFactory implements FallbackFactory {

    @Override
    public DeptService create(Throwable throwable) {
        return new DeptService() {
            @Override
            public boolean addDept(Dept dept) {
                return false;
            }

            @Override
            public Dept queryById(long deptno) {
                return new Dept().setDeptno(-100).setDeptname("小王").setDb_source("没有对应数据源");
            }

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

在服务消费者的启动类上添加@EnableFeignClients(“需要扫描的包(自己添加feign注解)”)

​ 服务降级的作用,当我们发现某些服务注册者使用的较少时,就可以将该服务实例先中断,在启动使用爆满的服务分摊请求压力,这时有其他请求访问该节点时,就会将api提供好的错误返回,当需要启用该节点时,服务将会正常返回请求

7.Hystrix 服务熔断

在了解Hysrtix之前先了解什么是服务雪崩

什么是Hysrix

能干嘛

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

服务熔断

是什么

如何使用

为需要对服务进行熔断的方法编写一个服务瘫痪的方法,导入依赖并添加相应注解即可

具体步骤

//导入依赖
		<dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-hystrixartifactId>
            <version>1.4.7.RELEASEversion>
        dependency>

@SpringBootApplication
@EnableEurekaClient //在服务启动后自动注册到Eureka中
@EnableDiscoveryClient //开启服务注册发现
@EnableCircuitBreaker //开启Hystrix功能
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
//为queryById服务注册编写一个hystrix_QueryById服务熔断调用方法
  	@GetMapping("/dept/get/{id}")
    @HystrixCommand(fallbackMethod = "hystrix_QueryById")
    public Dept queryById(@PathVariable("id") Long deptno) {

        Dept dept = deptService.queryById(deptno);
        int i = 1/0;
        if (dept == null) {
            throw new RuntimeException("该用户不存在!");
        }
        return dept;
    }

    public Dept hystrix_QueryById(@PathVariable("id") Long deptno) {

        return new Dept().setDeptno(-100)
                .setDeptname("用户不存在")
                .setDb_source("该用户不存在");
    }

Dashboard流监控

如何使用

创建一个新的module用于启动监控服务

导入依赖
  
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-hystrixartifactId>
            <version>1.4.7.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-hystrix-dashboardartifactId>
            <version>1.4.7.RELEASEversion>
        dependency>

启动之前的eureka集群,并在上述以配置好Hystrix的module中加入一个servlet

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

启动80端口访问Hystrix注册的服务(如果不访问服务,直接访问/hystrix.stream页面将会一直ping)

在localhost:prot/hystrix页面输入需要监控的url和参数即可监控此节点

如何查看Dashboard流监控信息

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

8.Zuul路由网关

概述

什么是Zuul

​ zuul包含了对请求的路由和过滤两个最主要的功能:

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

​ 注意: Zuul服务最终还是会注册到Eureka

​ 提供: 代理+ 路由+ 过滤三大功能!

能干嘛

• 路由
• 过滤

怎么用

重新创建一个module

导入依赖

 <dependencies>
        <!--导入Zuul-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zuul</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
        <!--导入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>
        <!--导入eureka-client-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.7.RELEASE</version>
            <classifier>sources</classifier>
            <type>java-source</type>
        </dependency>
        <!--完善eureka监控信息-->
        <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>
    </dependencies>

编写配置

server:
  port: 9527
spring:
  application:
    name: springcloud-zuul-getway
eureka:
  client:
    service-url:
      defaultZone:   http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/  #需要监听的服务注册中心
  instance:
    instance-id: zuul-9527
    prefer-ip-address: true #显示服务IP地址
zuul:
  routes:
    mydept.serviceId: provider
    mydept.path: /mydept/**
  ignored-services:
    provider # 如果设为"*" 则所有配置的映射都不能通过服务注册的实例id访问只有通过routes映射的path访问
  prefix: /czp #设置公共的访问前缀

启动服务之后就可以通过http://localhost:9527/(配置的访问前缀如: czp)/(配置的映射路径如: mydept)/(服务注册的请求路径)

9. SpringCloud config分布式配置

概述

分布式系统面临的–配置文件的问题

​ 微服务意味着要将单体应用中的业务拆分成一个个子服务,每个服务的粒度相对较小,因此系统中会出现大量的服务,由于每个服务都需要必要的配置信息才能运行,所以一套集中式的,动态的配置管理设施是必不可少的,SpringCloud提供了ConfigServer来解决这个问题,我们每一个微服务自己带着一个application,那上百配置文件要修改起来,十分麻烦

​ Spring Cloud Config 为微服务架构中微服务提供集中化的外部配置支持,配置服务器为各种不同微服务应用的所有环节提供了一个中心化的外部配置

​ Spring Cloud Config 分为服务端和客户端两部分;

​ 服务端也称为分布式配置中心,它是一个独立的微服务应用,用来连接配置服务器并为客户端提供获取配置信息,加密,解密等访问接口。

​ 客户端则是通过指定的配置中心来管理应用资源,以及与业务相关的配置内容,并在启动的时候从配置中心获取和加载配置信息,配置服务器默认采用git来存储配置信息,这样有助于对环境配置进行版本管理,并且可以通过git客户端工具来方便的管理和访问配置内容

SpringCloud config分布式配置中心能干嘛?

• 集中管理配置文件
• 不同环境,不同配置,动态化的更新配置,分环境部署,比如 /dev /test /prod /beta /release
• 运行期间动态调整配置,不在需要在每个服务部署的机器上编写配置文件,服务回想配置中心统一拉取配置自己的信息
• 当配置发生变动时,服务不需要重启,即可感知到配置的变化,并应用新的配置
• 将配置信息以REST接口的形式暴露

SpringCloud config分布式配置中心与git整合

​ 由于SpringCLoud Config默认采用Git来存储配置文件(也支持SVN和本地文件),但是最推荐使用的还是Git,而且使用的是http/https访问的形式

怎么用

1. 在码云上编写好仓库和配置文件(各个项目对应的application.yml)

2. 编写服务器读取配置文件

   导入依赖
    
           <dependency>
               <groupId>org.springframework.cloudgroupId>
               <artifactId>spring-cloud-config-serverartifactId>
               <version>2.2.2.RELEASEversion>
           dependency>
           <dependency>
               <groupId>org.springframework.bootgroupId>
               <artifactId>spring-boot-starter-webartifactId>
           dependency>
   

   #编写配置
   server:
     port: 3344
   spring:
     application:
       name: springcloud-config-name
       #连接远程仓库
     cloud:
       config:
         server:
           git:
             uri: https://gitee.com/a_lazy_farmer/springcloud-config.git
             #仓库对应的配置文件 http形式地址
          
   

   在启动类上添加@EnableConfigServer注解 //开启配置服务

   服务器编写成功

3. 客户端编写(需要进行配置的程序)

   导入依赖
      
           <dependency>
               <groupId>org.springframework.cloudgroupId>
               <artifactId>spring-cloud-starter-configartifactId>
               <version>2.2.2.RELEASEversion>
           dependency>
           <dependency>
               <groupId>org.springframework.bootgroupId>
               <artifactId>spring-boot-starter-webartifactId>
           dependency>
   

新建bootstrap.yml #预读取配置文件的配置信息
# 系统级别的配置
spring:
  cloud:
    config:
      name: config-client #从git中读取的资源名称
      uri: http://localhost:3344	#服务器地址
      profile: dev		#部署环境
      label: master		#仓库分支

配置成功

总结

以后的提升道路

教程地址

感谢秦老师的讲解,此笔记为秦疆老师的SpringCloud笔记转载以及自己的一些感悟,仅供学习使用