AlibabaCloud

2020-12-18

Java

0 0

单机应用到分布式架构演进

单机架构

优点：易于测试便于集成小型项目友好
缺点：开发速度慢启动时间长依赖庞大

分布式架构

SOA ：Service Oriented Architecture 面向服务的架构其中包含多个服务，服务之间通过相互依赖最终提供一系列的功能, 一个服务通常以独立的形式存在与操作系统进程中, 各个服务之间通过网络调用。
微服务：将一个大的单体应用进行细粒度的服务化拆分，每个拆分出来的服务各自独立打包部署，各个服务之间通过网络调用。
优点
- 易开发、理解和维护
- 独立的部署和启动
缺点
- 分布式系统-》分布式事务问题
- 需要管理多个服务-》服务治理

微服务架构常见的核心组件

网关
- 路由转发 + 过滤器
  - /api/v1/video/ 视频服务
  - /api/v1/order/ 订单服务
  - /api/v1/user/ 用户服务
服务发现注册（注册中心）
- 调用和被调用方的信息维护
配置中心
- 管理配置，动态更新 application.properties
链路追踪
- 分析调用链路耗时例子：下单-》查询商品服务获取商品价格-》查询用户信息-》保存数据库
负载均衡器
- 分发流量到多个节点，降低压力
熔断
- 保护自己和被调用方

业界微服务架构常见解决方案

ServiceComb
- 华为内部的CSE(Cloud Service Engine)框架开源, 一个微服务的开源解决方案,社区相对于下面几个比较小
- 文档不多，通信领域比较强
dubbo
- zookeeper + dubbo + springmvc/springboot
- 官方地址：http://dubbo.apache.org/#!/?lang=zh-cn
- 配套
  - 通信方式：rpc
  - 注册中心：zookeper/redis/nacos
  - 配置中心：diamond、nacos
SpringCloud
- 全家桶+轻松嵌入第三方组件(Netflix 奈飞)
- 官网：https://spring.io/projects/spring-cloud
- 配套
  - 通信方式：http restful
  - 注册中心：eruka
  - 配置中心：config
  - 断路器：hystrix
  - 网关：zuul/gateway
  - 分布式追踪系统：sleuth+zipkin
Spring Alibaba Cloud
- 全家桶+阿里生态多个组件组合+SpringCloud支持
- 官网https://spring.io/projects/spring-cloud-alibaba
- 配套
  - 通信方式：http restful
  - 注册中心：nacos
  - 配置中心：nacos
  - 断路器：sentinel
  - 网关：gateway
  - 分布式追踪系统：sleuth+zipkin

AlibabaCloud核心组件介绍

官网介绍
- https://spring.io/projects/spring-cloud-alibaba#overview
为什么要选择AlibabaCloud , 和SpringCloud的区别
SpringCloud和AlibabaCloud组件存在很大交集，互相配合
- SpringCloud很多组件是基于第三方整合，目前多个已经不更新了，比如zuul、eureka、hystrix等
- AlibabaCloud 提供一站式微服务解决方法，已经和SpringCloud进行了整合，组件互相支持
AlibabaCloud全家桶介绍
- https://github.com/alibaba/spring-cloud-alibaba
- 服务注册发现：Nacos
- 服务限流降级：Sentinel
- 分布配置中心：Nacos
- 服务网关：SpringCloud Gateway
- 服务之间调用：Feign、Ribbon
- 链路追踪：Sleuth+Zipkin
版本说明
- 【注意文档：】官方经常改地址，如果本课程的地址失效后重新搜索下找入口
- Spring5以上
- SpringBoot2.x以上
- AlibabaCloud 版本 2.2.xhttps://spring.io/projects/spring-cloud-alibaba#learn
- SpirngCloud版本 Hoxtonhttps://spring.io/projects/spring-cloud

在线教育环微服务模块划分和环境准备

在线教育模块划分

视频服务
订单服务
用户服务

微服务数据库介绍和数据导入

视频服务 cloud_video库 video表

CREATE TABLE `video` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `title` varchar(524) DEFAULT NULL COMMENT '视频标题',
  `summary` varchar(1026) DEFAULT NULL COMMENT '概述',
  `cover_img` varchar(524) DEFAULT NULL COMMENT '封面图',
  `price` int(11) DEFAULT NULL COMMENT '价格,分',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `point` double(11,2) DEFAULT '8.70' COMMENT '默认8.7，最高10分',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=48 DEFAULT CHARSET=utf8;

INSERT INTO `video` (`id`, `title`, `summary`, `cover_img`, `price`, `create_time`, `point`)
VALUES
  (30, '互联网架构之JAVA虚拟机JVM零基础到高级实战', 'https://xdvideo-file.oss-cn-shenzhen.aliyuncs.com/video/2020/maven/%E8%AF%A6%E6%83%85%E5%9B%BE.png', 'https://xdvideo-file.oss-cn-shenzhen.aliyuncs.com/video/2020/maven/%E5%AE%98%E7%BD%91%E4%B8%BB%E5%9B%BE-mawen.png', 3980, '2021-06-24 22:14:00', 9.10),
  (40, '全新微信小程序零基础到项目实战', 'https://xdvideo-file.oss-cn-shenzhen.aliyuncs.com/video/2020/%E5%BE%AE%E4%BF%A1%E5%B0%8F%E7%A8%8B%E5%BA%8F/%E8%AF%A6%E6%83%85%E5%9B%BE.png', 'https://xdvideo-file.oss-cn-shenzhen.aliyuncs.com/video/2020/%E5%BE%AE%E4%BF%A1%E5%B0%8F%E7%A8%8B%E5%BA%8F/%E5%AE%98%E7%BD%91%E4%B8%BB%E5%9B%BE-%E5%B0%8F%E7%A8%8B%E5%BA%8F.png', 5980, '2021-01-18 22:14:00', 9.10),
  (41, '玩转搜索框架ElasticSearch7.x实战', 'https://xd-video-pc-img.oss-cn-beijing.aliyuncs.com/xdclass_pro/video/2019_backend/elasticsearch7_detail.jpeg', 'https://xd-video-pc-img.oss-cn-beijing.aliyuncs.com/xdclass_pro/video/2019_backend/elasticsearch7.png', 4880, '2021-01-10 22:14:00', 8.70),
  (45, 'Docker实战视频教程入门到高级dockerfile/compose-Harbor', 'https://xdvideo-file.oss-cn-shenzhen.aliyuncs.com/video/2020/Docker/%E8%AF%A6%E6%83%85%E5%9B%BE.jpeg', 'https://xdvideo-file.oss-cn-shenzhen.aliyuncs.com/video/2020/Docker/%E5%AE%98%E7%BD%91%E4%B8%BB%E5%9B%BE-docker.png', 5980, '2021-01-10 22:14:00', 9.30),
  (46, '新版javase零基础到高级教程小白自学编程', 'https://xdvideo-file.oss-cn-shenzhen.aliyuncs.com/video/2020/%E6%96%B0%E7%89%88javase/%E8%AF%A6%E6%83%85%E5%9B%BE.png', 'https://file.xdclass.net/video/2020/%E6%96%B0%E7%89%88javase/%E5%AE%98%E7%BD%91%E4%B8%BB%E5%9B%BE-javase.png', 3980, '2021-01-24 22:14:00', 8.80),
  (47, 'Nodejs教程零基础入门到项目实战前端视频教程', 'https://xdvideo-file.oss-cn-shenzhen.aliyuncs.com/video/2020/node/%E5%AE%98%E7%BD%91%E8%AF%A6%E6%83%85%E5%9B%BE-node.png', 'https://xdvideo-file.oss-cn-shenzhen.aliyuncs.com/video/2020/node/%E5%AE%98%E7%BD%91%E4%B8%BB%E5%9B%BE-node.png', 6980, '2021-01-24 22:14:00', 8.90);

