springcloud(奈飞)Finchley从入门到放弃【后端专题】

2022-10-18

405 1

资料下载，文章中出现的pom不对，可以直接使用资料中的pom版本

链接: https://pan.baidu.com/s/1BB_a-IsnrNBx8A7MI2MSlQ 提取码: i9kp

全部基于
<spring-cloud.version>Finchley.RELEASE</spring-cloud.version> 版本

第一章架构演进和分布式系统基础知识

第1集传统架构演进到分布式架构

简介：讲解单机应用和分布式应用架构演进基础知识

		高可用 LVS+keepalive 


	1、单体应用：
		开发速度慢
		启动时间长
		依赖庞大
		等等

2、微服务
易开发、理解和维护
独立的部署和启动
等

		不足：
			分布式系统-》分布式事务问题
			需要管理多个服务-》服务治理

第2集微服务核⼼心基础讲解

简介：讲解微服务核心知识：网关、服务发现注册、配置中心、链路追踪、负载均衡器、熔断

⽹网
关：路路由转发 + 过滤器器 /api/v1/pruduct/ 商品服务 /api/v1/order/ 订单服务 /api/v1/user/ ⽤用户服务
服务注册发现：调⽤用和被调⽤用⽅方的信息维护 3、配置中⼼心：管理理配置，动态更更新
application.properties 4、链路路追踪：分析调⽤用链路路耗时例例⼦子：下单-》查询商品服务获取商品价格-》
查询⽤用户信息-》保存数据库 5、负载均衡器器：分发负载 6、熔断：保护⾃自⼰己和被调⽤用⽅方

第3集常⻅见的微服务框架

简介:讲解常⽤用的微服务框架

consumer: 调用方
provider: 被调用方
一个接口一般都会充当两个角色（不是同时充当）

1、dubbo: zookeeper + dubbo + springmvc/springboot
官方地址：http://dubbo.apache.org/#!/?lang=zh-cn
配套
通信方式：rpc
注册中心：zookeper/redis
配置中心：diamond

2、springcloud: 全家桶+轻松嵌入第三方组件(Netflix 奈飞)
官网：http://projects.spring.io/spring-cloud/
配套
通信方式：http restful
注册中心：eruka/consul
配置中心：config
断路器：hystrix
网关：zuul
分布式追踪系统：sleuth+zipkin

学习资料：https://blog.csdn.net/zhangweiwei2020/article/details/78646252

第4集微服务下电商项⽬目基础模块设计

简介：微服务下电商项⽬目基础模块设计分离⼏几个模块，课程围绕这个基础项⽬目进⾏行行学习⼩小⽽而精的⽅方式
学习微服务

⽤用户服务
1）⽤用户信息接⼝口
2）登录接⼝口
商品服务
1）商品列列表
2）商品详情
订单服务
1）我的订单
2）下单接⼝口

第二章 SpringCloud核⼼心组件注册中⼼心

第1集什么是微服务的注册中⼼心

简介：讲解什什么是注册中⼼心，常⽤用的注册中⼼心有哪些

理理解注册中⼼心：服务管理理,核⼼心是有个服务注册表，⼼心跳机制动态维护
服务提供者provider: 启动的时候向注册中⼼心上报⾃自⼰己的⽹网络信息
服务消费者consumer: 启动的时候向注册中⼼心上报⾃自⼰己的⽹网络信息，拉取provider的相关⽹网络
信息
为什什么要⽤用：
微服务应⽤用和机器器越来越多，调⽤用⽅方需要知道接⼝口的⽹网络地址，如果靠配置⽂文件的⽅方式去控制
⽹网络地址，对于动态新增机器器，维护带来很⼤大问题
主流的注册中⼼心：
zookeeper、Eureka、consul、etcd 等

第2集分布式应⽤用知识CAP理理论知识

简介：讲解分布式核⼼心知识CAP理理论

CAP定理：
指的是在一个分布式系统中，Consistency（一致性）、 Availability（可用性）、Partition tolerance（分区容错性），三者不可同时获得。

一致性（C）：在分布式系统中的所有数据备份，在同一时刻是否同样的值。（所有节点在同一时间的数据完全一致，越多节点，数据同步越耗时）

可用性（A）：负载过大后，集群整体是否还能响应客户端的读写请求。（服务一直可用，而且是正常响应时间）

分区容错性（P）：分区容忍性，就是高可用性，一个节点崩了，并不影响其它的节点（100个节点，挂了几个，不影响服务，越多机器越好）

CAP理论就是说在分布式存储系统中，最多只能实现上面的两点。而由于当前的网络硬件肯定会出现延迟丢包等问题，所以分区容忍性是我们必须需要实现的。所以我们只能在一致性和可用性之间进行权衡

第3集分布式系统CAP原理理常⻅见⾯面试题和注册中⼼心选择

简介:讲解CAP原则在⾯面试中回答和注册中⼼心选择


		C A 满足的情况下，P不能满足的原因：
			数据同步(C)需要时间，也要正常的时间内响应(A)，那么机器数量就要少，所以P就不满足
		
		CP 满足的情况下，A不能满足的原因：
			数据同步(C)需要时间, 机器数量也多(P)，但是同步数据需要时间，所以不能再正常时间内响应，所以A就不满足

		AP 满足的情况下，C不能满足的原因：
			机器数量也多(P)，正常的时间内响应(A)，那么数据就不能及时同步到其他节点，所以C不满足

		注册中心选择：
			Zookeeper：CP设计，保证了一致性，集群搭建的时候，某个节点失效，则会进行选举行的leader，或者半数以上节点不可用，则无法提供服务，因此可用性没法满足

			Eureka：AP原则，无主从节点，一个节点挂了，自动切换其他节点可以使用，去中心化



		结论：分布式系统中P,肯定要满足，所以只能在CA中二选一
			没有最好的选择，最好的选择是根据业务场景来进行架构设计

			如果要求一致性，则选择zookeeper，如金融行业
			
			如果要去可用性，则Eureka，如电商系统

