一、Spring Cloud Alibaba

1.1.简介

Spring Cloud Alibaba 软件开发定制致力于提供开发的一站软件开发定制式解决方案。软件开发定制此项目包含开发分布式软件开发定制应用微服务的必需组件，软件开发定制方便开发者通过 Spring Cloud 软件开发定制编程模型轻松使用这些软件开发定制组件来开发分布式应用服务。

依托 Spring Cloud Alibaba，软件开发定制您只需要添加一些注解软件开发定制和少量配置，就可以将 Spring Cloud 软件开发定制应用接入阿里微服务解决方案，软件开发定制通过阿里中间件来迅速软件开发定制搭建分布式应用系统。

Spring Cloud :软件开发定制是一种微服务开发规范，软件开发定制是一套标准接口。软件开发定制所有器实现的框架都软件开发定制必须要符合该标准

实现框架：

Spring Cloud Netflix 软件开发定制第一点版本软件开发定制在去年已经停止更新

Spring Cloud Alibaba 软件开发定制第二代版本，软件开发定制非常的便于介入阿里云软件开发定制各种云服务

1.2. 主要功能

软件开发定制服务限流降级：默认支持WebServlet、WebFlux、OpenFeign、RestTemplate、Spring Cloud Gateway、Zuul、Dubbo 和 RocketMQ软件开发定制限流降级功能的接入，软件开发定制可以在运行时通过控制软件开发定制台实时修改限流降级规则，软件开发定制还支持查看限流降级Metrics监控。
软件开发定制服务注册与发现：适配Spring Cloud 软件开发定制服务注册与发现标准，软件开发定制默认集成了Ribbon的支持。软件开发定制提供注册中心相关功能（nacos,eureka,zk）
软件开发定制分布式配置管理：软件开发定制支持分布式系统中的外部化配置，软件开发定制配置更改时自动刷新。软件开发定制我们可以让很多实例去共享软件开发定制同一个远程的 application.proerties
软件开发定制消息驱动能力：基于 Spring Cloud Stream 软件开发定制为微服务应用构建消息驱动能力。软件开发定制消息推送功能，通知

软件开发定制分布式事务：使用 @GlobalTransactional 注解，高效并且对业务零侵入地解决分布式事务问题。。解决跨应用之间的事务一致性

阿里云对象存储：阿里云提供的海量、安全、低成本、高可靠的云存储服务。支持在任何应用、任何时间、任何地点存储和访问任意类型的数据。可以将文件直接存储 阿里云对象存储

分布式任务调度：提供秒级、精准、高可靠、高可用的定时（基于 Cron 表达式）任务调度服务。同时提供分布式的任务执行模型，如网格任务。网格任务支持海量子任务均匀分配到所有 Worker（schedulerx-client）上执行。 Redis + Quartz或者Elastic-Job来解决。

阿里云短信服务：覆盖全球的短信服务，友好、高效、智能的互联化通讯能力，帮助企业迅速搭建客户触达通道。

1.3. 组件

：把流量作为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

：一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。

：一款开源的分布式消息系统，基于高可用分布式集群技术，提供低延时的、高可靠的消息发布与订阅服务。

：Apache Dubbo™ 是一款高性能 Java RPC 框架。

：阿里巴巴开源产品，一个易于使用的高性能微服务分布式事务解决方案。

: 阿里云对象存储服务（Object Storage Service，简称 OSS），是阿里云提供的海量、安全、低成本、高可靠的云存储服务。您可以在任何应用、任何时间、任何地点存储和访问任意类型的数据。

: 阿里中间件团队开发的一款分布式任务调度产品，提供秒级、精准、高可靠、高可用的定时（基于 Cron 表达式）任务调度服务。

: 覆盖全球的短信服务，友好、高效、智能的互联化通讯能力，帮助企业迅速搭建客户触达通道。

1.4.为什么要用Spring Cloud Alibaba？

1.我们需要知道Spring Cloud Alibaba在Spring Cloud家族中的地位，它是一个套件，与Netflix OSS一样，涵盖了非常多的实用组件，其中也有不少内容存在重叠。

