繁依Fanyi0

这个屌丝很懒，什么也没留下！

热门标签

Spring Cloud Alibaba 第一篇（Nacos组件）_springcloud alibaba组件

作者：繁依Fanyi0 | 2024-02-08 11:19:52

踩

springcloud alibaba组件

一、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. 组件

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

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

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

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

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

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

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

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

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

2.1 特性

服务发现和服务健康监测

Nacos 支持基于 DNS 和基于 RPC 的服务发现。服务提供者使用原生SDK、OpenAPI、或一个独立的Agent TODO注册 Service 后，服务消费者可以使用DNS TODO 或HTTP&API查找和发现服务。

相当于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.访问路径

http://localhost:8848/nacos

三、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管理界面，可以看到

访问 http://localhost:8083/getMessage/hello 和 http://localhost:8083/say?msg=bye

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

浏览器访问:http://localhost:8085/test1

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/

打开新的页面，输入：http://localhost:8085/test1

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关掉，继续访问：http://localhost:8086/test1

六、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 查看服务注册上没

然后访问服务：http://localhost:8086/getStudent

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

刷新页面：http://localhost:8086/getStudent

修改配置文件的内容，再次发布，再次刷新页面： http://localhost:8086/getStudent

可以看到内容实时在更新

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/68836