用户服务 cloud_user库 user表

CREATE TABLE `user` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `phone` varchar(32) DEFAULT NULL,
  `pwd` varchar(128) DEFAULT NULL,
  `sex` int(2) DEFAULT NULL,
  `img` varchar(128) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `role` int(11) DEFAULT NULL COMMENT '1是普通用户，2是管理员',
  `username` varchar(128) DEFAULT NULL,
  `wechat` varchar(128) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4;

INSERT INTO `user` (`id`, `phone`, `pwd`, `sex`, `img`, `create_time`, `role`, `username`, `wechat`)
VALUES
  (1, '123', '666', 1, 'xdclass.net', '2021-09-09 00:00:00', 1, 'jack', 'xdclass6'),
  (2, '2323432', '794666918', 1, 'wwwww', '2020-05-20 04:54:01', 1, '小滴Anna姐姐', 'xdclass-anna'),
  (3, '2323432', 'xdclass-lw', 1, 'wwwww', '2020-05-20 04:54:42', 1, '二当家小D', 'xdclass1'),
  (4, '2323432', '3232323', 1, 'wwwww', '2020-05-20 04:55:07', 1, '老王', 'xdclass-lw');

订单服务 cloud_order库 video_order表

CREATE TABLE `video_order` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `out_trade_no` varchar(64) DEFAULT NULL COMMENT '订单唯一标识',
  `state` int(11) DEFAULT NULL COMMENT '0表示未支付，1表示已支付',
  `create_time` datetime DEFAULT NULL COMMENT '订单生成时间',
  `total_fee` int(11) DEFAULT NULL COMMENT '支付金额，单位分',
  `video_id` int(11) DEFAULT NULL COMMENT '视频主键',
  `video_title` varchar(256) DEFAULT NULL COMMENT '视频标题',
  `video_img` varchar(256) DEFAULT NULL COMMENT '视频图片',
  `user_id` int(12) DEFAULT NULL COMMENT '用户id',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=42 DEFAULT CHARSET=utf8;

使用Maven聚合工程创建微服务架构

maven聚合工程
- xdclass-common
- xdclass-video-service
- xdclass-user-service
- xdclass-order-service
创建聚合工程（记得删除聚合工程src目录）

<?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>net.xdclass</groupId>
    <artifactId>xdclass-cloud</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>xdclass-common</module>
        <module>xdclass-video-service</module>
        <module>xdclass-user-service</module>
        <module>xdclass-order-service</module>
    </modules>

    <!-- 一般来说父级项目的packaging都为pom，packaging默认类型jar类型-->
    <packaging>pom</packaging>


    <properties>
        <java.version>1.8</java.version>
    </properties>


    <!-- 锁定版本 -->
    <dependencyManagement>
        <dependencies>
            <!--https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-dependencies/2.3.3.RELEASE-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.3.3.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!--https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-dependencies/Hoxton.SR8-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR8</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!--https://mvnrepository.com/artifact/com.alibaba.cloud/spring-cloud-alibaba-dependencies/2.2.1.RELEASE-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2.2.1.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                    <addResources>true</addResources>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

添加子项目依赖，在三个子项目中添加springboot的依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>net.xdclass</groupId>
            <artifactId>xdclass-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

在common包中创建实体类，生成setter、getter方法

package net.xdclass.domain;

import java.util.Date;

public class User {
        private Integer id;
        private String name;
        private String pwd;
        private String headImg;
        private String phone;
        private Date createTime;
        private String wechat;
}

public class Video {
    private Integer id;
    private String title;
    private String summary;
    private String coverImg;
    private Integer  price;
    private Date createTime;
    private Double point;
}

public class VideoOrder {
    private Integer id;
    private String outTradeNo;
    private Integer state;
    private Date createTime;
    private  Integer totalFee;
    private Integer videoId;
    private String videoTitle;
    private String videoImg;
    private Integer userId;
}

聚合工程pom.xml修改【注意】

    <properties>
        <java.version>1.8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
  
  
  <dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.2</version>
    <type>pom</type>
    <scope>import</scope>
  </dependency>

分别在三个项目中引入 mybatis依赖和数据库驱动

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

        <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
      </dependency>

3个模块配置数据库连接（记得修改端口、应用名称、数据库名称）application.yml

server:
  port: 9000
spring:
  application:
    name: xdclass-video-service
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://192.168.31.101:50000/cloud_video?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456
# 控制台输出sql、下划线转驼峰
mybatis:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    map-underscore-to-camel-case: true

video 启动类

package net.xdclass;

import org.springframework.boot.SpringApplication;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("net.xdclass.dao")
public class VideoApplication {
    public static void main(String[] args) {
        SpringApplication.run(VideoApplication.class, args);
    }
}

controller

package net.xdclass.controller;

import net.xdclass.service.VideoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("api/v1/video")
public class VideoController {
    @Autowired
    private VideoService videoService;

    @RequestMapping("find_by_id")
    public Object findById(int videoId) {
        return videoService.findById(videoId);
    }
}

service

package net.xdclass.service;

import net.xdclass.domain.Video;

public interface VideoService {
    Video findById(int videoId);
}



package net.xdclass.service.impl;

import net.xdclass.dao.VideoMapper;
import net.xdclass.domain.Video;
import net.xdclass.service.VideoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class VideoServiceImpl implements VideoService {
    @Autowired
    private VideoMapper videoMapper;
  
    @Override
    public Video findById(int videoId) {
        return videoMapper.findById(videoId);
    }
}

mapper

package net.xdclass.dao;

import net.xdclass.domain.Video;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

@Repository
public interface VideoMapper {

    @Select("select * from video where id=#{videoId}")
    Video findById(int videoId);
}

测试

// http://localhost:9000/api/v1/video/find_by_id?videoId=40

{
  "id": 40,
  "title": "全新微信小程序零基础到项目实战",
  "summary": "https://xdvideo-file.oss-cn-shenzhen.aliyuncs.com/video/2020/%E5%BE%AE%E4%BF%A1%E5%B0%8F%E7%A8%8B%E5%BA%8F/%E8%AF%A6%E6%83%85%E5%9B%BE.png",
  "coverImg": "https://xdvideo-file.oss-cn-shenzhen.aliyuncs.com/video/2020/%E5%BE%AE%E4%BF%A1%E5%B0%8F%E7%A8%8B%E5%BA%8F/%E5%AE%98%E7%BD%91%E4%B8%BB%E5%9B%BE-%E5%B0%8F%E7%A8%8B%E5%BA%8F.png",
  "price": 5980,
  "createTime": "2021-01-18T22:14:00.000+00:00",
  "point": 9.1
}

服务直接的调用-下单购买视频

服务直接怎么调用：

RPC:
  远程过程调用，像调用本地服务(方法)一样调用服务器的服务
  支持同步、异步调用
  客户端和服务器之间建立TCP连接，可以一次建立一个，也可以多个调用复用一次链接
  RPC数据包小
    protobuf
    thrift
  rpc：编解码，序列化，链接，丢包，协议
  
Rest(Http):
  http请求，支持多种协议和功能
  开发方便成本低
  http数据包大
  java开发：resttemplate或者httpclient

启动类

package net.xdclass;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;


@SpringBootApplication
public class OrderApplication {

    public static void main(String [] args){

        SpringApplication.run(OrderApplication.class,args);
    }
  
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }


}

controller

package net.xdclass.controller;