2.我们需要知道Netflix OSS下的诸多重要组件先后宣布停止新功能开发的大背景，而Spring Cloud Alibaba是一个新生项目，正处于高速迭代中。对于未来，相信谁都会选。

3.对于中国用户来说，Spring Cloud Alibaba还有一个非常特殊的意义：它将曾经红极一时的Dubbo，以及阿里巴巴的强力消息中间件RocketMQ融入Spring Cloud体系。还在纠结于如何让这些共存的团队，你们所面临过的各种困难与问题，马上就会迎刃而解。不用再烦恼是不是要扩展Dubbo的注册中心，还是自己为RocketMQ实现一套的Spring Cloud Stream的Binder等等问题。

4.对于Spring Cloud Alibaba的上手学习成本如何呢？

如果您已经是Spring Cloud的用户，那么恭喜您，在Spring Cloud Common的抽象和Spring Cloud Alibaba团队的努力下，你会非常容易、甚至不需要改变多少编码模式，就能适应它。如果您第一次接触Spring Cloud，那么也恭喜您，因为这是有史以来，中文文档最全的一个Spring Cloud组件了，相信机制的您一定也能很快的上手使用它

如何引入依赖


 
    <packaging>pom</packaging>
 
 
    <properties>
        <!-- Environment Settings -->
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <!-- Spring Settings -->
        <spring-cloud.version>Hoxton.SR1</spring-cloud.version>
        <spring-cloud-alibaba.version>2.2.0.RELEASE</spring-cloud-alibaba.version>
    </properties>
 
 
    <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>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

二、Nacos组件

致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据及流量管理。

Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。 Nacos 是构建以“服务”为中心的现代应用架构 (例如微服务范式、云原生范式) 的服务基础设施。

2.1 特性

服务发现和服务健康监测

Nacos 支持基于 DNS 和基于 RPC 的服务发现。服务提供者使用、、或一个注册 Service 后，服务消费者可以使用或查找和发现服务。

相当于dubbo的zookeeper和springcloud的eureka

实现：nacos ,eureka,zookeeper

动态配置服务

动态配置服务可以让您以中心化、外部化和动态化的方式管理所有环境的应用配置和服务配置。

动态配置消除了配置变更时重新部署应用和服务的需要，让配置管理变得更加高效和敏捷。

配置中心化管理让实现无状态服务变得更简单，让服务按需弹性扩展变得更容易。

相当于动态配置的zookeeper和springcloude-nacos-config

动态 DNS 服务

动态 DNS 服务支持权重路由，让您更容易地实现中间层负载均衡、更灵活的路由策略、流量控制以及数据中心内网的简单DNS解析服务。动态DNS服务还能让您更容易地实现以 DNS 协议为基础的服务发现，以帮助您消除耦合到厂商私有服务发现 API 上的风险。

服务及其元数据管理

Nacos 能让您从微服务平台建设的视角管理数据中心的所有服务及元数据，包括管理服务的描述、生命周期、服务的静态依赖分析、服务的健康状态、服务的流量管理、路由及安全策略、服务的 SLA 以及最首要的 metrics 统计数据。

我们可以通过 nacos 完成对注册到nacos 中的所有的实例进行健康检测，包保存其元数据

2.2 作用

注册中心：帮助发现其他服务对应的实例

配置中心：全局的配置文件

健康监控管理中心：监控实例的健康状态

2.3 安装

环境要求

64 bit OS，支持 Linux/Unix/Mac/Windows，推荐选用 Linux/Unix/Mac。

64 bit JDK 1.8+； & 。

Maven 3.2.x+； & 。

2.3.1.下载安装包

nacos-server-1.2.0-beta.0.zip

