SpringCloud记录

1、Cloud官网

https://cloud.spring.io/spring-cloud-static/Hoxton.SR1/reference/htmlsingle

2、中文文档

https://www.bookstack.cn/read/spring-cloud-docs/docs-index.md

3、SpringCloud与springboot版本选型查询地址

https://start.spring.io/actuator/info

4、IDEA创建父工程并设置开发环境

1.New Project（IDEA-File-new -Project-左侧选择版本，右侧选择jdk并可以勾选骨架或不勾选）；
2.聚合总工程名字；
3.Maven选版本；
4.工程名字；
5.字符编码（File-Settings-Editor-File Encodings-全局、工程、属性文件选择一致的编码方式及右侧打钩；
6.注解生效激活（File-Settings-Build,Execution,Deploment-Compiler-Annotation Processors-左侧选择Default右侧Enable annotation。。。打钩）；
7.java编译版本（File-Settings-Build,Execution,Deploment-Java Compiler-项目名字右侧选择java版本）；
8.File Type过滤（File-Settings-Editor-File Types-右侧最下方将不显示的文件类型添加上）。
9.指定父工程pom文件中的packaging的类型为pom并删除父工程下除了pom.xml文件之外的其他文件夹(如src文件夹)，配置统一管理的jar包版本并引入坐标，这样子模块在继承之后就不需要写版本号引入即可使用。
10.Maven使用dependencyManagement元素来提供一种管理版本号的方式，通常会在一个组织或者项目的最顶层(父)的pom文件中看到
dependencyManagement元素。
子模块在引用依赖时就不用显示的列出依赖的版本号了，maven会找到其父类中定义的版本号进行使用
待版本升级时只修改父类的即可，同时子模块也可以单独使用自己想用的某个版本
注意！！！
dependencyManagement中只是声明依赖，并不实际引入，因此子模块中需要显示的声明需要用到的依赖

5、项目热部署

(1)在使用的module中引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>为true时表示项目之间依赖不传递
</dependency>

（2）在父工程中引入maven插件

<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>

（3）配置IDEA Ctrl+Shift+Alt+/ 选择Registry…
将compiler.automake.allow.when.app.running
和actionSystem.assertFocusAccessFromEdt选中打钩

（4）重启IDEA

6、Run Dashboard强制显示操作

当使用IDEA开发时，服务有多个的情况下run dashboard没有自动出现进行如下配置：
（1）找到当前项目工作空间的.idea文件夹下的workspace.xml文件，如：D:\workspace\cloud2021.idea
（2）workspace.xml中搜索找到的标签在下面添加如下标签

<option name=”configurationTypes”>
   <set>
       <option value=”SpringBootApplicationConfigurationType”/>
   </set>
</option>

7、eureka服务与注册
（1）eureka服务单机版
一、创建eureka服务

（1）创建模块后修改pom文件

<dependencies>
    <!-- eureka server -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
    <dependency>
        <groupId>com.yang.springcloud</groupId>
        <artifactId>cloud-api-commons</artifactId>
        <version>${project.version}</version>
    </dependency>
    <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-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
    </dependency>
</dependencies>

（2）配置文件添加配置

server.port=7001
#eureka服务端的实例名称
eureka.instance.hostname=localhost
#false表示不向注册中心注册自己
eureka.client.register-with-eureka=false
#false表示自己是注册中心，职责是维护服务实例，并不需要去检索服务
eureka.client.fetch-registry=false
#设置与eureka server交互的地址,查询服务和注册服务都需要依赖这个地址
eureka.client.service-url.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/

(3)创建启动类并添加开启eureka服务注解，启动服务即可

@SpringBootApplication
@EnableEurekaServer//开启eureka服务注解
public class EurekaMain7001 {
   
    public static void main(String[] args) {
   
        SpringApplication.run(EurekaMain7001.class,args);
    }
}

二、注册服务至eureka注册中心