import net.xdclass.domain.Video;
import net.xdclass.domain.VideoOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.Date;

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


    @Autowired
    private RestTemplate restTemplate;
  
    @RequestMapping("/save")
    public Object save(int videoId){

        Video video = restTemplate.getForObject("http://localhost:9000/api/v1/video/find_by_id?videoId="+videoId, Video.class);

        VideoOrder videoOrder = new VideoOrder();
        videoOrder.setVideoId(video.getId());
        videoOrder.setVideoTitle(video.getTitle());
        videoOrder.setCreateTime(new Date());
        return videoOrder;

    }
}

测试

// 20201214161212
// http://localhost:8000/api/v1/video_order/save?videoId=40

{
  "id": null,
  "outTradeNo": null,
  "state": null,
  "createTime": "2020-12-14T08:12:12.640+00:00",
  "totalFee": null,
  "videoId": 40,
  "videoTitle": "全新微信小程序零基础到项目实战",
  "videoImg": null,
  "userId": null
}

存在的问题：

* 服务之间的IP信息写死
* 服务之间无法提供负载均衡
* 多个服务直接关系调用维护复杂

Nacos（服务治理）

微服务架构图讲解
什么是注册中心（服务治理）
- 服务注册：服务提供者provider，启动的时候向注册中心上报自己的网络信息
- 服务发现：服务消费者consumer,启动的时候向注册中心上报自己的网络信息，拉取provider的相关网络信息
- 核心:服务管理,是有个服务注册表，心跳机制动态维护，服务实例在启动时注册到服务注册表，并在关闭时注销。
为什么要用
- 微服务应用和机器越来越多，调用方需要知道接口的网络地址，如果靠配置文件的方式去控制网络地址，对于动态新增机器，维护带来很大问题
主流的注册中心：zookeeper、Eureka、consul、etcd、Nacos
- AlibabaCloud搭配最好的是Nacos，且服务的注册发现之外，还支持动态配置服务

Nacos搭建

官网：https://nacos.io/zh-cn/
Linux/Mac安装Nacos
- 解压安装包
- 进入bin目录
- 启动 sh startup.sh -m standalone
- 访问 localhost:8848/nacos
- 默认账号密码 nacos/nacos

订单-视频服务之间的调用

视频服务集成Nacos

添加依赖

<!--添加nacos客户端-->
<dependency>
     <groupId>com.alibaba.cloud</groupId>
     <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

配置Nacos地址

server:
  port: 9000

spring:
  application:
    name: xdclass-video-service
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.31.101:8848

启动类增加注解

@EnableDiscoveryClient

订单服务集成Nacos
用户服务集成Nacos
服务之间的调用

package net.xdclass.controller;

import net.xdclass.domain.Video;
import net.xdclass.domain.VideoOrder;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.Date;
import java.util.List;

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

    @Autowired
    private DiscoveryClient discoveryClient;

    @Autowired
    private RestTemplate restTemplate;

    @RequestMapping("/save")
    public Object save(int videoId){

        //Video video = restTemplate.getForObject("http://localhost:9000/api/v1/video/find_by_id?videoId="+videoId, Video.class);

        List<ServiceInstance> list = discoveryClient.getInstances("xdclass-video-service");
        ServiceInstance serviceInstance = list.get(0);

        Video video = restTemplate.getForObject("http://"+serviceInstance.getHost()+":"+serviceInstance.getPort()+
                "/api/v1/video/find_by_id?videoId="+videoId,Video.class);

        VideoOrder videoOrder = new VideoOrder();
        videoOrder.setVideoId(video.getId());
        videoOrder.setVideoTitle(video.getTitle());
        videoOrder.setCreateTime(new Date());
        return videoOrder;

    }
}

测试

// 20201215120717
// http://localhost:8000/api/v1/video_order/save?videoId=40

{
  "id": null,
  "outTradeNo": null,
  "state": null,
  "createTime": "2020-12-15T04:07:17.708+00:00",
  "totalFee": null,
  "videoId": 40,
  "videoTitle": "全新微信小程序零基础到项目实战",
  "videoImg": null,
  "userId": null
}

负载均衡和常见的解决方案

什么是负载均衡（Load Balance）

分布式系统中一个非常重要的概念，当访问的服务具有多个实例时，需要根据某种“均衡”的策略决定请求发往哪个节点，这就是所谓的负载均衡，
原理是将数据流量分摊到多个服务器执行，减轻每台服务器的压力，从而提高了数据的吞吐量

软硬件角度负载均衡的种类
- 通过硬件来进行解决，常见的硬件有NetScaler、F5、Radware和Array等商用的负载均衡器，但比较昂贵的
- 通过软件来进行解决，常见的软件有LVS、Nginx等,它们是基于Linux系统并且开源的负载均衡策略
从端的角度负载均衡有两种
- 服务端负载均衡
- 客户端负载均衡（订单服务调用视频服务，订单服务在本地决定最终调用哪个节点）

常见的负载均衡策略（看组件的支持情况）

节点轮询
- 简介：每个请求按顺序分配到不同的后端服务器
weight 权重配置
- 简介：weight和访问比率成正比，数字越大，分配得到的流量越高
固定分发
- 简介：根据请求按访问ip的hash结果分配，这样每个用户就可以固定访问一个后端服务器
随机选择、最短响应时间等等

AlibabaCloud集成Ribbon实现负载均衡

什么是Ribbon Ribbon是一个客户端负载均衡工具，通过Spring Cloud封装，可以轻松和AlibabaCloud整合
订单服务增加@LoadBalanced 注解

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

调用实战

package net.xdclass.controller;

import net.xdclass.domain.Video;
import net.xdclass.domain.VideoOrder;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.Date;
import java.util.List;

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

    @Autowired
    private DiscoveryClient discoveryClient;

    @Autowired
    private RestTemplate restTemplate;

    @RequestMapping("/save")
    public Object save(int videoId){

        //Video video = restTemplate.getForObject("http://localhost:9000/api/v1/video/find_by_id?videoId="+videoId, Video.class);

        List<ServiceInstance> list = discoveryClient.getInstances("xdclass-video-service");
        ServiceInstance serviceInstance = list.get(0);

        //Video video = restTemplate.getForObject("http://"+serviceInstance.getHost()+":"+serviceInstance.getPort()+"/api/v1/video/find_by_id?videoId="+videoId,Video.class);

        Video video = restTemplate.getForObject("http://xdclass-video-service/api/v1/video/find_by_id?videoId="+videoId, Video.class);

        VideoOrder videoOrder = new VideoOrder();
        videoOrder.setVideoId(video.getId());
        videoOrder.setVideoTitle(video.getTitle());
        videoOrder.setCreateTime(new Date());

        videoOrder.setServerInfo(video.getServeInfo());
        return videoOrder;

    }
}

测试两次的请求端口号不同

// 20201215124016
// http://localhost:8000/api/v1/video_order/save?videoId=40

{
  "id": null,
  "outTradeNo": null,
  "state": null,
  "createTime": "2020-12-15T04:40:16.015+00:00",
  "totalFee": null,
  "videoId": 40,
  "videoTitle": "全新微信小程序零基础到项目实战",
  "videoImg": null,
  "userId": null,
  "serverInfo": "192.168.31.100:9000"
}

// 20201215124041
// http://localhost:8000/api/v1/video_order/save?videoId=40

{
  "id": null,
  "outTradeNo": null,
  "state": null,
  "createTime": "2020-12-15T04:40:41.175+00:00",
  "totalFee": null,
  "videoId": 40,
  "videoTitle": "全新微信小程序零基础到项目实战",
  "videoImg": null,
  "userId": null,
  "serverInfo": "192.168.31.100:9001"
}

负载均衡策略调整

订单服务增加配置

xdclass-video-service:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

微服务新一代负载均衡组件Open-Feign