注意下载[nacos-server-1.2.0 以上版本会报错

2.3.2 解压

2.3.3 启动

进入到bin目录

2.3.4.访问路径

三、springcloud alibaba 实例

1.创建一个服务的生产者提供服务 springcloud-alibaba-provider

2.创建一个服务的消费者消费提供的服务springcloud-alibaba-consume

3.1.创建父工程springcloudalibaba

在父工程的pom.xml文件引入以下依赖


  <!-- 标记该工程 为父工程-->
    <packaging>pom</packaging>
 
    <!--
        spring cloud  必须 基于spring boot 实现
    -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.4.RELEASE</version>
    </parent>
 
    <properties>
        <!-- Environment Settings -->
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <!-- Spring Settings
             spirng cloud 版本是 以伦敦地铁站 命名 Hoxton.SR1
        -->
        <spring-cloud.version>Hoxton.SR1</spring-cloud.version>
 
        <!--
            spring-cloud-alibaba 版本
         -->
        <spring-cloud-alibaba.version>2.2.0.RELEASE</spring-cloud-alibaba.version>
    </properties>
 
    <!--  管理子工程 的依赖 ，保证子工程依赖的 jar 和 父工程 保持一致
           在子工程中 不需要加版本号
      -->
    <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>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

3.2 创建服务提供者springcloud-alibaba-provider

创建子工程springcloud-alibaba-providerr，引入以下依赖，下面是我的pom.xml文件


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloudalibaba</artifactId>
        <groupId>com.qf</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
 
    <artifactId>springcloud-alibaba-provider</artifactId>
 
    <dependencies>
 
        <!--springBoot 相关  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
 
        <!-- alibaba.cloud 相关-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
 
 
    </dependencies>
 
</project>

创建配置文件，application.properties


 
# 应用名  模块名  注意应用名 不可以使用_
spring.application.name=springcloud-alibaba-provider
 
#配置nacos 服务器地址
spring.cloud.nacos.server-addr=localhost:8848
 
#配置tomcat端口号
server.port=8083
 
#暴露所有应用断点，便于监控
management.endpoints.web.exposure.include=*

创建启动类


package com.qf;
 
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
 
@EnableDiscoveryClient  //激活nacos相关功能
@SpringBootApplication
public class ProviderApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(ProviderApplication.class,args);
    }
}

创建测试类


package com.qf.controller;
 
 
import com.qf.entity.Student;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
 
@RestController  //Controller  + ResponseBody 该注解下面的方法返回的都是Json数据
public class HelloController {
 
    @Value("${server.port}")
    private Integer port;
 
    @RequestMapping("/getMessage/{msg}")  //restFul风格
    public String getMessage(@PathVariable("msg") String msg){
        return "msg:"+msg + "--from-port:" + port;
    }
 
    @RequestMapping("/say")
    public String say(@RequestParam("msg") String msg){
        return "msg:"+msg + "--from-port:" + port;
    }
 
}

测试启动provider

访问nacos管理界面，可以看到

访问和

3.3 创建服务消费者 springcloud-alibaba-consumer

消费者通过nacos调用服务提供者的接口使用LoadBalanceClient 和 RestTemplate来完成

1.创建springcloud-alibaba-consumer

引入以下pom和provider 一致


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloudalibaba</artifactId>
        <groupId>com.qf</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
 
    <artifactId>springcloud-alibaba-consumer</artifactId>
 
    <dependencies>
 
        <!--springBoot 相关  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
 
        <!-- alibaba.cloud 相关-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
 
 
    </dependencies>
 
</project>

2.创建配置文件


 
#应用名  模块名  注意应用名  不可以使用_
spring.application.name=springcloud-alibaba-consumer
 
#配置nacos 服务器地址
spring.cloud.nacos.server-addr=localhost:8848
 
#配置tomcat端口号
server.port=8085
 
#暴露所有应用断点，便于监控
management.endpoints.web.exposure.include=*

3.创建启动类


package com.qf;
 
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
 
@EnableDiscoveryClient  //激活nacos相关功能
@SpringBootApplication
public class ConsumerApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }
}

5.创建配置类


package com.qf.config;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
 
@Configuration  //标记当前类是配置类，相当于spring中的bean.xml
public class NacosConfig {
 
    /**
     * RestTemplate 就是一个帮助我们发起远程http请求的客户端（类似于postman，浏览器）
     * */
    @Bean  //向容器中加入一个RestTemplate
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

6.创建测试类


package com.qf.controller;
 
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
 
import java.util.HashMap;
import java.util.Map;
 
/**
 * 主要用于consumer向provider发起远程请求
 * */
@RestController
public class NacosConsumerController {
 