第4集 SpringCloud微服务核⼼心组件Eureka介绍和闭源后影响

简介：SpringCloud体系介绍

		SpringCloud体系介绍
			官方地址：http://projects.spring.io/spring-cloud/


		Eureka的基础知识-->交互流程，服务提供者<-->服务消费者 ;

		Eureka 2.x闭源后选择
	
	参考：https://www.jianshu.com/p/d32ae141f680
		 https://blog.csdn.net/zjcjava/article/details/78608892

第5集服务注册和发现Eureka Server搭建实战

简介：使⽤用IDEA搭建Eureka服务中⼼心Server端并启动，项⽬目基本⻣骨架介绍

官方文档：http://cloud.spring.io/spring-cloud-netflix/single/spring-cloud-netflix.html#spring-cloud-eureka-server

第一步：创建项目

第二步: 添加注解 @EnableEurekaServer


	第三步：增加配置application.yml
server:
  port: 8761
eureka:
  server:
    enable-self-preservation: false
  instance:
    hostname: localhost
  client:
    #声明自己是个服务端
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

第四步：访问注册中心页面
http://localhost:8761/eureka/
maven地址: https://www.cnblogs.com/sword-successful/p/6408281.html

第6集服务注册和发现之Eureka Client搭建商品服务实战

简介：搭建⽤用商品服务，并将服务注册到注册中⼼心

1、创建一个SpirngBoot应用，增加服务注册和发现依赖

2、模拟商品信息，存储在内存中
pom另外添加

     <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

3、开发商品列表接口，商品详情接口
controller

@RestController
@RequestMapping("/api/v1/product")
public class ProductController {


    @Autowired
    private ProductService productService;

    /**
     * 获取所有商品列表
     * @return
     */
    @RequestMapping("list")
    public Object list(){
        return productService.listProduct();
    }


    /**
     * 根据id查找商品详情
     * @param id
     * @return
     */
    @RequestMapping("find")
    public Object findById(@RequestParam("id") int id){
        return productService.findById(id);
    }



}

service


public interface ProductService {

    List<Product> listProduct();

    Product findById(int id);


}


@Service
public class ProductServiceImpl implements ProductService {

    private static final Map<Integer, Product> daoMap = new HashMap<>();

    static {

        Product p1 = new Product(1,"iphonex",9999, 10);
        Product p2 = new Product(2,"冰箱",5342, 19);
        Product p3 = new Product(3,"洗衣机",523, 90);
        Product p4 = new Product(4,"电话",64345, 150);
        Product p5 = new Product(5,"汽车",2345, 140);
        Product p6 = new Product(6,"椅子",253, 20);
        Product p7 = new Product(7,"java编程思想",2341, 10);

        daoMap.put(p1.getId(),p1);
        daoMap.put(p2.getId(),p2);
        daoMap.put(p3.getId(),p3);
        daoMap.put(p4.getId(),p4);
        daoMap.put(p5.getId(),p5);
        daoMap.put(p6.getId(),p6);
        daoMap.put(p7.getId(),p7);
    }




    @Override
    public List<Product> listProduct() {

        Collection<Product> collection = daoMap.values();
        List<Product> list = new ArrayList<>(collection);

        return list;
    }

    @Override
    public Product findById(int id) {
        return daoMap.get(id);
    }
}

domain

package com.product.domain;

import java.io.Serializable;

public class Product implements Serializable {


    public  Product(){ }

    public  Product(int id, String name, int price, int store){
        this.id = id;
        this.name = name;
        this.price = price;
        this.store = store;
    }

    private int id;

    /**
     * 商品名称
     */
    private String name;

    /**
     * 价格,分为单位
     */
    private int price;

    /**
     * 库存
     */
    private int store;

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public int getStore() {
        return store;
    }

    public void setStore(int store) {
        this.store = store;
    }
}

4、配置文件加入注册中心地址

server:
  port: 8771


#指定注册中心地址
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

#服务的名称
spring:
  application:
    name: product-service

使用eureka客户端官方文档：http://cloud.spring.io/spring-cloud-netflix/single/spring-cloud-netflix.html#netflix-eureka-client-starter

第7集 Eureka服务注册中⼼心配置控制台问题处理理

简介：讲解服务注册中⼼心管理理后台


	问题：eureka管理后台出现一串红色字体：是警告，说明有服务上线率低

	EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY'RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE.

	关闭检查方法：eureka服务端配置文件加入
	server:
    	enable-self-preservation: false
    注意：自我保护模式禁止关闭，默认是开启状态true

		
	问题二：为什么只加一个注册中心地址，就可以注册
	By having spring-cloud-starter-netflix-eureka-client on the classpath, your application automatically registers with the Eureka Server. Configuration is required to locate the Eureka server, as shown in the following example:

第三章服务消费者ribbon和feign实战和注册中⼼心⾼高可⽤用