消费者从注册中心获取服务地址后会缓存至本地的jvm内存中，默认每30s更新一次服务调用地址

（1）pom中添加eureka客户端的依赖

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

（2）修改配置文件，配置eureka信息

#表示是否将自己注册到eurekaServer中
eureka.client.register-with-eureka=true
#是否从EurekaServer抓取自己的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配置ribbon使用负载均衡
eureka.client.fetch-registry=true
#设置与eureka server交互的地址,查询服务和注册服务都需要依赖这个地址
eureka.client.service-url.defaultZone=http://localhost:7001/eureka/

(3)启动类添加开启eureka客户端的注解

@SpringBootApplication
@MapperScan(basePackages = {
   "com.yang.springcloud.dao"})
@EnableEurekaClient//表示自己是eureka的客户端
public class PaymentMain8001 {
   

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

（2）eureka服务集群版

使用eureka集群实现高可用（当某个节点挂掉之后不会影响服务间的调用），实现原理：相互注册，相互守望。（即1向2注册，2也向1中注册）多个也一样

一、eureka集群搭建

7001和7002是eureka集群的两个服务的端口

（1）由于在同一台机器上搭建集群为了区分不同的服务实例名，更改域名映射：C:\Windows\System32\drivers\etc\hosts文件添加
127.0.0.1 eureka7001.com
127.0.0.1 eureka7002.com

（2）修改7001和7002的配置文件令其相互注册
7001

server.port=7001
#eureka服务端的实例名称 eureka7001.com
eureka.instance.hostname=eureka7001.com
#false表示不向注册中心注册自己
eureka.client.register-with-eureka=false
#false表示自己是注册中心，职责是维护服务实例，并不需要去检索服务
eureka.client.fetch-registry=false
#设置与eureka server交互的地址,查询服务和注册服务都需要依赖这个地址
eureka.client.service-url.defaultZone=http://eureka7002.com:7002/eureka/

7002

server.port=7002
#eureka服务端的实例名称 eureka7002.com
eureka.instance.hostname=eureka7002.com
#false表示不向注册中心注册自己
eureka.client.register-with-eureka=false
#false表示自己是注册中心，职责是维护服务实例，并不需要去检索服务
eureka.client.fetch-registry=false
#设置与eureka server交互的地址,查询服务和注册服务都需要依赖这个地址
eureka.client.service-url.defaultZone=http://eureka7001.com:7001/eureka/

二、将服务注册到集群中

（1）修改服务的配置文件，将eureka注册中心的地址由一个配置成两个，集群多个可配置多个，其他无需改动

#设置与eureka server交互的地址,查询服务和注册服务都需要依赖这个地址,,集群版
eureka.client.service-url.defaultZone=http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/

（3）eureka自我保护机制

概述：心跳机制：注册到eureka中的服务每30s会向中心发送一次心跳证明自己的服务是没有问题的，当eureka连续三次（90s）未收到该心跳eureka认为服务有问题不可用，会将该服务注销掉。
自我保护机制（默认开启）：Eureka服务端会检查最近15分钟内所有Eureka 实例正常心跳占比，如果低于85%就会触发自我保护机制。触发了保护机制，Eureka将暂时把这些失效的服务保护起来，不让其过期，但这些服务也并不是永远不会过期。Eureka在启动完成后，每隔60秒会检查一次服务健康状态，如果这些被保护起来失效的服务过一段时间后（默认90秒）还是没有恢复，就会把这些服务剔除。如果在此期间服务恢复了并且实例心跳占比高于85%时，就会自动关闭自我保护机制。
EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY’RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE.
该提示表示开启了自我保护机制
禁用自我保护机制配置：配置在服务端
eureka.server.enable-self-preservation=false
eureka客户端向服务端发送心跳的时间间隔配置，默认30s配置在客户端
eureka.instance.lease-renewal-interval-in-seconds=30
eureka服务端在收到最后一次心跳后等待的时间上限，默认90s，超时剔除配置在客户端
eureka.instance.lease-expiration-duration-in-seconds=90

8、服务提供者集群搭建

参考cloud-provider-payment8001创建cloud-provider-payment 8002模块来搭建集群，除了端口其他配置业务类都是一样，注册中心注册后展示如下：
CLOUD-PAYMENT-SERVICE n/a (2) (2) UP (2) - USER-20190123BS:cloud-payment-service:8002 , USER-20190123BS:cloud-payment-service:8001
eureka客户端配置可参考如下：

#是否向注册中心注册自己
eureka.client.register-with-eureka=true
#是否从注册中心拉取服务信息
eureka.client.fetch-registry=true
#在注册中心显示的服务名称
eureka.instance.instance-id=cloud-provider-payment8001
#为true时就可以将IP注册到Eureka Server上，而如果不配置就是机器的主机名，但上面有eureka.instance.instance-id起作用了
eureka.instance.prefer-ip-address=true
#注册中心地址，集群部署
eureka.client.service-url.defaultZone=http://192.168.0.128:7001/eureka/,http://192.168.0.129:7001/eureka/

9、zookeeper服务注册与发现

官方网站：https://zookeeper.apache.org/
启动zookeeper注意事项：需要将conf目录下的zoo.simple.cfg配置文件名改成zoo.cfg否则启动时会报找不到zoo.cfg文件错误

（1）服务提供者cloud-provider-payment8004注册到zookeeper

1、引入zookeeper依赖

<!-- springboot整合zookeeper客户端 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
    <version>2.2.0.RELEASE</version>
</dependency>

2、创建配置文件并添加配置

#服务端口
server.port=8004
#服务名称
spring.application.name=cloud-provider-payment
#zookeeper地址
spring.cloud.zookeeper.connect-string=localhost:2181

3、启动类

@SpringBootApplication
@EnableDiscoveryClient//该注解用于向适用consul/zookeeper/eureka作为注册中心时注册服务
public class PaymentMain8004 {
   

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

4、启动zookeeper启动服务查看控制台log注册成功

（2）服务消费者consumer注册到zookeeper

1、创建cloud-consumerzk-order80模块并修改pom文件

<!-- springboot整合zookeeper客户端 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
    <version>2.2.0.RELEASE</version>
</dependency>

2、修改配置文件

#服务端口
server.port=80
#服务名称
spring.application.name=cloud-consumer-order
#zookeeper地址
spring.cloud.zookeeper.connect-string=localhost:2181

3、创建启动类

@SpringBootApplication
@EnableDiscoveryClient
public class OrderZkMain80 {
   

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

4、创建业务类调用zookeeper中的服务端接口进行测试

@RestController
@RequestMapping("/order")
public class OrderController {
   