    /**
     * loadBalancerClient负载均衡的客户端，用来根据服务名从nacos中获取对应的ip
     * */
    @Autowired
    private LoadBalancerClient loadBalancerClient;
 
    /**
     * RestTemplate 就是一个帮助我们发起远程http请求的客户端（类似于postman，浏览器）
     * */
    @Autowired
    private RestTemplate restTemplate;
 
    @RequestMapping("/test1")
    public String test1(){
        // 调用远程 provider 中的   @RequestMapping("/getMessage/{msg}")
 
        // 现在是 写死 地址，也可以使用 nacos 找到    springcloud-alibaba-provider 对应的ip 端口
//        String url = "http://localhost:8083/getMessage/hello";
 
        // serviceInstance 就是远程 provider 实例的 ip 和 端口 的封装
        ServiceInstance serviceInstance = loadBalancerClient.choose("springcloud-alibaba-provider");
 
        // 得到远程服务实例的ip
        //serviceInstance.getHost();
        // 得到端口
        // serviceInstance.getPort();
 
        //%s 就是需要替换的参数
        String url = String.format("http://%s:%s/getMessage/%s",serviceInstance.getHost(),serviceInstance.getPort(),"hello");
 
 
        // 使用restTemplate 发起网络请求
        return restTemplate.getForObject(url,String.class);
    }
    @RequestMapping("/test2")
    public String test2(){
 
        // 远程调用  @RequestMapping("/say")
        //    public String say(@RequestParam("msg") String msg)
 
        ServiceInstance serviceInstance= loadBalancerClient.choose("springcloud-alibaba-provider");
 
        String url = String.format("http://%s:%s/say?msg={msg}",serviceInstance.getHost(),serviceInstance.getPort());
 
        //msg值的初始化
        Map map = new HashMap();
        map.put("msg","hello java2109");
        // 使用restTemplate 发起网络请求
        return restTemplate.getForObject(url,String.class,map);
    }
 
}

启动服务提供者和服务消费者进行测试，

查看nacos管理界面可以看到：http://localhost:8848/nacos

浏览器访问:

RestTemplate:帮助我们发起远程请求的客户端

使用的都是模板设计模式

LoadBalancerClient:loadBalancerClient 负载均衡的客户端，用来根据服务名从nacos 中获取对应的ip

四、Ribbon

如果provider 提供的服务有多个，那么consumer 调用provider时，就需要更多不同的负载均衡算法选择不同的实例发起请求

4.1 Ribbon概述

是一个客户端的负载均衡器，它提供对大量的HTTP和TCP客户端的访问控制
可以实现服务的远程调用和服务的负载均衡协调

4.2 Ribbon的负载均衡

4.3 示例

1. 在springcloud-alibaba-consumer中引入负载均衡依赖


<!-- 引入负载均衡-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon
    </artifactId>
</dependency>

2.在配置文件中配置负载均衡器（将原来的myConfig类屏蔽）


 
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
 
@Configuration
public class RibbonConfig {
 
    @LoadBalanced // 对RestTemplate 的发起网络请求 进行拦截，
    // 运用负载均衡策略（就是按照策略选择对应的ip）
    @Bean //向容器中加入一个 RestTemplate
    public RestTemplate restTemplate(){
 
        return new RestTemplate();
    }
 
 
    @Bean // 将随机的 策略加入到容器中
    public IRule iRule(){
 
        // 创建一个随机的负载均衡策略
        IRule rule = new RandomRule();
 
        //2.权重响应时间分配规则 代替ResponseTimeRule 响应时间加权策略
//        WeightedResponseTimeRule responseTimeRule=new WeightedResponseTimeRule();
//        //3.最低并发策略 分配的时候选择目前并发量最小的
//        BestAvailableRule bestAvailableRule=new BestAvailableRule();
//        //4.轮训策略
//        RoundRobinRule roundRobinRule=new RoundRobinRule();
//        //5.重试策略 如果在配置时间内，无法选择服务，尝试选择一个服务 重试机制
//        RetryRule retryRule=new RetryRule();
//        //6.区域感知策略 就近访问
//        ZoneAvoidanceRule zoneAvoidanceRule=new ZoneAvoidanceRule();
         7.可用过滤策略 可用根据阈值进行服务过滤
//        AvailabilityFilteringRule filteringRule=new AvailabilityFilteringRule();
 
        return rule;
    }
 
}

3.创建RibbonTestController 测试（屏蔽原来 TestController）


package com.qf.controller;
 
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.HashMap;
import java.util.Map;
 
@RestController
public class RibbonTestController {
 