第1集常⽤用的服务间调⽤用⽅方式讲解

简介：讲解常⽤用的服务间的调⽤用⽅方式


		RPC:
			远程过程调用，像调用本地服务(方法)一样调用服务器的服务
			支持同步、异步调用
			客户端和服务器之间建立TCP连接，可以一次建立一个，也可以多个调用复用一次链接

			PRC数据包小
				protobuf
				thrift
			rpc：编解码，序列化，链接，丢包，协议


		Rest(Http):
			http请求，支持多种协议和功能
			开发方便成本低

			http数据包大

			java开发：HttpClient，URLConnection

第2集微服务调⽤用⽅方式之ribbon实战订单调⽤用商品服务

简介：实战电商项⽬目订单服务调⽤用商品服务获取商品信息
1、创建order_service项目（方法同上）
需要多加openfeign依赖

2、开发伪下单接口
控制层

@RestController
@RequestMapping("api/v1/order")
public class OrderController {


    @Autowired
    private ProductOrderService productOrderService;


    @RequestMapping("save")
    public Object save(@RequestParam("user_id")int userId, @RequestParam("product_id") int productId){

        return productOrderService.save(userId, productId);
    }




}

service

/**
 * 订单业务类
 */
public interface ProductOrderService {


    /**
     * 下单接口
     * @param userId
     * @param productId
     * @return
     */
     ProductOrder save(int userId, int productId);


}
@Service
public class ProductOrderServiceImpl implements ProductOrderService {


    @Autowired
    private RestTemplate restTemplate;

    @Override
    public ProductOrder save(int userId, int productId) {

        Object obj = restTemplate.getForObject("http://product-service/api/v1/product/find?id="+productId, Object.class);

        System.out.println(obj);

        ProductOrder productOrder = new ProductOrder();
        productOrder.setCreateTime(new Date());
        productOrder.setUserId(userId);
        productOrder.setTradeNo(UUID.randomUUID().toString());

        return productOrder;
    }
}

domain

/**
 * 商品订单实体类
 */
public class ProductOrder implements Serializable {


    private int id;

    /**
     * 商品名称
     */
    private String productName;

    /**
     * 订单号
     */
    private  String tradeNo;

    /**
     * 价格,分
     */
    private int price;


    private Date createTime;


    private int userId;

    private String userName;


    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getId() {
        return id;
    }

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

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    public String getTradeNo() {
        return tradeNo;
    }

    public void setTradeNo(String tradeNo) {
        this.tradeNo = tradeNo;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
}

启动类

@SpringBootApplication
@EnableEurekaClient
public class OrderServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

}

3、使用ribbon. (类似httpClient,URLConnection)

4、根据名称进行调用商品，获取商品详情
http://localhost:8781/api/v1/order/save?user_id=1&product_id=1

第3集⾼高级篇幅之Ribbon负载均衡源码分析实战

简介: 讲解ribbon服务间调⽤用负载均衡源码分析

		1、完善下单接口
		2、分析@LoadBalanced
			1）首先从注册中心获取provider的列表
			2）通过一定的策略选择其中一个节点
			3）再返回给restTemplate调用

第4集⾼高级篇幅之服务间调⽤用之负载均衡策略略调整实战

简介：实战调整默认负载均衡策略略实战


	自定义负载均衡策略：http://cloud.spring.io/spring-cloud-static/Finchley.RELEASE/single/spring-cloud.html#_customizing_the_ribbon_client_by_setting_properties

	在配置文件yml里面，自定义负载均衡策略
		#自定义负载均衡策略
		product-service:
		  ribbon:
		    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

	策略选择：
		1、如果每个机器配置一样，则建议不修改策略 (推荐)
		2、如果部分机器配置强，则可以改为 WeightedResponseTimeRule

第5集微服务调⽤用⽅方式之feign 实战订单调⽤用商品服务

简介：改造电商项⽬目订单服务调⽤用商品服务获取商品信息

Feign：伪RPC客户端(本质还是用http)
官方文档: https://cloud.spring.io/spring-cloud-openfeign/

使用feign步骤讲解（新旧版本依赖名称不一样）
加入依赖

org.springframework.cloud
spring-cloud-starter-openfeign

启动类增加@EnableFeignClients
增加一个接口并@FeignClient(name=“product-service”)
编码实战

@FeignClient(name="product-service")
public interface ProductFeign {
    @RequestMapping("/api/v1/productfind")
    String findById(@RequestParam("id") int id);
}

注意点：
1、路径
2、Http方法必须对应
3、使用requestBody，应该使用@PostMapping
4、多个参数的时候，通过@RequestParam（“id”) int id)方式调用

第6集 Feign核⼼心源码解读和服务调⽤用⽅方式ribbon和Feign选择

简介: 讲解Feign核⼼心源码解读和服务间的调⽤用⽅方式ribbon、feign选择

		1、ribbon和feign两个的区别和选择
			选择feign
				默认集成了ribbon
				写起来更加思路清晰和方便
				采用注解方式进行配置，配置熔断等方式方便

		2、超时配置
			默认optons readtimeout是60，但是由于hystrix默认是1秒超时

			#修改调用超时时间
			feign:
			  client:
			    config:
			      default:
			        connectTimeout: 2000
			        readTimeout: 2000

			模拟接口响应慢，线程睡眠新的方式
			  try {
		            TimeUnit.SECONDS.sleep(1);
		        } catch (InterruptedException e) {
		            e.printStackTrace();
		        }