    @Autowired
    private RestTemplate restTemplate;
    private static final String URL="http://cloud-provider-payment";

    @GetMapping("/zk")
    public String zk(){
   
        return restTemplate.getForObject(URL+"/payment/zkp",String.class);
    }
}
注意使用restTemplate调用时创建该对象时一定要加负载均衡的注解@LoadBalanced否则调用不到，如下：
@Configuration
public class ApplicationContextConfig {
   

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

10、consul服务与注册

简介：
consul是一套开源的分布式服务发现和配置管理系统，使用GO语言开发，其提供了微服务系统中的服务治理、配置中心和控制总线等功能；这些功能可单独使用也可以一起使用，优点如：基于raft协议比较简洁，支持健康检查，同时支持HTTP和DNS协议，支持跨数据中心的WAN集群，提供图形界面，跨平台，支持linux、mac、windows系统（服务发现、健康监测、KV存储、多数据中心
和可视化界面等功能）
官网：https://consul.io/
中文教程：https://springcloud.cc/spring-cloud-consul.html

（1）consul服务服务端使用

下载后解压，使用consul agent –dev命令在cmd窗口启动consul，启动后访问http://localhost:8500是否成功

（2）服务提供者注册到consul

1、创建模块后修改pom文件引入consul依赖

<!-- springcloud consul server-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-consul-discovery</artifactId>
    <version>2.2.1.RELEASE</version>
</dependency>

2、创建配置文件并添加配置

server.port=8006
spring.application.name=consul-provider-payment
#consul注册中心地址
spring.cloud.consul.host=localhost
spring.cloud.consul.port=8500
spring.cloud.consul.discovery.service-name=${spring.application.name}

3、创建启动类并添加注解

@SpringBootApplication
@EnableDiscoveryClient
public class PaymentMain8006 {
   

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

4、创建业务类测试

@RestController
@RequestMapping("/payment")
public class PaymentController {
   