原先ribbon代码存在的问题：不规范，风格不统一，维护性比较差
什么是Feign:

SpringCloud提供的伪http客户端(本质还是用http)，封装了Http调用流程，更适合面向接口化
让用Java接口注解的方式调用Http请求.

不用像Ribbon中通过封装HTTP请求报文的方式调用 Feign默认集成了Ribbon

官方文档
- https://spring.io/projects/spring-cloud-openfeign
- 版本 2.2.5
Nacos支持Feign,可以直接集成实现负载均衡的效果

改造微服务集成Feign实现远程方法调用

Feign让方法调用更加解耦
使用feign步骤讲解
- 加入依赖（订单服务）

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

配置注解

启动类增加@EnableFeignClients

增加一个接口

订单服务增加接口，服务名称记得和nacos保持一样
@FeignClient(name="xdclass-video-service")

编写代码

package net.xdclass.service;

import net.xdclass.domain.Video;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

@FeignClient(name="xdclass-video-service")
public interface VideoService {
    @GetMapping(value = "/api/v1/video/find_by_id")
    Video findById(@RequestParam("videoId") int videoId);
}

controller调用视频服务

package net.xdclass.controller;

import net.xdclass.domain.Video;
import net.xdclass.domain.VideoOrder;
import net.xdclass.service.VideoService;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.Date;
import java.util.List;

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

    @Autowired
    private DiscoveryClient discoveryClient;

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private VideoService videoService;

    @RequestMapping("/save")
    public Object save(int videoId){

        //Video video = restTemplate.getForObject("http://localhost:9000/api/v1/video/find_by_id?videoId="+videoId, Video.class);

        List<ServiceInstance> list = discoveryClient.getInstances("xdclass-video-service");
        ServiceInstance serviceInstance = list.get(0);

        // Video video = restTemplate.getForObject("http://"+serviceInstance.getHost()+":"+serviceInstance.getPort()+ "/api/v1/video/find_by_id?videoId="+videoId,Video.class);

        //Video video = restTemplate.getForObject("http://xdclass-video-service/api/v1/video/find_by_id?videoId="+videoId, Video.class);

        Video video = videoService.findById(videoId);
        VideoOrder videoOrder = new VideoOrder();
        videoOrder.setVideoId(video.getId());
        videoOrder.setVideoTitle(video.getTitle());
        videoOrder.setCreateTime(new Date());

        videoOrder.setServerInfo(video.getServeInfo());
        return videoOrder;

    }
}

测试

http://localhost:8000/api/v1/video_order/find_by_id?videoId=40

post方式对象传输 Open-Feign 实现远程方法调用

ordercontroller

package net.xdclass.controller;

import net.xdclass.domain.Video;
import net.xdclass.domain.VideoOrder;
import net.xdclass.service.VideoService;
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.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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

    @Autowired
    private DiscoveryClient discoveryClient;

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private VideoService videoService;

    @RequestMapping("/find_by_id")
    public Object findById(int videoId){

        //Video video = restTemplate.getForObject("http://localhost:9000/api/v1/video/find_by_id?videoId="+videoId, Video.class);

        List<ServiceInstance> list = discoveryClient.getInstances("xdclass-video-service");
        ServiceInstance serviceInstance = list.get(0);

        // Video video = restTemplate.getForObject("http://"+serviceInstance.getHost()+":"+serviceInstance.getPort()+ "/api/v1/video/find_by_id?videoId="+videoId,Video.class);

        //Video video = restTemplate.getForObject("http://xdclass-video-service/api/v1/video/find_by_id?videoId="+videoId, Video.class);

        Video video = videoService.findById(videoId);
        VideoOrder videoOrder = new VideoOrder();
        videoOrder.setVideoId(video.getId());
        videoOrder.setVideoTitle(video.getTitle());
        videoOrder.setCreateTime(new Date());

        videoOrder.setServerInfo(video.getServeInfo());
        return videoOrder;

    }

    @RequestMapping("save")
    public Object save(@RequestBody Video video) {
        int rows = videoService.save(video);

        Map<String, Object> map = new HashMap<>();
        map.put("rows", rows);
        return map;
    }
}

VideoService

package net.xdclass.service;

import net.xdclass.domain.Video;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;

@FeignClient(name="xdclass-video-service")
public interface VideoService {
    @GetMapping(value = "/api/v1/video/find_by_id")
    Video findById(@RequestParam("videoId") int videoId);

    @PostMapping(value = "/api/v1/video/save")
    int save(@RequestBody Video video);
}

VideoController

package net.xdclass.controller;

import net.xdclass.domain.Video;
import net.xdclass.service.VideoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

/**
 * @Description 旭瑶&小滴课堂 xdclass.net
 * @Author 二当家小D  代码、笔记和技术指导联系我即可
 * @Version 1.0
 **/

@RestController
@RequestMapping("api/v1/video")
public class VideoController {



    @Autowired
    private VideoService videoService;


    @RequestMapping("find_by_id")
    public Object findById(int videoId, HttpServletRequest request){
        Video video = videoService.findById(videoId);
        video.setServeInfo(request.getServerName() + ":" + request.getServerPort());
        return video;
    }

    @PostMapping("save")
    public int save(@RequestBody Video video){
        System.out.println(video.getTitle());
        return  1;
    }
}

测试

localhost:8000/api/v1/video_order/save

{
    "title":"post方式测试"
}


VideoController控制台打印
post方式测试

postman返回数据
{
    "rows": 1
}

Ribbon和feign两个的区别和选择

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

CAP

可能会有疑惑，可以看多几遍
CAP定理: 指的是在一个分布式系统中，Consistency（一致性）、 Availability（可用性）、Partition tolerance（分区容错性），三者不可同时获得
- 一致性（C）：所有节点都可以访问到最新的数据
- 可用性（A）：每个请求都是可以得到响应的，不管请求是成功还是失败
- 分区容错性（P）：除了全部整体网络故障，其他故障都不能导致整个系统不可用
CAP理论就是说在分布式存储系统中，最多只能实现上面的两点。而由于当前的网络硬件肯定会出现延迟丢包等问题，所以分区容忍性是我们必须需要实现的。所以我们只能在一致性和可用性之间进行权衡

CA： 如果不要求P（不允许分区），则C（强一致性）和A（可用性）是可以保证的。但放弃P的同时也就意味着放弃了系统的扩展性，也就是分布式节点受限，没办法部署子节点，这是违背分布式系统设计的初衷的

CP: 如果不要求A（可用），每个请求都需要在服务器之间保持强一致，而P（分区）会导致同步时间无限延长(也就是等待数据同步完才能正常访问服务)，一旦发生网络故障或者消息丢失等情况，就要牺牲用户的体验，等待所有数据全部一致了之后再让用户访问系统

AP：要高可用并允许分区，则需放弃一致性。一旦分区发生，节点之间可能会失去联系，为了高可用，每个节点只能用本地数据提供服务，而这样会导致全局数据的不一致性。

常见注册中心：zk、eureka、nacos
那你应该怎么选择

| | Nacos | Eureka | Consul | Zookeeper |
| - | - | - | - | - |
| 一致性协议 | CP+AP | AP | CP | CP |
| 健康检查 | TCP/HTTP/MYSQL/Client Beat | 心跳 | TCP/HTTP/gRPC/Cmd | Keep Alive |
| 雪崩保护 | 有 | 有 | 无 | 无 |
| 访问协议 | HTTP/DNS | HTTP | HTTP/DNS | TCP |
| SpringCloud集成 | 支持 | 支持 | 支持 | 支持 |