第四章互联⽹网架构服务降级熔断 Hystrix 实战

order本章全部的配置

server:
  port: 8781


#指定注册中心地址
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

#服务的名称
spring:
  application:
    name: order-service
  redis:
    database: 0
    host: 127.0.0.1
    port: 6379
    timeout: 2000

#自定义负载均衡策略
product-service:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule


#修改调用超时时间
feign:
  hystrix:
    enabled: true
  client:
    config:
      default:
        connectTimeout: 2000
        readTimeout: 1000

#把hystrix超时时间禁用
#hystrix:
#  command:
#    default:
#      execution:
#        timeout:
#          enabled: false

#execution.isolation.thread.timeoutInMilliseconds=4000

#设置超时时间
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 1000

#暴露全部的监控信息
management:
  endpoints:
    web:
      exposure:
        include: "*"

第1集分布式核⼼心知识之熔断、降级讲解

简介：系统负载过高，突发流量或者网络等各种异常情况介绍，常用的解决方案

	1、熔断：
		保险丝，熔断服务，为了防止整个系统故障，包含子和下游服务

		下单服务 -》商品服务
				-》用户服务 （出现异常-》熔断）

	2、降级：
		抛弃一些非核心的接口和数据

		旅行箱的例子：只带核心的物品，抛弃非核心的，等有条件的时候再去携带这些物品

		
	3、熔断和降级互相交集
		相同点：
			1）从可用性和可靠性触发，为了防止系统崩溃
			2）最终让用户体验到的是某些功能暂时不能用

		不同点
			1）服务熔断一般是下游服务故障导致的，而服务降级一般是从整体系统负荷考虑，由调用方控制

第2集 Netflix开源组件断路路器器Hystrix介绍

简介：介绍Hystrix基础知识和使用场景

	文档地址：
		https://github.com/Netflix/Hystrix
		https://github.com/Netflix/Hystrix/wiki

	1、什么是Hystrix？
		1）hystrix对应的中文名字是“豪猪”
		
		2）hystrix	英[hɪst'rɪks] 美[hɪst'rɪks]

	
	2、为什么要用？
		在一个分布式系统里，一个服务依赖多个服务，可能存在某个服务调用失败，
		比如超时、异常等，如何能够保证在一个依赖出问题的情况下，不会导致整体服务失败，
		通过Hystrix就可以解决

		http://cloud.spring.io/spring-cloud-netflix/single/spring-cloud-netflix.html#_circuit_breaker_hystrix_clients

	3、提供了熔断、隔离、Fallback、cache、监控等功能


	4、熔断后怎么处理？
		出现错误之后可以 fallback 错误的处理信息

		兜底数据

第3集 Feign结合Hystrix断路路器器开发实战《上》

简介：讲解SpringCloud整合断路器的使用，用户服务异常情况


	1、加入依赖
	
	注意：网上新旧版本问题，所以要以官网为主，不然部分注解会丢失
	最新版本 2.0

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
       
        </dependency>


	2、增加注解
		启动类里面增加注解
		@EnableCircuitBreaker

		注解越来越多-》 SpringCloudApplication注解

	3、API接口编码实战
	  熔断-》降级

		1）最外层api使用，好比异常处理（网络异常，参数或者内部调用问题）
			api方法上增加 @HystrixCommand(fallbackMethod = "saveOrderFail")
			
			编写fallback方法实现，方法签名一定要和api方法签名一致（注意点！！！）



		

	补充： 修改maven仓库地址
	pom.xml中修改

	<repositories>
        <repository>
            <id>nexus-aliyun</id>
            <name>Nexus aliyun</name>
            <layout>default</layout>
            <url>http://maven.aliyun.com/nexus/content/groups/public</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>

第4集 Feign结合Hystrix断路路器器开发实战《下》

简介：讲解SpringCloud整合断路器的使用，用户服务异常情况

	1、feign结合Hystrix
		
		1）开启feign支持hystrix  (注意，一定要开启，旧版本默认支持，新版本默认关闭)
			feign:
			  hystrix:
			    enabled: true

		2）FeignClient(name="xxx", fallback=xxx.class ), class需要继承当前FeignClient的类
		@Component
public class FallBack implements ProductFeign {
    @Override
    public String findById(int id) {
        return null;
    }
}

第5集熔断降级服务异常报警通知实战(包有问题)

简介：完善服务熔断处理，报警机制完善

	1、加入redis依赖
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    2、配置redis链接信息
      redis:
	    database: 0
	    host: 127.0.0.1
	    port: 6379
	    timeout: 2000

	3、使用

        //监控报警
        String saveOrderKye = "save-order";
        String sendValue = redisTemplate.opsForValue().get(saveOrderKye);
        final String ip = request.getRemoteAddr();
        new Thread( ()->{
            if (StringUtils.isBlank(sendValue)) {
                System.out.println("紧急短信，用户下单失败，请离开查找原因,ip地址是="+ip);
                //发送一个http请求，调用短信服务 TODO
                redisTemplate.opsForValue().set(saveOrderKye, "save-order-fail", 20, TimeUnit.SECONDS);
            }else{
                System.out.println("已经发送过短信，20秒内不重复发送");
            }
        }).start();

第6集⾼高级篇幅之深⼊入源码剖析Hystrix降级策略略和调整(包有问题)