    private Logger log = LoggerFactory.getLogger(PaymentController.class);
    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/consul")
    public String consul() {
   
        return "springcloud with consul :" + serverPort + "," + UUID.randomUUID().toString();
    }
}

5、启动服务查看consul的界面
访问地址：http://localhsot:8500
6、消费者服务同zookeeper一样

11、CAP理论

CAP理论关注的粒度是数据，而不是整体系统设计的策略
C：Consistency 强一致性:⼀个分布式系统中各个结点之间能及时的同步数据，在数据同步过程中，是不能对外提供服务的，不然就会造成数据不⼀致，所以强⼀致性和可⽤性是不能同时满⾜的。
A：Availability 可用性:⼀个分布式系统对外要保证可⽤。
P：Partition tolerance 分区容错性:⼀个系统虽然是分布式的，但是对外看上去应该是⼀个整体，不能由于分布式系统内部的某个结点挂点，或⽹络出现了故障，⽽导致系统对外出现异常。所以，对于分布式系统⽽⾔是⼀定要保证分区容错性的。
在一个系统中最多只能同时较好的满足两个，这也是CAP理论的核心即一个分布式系统不可能同时很好的满足一致性、可用性和分区容错性这三个需求。
CA:单点集群，满足一致性、可用性的系统，通常在可扩展上不太强大；
CP:满足一致性、分区容错性的系统，通常性能不是特别高；
AP:满足可用性、分区容错性的系统，通常可能对一致性要求低一些。
Eureka实现了AP，zookeeper和consul实现了CP

12、Ribbon负载均衡
一、简介：

Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡工具（所以应配置在客户端）。
Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法和服务调用，Ribbon客户端组件提供一系列完善的配置如连接超时、重试等。简单的说就是在配置文件中列出Load Balancer（简称LB）后面所有的机器，Ribbon会自动帮助你基于某种规则（如轮询、随机连接等）去连接这些机器，很容易使用Ribbon实现自定义的负载均衡算法。
Ribbon = 负载均衡+RestTemplate调用
LB（负载均衡）定义：就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA（高可用）。
Ribbon负载均衡与Nginx负载均衡的区别：
nginx是服务器负载均衡，客户端所有请求都会交给nginx然后由nginx实现请求转发，即负载均衡是由服务端实现的。
Ribbon本地负载均衡，在调用服务接口的时候，会在注册中心上获取注册信息服务列表后缓存到JVM本地，从而在本地实现RPC远程服务调用技术。

二、客户端使用Ribbon实现负载均衡

（1）pom中引入ribbon依赖
注意新版本的spring-cloud-starter-netflix-eureka-client中已经引入了ribbon的依赖，所以不引入可以，若引入如下：

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

（2）LoadBalance注解+RestTemplate实现负载均衡
注入restTemplate对象到容器

@Configuration
public class ApplicationContextConfig {
   