Zookeeper：CP设计，保证了一致性，集群搭建的时候，某个节点失效，则会进行选举行的leader，或者半数以上节点不可用，则无法提供服务，因此可用性没法满足
Eureka：AP原则，无主从节点，一个节点挂了，自动切换其他节点可以使用，去中心化
结论：
- 分布式系统中P,肯定要满足，所以只能在CA中二选一
- 没有最好的选择，最好的选择是根据业务场景来进行架构设计
- 如果要求一致性，则选择zookeeper/Nacos，如金融行业 CP
- 如果要求可用性，则Eureka/Nacos，如电商系统 AP
- CP ：适合支付、交易类，要求数据强一致性，宁可业务不可用，也不能出现脏数据
- AP: 互联网业务，比如信息流架构，不要求数据强一致，更想要服务可用

BASE

什么是Base理论

CAP 中的一致性和可用性进行一个权衡的结果，核心思想就是：我们无法做到强一致，但每个应用都可以根据自身的业务特点，采用适当的方式来使系统达到最终一致性, 来自 ebay 的架构师提出

Basically Available(基本可用)
- 假设系统，出现了不可预知的故障，但还是能用, 可能会有性能或者功能上的影响
Soft state（软状态）
- 允许系统中的数据存在中间状态，并认为该状态不影响系统的整体可用性，即允许系统在多个不同节点的数据副本存在数据延时
Eventually consistent（最终一致性）
- 系统能够保证在没有其他新的更新操作的情况下，数据最终一定能够达到一致的状态，因此所有客户端对系统的数据访问最终都能够获取到最新的值

海量请求下的微服务架构存在的问题

高并发下存在的问题
- 微服务拆分多个系统，服务之间互相依赖，可能会由于系统负载过高，突发流量或者网络等各种异常情况导致服务不可用。
核心思想-面向失败编程
- 不要外界影响
- 不被请求拖垮
  - 上游服务（限流保护好自己）
  - 下游服务（熔断，不会一直等待下游服务的应答）

面向失败编程-微服务架构容错方案介绍

限流
漏斗，不管流量多大，均匀的流入容器，令牌桶算法，漏桶算法
熔断：
- 保险丝，熔断服务，为了防止整个系统故障，包含当前和下游服务下单服务 -》商品服务-》用户服务 -》（出现异常-》熔断风控服务
降级：
- 抛弃一些非核心的接口和数据，返回兜底数据旅行箱的例子：只带核心的物品，抛弃非核心的，等有条件的时候再去携带这些物品
隔离：
- 服务和资源互相隔离，比如网络资源，机器资源，线程资源等，不会因为某个服务的资源不足而抢占其他服务的资源
熔断和降级互相交集
- 相同点：
  - 从可用性和可靠性触发，为了防止系统崩溃
  - 最终让用户体验到的是某些功能暂时不能用
- 不同点
  - 服务熔断一般是下游服务故障导致的，而服务降级一般是从整体系统负荷考虑，由调用方控制
想进行微服务的容错，业界目前有Sentinel、Hystrix，相对于AlibabaCloud而言，Sentinel是最好的搭配

新版分布式系统的流量防卫兵-Sentinel介绍

什么是Sentinel
- 阿里巴巴开源的分布式系统流控工具
- 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性
- 丰富的应用场景：消息削峰填谷、集群流量控制、实时熔断下游不可用应用等
- 完备的实时监控：Sentinel 同时提供实时的监控功能
- 提供开箱即用的与其它开源框架/库的整合模块，例如与 Spring Cloud、Dubbo、gRPC 的整合
官网：https://github.com/alibaba/Sentinel/wiki/%E4%BB%8B%E7%BB%8D
Sentinel版本：2.2.1
核心概念：
- 资源：是 Sentinel 中的核心概念之一，可以是java程序中任何内容，可以是服务或者方法甚至代码，总结起来就是我们要保护的东西
- 规则：定义怎样的方式保护资源，主要包括流控规则、熔断降级规则等

Sentinel-features-overview

流量防卫兵-Sentinel依赖引入和控制台搭建

Sentinel 分为两个部分
- 核心库（Java 客户端）不依赖任何框架/库，能够运行于所有 Java 运行时环境，同时对 Dubbo、Spring Cloud 等框架也有较好的支持。
- 控制台（Dashboard）基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器。
微服务引入Sentinel依赖

 <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

Sentinel控制台搭建
文档：https://github.com/alibaba/Sentinel/wiki/控制台
控制台包含如下功能:
- 查看机器列表以及健康情况：收集 Sentinel 客户端发送的心跳包，用于判断机器是否在线。
- 监控 (单机和集群聚合)通过 Sentinel 客户端暴露的监控 API，定期拉取并且聚合应用监控信息，最终可以实现秒级的实时监控。
- 规则管理和推送：统一管理推送规则。
- 鉴权：生产环境中鉴权非常重要。这里每个开发者需要根据自己的实际情况进行定制。
注意：Sentinel 控制台目前仅支持单机部署

//启动 Sentinel 控制台需要 JDK 版本为 1.8 及以上版本，
//-Dserver.port=8090 用于指定 Sentinel 控制台端口为 8090 
//默认用户名和密码都是 sentinel

java -Dserver.port=8090 -Dcsp.sentinel.dashboard.server=localhost:8080 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.8.0.jar


http://192.168.31.101:8090/#/login

AliababCloud微服务整合Sentinel限流配置实操

多个微服务接入Sentinel配置

spring:
  cloud:
    sentinel:
      transport:
        dashboard: 192.168.31.101:8090 
        port: 9999 

#dashboard: 8080 控制台端口
#port: 9999 本地启的端口，随机选个不能被占用的，与dashboard进行数据交互，会在应用对应的机器上启动一个 Http Server，该 Server 会与 Sentinel 控制台做交互, 若被占用,则开始+1一次扫描

微服务注册上去后，由于Sentinel是懒加载模式，所以需要访问微服务后才会在控制台出现
限流配置实操
- 控制台配置