简介：源码分析Hystrix降级策略和调整

	1、查看默认讲解策略 HystrixCommandProperties
		1）execution.isolation.strategy   隔离策略
			THREAD 线程池隔离 （默认）
			SEMAPHORE 信号量
				信号量适用于接口并发量高的情况，如每秒数千次调用的情况，导致的线程开销过高，通常只适用于非网络调用，执行速度快

		2）execution.isolation.thread.timeoutInMilliseconds  超时时间
			默认 1000毫秒

		3）execution.timeout.enabled 是否开启超时限制 （一定不要禁用）


		4）execution.isolation.semaphore.maxConcurrentRequests 隔离策略为 信号量的时候，如果达到最大并发数时，后续请求会被拒绝，默认是10


	官方文档:
		https://github.com/Netflix/Hystrix/wiki/Configuration#execution.isolation.strategy

	2、调整策略
		超时时间调整

	hystrix:
	  command:
	    default:
	      execution:
	        isolation:
	          thread:
	            timeoutInMilliseconds: 4000

第7集断路路器器Dashboard监控仪表盘实战(包有问题)

简介：讲解断路器Dashboard基础使用和查看

1、加入依赖
		 <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

    2、启动类增加注解
    	@EnableHystrixDashboard

    	
    3、配置文件增加endpoint
management:
  endpoints:
    web:
      exposure:
        include: "*"


    4、访问入口
    	http://localhost:8781/hystrix

    	Hystrix Dashboard输入： http://localhost:8781/actuator/hystrix.stream 

    
    参考资料
    	默认开启监控配置
    	https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#boot-features-security-actuator

        配置文件类：
    		spring-configuration-metadata.json

第8集断路路器器监控仪表参数讲解和模拟熔断

简介：讲解断路器监控仪表盘参数和模拟熔断

	1、sse  server-send-event推送到前端

	资料：https://github.com/Netflix/Hystrix/wiki/Dashboard

第五章微服务⽹网关zuul开发实战

第1集微服务⽹网关介绍和使⽤用场景

简介：讲解网关的作用和使用场景

	1）什么是网关
		API Gateway，是系统的唯一对外的入口，介于客户端和服务器端之间的中间层，处理非业务功能 提供路由请求、鉴权、监控、缓存、限流等功能

			统一接入
				智能路由
				AB测试、灰度测试
				负载均衡、容灾处理
				日志埋点（类似Nignx日志）

			流量监控
				限流处理
				服务降级

			安全防护
				鉴权处理
				监控
				机器网络隔离


	2）主流的网关
		zuul：是Netflix开源的微服务网关，和Eureka,Ribbon,Hystrix等组件配合使用，Zuul 2.0比1.0的性能提高很多
		
		kong: 由Mashape公司开源的，基于Nginx的API gateway
		
		nginx+lua：是一个高性能的HTTP和反向代理服务器,lua是脚本语言，让Nginx执行Lua脚本，并且高并发、非阻塞的处理各种请求

第2集 SpringCloud的⽹网关组件zuul基本使⽤用

简介：讲解zuul网关基本使用

1、加入依赖

  <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>

        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.SR1</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

	2、启动类加入注解 @EnableZuulProxy
		默认集成断路器  @EnableCircuitBreaker

		默认访问规则  
			http://gateway:port/service-id/**

				例子：默认 /order-service/api/v1/order/save?user_id=2&product_id=1
					 自定义 /xdclass_order/api/v1/order/save?user_id=2&product_id=1

		自定义路由转发：
			zuul:
			 routes:
			 	order-service: /apigateway/**


		环境隔离配置：
			需求 ：不想让默认的服务对外暴露接口
				/order-service/api/v1/order/save

			配置：
			zuul: 
				ignored-patterns:
					- /*-service/api/v1/order/save

第3集⾼高级篇幅之Zuul常⽤用问题分析和⽹网关过滤器器原理理分析

简介：讲解Zuul网关原理和过滤器生命周期，

@Component
public class LoginFilter  extends ZuulFilter {

    /**
     * 过滤器类型，前置过滤器
     * @return
     */
    @Override
    public String filterType() {
        return PRE_TYPE;
    }

    /**
     * 过滤器顺序，越小越先执行
     * @return
     */
    @Override
    public int filterOrder() {

        return 4;
    }


    /**
     * 过滤器是否生效
     * @return
     */
    @Override
    public boolean shouldFilter() {

        RequestContext requestContext = RequestContext.getCurrentContext();
        HttpServletRequest  request = requestContext.getRequest();

       //System.out.println(request.getRequestURI()); ///apigateway/product/api/v1/product/list
        //System.out.println(request.getRequestURL()); //http://localhost:9000/apigateway/product/api/v1/product/list

        //ACL

        if ("/apigateway/order/api/v1/order/save".equalsIgnoreCase(request.getRequestURI())){
            return true;
        }else if ("/apigateway/order/api/v1/order/list".equalsIgnoreCase(request.getRequestURI())){
            return true;
        }else if ("/apigateway/order/api/v1/order/find".equalsIgnoreCase(request.getRequestURI())){
            return true;
        }

        return false;
    }

    /**
     * 业务逻辑
     * @return
     * @throws ZuulException
     */
    @Override
    public Object run() throws ZuulException {

        //JWT
        RequestContext requestContext =  RequestContext.getCurrentContext();
        HttpServletRequest  request = requestContext.getRequest();

        //token对象
        String token = request.getHeader("token");

        if(StringUtils.isBlank((token))){
            token  = request.getParameter("token");
        }


        //登录校验逻辑  根据公司情况自定义 JWT
        if (StringUtils.isBlank(token)) {
                requestContext.setSendZuulResponse(false);
                requestContext.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value());
        }

        return null;
    }



}