    @Bean
    @LoadBalanced//赋予RestTemplate负载均衡的能力，因服务提供者目前是集群模式
   public RestTemplate getRestTemplate(){
   
       return new RestTemplate();
   }
}

使用实现负载均衡

@GetMapping("/payment/get/{id}")
public CommonResult getPayment(@PathVariable("id") Long id){
   
   return restTemplate.getForObject(PAYMENT_URL + "/payment/get/" + id,CommonResult.class);
}
/**
 * restTemplate.getForObject/postForObject响应对象为响应体中数据转换成的对象，可理解为是json
 * restTemplate.getForEntity/postForEntity返回对象为ResponseEntity对象，包含了响应信息中重要的信息比如
 * 响应头、响应状态码、响应体等。
 */
@GetMapping("/payment/getEntity/{id}")
public CommonResult getPayment2(@PathVariable("id") Long id){
   
    ResponseEntity<CommonResult> entity = restTemplate.getForEntity(PAYMENT_URL + "/payment/get/" + id, CommonResult.class);
    log.info("响应头********:"+entity.getHeaders());
    log.info("响应状态********:"+entity.getStatusCode());
    log.info("响应状态值********:"+entity.getStatusCodeValue());
    log.info("响应体********:"+entity.getBody());
    return entity.getBody();
}

三、Ribbon负载均衡策略

顶层接口为IRule，其中包含三个方法分别为choose、setLoadBalancer和getLoadBalancer方法。

1、七种负载均衡策略

（1）com.netflix.loadbalancer. RoundRobinRule 轮询 默认规则
按照注册中心服务列表中的所有服务进行轮询调用
（2）com.netflix.loadbalancer.RandomRule 随机
按照注册中心服务列表中的所有服务进行随机调用
（3）com.netflix.loadbalancer.RetryRule 重试
先按照RandomRule的策略获取服务，如果获取服务失败则在指定时间内进行重试，获取可用的服务。
（4）com.netflix.loadbalancer.WeightedResponseTimeRule 响应时间权重
对RoundRobinRule的扩展，响应速度越快的实例选择权重越大，越容易被选择。
（5）com.netflix.loadbalancer.BestAvailableRule
会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，然后选择一个并发量最小的服务。（即先过故障实例在从可用的服务中选择一个并发量最小的服务进行调用）
（6）com.netflix.loadbalancer.AvailabilityFilteringRule
先过滤掉故障实例，在选择并发较小的实例
（7）com.netflix.loadbalancer.ZoneAvoidanceRule
复合判断server所在区域的性能和server的可用性选择服务器

2、替换负载均衡策略

Ribbon默认使用轮询的负载均衡策略

（1）使用配置类替换默认的随机策略

注意：官方明确提示了ribbon的选择负载均衡策略的自定义类不能放在ComponentScan注解所能扫描的当前包及子包下（即启动类所在包及子包（因为启动类中的SpringBootApplication注解包含了ComponentScan注解）），否则配置类会被所有的ribbon客户端所共享，不能达到特殊化定制的目的。所以需要重新创建包进行类的配置
启动类所在包路径：com.yang.springcloud
自定义配置类所在包路径:com.yang.myrule

1、自定义配置类如下：

/**
 * 选择ribbon负载均衡策略的自定义配置类
 */
@Configuration
public class MySelfRule {
   