浏览器刷新(http://localhost:8000/api/v1/video_order/find_by_id?videoId=40)
```
Blocked by Sentinel (flow limiting)
```

Sentinel流量控制功能

流量控制（flow control）

原理是监控应用流量的 QPS 或并发线程数等指标，当达到指定的阈值时对流量进行控制，以避免被瞬时的流量高峰冲垮，从而保障应用的高可用性。

两种规则

基于统计并发线程数的流量控制

并发数控制用于保护业务线程池不被慢调用耗尽

Sentinel 并发控制不负责创建和管理线程池，而是简单统计当前请求上下文的线程数目（正在执行的调用数目）

如果超出阈值，新的请求会被立即拒绝，效果类似于信号量隔离

基于统计QPS的流量控制

当 QPS 超过某个阈值的时候，则采取措施进行流量控制

控制面板介绍
- 资源名：默认是请求路径，可自定义
- 针对来源：对哪个微服务进行限流，默认是不区分来源，全部限流，这个是针对区分上游服务进行限流, 比如视频服务被订单服务、用户服务调用，就可以针对来源进行限流

基于并发线程进行限流配置实操

开发临时接口，方便测试

    @RequestMapping("list")
    public Object list(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Map<String,String> map  = new HashMap<>();

        map.put("title1","ALibabaCloud微服务专题");
        map.put("title2","小滴课堂面试专题第一季");

        return map;
    }

基于统计并发线程数的流量控制

并发数控制用于保护业务线程池不被慢调用耗尽

Sentinel 并发控制不负责创建和管理线程池，而是简单统计当前请求上下文的线程数目（正在执行的调用数目）

如果超出阈值，新的请求会被立即拒绝，效果类似于信号量隔离。并发数控制通常在调用端进行配置

流控规则会下发到微服务，微服务如果重启，则流控规则会消失可以持久化配置
选择阈值类型 ”线程数“ ，配置是1
刷新浏览器

流控规则效果

直接拒绝
冷启动预热
匀速排队
流量控制的效果包括以下几种：
- 直接拒绝：默认的流量控制方式，当QPS超过任意规则的阈值后，新的请求就会被立即拒绝
- Warm Up：冷启动/预热，如果系统在此之前长期处于空闲的状态，我们希望处理请求的数量是缓步的增多，经过预期的时间以后，到达系统处理请求个数的最大值
- 匀速排队：严格控制请求通过的间隔时间，也即是让请求以均匀的速度通过，对应的是漏桶算法，主要用于处理间隔性突发的流量，如消息队列，想象一下这样的场景，在某一秒有大量的请求到来，而接下来的几秒则处于空闲状态，我们希望系统能够在接下来的空闲期间逐渐处理这些请求，而不是在第一秒直接拒绝多余的请求
  - 注意：
    - 匀速排队等待策略是 Leaky Bucket 算法结合虚拟队列等待机制实现的。
    - 匀速排队模式暂时不支持 QPS > 1000 的场景
流控文档
- https://github.com/alibaba/Sentinel/wiki/流量控制#基于调用关系的限流

Sentinel-微服务高可用利器-熔断降级规则

熔断降级（虽然是两个概念，基本都是互相配合）
- 对调用链路中不稳定的资源进行熔断降级也是保障高可用的重要措施之一
- 对不稳定的弱依赖服务调用进行熔断降级，暂时切断不稳定调用，避免局部不稳定因素导致整体的雪崩
- 熔断降级作为保护自身的手段，通常在客户端（调用端）进行配置
什么是Sentinel降级规则
- 文档：https://github.com/alibaba/Sentinel/wiki/熔断降级
- 就是配置一定规则，然后满足之后就对服务进行熔断降级
Sentinel 熔断策略
- 慢调用比例(响应时间): 选择以慢调用比例作为阈值，需要设置允许的慢调用 RT（即最大的响应时间），请求的响应时间大于该值则统计为慢调用
  - 比例阈值：修改后不生效-目前已经反馈给官方那边的bug
  - 熔断时长：超过时间后会尝试恢复
  - 最小请求数：熔断触发的最小请求数，请求数小于该值时即使异常比率超出阈值也不会熔断
- 异常比例：当单位统计时长内请求数目大于设置的最小请求数目，并且异常的比例大于阈值，则接下来的熔断时长内请求会自动被熔断
  - 比例阈值
  - 熔断时长：超过时间后会尝试恢复
  - 最小请求数：熔断触发的最小请求数，请求数小于该值时，即使异常比率超出阈值也不会熔断
- 异常数：当单位统计时长内的异常数目超过阈值之后会自动进行熔断
  - 异常数:
  - 熔断时长：超过时间后会尝试恢复
  - 最小请求数：熔断触发的最小请求数，请求数小于该值时即使异常比率超出阈值也不会熔断

Sentinel的熔断状态和恢复

服务熔断一般有三种状态（画图）
- 熔断关闭（Closed）
  - 服务没有故障时，熔断器所处的状态，对调用方的调用不做任何限制
- 熔断开启（Open）
  - 后续对该服务接口的调用不再经过网络，直接执行本地的fallback方法
- 半熔断（Half-Open）
  - 所谓半熔断就是尝试恢复服务调用，允许有限的流量调用该服务，并监控调用成功率
熔断恢复：
- 经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态）尝试恢复服务调用，允许有限的流量调用该服务，并监控调用成功率。
- 如果成功率达到预期，则说明服务已恢复，进入熔断关闭状态；如果成功率仍旧很低，则重新进入熔断状态

服务调用熔断例子

修改代码
熔断测试（异常比例）

 int temp = 0;
    @RequestMapping("list")
    public Object list(){

//        try {
//            TimeUnit.SECONDS.sleep(3);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }

        temp++;
        if(temp%3 == 0){
            throw  new RuntimeException();
        }
        Map<String,String> map  = new HashMap<>();
        map.put("title1","ALibabaCloud微服务专题");
        map.put("title2","小滴课堂面试专题第一季");

        return map;
    }

Sentinel自定义异常

默认降级返回数据问题
- 限流和熔断返回的数据有问题-
- 微服务交互基本都是json格式，如果让自定义异常信息
AlibabCloud版本升级，不兼容问题
- v2.1.0到v2.2.0后，Sentinel里面依赖进行了改动，且不向下兼容
自定义降级返回数据
- 【旧版】实现UrlBlockHandler并且重写blocked方法

@Component
public class XdclassUrlBlockHandler implements UrlBlockHandler {
    @Override
    public void blocked(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, BlockException e) throws IOException {
       //降级业务处理
    }
}

【新版】实现BlockExceptionHandler并且重写handle方法

public class XdclassUrlBlockHandler implements BlockExceptionHandler {
   
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, BlockException e) throws Exception {
    //降级业务处理
    }
}

Sentinel自定义降级异常数据开发实战

异常种类

FlowException  //限流异常
DegradeException  //降级异常
ParamFlowException //参数限流异常
SystemBlockException //系统负载异常
AuthorityException //授权异常

【新版】实现BlockExceptionHandler并且重写handle方法

package net.xdclass.config;

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.BlockExceptionHandler;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import com.alibaba.csp.sentinel.slots.system.SystemBlockException;
import com.alibaba.fastjson.JSON;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@Component
public class XdclassUrlBlockHandler implements BlockExceptionHandler {
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, BlockException e) throws IOException {
        Map<String,Object> backMap=new HashMap<>();
        if (e instanceof FlowException){
            backMap.put("code",-1);
            backMap.put("msg","限流-异常啦");
        }else if (e instanceof DegradeException){
            backMap.put("code",-2);
            backMap.put("msg","降级-异常啦");
        }else if (e instanceof ParamFlowException){
            backMap.put("code",-3);
            backMap.put("msg","热点-异常啦");
        }else if (e instanceof SystemBlockException){
            backMap.put("code",-4);
            backMap.put("msg","系统规则-异常啦");
        }else if (e instanceof AuthorityException){
            backMap.put("code",-5);
            backMap.put("msg","认证-异常啦");
        }

        // 设置返回json数据
        httpServletResponse.setStatus(200);
        httpServletResponse.setHeader("content-Type","application/json;charset=UTF-8");
        httpServletResponse.getWriter().write(JSON.toJSONString(backMap));
    }
}

测试（添加限流、或者降级）

// 20201216160043
// http://localhost:8000/api/v1/video_order/list

{
  "msg": "限流-异常啦",
  "code": -1
}

Sentinel整合OpenFeign配置实战

订单服务（假设调视频服务失败，视频服务不可用，兜底数据）

整合步骤

加入依赖

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

开启Feign对Sentinel的支持

feign:
  sentinel:
    enabled: true

创建容错类, 实现对应的服务接口, 记得加注解 @Service

package net.xdclass.service.fallback;

import net.xdclass.domain.Video;
import net.xdclass.service.VideoService;
import org.springframework.stereotype.Service;

@Service
public class VideoServiceFallback implements VideoService {

    @Override
    public Video findById(int videoId) {
        Video video = new Video();
        video.setTitle("熔断降级数据");
        return video;
    }

    @Override
    public int save(Video video) {
        return 0;
    }
}

配置feign容错类，@FeignClient(name="xdclass-video-service"， fallback = VideoServiceFallback.class)

package net.xdclass.service;

import net.xdclass.domain.Video;
import net.xdclass.service.fallback.VideoServiceFallback;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;

@FeignClient(name="xdclass-video-service", fallback = VideoServiceFallback.class)
public interface VideoService {
    @GetMapping(value = "/api/v1/video/find_by_id")
    Video findById(@RequestParam("videoId") int videoId);