1、路由名称定义问题
路由映射重复覆盖问题

2、Http请求头过滤问题

3、过滤器执行顺序问题，过滤器的order值越小，越先执行

4、共享RequestContext，上下文对象

第4集⾃自定义Zuul过滤器器实现登录鉴权实战

简介：自定义Zuul过滤器实现登录鉴权实战


	1、新建一个filter包

	2、新建一个类，实现ZuulFilter，重写里面的方法

	3、在类顶部加注解，@Component,让Spring扫描

第5集⾼高级篇幅之⾼高并发情况下接⼝口限流特技

简介：谷歌guava框架介绍，网关限流使用

1、nginx层限流

2、网关层限流

第6集 Zuul微服务⽹网关集群搭建

** 简介：微服务网关Zull集群搭建**

1、nginx+lvs+keepalive 
https://www.cnblogs.com/liuyisai/p/5990645.html

第六章分布式链路路追踪系统Sleuth和ZipKin实战

第1集微服务下的链路路追踪讲解和重要性

简介：讲解什么是分布式链路追踪系统，及使用好处

第2集 SpringCloud的链路路追踪组件Sleuth实战

简介：讲解分布式链路追踪组件Sleuth实战

		1、官方文档
		http://cloud.spring.io/spring-cloud-static/Finchley.SR1/single/spring-cloud.html#sleuth-adding-project

		2、什么是Sleuth
			一个组件，专门用于记录链路数据的开源组件

			[order-service,96f95a0dd81fe3ab,852ef4cfcdecabf3,false]

			1、第一个值，spring.application.name的值
			
			2、第二个值，96f95a0dd81fe3ab ，sleuth生成的一个ID，叫Trace ID，用来标识一条请求链路，一条请求链路中包含一个Trace ID，多个Span ID
			
			3、第三个值，852ef4cfcdecabf3、spanid 基本的工作单元，获取元数据，如发送一个http

			4、第四个值：false，是否要将该信息输出到zipkin服务中来收集和展示。

		3、添加依赖
			<dependency>
	         <groupId>org.springframework.cloud</groupId>
	         <artifactId>spring-cloud-starter-sleuth</artifactId>
	     	</dependency>

第3集 SpringCloud的链路路追踪组件Sleuth常⻅见问题说明

简介：讲解分布式链路追踪组件Sleuth常见问题说明

第4集可视化链路路追踪系统Zipkin部署

简介：讲解Zipkin的介绍和部署
资料有这个jar

curl -sSL https://zipkin.io/quickstart.sh | bash -s
java -jar zipkin.jar
~!!!!!!!!!!!!~
docker run -d -p 9411:9411 openzipkin/zipkin

	1、什么是zipkin
			官网：https://zipkin.io/
			大规模分布式系统的APM工具（Application Performance Management）,基于Google Dapper的基础实现，和sleuth结合可以提供可视化web界面分析调用链路耗时情况			
			
		2、同类产品
			鹰眼（EagleEye）
			CAT
			twitter开源zipkin，结合sleuth
			Pinpoint，运用JavaAgent字节码增强技术
			StackDriver Trace (Google) 

		3、开始使用
			https://github.com/openzipkin/zipkin
			https://zipkin.io/pages/quickstart.html

			zipkin组成：Collector、Storage、Restful API、Web UI组成

		4、知识拓展：OpenTracing
		OpenTracing 已进入 CNCF，正在为全球的分布式追踪，提供统一的概念和数据标准。 
		通过提供平台无关、厂商无关的 API，使得开发人员能够方便的添加（或更换）追踪系统的实现。


		推荐阅读：
			http://blog.daocloud.io/cncf-3/
			https://www.zhihu.com/question/27994350
			https://yq.aliyun.com/articles/514488?utm_content=m_43347

第5集⾼高级篇幅之链路路追踪组件Zipkin+Sleuth实战

简介：使用Zipkin+Sleuth业务分析调用链路分析实战

1、文档
http://cloud.spring.io/spring-cloud-static/Finchley.SR1/single/spring-cloud.html#_sleuth_with_zipkin_via_http

sleuth收集跟踪信息通过http请求发送给zipkin server，zipkinserver进行跟踪信息的存储以及提供Rest API即可，Zipkin UI调用其API接口进行数据展示

默认存储是内存，可也用mysql、或者elasticsearch等存储

2、加入依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>
里面包含 spring-cloud-starter-sleuth、spring-cloud-sleuth-zipkin

3、文档说明：http://cloud.spring.io/spring-cloud-static/Finchley.SR1/single/spring-cloud.html#_features_2

4、配置zipkin.base-url

spring:
#zipkin服务所在地址
  zipkin:
    base-url: http://localhost:9411/
#配置采样百分比,开发环境可以设置为1，表示全部，生产就用默认
  sleuth:
    sampler:
      probability: 1

5、配置采样百分闭spring.sleuth.sampler

第七章微服务核⼼心知识分布式配置中⼼心Config实战

第1集微服务下的分布式配置中⼼心