    /**
     * RestTemplate 就是一个帮助我们发起远程http请求的客户端（类似于postman，浏览器）
     * */
    @Autowired
    private RestTemplate restTemplate;
 
    @RequestMapping("/test1")
    public String test1(){
        // 调用远程 provider 中的   @RequestMapping("/getMessage/{msg}")
 
        // http://springcloud-alibaba-provider/getMessage/%s
        //restTemplate 向 http://springcloud-alibaba-provider服务发起请求，但是会被ribbon 进行拦截，
        // 会根据负载均衡策略选择其中一台 provider实例，并替换    springcloud-alibaba-provider为 ip:端口
        //    %s  就是需要替换的参数
        String url = String.format("http://springcloud-alibaba-provider/getMessage/%s","hello");
 
 
        // 使用restTemplate 发起网络请求
        return restTemplate.getForObject(url,String.class);
    }
    @RequestMapping("/test2")
    public String test2(){
 
        // 远程调用  @RequestMapping("/say")
        //    public String say(@RequestParam("msg") String msg)
 
 
        String url = String.format("http://springcloud-alibaba-provider/say?msg={msg}");
 
        //msg值的初始化
        Map map = new HashMap();
        map.put("msg","hello java2109");
        // 使用restTemplate 发起网络请求
        return restTemplate.getForObject(url,String.class,map);
    }
 
}

4.启动两个provider （端口一定不同），在启动一个consumer进行测试

然后修改端口号为8084，再次启动

然后启动consumer

然后访问：http://localhost:8848/nacos/

打开新的页面，输入：

Ribbon：是一个负载均衡的客户端，他可以拦截RestTemplate 发起的请求，并且将请求路径中的服务名，根据负载均衡策略替换为ip:端口，并发起网络请求

底层原理：使用aop ，动态代理实现

五、Feign

Feign:就是伪装，feign 就是可以将远程的访问调用，伪装成本地的接口调用。

Feign = RestTemplate + Ribbon

5.1 什么是Feign？

Feign 的英文表意为“假装，伪装，变形”，是一个http请求调用的轻量级框架，可以Java接口注解的方式调用Http请求，而不用像Java中通过封装HTTP请求报文的方式直接调用。Feign通过处理注解，将请求模板化，当实际调用的时候，传入参数，根据参数再应用到请求上，进而转化成真正的请求，这种请求相对而言比较直观。 Feign被广泛应用在Spring Cloud 的解决方案中，是学习基于Spring Cloud 微服务架构不可或缺的重要组件。

5.2 实例1

1.创建一个springcloud-feign-cosumer工程，导入依赖


  <dependencies>
 
        <!--springBoot 相关  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
 
        <!-- alibaba.cloud nacos 相关-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
 
        <!-- opengin -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
 
    </dependencies>

2.创建配置文件application.properties


# 应用名 模块名  注意应用名 不可以使用_  springcloud-alibaba-feign-consumer
spring.application.name=springcloud-alibaba-feign-consumer
 
#配置nacos 服务地址
spring.cloud.nacos.server-addr=localhost:8848
 
server.port=8086
 
#暴露所有应用断点，便于监控
management.endpoints.web.exposure.include=*

3.创建启动类


package com.qf;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
 
@EnableFeignClients  //激活feign 相关功能
@EnableDiscoveryClient  //激活nacos功能
@SpringBootApplication
public class FeignApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(FeignApplication.class,args);
    }
}

4.创建Feign伪装接口


package com.qf.service;
 
import com.qf.entity.Student;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;
 