    @PostMapping(value = "/api/v1/video/save")
    int save(@RequestBody Video video);
}

测试（兜底数据，对用户更加友好）

localhost:8000/api/v1/video_order/save?videoId=40

{
    "id": null,
    "outTradeNo": null,
    "state": null,
    "createTime": "2020-12-16T08:24:54.173+00:00",
    "totalFee": null,
    "videoId": 40,
    "videoTitle": "全新微信小程序零基础到项目实战",
    "videoImg": null,
    "userId": null,
    "serverInfo": "192.168.31.100:9001"
}

//关闭视频服务之后再访问
localhost:8000/api/v1/video_order/save?videoId=40

{
    "id": null,
    "outTradeNo": null,
    "state": null,
    "createTime": "2020-12-16T08:23:05.331+00:00",
    "totalFee": null,
    "videoId": null,
    "videoTitle": "熔断降级数据",
    "videoImg": null,
    "userId": null,
    "serverInfo": null
}

微服务的网关和应用场景

什么是网关
- API Gateway，是系统的唯一对外的入口，介于客户端和服务器端之间的中间层，处理非业务功能提供路由请求、鉴权、监控、缓存、限流等功能
- 统一接入
  - 智能路由
  - AB测试、灰度测试
  - 负载均衡、容灾处理
  - 日志埋点（类似Nignx日志）
- 流量监控
  - 限流处理
  - 服务降级
- 安全防护
  - 鉴权处理
  - 监控
  - 机器网络隔离
主流的网关
- zuul：是Netflix开源的微服务网关，和Eureka,Ribbon,Hystrix等组件配合使用，依赖组件比较多，性能教差
- kong: 由Mashape公司开源的，基于Nginx的API gateway
nginx+lua：是一个高性能的HTTP和反向代理服务器,lua是脚本语言，让Nginx执行Lua脚本，并且高并发、非阻塞的处理各种请求
springcloud gateway: Spring公司专门开发的网关，替代zuul
注意：AlibabaCloud全家桶还没对应的网关，我们就用SpringCloud官方推荐的Gateway

介绍网关SpringCloud Gateway

什么是 SpringCloud Gateway
- Spring官方出品，基于Spring5+Reactor技术开发的网关
- 性能强劲基于Reactor+WebFlux、功能多样
- 基于springboot2.x, 直接可以jar包方式运行
官方文档
- https://spring.io/projects/spring-cloud-gateway

创建SpringCloud网关项目和依赖添加

创建Gateway项目

添加依赖

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

主启动类

package net.xdclass;

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

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

配置实战 application.yml

server:
  port: 8888