简介：讲解什么是配置中心及使用前后的好处

		什么是配置中心：
			一句话：统一管理配置, 快速切换各个环境的配置
		
		相关产品：
			百度的disconf 
				地址:https://github.com/knightliao/disconf
			
			阿里的diamand
				地址：https://github.com/takeseem/diamond

			springcloud的configs-server:
				地址：http://cloud.spring.io/spring-cloud-config/


		推荐干货文章：http://jm.taobao.org/2016/09/28/an-article-about-config-center/

第2集 SpringCloud的配置中⼼心组件config-server实战

简介：讲解SpringCloud配置中心config-server实战

1、新建项目，创建config-server

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.SR1</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

yml

#服务名称
spring:
  application:
    name: config-server
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/dsad/config_cloud
          username: dsad@qq.com
          password: dsad
          timeout: 5
          default-label: master



#服务的端口号
server:
  port: 9100


#指定注册中心地址
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

2、启动类增加注解
@EnableConfigServer

第3集使⽤用git服务器器结合Config搭建分布式配置中⼼心

简介：讲解使用git服务器结合Config搭建分布式配置中心

1、默认使用git存储配置中心
使用git服务器，可以自己搭建gitlab服务器
或者使用github、开源中国git、阿里云git

652133917qq.com
********

https://gitee.com/$$$$/config_cloud.git

2、配置文件添加配置

#服务名称
spring:
  application:
    name: config-server
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/dsad/config_cloud
          username: dsad@qq.com
          password: dsad
          timeout: 5
          default-label: master



#服务的端口号
server:
  port: 9100


#指定注册中心地址
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

3、访问方式（一定要注意语法，如果有问题，会出错）
多种访问路径，可以通过启动日志去查看
例子 http://localhost:9100/product-service.yml

		/{name}-{profiles}.properties
		/{name}-{profiles}.yml
		/{name}-{profiles}.json
		/{label}/{name}-{profiles}.yml

		name 服务器名称
		profile 环境名称，开发、测试、生产
		lable 仓库分支、默认master分支

第4集分布式配置中⼼心客户端使⽤用实战

简介：微服务里面客户端接入配置中心实战

     <!--配置中心客户端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-client</artifactId>
        </dependency>

bootstrap.yml



#指定注册中心地址
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

#服务的名称
spring:
  application:
    name: product-service
  #指定从哪个配置中心读取
  cloud:
    config:
      discovery:
        service-id: CONFIG-SERVER
        enabled: true
      profile: test
      # test=product-service-test.yml
      #建议用lable去区分环境，默认是lable是master分支
      #label: test

第八章微服务消息总线Bus结合消息队列列RabbitMQ实战

第1集消息总线Bus介绍和使⽤用场景

简介：讲解消息总线Bus介绍和使用场景
1、什么是消息
一个事件，需要广播或者单独传递给某个接口

	2、为什么使用这个
		配置更新了，但是其他系统不知道是否更新

第2集消息队列列和RabbitMQ基础介绍

简介：消息队列和RabbitMQ基础介绍

1、消息队列介绍
				参考：https://www.cnblogs.com/linjiqin/p/5720865.html

			2、同类产品
				ActiveMQ
				RocketMQ
				Kafka
				等

			3、SpringCloud默认推荐使用RabbitMQ


			4、RabbitMQ介绍	
				官方文档：http://www.rabbitmq.com/getstarted.html
				中文文档：http://rabbitmq.mr-ping.com/

第3集实战系列列使⽤用Docker搭建RabbitMQ3.7

简介：使用Docker安装RabbitMQ

1、如果对Docker没基础，课程后续有讲解Docker，可以先跳转过去学习Docker
		2、安装步骤
			1)拉取镜像：docker pull rabbitmq:management
			2)查看当前镜像列表：docker images
			3)删除指定镜像：docker rmi  IMAGE_ID  (如果需要强制删除加 -f)
			
			4)创建容器
			docker run -d --name="myrabbitmq" -p 5671:5671 -p 15672:15672 rabbitmq:management

			参数讲解: 
				run: 创建一个新的容器并运行一个命令
			 	-d: 后台运行容器，并返回容器ID
			 	-p: 端口映射，格式为：主机(宿主)端口:容器端口
			 	--name="rabbitmq": 为容器指定一个名称
	3、RabbitMQ默认创建了一个 guest 用户，密码也是 guest, 如果访问不了记得查看防火墙，端口或者云服务器的安全组
		  管理后台：http://127.0.0.1:15672

第4集⾼高级篇幅消息总线整合配置中⼼心架构流程图

简介：讲解消息总线Bus结合config组件搭建配置中心项目架构图和操作流程


			启动
			rabbitmq： docker run -d -p 5672:5672 -p 15672:15672 rabbitmq:management
			rabbitmq默认是5672,所以改为5672端口
			
			1、config-client加入依赖
						   
		        <!--配置中心结合消息队列-->
		       
		        <dependency>
		            <groupId>org.springframework.boot</groupId>
		            <artifactId>spring-boot-starter-actuator</artifactId>
		        </dependency>

		        <dependency>
		            <groupId>org.springframework.cloud</groupId>
		            <artifactId>spring-cloud-starter-bus-amqp</artifactId>
		        </dependency>


			
			官方文档：http://cloud.spring.io/spring-cloud-bus/single/spring-cloud-bus.html#_bus_refresh_endpoint
			文档里面 暴露端点 management.endpoints.web.exposure.include=bus-refresh

			2、在配置文件中增加关于RabbitMQ的连接(如果是本机，则可以直接启动，采用默认连接配置)
				spring:
				  rabbitmq:
				    host: localhost
				    port: 5672
				    username: guest
				    password: guest
			
				#暴露全部的监控信息
				management:
				  endpoints:
				    web:
				      exposure:
				        include: "*"

			3、需要刷新配置的地方，增加注解 (使用@value(读取))
				@RefreshScope

			4、访问验证 post方式：
				http://localhost:8773/actuator/bus-refresh
			

			5、动态刷新配置: 在开发和测试环境使用，尽量少在生产环境使用