    @Bean
    public IRule myRule(){
   
//想用哪种创建哪种策略的对象即可
        return new RandomRule();//随机策略
    }
}

2、启动类添加RibbonClient注解并指定具体服务使用的具体负载均衡策略自定义配置类

/**
 * 客户端消费者
 */
@SpringBootApplication
@EnableEurekaClient//注册至eureka
@RibbonClient(name = "CLOUD-PAYMENT-SERVICE",configuration = MySelfRule.class)
public class OrderMain80 {
   

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

（2）轮询算法原理

算法：rest接口第几次请求数 % 服务器集群总数量 = 实际调用服务器位置下标，，，，，每次服务重启后rest接口计数从1开始
List instances =
discoveryClient.getInstances(“注册在注册中心的服务名”);
服务器集群总数量=2
第一次请求 1%2=0 调用list[0]的服务
第二次请求 2%2=1 调用list[1]的服务
第三次请求 3%2=0 调用list[0]的服务
一次类推。。。。。

13、OpenFeign服务调用
一、简介：

Feign是一个声明式WebService客户端，Feign能让编写Web Service客户端更加简单。它的使用方法是定义一个服务接口之后再上面添加注解。Feign也支持插拔式的编码器和解码器。SpringCloud对Feign进行了封装使其支持了SpringMVC的标准注解如@RequestMapping等（OpenFeign的@FeignClient可以解析springMvc的@RequestMapping注解下的接口并通过动态代理的方式产生实现类，实现类中做负载均衡并调用服务）和HttpMessageConverters，Feign可以与Eureka和Ribbon组合使用以支持负载均衡。
同时Feign集成了Ribbon，利用Ribbon维护了服务列表信息，并且通过默认的策略轮询实现客户端的负载均衡，与Ribbon不同的是通过Feign只需要定义服务绑定接口且以声明式的方法即实现优雅而简单的服务调用，因为使用Ribbon还需要结合RestTemplate一起调用服务。

二、Feign服务调用的使用，使用在消费端
1、创建feign接口实现远程调用并实现负载均衡

（1）引入openFeign的依赖
默认已经集成了ribbon

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

（2）创建配置文件配置注册中心内容

server.port=80

spring.application.name=cloud-order-feignService

#表示是否将自己注册到eurekaServer中
eureka.client.register-with-eureka=true
#是否从EurekaServer抓取自己的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配置ribbon使用负载均衡
eureka.client.fetch-registry=true
#配置服务实例名称，不在显示主机名+注册的服务名+端口例USER-20190123BS:CLOUD-ORDER-SERVICE:80
#即eureka界面Status下面的显示内容
eureka.instance.instance-id=orderFeign80
#访问路径显示ip地址,即将鼠标放在上面实例名子上时会显示具体的ip地址
eureka.instance.prefer-ip-address=true
#设置与eureka server交互的地址,查询服务和注册服务都需要依赖这个地址
#eureka.client.service-url.defaultZone=http://eureka7001.com:7001/eureka/ 单机版
eureka.client.service-url.defaultZone=http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/

（3）创建启动类并添加开启feign的注解

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients//开启feign
public class OrderFeignMain80 {
   

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

（4）创建feign接口并指定服务名称和请求的方法

@Component
@FeignClient(name = "CLOUD-PAYMENT-SERVICE")
public interface PaymentFeignService {
   

    /**
     * 注意，在feign接口中使用@PathVariable注解一定要加别名，否则报错
     * 而且映射路径需要写全路径（包括类上定义的映射路径+方法上定义的映射路径）
     */
    @GetMapping("/payment/get/{id}")
    CommonResult getPayment(@PathVariable("id") Long id);
}

(5)实现调用查看结果

@RestController
public class OrderFeignController {
   

    @Autowired
    private PaymentFeignService paymentFeignService;

    @GetMapping("/consumer/feignOrder/{id}")
    public CommonResult feignOrder(@PathVariable String id){
   
        CommonResult commonResult = paymentFeignService.getPayment(id);
        return commonResult;
    }
}
http://localhost//consumer/feignOrder/1正确返回结果

2、feign超时控制

Feign客户端默认的超时时间是1s，通过以下配置可重新设置超时时间：单位为ms
#设置feign服务调用的超时时间默认集成了Ribbon
#指的是建立连接所用的时间，使用于网络状况正常的情况下两端连接所用时间
ribbon.ConnectTimeout=5000
#指的是建立连接后服务器读取到可用资源所用的时间
ribbon.ReadTimeout=5000
#Feign开启熔断
feign.hystrix.enabled=true
#设置超时熔断时间（spring-cloud-starter-openfeign中的HystrixCommandProperties默认为1000毫秒）
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=6000

3、OpenFeign日志增强
（1）简介

Feign提供了日志打印功能，我们可通过配置来调整日志级别，从而了解feign中http的请求细节，即对feign接