/**
 * 伪装 接口
 *
 * 我们需要向那个一个 服务发起远程调用，就需要将远程的处理器 方法拷贝过来，只剩方法名，没有方法体
 *  1.拷贝 provider 中的 处理器方法
 *  2.删除方法体
 *
 *  @FeignClient(value = "springcloud-alibaba-provider")
 *  //标记当前接口 是一个feign伪装接口，feign 更具接口配置的方法，生成对应的实现类
 *  向远程服务发起请求  ----》 将改接口实现 完成 RestTemplate 请求
 *
 */
@FeignClient(value = "springcloud-alibaba-provider")
public interface FeignService {
 
 
    @RequestMapping("/getMessage/{msg}")  //restFul风格
    public String getMessage(@PathVariable("msg") String msg);
 
    @RequestMapping("/say")
    public String say(@RequestParam("msg") String msg);
 
    /**
     * 更新学生
     * @param Student
     * @return
     */
    @RequestMapping("/updateStudent")
    public Student updateStudent(@RequestBody Student student);
}

5.创建FeignTestController使用伪装接口进行测试


package com.qf.controller;
 
import com.qf.entity.Student;
import com.qf.service.FeignService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class FeignTestController {
 
    @Autowired
    private FeignService feignService;
 
    @RequestMapping("/test1")
    public String test1(){
        // 调用远程 provider 中的   @RequestMapping("/getMessage/{msg}")
        return feignService.getMessage("hello BeiJing");
    }
 
    @RequestMapping("/test2")
    public String test2(){
        // 远程调用  @RequestMapping("/say")
        //    public String say(@RequestParam("msg") String msg)
 
        return feignService.say("hello - java2109");
    }
}

启动两个provider （端口一定不同）,再启动Fegin-consumer进行测试

5.3 实例二（使用feign 远程调用传递对象）

1.创建common工程

2.创建实体类Student


import java.io.Serializable;
 
/**
 * 创建一个实体类
 *  1.get set 方法
 *  2.toString()
 *  3.实现序列化   序列化作用：1.便于保存对象存入磁盘  2.便于网络间传输
 *
 *  4.如果创建了 有参构造 ，必须创建无参构造      必须注意
 */
public class Student implements Serializable {
 
    private int id;
 
    private String name;
 
    private int age;
 
    private String sex;
 
    private float height;
 
    public Student() {
    }
 
    public Student(int id, String name, int age, String sex, float height) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.height = height;
    }
 
    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 getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getSex() {
        return sex;
    }
 
    public void setSex(String sex) {
        this.sex = sex;
    }
 
    public float getHeight() {
        return height;
    }
 
    public void setHeight(float height) {
        this.height = height;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", height=" + height +
                '}';
    }
}

打成jar包，并存入到本地仓库

4.在provider中引入依赖


<!-- 引入 公共的依赖 -->
        <dependency>
            <groupId>com.qfedu</groupId>
            <artifactId>springcloud-alibaba-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

5.在provider 创建接受方法 一定要加 @RequestBody


  /**
     * 更新学生
     * // 普通 的键值对 转对象  updateStudent(Student student)，不可以被接受，只能接受json  转对象
     *
     * Student updateStudent(@RequestBody Student student)
     *
     * @param Student
     * @return
     */
    @RequestMapping("/updateStudent")
    public Student updateStudent(@RequestBody Student student){
 
        // 修改名字
        student.setName(student.getName() +" --port:"+port);
 
        System.out.println("服务提供者 更新student = " + student);
 
 
        return  student;
    }

6.在feign-consumer 中引入 common


<!-- 引入 公共的依赖 -->
        <dependency>
            <groupId>com.qfedu</groupId>
            <artifactId>springcloud-alibaba-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

7.在feign-consumer 的 FeignService 中添加


 /**
     * 更新学生
     * @param Student
     * @return
     */
    @RequestMapping("/updateStudent")
    public Student updateStudent(@RequestBody Student student);

8.在FeignTestController添加方法


@RequestMapping("/test3")
    public Student test3() {
 
        Student student = new Student(100,"xiaoming", 13,"F",170);
 
 
        return feignService.updateStudent(student);
 
    }

9.测试

先重新启动 provider ，feign-consumer

然后观察 nacos ,再测试