spring:
  application:
    name: api-gateway
  cloud:
    gateway:
      routes: #数组形式
        - id: order-service  #路由唯一标识
          uri: http://127.0.0.1:8000  #想要转发到的地址
          order: 1 #优先级，数字越小优先级越高
          predicates: #断言 配置哪个路径才转发
            - Path=/order-server/**
          filters: #过滤器，请求在传递过程中通过过滤器修改
            - StripPrefix=1  #去掉第一层前缀

#访问路径 http://localhost:8888/order-server/api/v1/video_order/list
#转发路径 http://localhost:8000/order-server/api/v1/video_order/list
#转发路径 http://localhost:8000/api/v1/video_order/list
#需要过滤器去掉前面第一层

测试（记得启动订单服务）

http://localhost:8888/order-server/api/v1/video_order/list

ALibabaCloud

配置项怎么看？

点击routes进去

SpringCloud Gateway网关整合Nacos开发实战

原先存在的问题

微服务地址写死
负载均衡没做到

添加Nacos服务治理配置

网关添加naocs依赖

        <!--添加nacos客户端-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

启动类开启支持

@EnableDiscoveryClient

修改配置文件

server:
  port: 8888
spring:
  application:
    name: api-gateway

  cloud:
    nacos:
      discovery:
        server-addr: 192.168.31.101:8848

    gateway:
      routes: #数组形式
        - id: order-service  #路由唯一标识
          #uri: http://127.0.0.1:8000  #想要转发到的地址
          uri: lb://xdclass-order-service #从nacos进行转发，负载均衡
          order: 1 #优先级，数字越小优先级越高
          predicates: #断言 配置哪个路径才转发
            - Path=/order-server/**
          filters: #过滤器，请求在传递过程中通过过滤器修改
            - StripPrefix=1  #去掉第一层前缀
      discovery:
        locator:
          enabled: true  #开启网关拉起nacos的服务

#访问路径 http://localhost:8888/order-server/api/v1/video_order/list
#转发路径 http://localhost:8000/order-server/api/v1/video_order/list
#转发路径 http://localhost:8000/api/v1/video_order/list
#需要过滤器去掉前面第一层

测试（开启nacos，2个订单服务端口不同）

http://localhost:8888/order-server/api/v1/video_order/list

8000

8001

SpringCloud Gateway配置和交互流程

网关的配置项回顾

路由：是网关的基本单元，由ID、URI、一组Predicate、一组Filter组成，根据Predicate进行匹配转发

route组成部分
id：路由的ID
uri：匹配路由的转发地址
predicates：配置该路由的断言，通过PredicateDefinition类进行接收配置。
order：路由的优先级，数字越小，优先级越高。

交互流程

客户端向Spring Cloud Gateway发出请求
如果网关处理程序映射确定请求与路由匹配
则将其发送到网关Web处理程序
通过特定过滤器链运行，前置处理-后置处理

Spring Cloud网关图

Gateway内置的路由断言

什么是Gateway路由断言
- Predicate 来源于Java8，接受输入参数，返回一个布尔值结果
- Spring Cloud Gateway 中 Spring 利用 Predicate 的特性实现了各种路由匹配规则
- 转发的判断条件，SpringCloud Gateway支持多种方式，常见如：Path、Query、Method、Header等
- 支持多个Predicate请求的转发是必须满足所有的Predicate后才可以进行路由转发
内置路由断言介绍 RoutePredicateFactory 接口实现类
参数编写规则 XXXRoutePredicateFactory，使用XXX作为参数配置, 例如下面

predicates:
  - Host=
  - Path=
  - Method=
  - Header=
  - Query=
  - Cookie=

Gateway内置的路由接口定时下线实战

需求：接口需要在指定时间进行下线，过后不可以在被访问

使用Before ,只要当前时间小于设定时间，路由才会匹配请求
东8区的2020-09-11T01:01:01.000+08:00后，请求不可访问
为了方便测试，修改时间即可

predicates:
  - Before=2020-09-09T01:01:01.000+08:00
  - Query=source # 请求一定要带source这个参数，否则会被拒绝404

SpringCloud Gateway过滤器

什么是网关的过滤器

Spring Cloud网关图

过滤器生命周期
- PRE：这种过滤器在请求被路由之前调用,一般用于鉴权、限流等
- POST：这种过滤器在路由到微服务以后执行，一般用于修改响应结果，比如增加header信息、打点结果日志
网关过滤器分类
- 局部过滤器GatewayFilter：应用在某个路由上,每个过滤器工厂都对应一个实现类，并且这些类的名称必须以 GatewayFilterFactory 结尾
- 全局过滤器：作用全部路由上,
内置很多局部过滤器，顶级接口 GatewayFilterFactory,

内置很多全局过滤器，顶级接口 GlobalFilter

网关Gateway全局过滤器实现用户鉴权

自定义全局过滤器实现鉴权

package net.xdclass.filter;

import org.apache.commons.lang.StringUtils;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class UserGlobalFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

        String token = exchange.getRequest().getHeaders().getFirst("token");

        System.out.println(token);
        //TODO 根据业务开发对应的鉴权规则
        if(StringUtils.isBlank(token)){
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }

        //继续往下执行
        return chain.filter(exchange);

    }

    //数字越小，优先级越高
    @Override
    public int getOrder() {
        return 0;
    }
}

测试

http://localhost:8888/order-server/api/v1/video_order/list

Post   header  token

注意：网关不要加太多业务逻辑，否则会影响性能，务必记住

链路追踪系统

抛两个常见的问题
- 微服务调用链路出现了问题怎么快速排查？
微服务调用链路耗时长怎么定位是哪个服务？
链路追踪系统
- 分布式应用架构虽然满足了应用横向扩展的需求，但是运维和诊断的过程变得越来越复杂，例如会遇到接口诊断困难、应用性能诊断复杂、架构分析复杂等难题，传统的监控工具并无法满足，分布式链路系统由此诞生
核心：将一次请求分布式调用，使用GPS定位串起来，记录每个调用的耗时、性能等日志，并通过可视化工具展示出来
注意：AlibabaCloud全家桶还没对应的链路追踪系统，我们使用Sleuth和zipking（内部使用的鹰眼）

Sleuth链路追踪系统

什么是Sleuth

一个组件，专门用于记录链路数据的开源组件
文档：https://spring.io/projects/spring-cloud-sleuth
案例

    [order-service,96f95a0dd81fe3ab,852ef4cfcdecabf3,false]
  
    第一个值，spring.application.name的值
  
    第二个值，96f95a0dd81fe3ab ，sleuth生成的一个ID，叫Trace ID，用来标识一条请求链路，一条请求链路中包含一个Trace ID，多个Span ID
  
    第三个值，852ef4cfcdecabf3、spanid 基本的工作单元，获取元数据，如发送一个http
  
    第四个值：false，是否要将该信息输出到zipkin服务中来收集和展示。

各个微服务添加依赖

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

zipkin介绍和部署

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

java -jar zipkin-server-2.12.9-exec.jar

访问入口：http://127.0.0.1:9411/zipkin/
zipkin组成：Collector、Storage、Restful API、Web UI组成

architecture-1

链路追踪组件Zipkin+Sleuth整合

sleuth收集跟踪信息通过http请求发送给zipkin server
zipkin server进行跟踪信息的存储以及提供Rest API即可
Zipkin UI调用其API接口进行数据展示默认存储是内存，可也用mysql 或者elasticsearch等存储
微服务加入依赖

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

配置地址和采样百分比配置

spring:
  application:
    name: api-gateway
  zipkin:
    base-url: http://192.168.31.101:9411/ #zipkin地址
    discovery-client-enabled: false  #不用开启服务发现

  sleuth:
    sampler:
      probability: 1.0 #采样百分比

默认为0.1，即10%，这里配置1，是记录全部的sleuth信息，是为了收集到更多的数据（仅供测试用）。
在分布式系统中，过于频繁的采样会影响系统性能，所以这里配置需要采用一个合适的值。

微服务链路追踪系统Zipkin持久化配置

现存在的问题
- 服务重启会导致链路追踪系统数据丢失

持久化配置：mysql或者elasticsearch

创建数据库表SQL脚本，创建数据库名 zipkin_log

CREATE TABLE IF NOT EXISTS zipkin_spans (
  `trace_id_high` BIGINT NOT NULL DEFAULT 0 COMMENT 'If non zero, this means the trace uses 128 bit traceIds instead of 64 bit',
  `trace_id` BIGINT NOT NULL,
  `id` BIGINT NOT NULL,
  `name` VARCHAR(255) NOT NULL,
  `remote_service_name` VARCHAR(255),
  `parent_id` BIGINT,
  `debug` BIT(1),
  `start_ts` BIGINT COMMENT 'Span.timestamp(): epoch micros used for endTs query and to implement TTL',
  `duration` BIGINT COMMENT 'Span.duration(): micros used for minDuration and maxDuration query',
  PRIMARY KEY (`trace_id_high`, `trace_id`, `id`)
) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci;

ALTER TABLE zipkin_spans ADD INDEX(`trace_id_high`, `trace_id`) COMMENT 'for getTracesByIds';
ALTER TABLE zipkin_spans ADD INDEX(`name`) COMMENT 'for getTraces and getSpanNames';
ALTER TABLE zipkin_spans ADD INDEX(`remote_service_name`) COMMENT 'for getTraces and getRemoteServiceNames';
ALTER TABLE zipkin_spans ADD INDEX(`start_ts`) COMMENT 'for getTraces ordering and range';

CREATE TABLE IF NOT EXISTS zipkin_annotations (
  `trace_id_high` BIGINT NOT NULL DEFAULT 0 COMMENT 'If non zero, this means the trace uses 128 bit traceIds instead of 64 bit',
  `trace_id` BIGINT NOT NULL COMMENT 'coincides with zipkin_spans.trace_id',
  `span_id` BIGINT NOT NULL COMMENT 'coincides with zipkin_spans.id',
  `a_key` VARCHAR(255) NOT NULL COMMENT 'BinaryAnnotation.key or Annotation.value if type == -1',
  `a_value` BLOB COMMENT 'BinaryAnnotation.value(), which must be smaller than 64KB',
  `a_type` INT NOT NULL COMMENT 'BinaryAnnotation.type() or -1 if Annotation',
  `a_timestamp` BIGINT COMMENT 'Used to implement TTL; Annotation.timestamp or zipkin_spans.timestamp',
  `endpoint_ipv4` INT COMMENT 'Null when Binary/Annotation.endpoint is null',
  `endpoint_ipv6` BINARY(16) COMMENT 'Null when Binary/Annotation.endpoint is null, or no IPv6 address',
  `endpoint_port` SMALLINT COMMENT 'Null when Binary/Annotation.endpoint is null',
  `endpoint_service_name` VARCHAR(255) COMMENT 'Null when Binary/Annotation.endpoint is null'
) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci;

ALTER TABLE zipkin_annotations ADD UNIQUE KEY(`trace_id_high`, `trace_id`, `span_id`, `a_key`, `a_timestamp`) COMMENT 'Ignore insert on duplicate';
ALTER TABLE zipkin_annotations ADD INDEX(`trace_id_high`, `trace_id`, `span_id`) COMMENT 'for joining with zipkin_spans';
ALTER TABLE zipkin_annotations ADD INDEX(`trace_id_high`, `trace_id`) COMMENT 'for getTraces/ByIds';
ALTER TABLE zipkin_annotations ADD INDEX(`endpoint_service_name`) COMMENT 'for getTraces and getServiceNames';
ALTER TABLE zipkin_annotations ADD INDEX(`a_type`) COMMENT 'for getTraces and autocomplete values';
ALTER TABLE zipkin_annotations ADD INDEX(`a_key`) COMMENT 'for getTraces and autocomplete values';
ALTER TABLE zipkin_annotations ADD INDEX(`trace_id`, `span_id`, `a_key`) COMMENT 'for dependencies job';

CREATE TABLE IF NOT EXISTS zipkin_dependencies (
  `day` DATE NOT NULL,
  `parent` VARCHAR(255) NOT NULL,
  `child` VARCHAR(255) NOT NULL,
  `call_count` BIGINT,
  `error_count` BIGINT,
  PRIMARY KEY (`day`, `parent`, `child`)
) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci;

启动命令

java -jar zipkin-server-2.12.9-exec.jar --STORAGE_TYPE=mysql --MYSQL_HOST=192.168.31.101 --MYSQL_TCP_PORT=3306 --MYSQL_DB=zipkin_log --MYSQL_USER=root --MYSQL_PASS=123456

作者：Soulboy