第5集微服务相关项⽬目改造配置中⼼心

简介：把课程项目改造成配置中心讲解

1、git里面新增对应项目的配置文件，都要添加下面的配置
		#服务的名称
		spring:
		  rabbitmq:
		    host: localhost
		    port: 5672
		    username: guest
		    password: guest

		#暴露全部的监控信息
		management:
		  endpoints:
		    web:
		      exposure:
		        include: "*"


	
	2、项目里面添加maven依赖

        <!--配置中心客户端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-client</artifactId>
        </dependency>

        <!--config server-->

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-bus-amqp</artifactId>
        </dependency>


    3、修改application.properties为bootstrap.yml 并拷贝配置文件
    			
			#指定注册中心地址
			eureka:
			  client:
			    serviceUrl:
			      defaultZone: http://localhost:8761/eureka/

			#服务的名称
			spring:
			  application:
			    name: order-service
			  #指定从哪个配置中心读取
			  cloud:
			    config:
			      discovery:
			        service-id: CONFIG-SERVER
			        enabled: true
			      profile: test

	4、各个项目启动顺序
		1）注册中心
		2）配置中心
		3）对应的服务：商品服务、订单服务。。。
		4）启动网关

第九章 SpringCloud课程内容上半部分总结

第1集微服务核⼼心知识内容回顾

简介：回顾SpringCloud前面10章的基础内容

  1)介绍微服务的基础知识，核心组件，CAP原理

	2）SpringCloud注册中心 Eureka

	3）product-service / order-service

	4) 伪RPC Ribbon / feign 

	5) hystrix熔断

	6) 服务网关介绍，zuul

	7）配置中心config-server

springcloud(奈飞)Finchley从入门到放弃【后端专题】

第一章 架构演进和分布式系统基础知识

第1集 传统架构演进到分布式架构

第2集 微服务核⼼心基础讲解

第3集 常⻅见的微服务框架

第4集 微服务下电商项⽬目基础模块设计

第二章 SpringCloud核⼼心组件注册中⼼心

第1集 什么是微服务的注册中⼼心

第2集 分布式应⽤用知识CAP理理论知识

第3集 分布式系统CAP原理理常⻅见⾯面试题和注册中⼼心选择

第4集 SpringCloud微服务核⼼心组件Eureka介绍和闭源后影响

第5集 服务注册和发现Eureka Server搭建实战

第6集 服务注册和发现之Eureka Client搭建商品服务实战

第7集 Eureka服务注册中⼼心配置控制台问题处理理

第三章 服务消费者ribbon和feign实战和注册中⼼心⾼高可⽤用

第1集 常⽤用的服务间调⽤用⽅方式讲解

第2集 微服务调⽤用⽅方式之ribbon实战 订单调⽤用商品服务

第3集 ⾼高级篇幅之Ribbon负载均衡源码分析实战

第4集 ⾼高级篇幅之服务间调⽤用之负载均衡策略略调整实战

第5集 微服务调⽤用⽅方式之feign 实战 订单调⽤用商品服务

第6集 Feign核⼼心源码解读和服务调⽤用⽅方式ribbon和Feign选择

第四章 互联⽹网架构服务降级熔断 Hystrix 实战

第1集 分布式核⼼心知识之熔断、降级讲解

第2集 Netflix开源组件断路路器器Hystrix介绍

第3集 Feign结合Hystrix断路路器器开发实战《上》

第4集 Feign结合Hystrix断路路器器开发实战《下》

第5集 熔断降级服务异常报警通知实战(包有问题)

第6集 ⾼高级篇幅之深⼊入源码剖析Hystrix降级策略略和调整(包有问题)

第7集 断路路器器Dashboard监控仪表盘实战(包有问题)

第8集 断路路器器监控仪表参数讲解和模拟熔断

第五章 微服务⽹网关zuul开发实战

第1集 微服务⽹网关介绍和使⽤用场景

第2集 SpringCloud的⽹网关组件zuul基本使⽤用

第3集 ⾼高级篇幅之Zuul常⽤用问题分析和⽹网关过滤器器原理理分析

第4集 ⾃自定义Zuul过滤器器实现登录鉴权实战

第5集 ⾼高级篇幅之⾼高并发情况下接⼝口限流特技

第6集 Zuul微服务⽹网关集群搭建

第六章 分布式链路路追踪系统Sleuth和ZipKin实战

第1集 微服务下的链路路追踪讲解和重要性

第2集 SpringCloud的链路路追踪组件Sleuth实战

第3集 SpringCloud的链路路追踪组件Sleuth常⻅见问题说明

第4集 可视化链路路追踪系统Zipkin部署

第5集 ⾼高级篇幅之链路路追踪组件Zipkin+Sleuth实战

第七章 微服务核⼼心知识分布式配置中⼼心Config实战

第1集 微服务下的分布式配置中⼼心