5.4 Feign的容错机制

容错：consumer 调用provider，如果Provider 有异常，消费者也会报错，容错机制就是保证，Provider 有异常，消费依然可以正常的返回兜底数据，客户感觉不到 provider有异常

1.在配置文件中开启容错


#开启 feign 容错机制
feign.hystrix.enabled=true

2.实现容错类


package com.qf.service.impl;
 
import com.qf.entity.Student;
import com.qf.service.FeignService;
import org.springframework.stereotype.Component;
 
/**
 * Feign 伪装接口的容错实现类
 * */
@Component   //加入到容器中
public class FeignServiceFallBackImpl implements FeignService {
    @Override
    public String getMessage(String msg) {
        return "feign  触发容错  getMessage  返回数据" + msg;
    }
 
    @Override
    public String say(String msg) {
        return "feign  触发容错  say  返回数据" + msg;
    }
 
    @Override
    public Student updateStudent(Student student) {
        student.setName(student.getName()+"----容错返回");
        return student;
    }
}

3.在FeignService伪装类接口中配置容错策略


package com.qf.service;
 
import com.qf.entity.Student;
import com.qf.service.impl.FeignServiceFallBackImpl;
import org.springframework.cloud.openfeign.FeignClient;
 
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
 
/**
 * 伪装 接口
 *
 * 我们需要向那个一个 服务发起远程调用，就需要将远程的处理器 方法拷贝过来，只剩方法名，没有方法体
 *  1.拷贝 provider 中的 处理器方法
 *  2.删除方法体
 *
 *  @FeignClient(value = "springcloud-alibaba-provider")
 *  //标记当前接口 是一个feign伪装接口，feign 更具接口配置的方法，生成对应的实现类
 *  向远程服务发起请求  ----》 将改接口实现 完成 RestTemplate 请求
 *
 * fallback=FeignServiceFallBackImpl.class 配置容错实现类
 */
@FeignClient(value = "springcloud-alibaba-provider",fallback= FeignServiceFallBackImpl.class)
public interface FeignService {
 
 
    @RequestMapping("/getMessage/{msg}")  //restFul风格
    public String getMessage(@PathVariable("msg") String msg);
 
    @RequestMapping("/say")
    public String say(@RequestParam("msg") String msg);
 
    /**
     * 更新学生
     * @param Student
     * @return
     */
    @RequestMapping("/updateStudent")
    public Student updateStudent(@RequestBody Student student);
}

4.进行测试

1.重新启动 feign-consumer 正常返回数据

2.停止provider ，则feign-consumer 返回容错数据

正常访问，此时的provider是正常状态

将provider关掉，继续访问：

六、Nacos Config（分布式配置中心）

在分布式系统中，由于服务数量巨多，为了方便服务配置文件统一管理，实时更新，所以需要分布式配置中心组件。

Nacos 提供用于存储配置和其他元数据的 key/value 存储，为分布式系统中的外部化配置提供服务器端和客户端支持。使用 Spring Cloud Alibaba Nacos Config，您可以在 Nacos Server 集中管理你 Spring Cloud 应用的外部属性配置。

Spring Cloud Alibaba Nacos Config 是 Spring Cloud Config Server 和 Client 的替代方案，客户端和服务器上的概念与 Spring Environment 和 PropertySource 有着一致的抽象，在特殊的 bootstrap 阶段，配置被加载到 Spring 环境中。当应用程序通过部署管道从开发到测试再到生产时，您可以管理这些环境之间的配置，并确保应用程序具有迁移时需要运行的所有内容。

1.创建springcloud-alibaba-nacos-fonfig 应用，并引入依赖


<dependencies>
 
    <!--springBoot 相关  -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
 
    <!-- spring 的监控模块-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
 
    <!-- alibaba.cloud 相关-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
 
 
</dependencies>

2.nacos 配置文件

springboot 读取配置文件的顺序

bootstrap.properties ---->bootstrap.yaml ------>application.proerties---->application.yaml

bootstrap.properties


 
#应用springboot 启动前 先去读取bootstrap.properties ，然后去配置中心拉取对应的配置文件
 
# 应用名 模块名  注意应用名 不可以使用_   springcloud_alibaba_provider
spring.application.name=springcloud-alibaba-nacos-provider
 
#配置nacos 服务地址
spring.cloud.nacos.server-addr=localhost:8848
 
server.port=8086
 
#暴露所有应用断点，便于监控
management.endpoints.web.exposure.include=*
 
student.name=xiaoming

3.在nacos 配置中创建对应配置文件

服务名.properties

4.配置启动类


 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
 
@EnableDiscoveryClient
@SpringBootApplication
public class ConfigApplication {
 
 
    public static void main(String[] args) {
        SpringApplication.run(ConfigApplication.class,args);
    }
 
}

5.读取配置文件内容测试


 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.netflix.archaius.ConfigurableEnvironmentConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class ConfigController {
 
    // 在启动时 获取配置文件一次数据，中间不改变
    @Value("${student.name}")
    private String studentName;
 
  @Autowired
  // ConfigurableEnvironmentConfiguration 实时得到配置中中对应配置文件的数据
    private ConfigurableEnvironmentConfiguration configuration;
 
 
   @RequestMapping("/getStudent")
    public String getStudent(){
 
        return "配置文件---studentName："+studentName +"---与配置中心保持一致的数据："+configuration.getString("student.name");
    }
 
}

测试

修改文件内容，得到立即的推送

可以在配置文件加入spring.cloud.nacos.config.refresh.enabled=false禁止自动刷新

七、Nacos Config 多环境的配置

bootstrap.properties application.properties 默认配置都是任何时候都生效的

我们还可以配置自定义环境，便于开发，但是前提必须是要先激活

自定义的环境有：

①开发环境：bootstrap-dev.properties

②测试环境：bootstrap-test.properties

多环境的配置有两种：

第一种是在bootstrap.properties中配置，下面是我的bootstrap.properties文件的内容


 
#应用SpringBoot 启动前，先去读取bootstrap.properties，然后去配置中心拉去对应的配置文件
 
#应用名  模块名  主要应用名不可以使用_
spring.application.name=springcloud-alibaba-nacos-config
 
 
#配置nacos服务地址
spring.cloud.nacos.server-addr=localhost:8848
 
#配置tomcat端口号
server.port=8087
 
#暴露所有应用端点，便于监控
management.endpoints.web.exposure.include=*
 
# 将该文件中配置的student.name注释掉
#student.name=xiaoming
 
#激活dev环境 让bootstrap-dev.properties生效
spring.cloud.nacos.config.file-extension=properties
spring.profiles.active=dev

创建bootstrap-dev.properties文件


#应用springboot 启动前 先去读取bootstrap.properties，然后去配置中心拉取对应的配置文件
#配置student.name
student.name=xiaoming-dev

先启动nacos,再启动项目，先访问：http://localhost:8848/nacos 查看服务注册上没

然后访问服务：

在配置中心创建配置文件springcloud-alibaba-nacos-config-dev.properties

刷新页面：

修改配置文件的内容，再次发布，再次刷新页面：

可以看到内容实时在更新

第二种方式：懒得测了，感兴趣的可以测测

软件开发定制Spring Cloud Alibaba 第一篇（Nacos组件）

一、Spring Cloud Alibaba

1.1.简介

1.2. 主要功能

1.3. 组件

1.4.为什么要用Spring Cloud Alibaba？

二、Nacos组件

2.1 特性

2.2 作用

2.3 安装

2.3.1.下载安装包

2.3.2 解压

2.3.3 启动

2.3.4.访问 路径

三、springcloud alibaba 实例

3.1.创建父工程springcloudalibaba

3.2 创建服务提供者springcloud-alibaba-provider

3.3 创建服务消费者 springcloud-alibaba-consumer

四、Ribbon

4.1 Ribbon概述

4.2 Ribbon的负载均衡

4.3 示例

五、Feign

5.1 什么是Feign？

5.2 实例1

5.3 实例二（使用feign 远程调用传递对象）

5.4 Feign的容错机制

六、Nacos Config（分布式配置中心）

七、Nacos Config 多环境的配置

2.3.4.访问路径