SpringCloud(Hoxton.SR7版alibaba)初级篇

编程入门行业动态更新时间:2024-10-12 16:30:15

SpringCloud(<a href=https://www.elefans.com/category/jswz/34/626674.html style= Hoxton.SR7版alibaba)初级篇"/>

SpringCloud(Hoxton.SR7版alibaba)初级篇

周阳微服务架构与SpringCloud

SrpringCloud：分布式微服务架构的一站式解决方案，是多种微服务架构落地技术的集合体，俗称微服务全家桶。
SpringCloud大集合：

服务注册与发现
服务调用
服务熔断
负载均衡
服务降级
服务消息队列
配置中心管理
服务网关
服务监控
全链路追踪
自动化构建部署
服务定时任务调度操作

Cloud升级，之前的一些技术停更，可以换成别的

技术	版本
cloud	Hoxton.SR7
boot	2.3.2.RELEASE
cloud alibaba	2.1.0.RELEASE
java	java8
Maven	3.5及以上
Mysql	5.7及以上

一、新建父项目

1.1. 新建Maven父工程 cloud2020

1.2. 选择模板 org.apache.maven.archetypes:maven-archetypes-site

1.3、选择项目字符编码setting->editor->file Encodings ->将所有字符编码全部换成 utf-8

1.4、支持注解setting->Build,Execution,Deployment->Compiler->Annotation Processors 内的 Enable annotation processing 打上勾表示能够使用注解。

1.5、更改编译版本setting->Build,Execution,Deployment->Compiler->Java Compiler 下 Pe-module butecode version 框内的编译版本换成 8

1.6、File Type过滤

二、父工程POM

maven架构选择org.apache.maven.archetypes:maven-archetype-site
pom.xml代码如下

<?xml version="1.0" encoding="UTF-8"?><project xmlns=".0.0" xmlns:xsi=""xsi:schemaLocation=".0.0 .0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.atguigu.springcloud</groupId><artifactId>cloud2020</artifactId><version>1.0-SNAPSHOT</version><packaging>pom</packaging><modules><module>cloud-provider-payment8001</module><module>cloud-consumer-order80</module><module>cloud-consumer-order80</module></modules><!--统一管理jar包版本--><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><mavenpiler.source>1.8</mavenpiler.source><mavenpiler.target>1.8</mavenpiler.target><junit.version>4.12</junit.version><log4j.version>1.2.17</log4j.version><lombok.version>1.16.18</lombok.version><mysql.version>5.1.47</mysql.version><druid.verison>1.1.16</druid.verison><mybatis.spring.boot.verison>1.3.0</mybatis.spring.boot.verison></properties><!--子模块继承之后，提供作用：锁定版本+子modlue不用写groupId和version--><dependencyManagement><dependencies><!--spring boot 2.3.2--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-dependencies</artifactId><version>2.3.2.RELEASE</version><type>pom</type><scope>import</scope></dependency><!--spring cloud Hoxton.SR7--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-dependencies</artifactId><version>Hoxton.SR7</version><type>pom</type><scope>import</scope></dependency><!--spring cloud alibaba 2.1.0.RELEASE--><dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-alibaba-dependencies</artifactId><version>2.2.0.RELEASE</version><type>pom</type><scope>import</scope></dependency><!-- MySql --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>${mysql.version}</version></dependency><!-- Druid --><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId><version>${druid.verison}</version></dependency><!-- mybatis-springboot整合 --><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>${mybatis.spring.boot.verison}</version></dependency><!--lombok--><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>${lombok.version}</version></dependency><!--junit--><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>${junit.version}</version></dependency><!-- log4j --><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>${log4j.version}</version></dependency></dependencies></dependencyManagement><build><finalName>cloud2020</finalName><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><version>2.3.2.RELEASE</version><configuration><fork>true</fork><addResources>true</addResources></configuration></plugin></plugins></build></project>

三、微服务模块

1、建module

2、改pom

3、写yum

4、主动类

5、业务类

1. 建立支付module: cloud-provider-payment8001

1.1项目结构目录如下：

1.2 pom.xml如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns=".0.0"xmlns:xsi=""xsi:schemaLocation=".0.0 .0.0.xsd"><parent><artifactId>cloud2020</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>cloud-provider-payment8001</artifactId><dependencies><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.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId><version>1.1.10</version></dependency><!--mysql-connector-java--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency><!--jdbc--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope><optional>true</optional></dependency></dependencies>
</project>

1.3 application.yml

server:port: 8001spring:application:name: cloud-payment-servicedatasource:type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包url: jdbc:mysql://localhost:3306/db2019?useUnicode=true&characterEncoding=utf-8&useSSL=falseusername: rootpassword:mybatis:mapperLocations: classpath:mapper/*.xmltype-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包logging:config: classpath:logback.xmllevel:com.atguigu.springcloud.dao: debug       #开启日志的feign接口文件夹   feign日志以什么级别监控哪个接口

1.4 主启动类 PaymentMain8001

package com.atguigu.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class PaymentMain8001 {public static void main(String[] args) {SpringApplication.run(PaymentMain8001.class,args);}}

1.5 数据库

建库：

CREATE TABLE `payment`(`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',`serial` varchar(200) DEFAULT '',PRIMARY KEY (`id`)
) ENGING=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8

1.6 业务类

//主实体类 Payment
package com.atguigu.springcloud.entities;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment {private Long id;private String serial;}

//Json封装体CommentResult,传给前端，判断编码是否成功，成功才显示
package com.atguigu.springcloud.entities;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T> {  //泛型：如果装的payment 返回payment,装的order 返回orderprivate Integer code;private String message;private T data;public CommonResult(Integer code,String message){this(code,message,null);}
}

//PaymentDao
package com.atguigu.springcloud.dao;
import com.atguigu.springcloud.entities.Payment;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;@Mapper
public interface PaymentDao {int create(Payment payment);Payment getPaymentById(@Param("id") Long id);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis//DTD Mapper 3.0//EN"".dtd">
<mapper namespace="com.atguigu.springcloud.dao.PaymentDao"><insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">insert into payment(serial) values(#{serial})</insert><resultMap id="BaseResultMap" type="com.atguigu.springcloud.entities.Payment"><id column="id" property="id" jdbcType="BIGINT"/><result column="serial" property="serial" jdbcType="VARCHAR"/></resultMap><select id="getPaymentById" parameterType="Long" resultMap="BaseResultMap">select * from payment where id=#{id};</select>
</mapper>

//PaymentService
package com.atguigu.springcloud.service;
import com.atguigu.springcloud.entities.Payment;
import org.apache.ibatis.annotations.Param;
public interface PaymentService {public int create(Payment payment);public Payment getPaymentById(@Param("id") Long id);
}

//PaymentServiceImpl
package com.atguigu.springcloud.service;
import com.atguigu.springcloud.dao.PaymentDao;
import com.atguigu.springcloud.entities.Payment;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
public class PaymentServiceImpl implements PaymentService{@Resourceprivate PaymentDao paymentDao;public int create(Payment payment){return paymentDao.create(payment);}public Payment getPaymentById(Long id){return paymentDao.getPaymentById(id);}
}

//PaymentController
package com.atguigu.springcloud.controller;import com.atguigu.springcloud.entities.CommonResult;
import com.atguigu.springcloud.entities.Payment;
import com.atguigu.springcloud.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
@RestController
@Slf4j
public class PaymentController {@Resourceprivate PaymentService paymentService;//只传给前端CommonResult，不需要前端了解其他的组件@PostMapping(value = "/payment/create")public CommonResult create(Payment payment){int result = paymentService.create(payment);log.info("*****插入结果："+result);if(result > 0){return new CommonResult(200,"插入数据成功",result);}else{return new CommonResult(444,"插入数据失败",null);}}@GetMapping(value = "/payment/get/{id}")public CommonResult getPaymentById(@PathVariable("id") Long id){Payment payment = paymentService.getPaymentById(id);log.info("*****插入结果："+payment);if(payment != null){return new CommonResult(200,"查询成功",payment);}else{return new CommonResult(444,"没有对应记录,查询ID："+id,null);}}
}

1.7测试

Chrom浏览器可能不支持Post请求，可以使用PostMan工具测试

总结： 1. 建module 2. 改pom 3. 写yml 4. 主启动 5. 业务类

2、热部署Devtools

1、添加devtools依赖到项目里

        <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope><optional>true</optional></dependency>

2、添加maven插件到父类的pom文件里(Spring Boot Maven plugin能够将Spring Boot应用打包为可执行的jar或war文件，然后以通常的方式运行Spring Boot应用)

  <build><finalName>cloud2020</finalName><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><version>2.3.2.RELEASE</version><configuration><fork>true</fork><addResources>true</addResources></configuration></plugin></plugins></build>

3、开启自动编译

更新

3. 建立消费者订单module:

3.1 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns=".0.0"xmlns:xsi=""xsi:schemaLocation=".0.0 .0.0.xsd"><parent><artifactId>cloud2020</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>cloud-consumer-order80</artifactId><dependencies><!--引入自己的公共api--><dependency><groupId>com.wxh.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>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId></dependency><!--eureka-client--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-client</artifactId></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-zipkin</artifactId></dependency></dependencies></project>

3.2 application.yml

server:port: 80
eureka:client:register-with-eureka: false    #表示是否将自己注册进EurekaServer默认为true。fetchRegistry: true            #是否从EurekaServer抓取已有的注册信息，默认为true。fetchRegistry等同于 fetch-registry 单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡

3.3 主启动

package com.atguigu.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class OrderMain80 {public static void main(String[] args) {SpringApplication.run(OrderMain80.class,args);}
}

3.4业务类

订单也需要Payment、CommonResult实体类，但是不需要操作数据库，没有Service、Dao，只需添加Controller即可。

//Payment
package com.atguigu.springcloud.entities;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment {private Long id;private String serial;
}

//CommonResult
package com.atguigu.springcloud.entities;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T> {  //泛型：如果装的payment 返回payment,装的order 返回orderprivate Integer code;private String message;private T data;public CommonResult(Integer code,String message){this(code,message,null);}
}

首说RestTemplate： RestTemplate提供了多种便捷访问远程Http服务的方法，是一种简单便捷的访问restful服务模板类，是Spring提供的用于访问Rest服务的客户端模板工具集，实现80到8001的远程调用。
官网地址：
.2.2.RELEASE/javadoc-api/org/springframework/web/client/RestTemplate.html
使用：
使用restTemplate访问restful接口非常的简单粗暴，（url、requestMap、ResponseBean.class）这三个参数分别代表REST请求地址、请求参数、HTTP响应转换被转换成的对象类型。

将RestTemplate对象注册到容器中

package com.atguigu.springcloud.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;@Configuration
public class ApplicationContextConfig {@Beanpublic RestTemplate getRestTemplate(){return new RestTemplate();}
}

package com.atguigu.springcloud.controller;
import com.atguigu.springcloud.entities.CommonResult;
import com.atguigu.springcloud.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import javax.annotation.Resource;@RestController
@Slf4j
public class OrderController {private static final String PAYMENT_URL="http://localhost:8001";@Resourceprivate RestTemplate restTemplate;@GetMapping("/consumer/payment/create")public CommonResult<Payment> create(Payment payment){return restTemplate.postForObject(PAYMENT_URL+"/payment/create",payment,CommonResult.class);}@GetMapping("/consumer/payment/get/{id}")public CommonResult<Payment> getPayment(@PathVariable("id") Long id){return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);}
}

3.5启动80、8001服务，测试

80服务调用8001服务，实现效果如下：

查询：
添加：

浏览器并没有返回错误，但是我们来看数据库：

可以看到数据库只插入主键，并没有插入内容，要在8001的PaymentController加@RequestBody注解。

然后就可以插入了

3.6、rundashbroad （现在叫做services）

运用spring cloud框架基于spring boot构建微服务，一般需要启动多个应用程序，在idea开发工具中，多个同时启动的应用

需要在RunDashboard运行仪表盘中可以更好的管理，但有时候idea中的RunDashboard窗口没有显示出来，也找不到直接的开启按钮

idea中打开Run Dashboard的方法如下

　　　　view > Tool Windows > Run Dashboard

如果上述列表找不到Run Dashboard,则可以在工程目录下找到.idea文件夹下的workspace.xml，在其中相应位置加入以下代码（替换）即可：

<component name="RunDashboard">
<option name="configurationTypes"><set><option value="SpringBootApplicationConfigurationType"/></set>
</option>
<option name="ruleStates"><list><RuleState><option name="name" value="ConfigurationTypeDashboardGroupingRule"/></RuleState><RuleState><option name="name" value="StatusDashboardGroupingRule"/></RuleState></list>
</option>
</component>

关闭重启后出现。

四、工程重构

项目中存在相同的代码（entities包下的Payment.class和CommonResult.class）,造成代码冗余，可以进行重构。
通过Maven聚合父工程，把相同重复的代码移到公开公用的工程里面，还可以放第三方接口、工具类，统一调配使用。

1 、建立公共module cloud-api-commons

2 、pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns=".0.0"xmlns:xsi=""xsi:schemaLocation=".0.0 .0.0.xsd"><parent><artifactId>cloud2020</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>cloud-api-commons</artifactId><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope><optional>true</optional></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><!-- .hutool/hutool-all --><dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artifactId><version>5.4.1</version></dependency></dependencies>
</project>

3 、将消费者和服务者中的entities拷贝至新模块中，删除原来的entities包，clean、install cloud-api-commons 模块，在消费者、服务者pom.xml中分别引入依赖，测试运行。

4、使用Maven打包发布上传到公用本地库里

打开Maven窗口，执行clean测试一下，无误后出现BUILD SUCCESS，然后执行install

5、删除重复entities，引入maven install的jar包坐标即可使用。

<!--引入自己定义的api通用包，可以使用Payment支付Entity-->
<dependency><groupId>com.atguigu</groupId><artifactId>cloud-api-commons</artifactId><version>1.0-SNAPSHOT</version>
</dependency>

五、EurekaServer服务端安装

1、Eureka是什么

Eureka 是 Netflix 开发的，一个基于 REST 服务的，服务注册与发现的组件，以实现中间层服务器的负载平衡和故障转移。

它主要包括两个组件：Eureka Server 和 Eureka Client

Eureka Client：一个Java客户端，用于简化与 Eureka Server 的交互（通常就是微服务中的客户端和服务端）
Eureka Server：提供服务注册和发现的能力（通常就是微服务中的注册中心）

服务在Eureka上注册，然后每隔30秒发送心跳来更新它们的租约。如果客户端不能多次续订租约，那么它将在大约90秒内从服务器注册表中剔除。注册信息和更新被复制到集群中的所有eureka节点。来自任何区域的客户端都可以查找注册表信息（每30秒发生一次）来定位它们的服务（可能在任何区域）并进行远程调用

2、 Eureka 客户端与服务器之间的通信

服务发现有两种模式：一种是客户端发现模式，一种是服务端发现模式。Eureka采用的是客户端发现模式。

2.1. Register（注册）

Eureka客户端将关于运行实例的信息注册到Eureka服务器。注册发生在第一次心跳。

2.2. Renew（更新 / 续借）

Eureka客户端需要更新最新注册信息（续借），通过每30秒发送一次心跳。更新通知是为了告诉Eureka服务器实例仍然存活。如果服务器在90秒内没有看到更新，它会将实例从注册表中删除。建议不要更改更新间隔，因为服务器使用该信息来确定客户机与服务器之间的通信是否存在广泛传播的问题。

2.3. Fetch Registry（抓取注册信息）

Eureka客户端从服务器获取注册表信息并在本地缓存。之后，客户端使用这些信息来查找其他服务。通过在上一个获取周期和当前获取周期之间获取增量更新，这些信息会定期更新(每30秒更新一次)。获取的时候可能返回相同的实例。Eureka客户端自动处理重复信息。

2.4. Cancel（取消）

Eureka客户端在关机时向Eureka服务器发送一个取消请求。这将从服务器的实例注册表中删除实例，从而有效地将实例从流量中取出。

3、Eureka自我保护模式

如果 Eureka 服务器检测到超过预期数量的注册客户端以一种不优雅的方式终止了连接，并且同时正在等待被驱逐，那么它们将进入自我保护模式。这样做是为了确保灾难性网络事件不会擦除eureka注册表数据，并将其向下传播到所有客户端。

任何客户端，如果连续3次心跳更新失败，那么它将被视为非正常终止，病句将被剔除。当超过当前注册实例15%的客户端都处于这种状态，那么自我保护将被开启。

当自我保护开启以后，eureka服务器将停止剔除所有实例，直到：

它看到的心跳续借的数量回到了预期的阈值之上，或者
自我保护被禁用

默认情况下，自我保护是启用的，并且，默认的阈值是要大于当前注册数量的15%

4、Eureka VS Zookeeper

4.1. Eureka保证AP

Eureka服务器节点之间是对等的，只要有一个节点在，就可以正常提供服务。

Eureka客户端的所有操作可能需要一段时间才能在Eureka服务器中反映出来，随后在其他Eureka客户端中反映出来。也就是说，客户端获取到的注册信息可能不是最新的，它并不保证强一致性

4.2. Zookeeper保证CP

Zookeeper集群中有一个Leader，多个Follower。Leader负责写，Follower负责读，ZK客户端连接到任何一个节点都是一样的，写操作完成以后要同步给所有Follower以后才会返回。如果Leader挂了，那么重新选出新的Leader，在此期间服务不可用。

4.3. 为什么用Eureka

分布式系统大都可以归结为两个问题：数据一致性和防止单点故障。而作为注册中心的话，即使在一段时间内不一致，也不会有太大影响，所以在A和C之间选择A是比较适合该场景的。

1、建module cloud-eureka-server7001

2、 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns=".0.0"xmlns:xsi=""xsi:schemaLocation=".0.0 .0.0.xsd"><parent><artifactId>cloud2020</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>cloud-eureka-server7001</artifactId><dependencies><!--eureka server--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-server</artifactId></dependency><!--引入自己定义的api通用包，可以使用payment支付Entity--><dependency><groupId>com.atguigu</groupId><artifactId>cloud-api-commons</artifactId><version>1.0-SNAPSHOT</version></dependency><!--boot web actuator--><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>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId></dependency></dependencies>
</project>

3 、application.yml

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

4 、主启动类

package com.atguigu.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloudflix.eureka.server.EnableEurekaServer;@SpringBootApplication
@EnableEurekaServer
public class EurekaMain7001 {public static void main(String[] args) {SpringApplication.run(EurekaMain7001.class,args);}
}

这是个服务注册中心，主要干的活就是服务注册，不需要写业务类。
但是注意：Eureka有两个组件，一定要标清楚哪个是Server，哪个是Client。@EnableEurekaServer代表服务注册中心

5、测试

出现上面图标，表示Eureka 服务端安装成功。No instances available表示当前没有服务注册进来

六、单机Eureka构建：支付微服务8001入驻进eurekaServer7001

1、将 Eureka-client 依赖引入，便于使用注解@EnableEurekaClient标注这是个Eureka Client端

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

2、在application.yml添加Eureka相关配置

eureka:client:#表示是否将自己注册进EurekaServer默认为trueregister-with-eureka: true#是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡fetch-registry: trueservice-url:defaultZone: http://localhost:7001/eureka

3、主启动类添加注解@EnableEurekaClient

4、测试

注意： 要先启动EurekaServer

这样就注册进来了，入住进Eureka服务器的名称就是8001yml中配置的spring.application.name。红色警告是Eureka的自我保护机制，后面会详细说。

七、单机Eureka构建：订单微服务80入驻进eurekaServer7001

1、在80的pom添加 Eureka-client依赖

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

2、在application.yml添加相关配置

spring:application:name: cloud-order-servereureka:client:#表示是否将自己注册进EurekaServer默认为trueregister-with-eureka: truefetch-registry: trueservice-url:defaultZone: http://localhost:7001/eureka

3、主启动类添加注解@EnableEurekaClient

4、测试

PS： 先启动EurekaServer，7001服务，再启动服务提供者provider，8001服务

cloud-order-server服务以入住，查询功能也可以正常执行

八、EurekaServer集群环境构建

1、创建module cloud-eureka-server7002

2、 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns=".0.0"xmlns:xsi=""xsi:schemaLocation=".0.0 .0.0.xsd"><parent><artifactId>cloud2020</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>cloud-eureka-server7002</artifactId><dependencies><!--eureka server--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-server</artifactId></dependency><!--引入自己定义的api通用包，可以使用payment支付Entity--><dependency><groupId>com.atguigu</groupId><artifactId>cloud-api-commons</artifactId><version>1.0-SNAPSHOT</version></dependency><!--boot web actuator--><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>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId></dependency></dependencies></project>

3、写yml之前修改映射文件

找到 C:\Windows\System32\drivers\etc路径下的hosts文件

修改映射配置添加进hosts文件

4、修改7001application.yml

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

修改7002项目 applicaton.yml

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

5、主启动类

package com.atguigu.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloudflix.eureka.EnableEurekaClient;@SpringBootApplication
@EnableEurekaServer
public class EurekaMain7002 {public static void main(String[] args) {SpringApplication.run(EurekaMain7002.class,args);}
}

6、测试

启动7001、7002

使用域名映射：

同时看到Eureka图标，且7001指着7002，7002指着7001，说明Eureka集群搭建成功。

九、将两个微服务发布到Eureka集群配置中

修改8001的application.yml

修改80的application.yml

测试

PS： 先启动EurekaServer，7001/7002服务；再启动服务提供者provider，8001；再启动消费者，80

现在，就已经把支付服务8001、订单服务80注册进Eureka集群环境，调用也OK。

十、支付提供者8001集群环境搭建

1、创建module cloud-provider-payment8002

2、 pom.xml 同8001的 pom.xml 一样

3、写application.yml，注意改端口

4、主启动类和业务类直接从8001拷贝

5、修改8001和8002的controller，默认的负载均衡方式是轮询，看执行查询具体调用那台provider

6 、测试

PS： 启动顺序：7001、7002、8001、8002、80

8001和8002也都访问正常，那如果我们用80访问呢？发现怎么刷新都是8001，这是因为我们的源程序地址是写死的：

单机版写死是没有问题的，但是现在有8001、8002了，所有不应该再关注具体的IP和端口，而是只认服务名称。代码修改为一下在试。

@RestController
@Slf4j
public class OrderController {public static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";@Autowiredprivate RestTemplate restTemplate;@GetMapping("/consumer/payment/create")public CommonResult<Payment> create(Payment payment) {return restTemplate.postForObject(PAYMENT_URL + "/payment/create", payment, CommonResult.class);}@GetMapping("/consumer/payment/get/{id}")public CommonResult<Payment> getPayment(@PathVariable("id")String id){return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);}
}

发现报错了，现在对外暴露的不再是地址和端口，只认微服务名称了，可是微服务并不知道下面有几个，找不到这个主机名称，需要使用#LoadBalanced注解开启RestTemplate负载均衡功能。
提前说一下：这个就是后面要介绍的Ribbon负载均衡功能。

然后测试，多次刷新，就会发现8001、8002端口交替出现。

这样Ribbon和Eureka整合后Consumer可以直接调用服务而不用再关心地址和端口号，且该服务还有负载均衡功能了。O(∩_∩)O

这个架构是初级篇里面的重点，务必要学会，难的是后面的Alibaba的Nacos，也有服务注册和配置中心，Alibaba Nacos集群就比这个复杂了

7、acturator微服务信息完善

7.1主机名称：服务名称的修改

状态启动

7.2、显示服务的ip地址

十一、服务发现Discovery

1、对于注册进eureka里面的微服务，可以通过服务发现来获得该服务的信息

package com.atguigu.springcloud.controller;import com.atguigu.springcloud.entities.CommonResult;
import com.atguigu.springcloud.entities.Payment;
import com.atguigu.springcloud.service.PaymentService;
import comflix.appinfo.InstanceInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;
import java.util.List;/*** @author wts* @date 2020/8/29 22:03*/
@RestController
@Slf4j
public class PaymentController {@Autowiredprivate PaymentService paymentService;@Autowiredprivate DiscoveryClient discoveryClient;@Value("${server.port}")private String serverPort;@PostMapping(value = "/payment/create")public CommonResult create(@RequestBody Payment payment){int result = paymentService.create(payment);log.info("*****插入结果："+result);if (result > 0){return new CommonResult(200,"插入数据库成功,serverPort:"+serverPort,result);}else {return new CommonResult(444,"插入数据库失败");}}@GetMapping(value = "/payment/get/{id}")public CommonResult getPaymentById(@PathVariable("id") Long id){Payment payment = paymentService.getPaymentById(id);log.info("*****查询结果1111："+payment);if (!StringUtils.isEmpty(payment)){return new CommonResult(200,"查询成功,serverPort:"+serverPort,payment);}else {return new CommonResult(444,"没有对应记录");}}@GetMapping(value = "/payment/discovery")public Object discovery(){List<String> services = discoveryClient.getServices();for (String service : services) {log.info("service====="+services);}List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");for (ServiceInstance instance: instances) {log.info(instance.getInstanceId()+"\t"+instance.getHost()+"\t"+instance.getUri()+"\t"+instance.getPort());}return this.discoveryClient;}
}

十二、Eureka的自我保护机制

为什么会产生自我保护机制？

为防止EurekaClient可以正常运行，但是与EurekaServer网络不同的情况下，EurekaServer不会立刻将EurekaClient服务剔除。

什么是自我保护机制？

默认情况下，当Eureka server在一定时间内没有收到实例的心跳，便会把该实例从注册表中删除（默认是90秒），但是，如果短时间内丢失大量的实例心跳，便会触发eureka server的自我保护机制。

比如在开发测试时，需要频繁地重启微服务实例，但是我们很少会把eureka server一起重启（因为在开发过程中不会修改eureka注册中心），当一分钟内收到的心跳数大量减少时，会触发该保护机制。可以在eureka管理界面看到Renews threshold和Renews(last min)，当后者（最后一分钟收到的心跳数）小于前者（心跳阈值）的时候，触发保护机制，会出现红色的警告：

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

从警告中可以看到，eureka认为虽然收不到实例的心跳，但它认为实例还是健康的，eureka会保护这些实例，不会把它们从注册表中删掉。

在自我保护模式中，EurekaServer会保护服务注册表中的信息，不再注销任何服务实例。

综上，自我保护模式是一种应对网络异常的安全保护措施它的架构哲学是宁可同时保留所有微服务，也不忙保姆注销如何健康的微服务，使用自我保护模式，可以让Eureka集群更加健壮，稳定。

署于CAP 的AP分支。

如何禁止自我保护机制

服务提供者：

lease-renewal-interval-in-seconds: 1 # eureka客户端向服务端发送心跳的时间间隔单位秒默认30
lease-expiration-duration-in-seconds: 2 # eureka服务端再收到最后一下心跳等待时间上线单位为秒（默认90秒），超时将踢出服务

server:
enable-self-preservation: false # 关闭自我保护机制保证不可用服务及时清除
eviction-interval-timer-in-ms: 2000

现在只有8001注册到7001中（7001改为单击模式），关闭8001的时候直接清除注册服务

十三、springboot 整合zookeeper

提供者8004项目结构

1、pom.xml中添加依赖

注意添加的zookeeper版本要与自己安装在服务器上的一致。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns=".0.0"xmlns:xsi=""xsi:schemaLocation=".0.0 .0.0.xsd"><parent><artifactId>cloud2020</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>cloud-provider-payment8004</artifactId><dependencies><!-- SpringBoot整合Web组件 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!--引入自己定义的api通用包，可以使用Payment支付Entity--><dependency><groupId>com.atguigu</groupId><artifactId>cloud-api-commons</artifactId><version>1.0-SNAPSHOT</version></dependency><!-- SpringBoot整合zookeeper客户端 --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-zookeeper-discovery</artifactId><!--先排除自带的zookeeper3.5.3--><exclusions><exclusion><groupId>org.apache.zookeeper</groupId><artifactId>zookeeper</artifactId></exclusion></exclusions></dependency><!--添加zookeeper3.4.9版本--><dependency><groupId>org.apache.zookeeper</groupId><artifactId>zookeeper</artifactId><version>3.4.9</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope><optional>true</optional></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies>
</project>

2、配置yml文件

server:port: 8004
spring:application:name: cloud-provider-paymentcloud:zookeeper:connect-string: 192.168.43.59:2181

3、编写控制层代码

package com.atguigu.springcloud.controller;import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import java.util.UUID;@RestController
@Slf4j
public class PaymentController {@Value("${server.port}")private String SERVER_PORT;@RequestMapping("/payment/zk")public String paymentZK() {return "springcloud with zookeeper :" + SERVER_PORT + "\t" + UUID.randomUUID().toString();}
}

问题:zookeeper中的节点是持久还是临时的？

答：临时的

消费者项目结构

1、添加pom依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns=".0.0"xmlns:xsi=""xsi:schemaLocation=".0.0 .0.0.xsd"><parent><artifactId>cloud2020</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>cloud-consumerzk-order80</artifactId><dependencies><!-- SpringBoot整合Web组件 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!--引入自己定义的api通用包，可以使用Payment支付Entity--><dependency><groupId>com.atguigu</groupId><artifactId>cloud-api-commons</artifactId><version>1.0-SNAPSHOT</version></dependency><!-- SpringBoot整合zookeeper客户端 --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-zookeeper-discovery</artifactId><!--先排除自带的zookeeper3.5.3--><exclusions><exclusion><groupId>org.apache.zookeeper</groupId><artifactId>zookeeper</artifactId></exclusion></exclusions></dependency><!--添加zookeeper3.4.9版本--><dependency><groupId>org.apache.zookeeper</groupId><artifactId>zookeeper</artifactId><version>3.4.9</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope><optional>true</optional></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies></project>

2、创建yml

server:port: 80
#服务别名------注册zookeeper到注册中心名称
spring:application:name: cloud-consumer-paymentcloud:zookeeper:connect-string: 192.168.43.162:2181

3、主启动类

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

4、配置RestTemplate

@Configuration
public class ApplicationContextConfig {@Bean@LoadBalancedpublic RestTemplate getRestTemplate(){return new RestTemplate();}
}

5、业务类

package com.atguigu.springcloud.controller;import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;/*** @author wts* @date 2020/9/3 9:53*/
@RestController
@Slf4j
public class OrderZKController {public static final String INVOKE_URL = "http://cloud-provider-payment";@Autowiredprivate RestTemplate restTemplate;@GetMapping("/consumer/payment/zk")public String paymentInfo(){String result = restTemplate.getForObject(INVOKE_URL+"/payment/zk",String.class);return result;}
}

九、consul

Consul是什么

Consul是一个服务网格（微服务间的 TCP/IP，负责服务之间的网络调用、限流、熔断和监控）解决方案，它是一个一个分布式的，高度可用的系统，而且开发使用都很简便。它提供了一个功能齐全的控制平面，主要特点是：服务发现、健康检查、键值存储、安全服务通信、多数据中心。

与其它分布式服务注册与发现的方案相比，Consul 的方案更“一站式”——内置了服务注册与发现框架、分布一致性协议实现、健康检查、Key/Value 存储、多数据中心方案，不再需要依赖其它工具。Consul 本身使用 go 语言开发，具有跨平台、运行高效等特点，也非常方便和 Docker 配合使用。

十、Eureka、Zookeeper、Consul三个注册中心的异同点

组件名	语言	健康检查	对外暴露接口	CAP	Spring Cloud 集成
Eureka	Java	可配支持	HTTP	AP	集成
Consul	Go	支持	HTTP/DFS	CP	集成
Zookeeper	java	支持	客户端	CP	集成

十一、Ribbon

1、简介

Spring Cloud Ribbon是一个基于HTTP和TCP的客户端负载均衡工具，它基于Netflix Ribbon实现。通过Spring Cloud的封装，可以让我们轻松地将面向服务的REST模版请求自动转换成客户端负载均衡的服务调用。Spring Cloud Ribbon虽然只是一个工具类框架，它不像服务注册中心、配置中心、API网关那样需要独立部署，但是它几乎存在于每一个Spring Cloud构建的微服务和基础设施中。因为微服务间的调用，API网关的请求转发等内容，实际上都是通过Ribbon来实现的，包括后续我们将要介绍的Feign，它也是基于Ribbon实现的工具。所以，对Spring Cloud Ribbon的理解和使用，对于我们使用Spring Cloud来构建微服务非常重要。

2、IRule:根据特定算法中服务列表中选取一个要访问的服务

实现负载均衡的算法。

负载规则替换，注意，不能与主启动类在同一个包下！

注意：这个自定义配置类不能放在@ComponentScan所扫描的当前包下以及子包下，否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享，达不到特殊化定制的目的了。

package com.atguigu.myrule;import comflix.loadbalancer.IRule;
import comflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;/*** @author wts* @date 2020/9/3 21:47*/
@Configuration
public class MySelfRule {@Beanpublic IRule myRule(){return new RandomRule();//定义随机}
}

主启动类添加注释：

@RibbonClient(name = "CLOUD-PAYMENT-SERVICE", configuration = MySelfRule.class)

作用是替换ribbon轮询负载均衡规则

负载均衡轮询算法 :rest接口第几次请求次数 % 服务器集群总数量 = 实际调用服务器位置下标，每次服务器重启后，rest接口计数从1开始。

ribbon源码

private int incrementAndGetModulo(int modulo) {int current;int next;do {current = this.nextServerCyclicCounter.get();next = (current + 1) % modulo;} while(!this.nextServerCyclicCounterpareAndSet(current, next));
return next;
}

手写一个负载的算法CAS+自旋锁

首先8001、8002服务controller层加上

 @GetMapping("/payment/lb")public String getPaymentLB() {return serverPort;}

去掉@LoadBalanced

LoadBalancer接口：

package com.atguigu.springcloud.lb;import org.springframework.cloud.client.ServiceInstance;
import java.util.List;/*** @author wts* @date 2020/9/3 22:16*/
public interface LoadBalancer {ServiceInstance instances(List<ServiceInstance> serviceInstances);}

实现类：

package com.atguigu.springcloud.lb;import org.springframework.cloud.client.ServiceInstance;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;/*** @author wts* @date 2020/9/3 22:21*/
@Component
public class MyLB implements LoadBalancer {private AtomicInteger atomicInteger = new AtomicInteger(0);public final int getAndIncrement(){int current;int next;do {current = this.atomicInteger.get();next = current >= 2147483647 ? 0 : current + 1;}while (!this.atomicIntegerpareAndSet(current,next));System.out.println("*************第几次访问的次数next:"+next);return next;}//负载均衡轮询算法 :rest接口第几次请求次数 % 服务器集群总数量 = 实际调用服务器位置下标，每次服务器重启后，rest接口计数从1开始。@Overridepublic ServiceInstance instances(List<ServiceInstance> serviceInstances) {int index = getAndIncrement() % serviceInstances.size();return serviceInstances.get(index);}
}

controller类中添加：

    @GetMapping(value = "/consumer/payment/lb")public String getPayementLB(){List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");if (instances == null || instances.size() <= 0){return  null;}ServiceInstance serviceInstance = loadBalancer.instances(instances);URI uri = serviceInstance.getUri();return restTemplate.getForObject(uri+"/payment/lb",String.class);}

十二、OpenFeign

OpenFeign是什么？

Feign是一个声明式的Web Service客户端。它的出现使开发Web Service客户端变得很简单。使用Feign只需要创建一个接口加上对应的注解，比如：FeignClient注解。Feign有可插拔的注解，包括Feign注解和JAX-RS注解。Feign也支持编码器和解码器，Spring Cloud Open Feign对Feign进行增强支持Spring MVC注解，可以像Spring Web一样使用HttpMessageConverters等。

Feign是一种声明式、模板化的HTTP客户端。在Spring Cloud中使用Feign，可以做到使用HTTP请求访问远程服务，就像调用本地方法一样的，开发者完全感知不到这是在调用远程方法，更感知不到在访问HTTP请求。

功能可插拔的注解支持，包括Feign注解和JAX-RS注解。支持可插拔的HTTP编码器和解码器（Gson，Jackson，Sax，JAXB，JAX-RS，SOAP）。支持Hystrix和它的Fallback。支持Ribbon的负载均衡。支持HTTP请求和响应的压缩。灵活的配置：基于 name 粒度进行配置支持多种客户端：JDK URLConnection、apache httpclient、okhttp，ribbon）支持日志支持错误重试url支持占位符可以不依赖注册中心独立运行

代码实现：

1、cloud-provider-payment8001模块controller层添加代码：

2、新建cloud-consumer-feign-order80模块

3、pom文件（注意将实体类依赖换成自己的！）

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns=".0.0"xmlns:xsi=""xsi:schemaLocation=".0.0 .0.0.xsd"><parent><artifactId>cloud2020</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>cloud-consumer-feign-order80</artifactId><dependencies><!--openfeign--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-openfeign</artifactId></dependency><!--eureka client--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-client</artifactId></dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity --><dependency><groupId>com.atguigu</groupId><artifactId>cloud-api-commons</artifactId><version>1.0-SNAPSHOT</version></dependency><!--web--><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>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies></project>

4、yml配置

server:port: 80eureka:client:#表示是否将自己注册进EurekaServer默认为trueregister-with-eureka: false#是否从EurekaServer抓取已有的注册信息，默认为true。fetchRegistry等同于 fetch-registry 单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡fetch-registry: trueservice-url:#单机版#defaultZone: http://localhost:7001/eureka#集群版defaultZone: :7001/eureka/, :7002/eureka/

5、主启动类

package com.atguigu.springcloud;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloudflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;/*** @author WangTianShun* @date 2020/9/7 9:20*/
@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients//启用feign客户端
public class OrderFeignMain80 {public static void main(String[] args) {SpringApplication.run(OrderFeignMain80.class,args);}
}

6、service包下创建PaymentFeignService接口

package com.atguigu.springcloud.service;import com.atguigu.springcloud.entities.CommonResult;
import com.atguigu.springcloud.entities.Payment;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;/*** @author WangTianShun* @date 2020/9/7 9:26*/
@Component
@FeignClient(value = "CLOUD-PAYMENT-SERVICE")
public interface PaymentFeignService {@GetMapping(value = "/payment/get/{id}")CommonResult<Payment> getPaymentById(@PathVariable("id")Long id);
}

7、controller层代码

package com.atguigu.springcloud.controller;import com.atguigu.springcloud.entities.CommonResult;
import com.atguigu.springcloud.entities.Payment;
import com.atguigu.springcloud.service.PaymentFeignService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;/*** @author WangTianShun* @date 2020/9/9 8:57*/
@RestController
@Slf4j
public class OrderFeignController {@Resourceprivate PaymentFeignService paymentFeignService;@GetMapping("/consumer/payment/get/{id}")public CommonResult<Payment> getPayment(@PathVariable("id") Long id){return paymentFeignService.getPaymentById(id);}
}

OpenFeign超时控制

1、cloud-provider-payment8001的controller添加超时接扣

2、cloud-consumer-feign-order80的service添加超时

3、cloud-consumer-feign-order80的controller添加超时

测试报错

原因：提供者超时3秒发送，但OpenFeign默认等待1秒，超过发送。导致Feign不想等待了，直接返回报错。

解决办法：

# 设置feign客户端超时时间(OpenFeign默认支持ribbon)
ribbon:# 指的是建立连接所用的时间,适用于网络状态正常的情况下,两端连接所用的时间ReadTimeout: 5000# 指的是建立连接后从服务器读取到可用资源所用的时间ConnectTimeout: 5000

OpenFeign日志打印功能

1、配置日志bean

package com.atguigu.springcloud.config;import feign.Logger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;/*** @author WangTianShun* @date 2020/9/9 14:08*/@Configuration
public class FeignConfig {@BeanLogger.Level feignLoggerLevel(){return Logger.Level.FULL;}
}

YML文件需要开启日志的Feign客户端

logging:level:# feign日志以什么级别监控哪个接口com.atguigu.springcloud.service.PaymentFeignService: debug

十三、Hystrix

分布式系统面临的问题

复杂分布式系统中的应用程序有数十个依赖关系，每个依赖关系在某些时候不可避免的失败。

多个微服务之间调用时，假设 A 调B和C，B和C又调其他微服务，就是所谓的扇出。当扇出的链路上某个微服务响应时间过长或不可用对A的调用就会占用越来越多的资源，进而引起系统崩溃，所谓的雪崩效应。

是什么

Hystrix 是处理分布式系统的延迟和容错的开源库，保证一个依赖出现问题时不会导致整体服务失败，避免级联故障，以提高分布式系统弹性。
断路器本身是一种开关装置，当某个服务单元发生故障后，通过断路器的故障监控，向调用方返回一个符合预期的可处理的备选响应，而不是长时间的等待或抛出调用方法无法处理的异常。

官网：

参考博客：.html

停更

1、Hystrix重要概念

服务降级

1. 服务器忙，请稍后重试，不让客户端等待并立即返回一个友好的提示。
2. 哪些情况会导致服务降级
1. 程序运行异常
2. 超时
3. 服务熔断触发服务降级
4. 线程池/信号量打满

服务熔断

1. 类比保险丝达到最大服务访问时，直接拒绝访问，拉闸限电，然后调用服务降级的方法返回友好提示。
2. 服务降级->进而熔断->恢复调用链路

服务限流

1. 秒杀高并发等操作，严禁一窝蜂过来拥挤，一秒N个有序进行。

Hystrix介绍

在微服务场景中，通常会有很多层的服务调用。如果一个底层服务出现问题，故障会被向上传播给用户。我们需要一种机制，当底层服务不可用时，可以阻断故障的传播。这就是断路器的作用。他是系统服务稳定性的最后一重保障。

在springcloud中断路器组件就是Hystrix。Hystrix也是Netflix套件的一部分。他的功能是，当对某个服务的调用在一定的时间内（默认10s），有超过一定次数（默认20次）并且失败率超过一定值（默认50%），该服务的断路器会打开。返回一个由开发者设定的fallback。

fallback可以是另一个由Hystrix保护的服务调用，也可以是固定的值。fallback也可以设计成链式调用，先执行某些逻辑，再返回fallback。

Hystrix的作用

对通过第三方客户端库访问的依赖项（通常是通过网络）的延迟和故障进行保护和控制。
在复杂的分布式系统中阻止级联故障。
快速失败，快速恢复。
回退，尽可能优雅地降级。
启用近实时监控、警报和操作控制。

2、服务降级

三种情况：

访问超时
运行错误
宕机

实例代码：

项目结构：

添加pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns=".0.0"xmlns:xsi=""xsi:schemaLocation=".0.0 .0.0.xsd"><parent><artifactId>cloud2020</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>cloud-provider-hystrix-payment8001</artifactId><dependencies><!--引入自己的公共api--><!--引入自己定义的api通用包，可以使用Payment支付Entity--><dependency><groupId>com.atguigu</groupId><artifactId>cloud-api-commons</artifactId><version>1.0-SNAPSHOT</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>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId></dependency><!--eureka-client--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-client</artifactId></dependency><!--  Hystrix      --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-hystrix</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-autoconfigure</artifactId></dependency></dependencies></project>

主启动类

package com.atguigu.springcloud;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloudflix.eureka.EnableEurekaClient;/*** @author WangTianShun* @date 2020/9/9 14:52*/@SpringBootApplication
@EnableEurekaClient
public class PaymentHystrixMain8001 {public static void main(String[] args) {SpringApplication.run(PaymentHystrixMain8001.class, args);}
}

service

package com.atguigu.springcloud.service;import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;/*** @author WangTianShun* @date 2020/9/9 14:56*/
@Service
public class PaymentService {/*** 正常访问肯定ok* @param id* @return*/public String paymentInfo_OK(Integer id){return "线程池:  "+Thread.currentThread().getName()+" paymentInfo_OK,id  "+id+"\t"+"哈哈哈";}public String paymentInfo_TimeOut(Integer id){try{//暂停3秒模拟超时任务TimeUnit.SECONDS.sleep(3);}catch (InterruptedException e){e.printStackTrace();}return "线程池:  "+Thread.currentThread().getName()+" paymentInfo_TimeOut,id  "+id+"\t"+"耗时3秒钟";}
}

controller

package com.atguigu.springcloud.controller;import com.atguigu.springcloud.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;/*** @author WangTianShun* @date 2020/9/9 15:03*/
@RestController
@Slf4j
public class PaymentController {@Autowiredprivate PaymentService paymentService;@Value("${server.port}")private String serverPort;@GetMapping("/payment/hystrix/ok/{id}")public String paymentInfo_OK(@PathVariable("id") Integer id){String  result = paymentService.paymentInfo_OK(id);log.info("******result"+result);return result;}@GetMapping("/payment/hystrix/timeOut/{id}")public String paymentInfo_TimeOut(@PathVariable("id") Integer id){String  result = paymentService.paymentInfo_TimeOut (id);log.info("******result"+result);return result;}
}

创建cloud-consumer-feign-hystrix-order80

1、添加pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns=".0.0"xmlns:xsi=""xsi:schemaLocation=".0.0 .0.0.xsd"><parent><artifactId>cloud2020</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>cloud-consumer-feign-hystrix-order80</artifactId><dependencies><!--引入自己的公共api--><dependency><groupId>com.atguigu</groupId><artifactId>cloud-api-commons</artifactId><version>1.0-SNAPSHOT</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>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId></dependency><!--eureka-client--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-client</artifactId></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-openfeign</artifactId></dependency><!--  Hystrix      --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-hystrix</artifactId></dependency></dependencies></project>

2、添加yml

server:port: 80
spring:application:name: cloud-consumer-ordereureka:client:#表示是否将自己注册进EurekaServer默认为trueregister-with-eureka: falseservice-url:defaultZone:  :7001/eureka/
feign:hystrix:enabled: true

3、主启动类

package com.atguigu.springcloud;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;/*** @author WangTianShun* @date 2020/9/9 15:32*/
@SpringBootApplication
@EnableFeignClients
public class OrderHystrixMain80 {public static void main(String[] args) {SpringApplication.run(OrderHystrixMain80.class,args);}
}

业务类

package com.atguigu.springcloud.service;import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;/*** @author WangTianShun* @date 2020/9/9 15:36*/
@Component
@FeignClient(value = "CLOUD-PROVIDER-HYSTRIX-PAYMENT")
public interface PaymentHystrixService {@GetMapping("/payment/hystrix/ok/{id}")public String paymentInfo_OK(@PathVariable("id") Integer id);@GetMapping("/payment/hystrix/timeOut/{id}")public String paymentInfo_TimeOut(@PathVariable("id") Integer id);
}

package com.atguigu.springcloud.controller;import com.atguigu.springcloud.service.PaymentHystrixService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;/*** @author WangTianShun* @date 2020/9/9 15:38*/
@RestController
@Slf4j
public class OrderHystrixController {@Autowiredprivate PaymentHystrixService paymentHystrixService;@GetMapping("/consumer/payment/hystrix/ok/{id}")public String paymentInfo_OK(@PathVariable("id") Integer id){String result = paymentHystrixService.paymentInfo_OK(id);return result;}@GetMapping("/consumer/payment/hystrix/timeOut/{id}")public String paymentInfo_TimeOut(@PathVariable("id") Integer id){String result = paymentHystrixService.paymentInfo_TimeOut(id);return result;}
}

服务降级解决办法

在cloud-provider-hystrix-payment8001模块的service添加@HystrixCommand

@HystrixCommand(fallbackMethod = "paymentInfo_TimeOutHandler",commandProperties = {@HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",value = "3000")
})

package com.atguigu.springcloud.service;import comflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import comflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;/*** @author WangTianShun* @date 2020/9/9 14:56*/
@Service
public class PaymentService {/*** 正常访问肯定ok* @param id* @return*/public String paymentInfo_OK(Integer id){return "线程池:  "+Thread.currentThread().getName()+" paymentInfo_OK,id  "+id+"\t"+"哈哈哈";}@HystrixCommand(fallbackMethod = "paymentInfo_TimeOutHandler",commandProperties = {@HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",value = "3000")})public String paymentInfo_TimeOut(Integer id){try{//暂停3秒模拟超时任务TimeUnit.SECONDS.sleep(3);}catch (InterruptedException e){e.printStackTrace();}return "线程池:  "+Thread.currentThread().getName()+" paymentInfo_TimeOut,id  "+id+"\t"+"耗时3秒钟";}public String paymentInfo_TimeOutHandler(Integer id){return "线程池:  "+Thread.currentThread().getName()+" paymentInfo_TimeOutHandler,id  "+id+"\t"+"超时了";}
}

问题：

1、每个方法有一个对应的处理方法，代码膨胀。

2、处理方法和主业务逻辑混合在一起

解决方案：(cloud-consumer-feign-hystrix-order80)

@DefaultProperties(defaultFallback="")

1、类上加上注解：

@RestController
@RequestMapping("/consumer")
@DefaultProperties(defaultFallback = "payment_Global_FallbackMethod")
public class OrderHystrixController {

2、默认全局处理方法

/*** 全局fallback方法** @return*/
private String payment_Global_FallbackMethod() {return "Global异常处理信息,请稍后再试。";
}

3、@HystrixCommand//不加属性代表使用默认的全局处理方法

整体就是这样

package com.atguigu.springcloud.controller;import com.atguigu.springcloud.service.PaymentHystrixService;
import comflix.hystrix.contrib.javanica.annotation.DefaultProperties;
import comflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import comflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;/*** @author WangTianShun* @date 2020/9/9 15:38*/
@RestController
@Slf4j
@DefaultProperties(defaultFallback="paymentGlobalFallBack")
public class OrderHystrixController {@Autowiredprivate PaymentHystrixService paymentHystrixService;@GetMapping("/consumer/payment/hystrix/ok/{id}")public String paymentInfo_OK(@PathVariable("id") Integer id){String result = paymentHystrixService.paymentInfo_OK(id);return result;}@GetMapping("/consumer/payment/hystrix/timeOut/{id}")
//    @HystrixCommand(fallbackMethod = "paymentInfo_TimeOutHandler",commandProperties = {
//            @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",value = "5000")
//    })@HystrixCommandpublic String paymentInfo_TimeOut(@PathVariable("id") Integer id){int age = 10/0;String result = paymentHystrixService.paymentInfo_TimeOut(id);return result;}public String paymentInfo_TimeOutHandler(Integer id){return "线程池:我是消费者80，对方支付系统繁忙";}// 下面是全局 fallbackpublic String paymentGlobalFallBack(){return "80：获取异常，调用方法为全局fallback";}
}

服务降级，客户端去调用服务端，碰上服务端宕机或者关闭

本次案例服务降级处理是在客户端80实现完成的，与服务端8001没有关系只需要为Feign客户端定义的接口添加一个服务降级处理的实现类即可实现解耦

package com.atguigu.springcloud.service;import org.springframework.stereotype.Component;/*** @author WangTianShun* @date 2020/9/9 20:52*/
@Component
public class paymentFallbackService implements PaymentHystrixService {@Overridepublic String paymentInfo_OK(Integer id) {return "----------paymentFallbackService fall back  paymentInfo_OK";}@Overridepublic String paymentInfo_TimeOut(Integer id) {return "----------paymentFallbackService fall back  paymentInfo_TimeOut";}
}

3、服务熔断

类比保险丝达到最大访问量后，直接拒绝访问，拉闸限电，然后调用服务降级的方法biang返回友好提示

就是保险丝服务的降级-------》进而熔断-----》恢复调用链路

Hystrix断路器使用时最常用的三个重要指标参数

在微服务中使用Hystrix 作为断路器时，通常涉及到以下三个重要的指标参数（这里是写在@HystrixProperties注解中，当然实际项目中可以全局配置在yml或properties中）

1、circuitBreaker.sleepWindowInMilliseconds

断路器的快照时间窗，也叫做窗口期。可以理解为一个触发断路器的周期时间值，默认为10秒（10000）。

2、circuitBreaker.requestVolumeThreshold

断路器的窗口期内触发断路的请求阈值，默认为20。换句话说，假如某个窗口期内的请求总数都不到该配置值，那么断路器连发生的资格都没有。断路器在该窗口期内将不会被打开。

3、circuitBreaker.errorThresholdPercentage

断路器的窗口期内能够容忍的错误百分比阈值，默认为50（也就是说默认容忍50%的错误率）。打个比方，假如一个窗口期内，发生了100次服务请求，其中50次出现了错误。在这样的情况下，断路器将会被打开。在该窗口期结束之前，即使第51次请求没有发生异常，也将被执行fallback逻辑。

综上所述，在以上三个参数缺省的情况下，Hystrix断路器触发的默认策略为：

在10秒内，发生20次以上的请求时，假如错误率达到50%以上，则断路器将被打开。（当一个窗口期过去的时候，断路器将变成半开（HALF-OPEN）状态，如果这时候发生的请求正常，则关闭，否则又打开）

//====服务熔断

/*** 在10秒窗口期中10次请求有6次是请求失败的,断路器将起作用** @param id* @return*/
@HystrixCommand(fallbackMethod = "paymentCircuitBreaker_fallback", commandProperties = {@HystrixProperty(name = "circuitBreaker.enabled", value = "true"),// 是否开启断路器@HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),// 请求次数@HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "10000"),// 时间窗口期/时间范文@HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "60")// 失败率达到多少后跳闸
}
)
public String paymentCircuitBreaker(@PathVariable("id") Integer id) {if (id < 0) {throw new RuntimeException("*****id不能是负数");}String serialNumber = IdUtil.simpleUUID();return Thread.currentThread().getName() + "\t" + "调用成功,流水号:" + serialNumber;
}

public String paymentCircuitBreaker_fallback(@PathVariable("id") Integer id) {return "id 不能负数,请稍后重试,o(╥﹏╥)o id:" + id;
}

熔断类型

断路器开启或关闭的条件

断路器打开之后

3、服务监控hystrixDashboard

十四、GateWay

三大核心概念

1. Route（路由）

网关的基本构建块。它由ID，目标URI，谓词集合和过滤器集合定义。如果断言为true，则匹配路由。

2. Predicate（断言）

这是Java 8 Function谓词。输入类型是Spring FrameworkServerWebExchange。这使您可以匹配HTTP请求中的所有内容，例如标头或参数。

3. Filter（过滤器）

这些是使用特定工厂构造的Spring FrameworkGatewayFilter实例。在这里，您可以在发送下游请求之前或之后修改请求和响应。

工作流程

客户端向Spring Cloud Gateway发出请求。如果网关处理程序映射确定请求与路由匹配，则将其发送到网关Web处理程序。该处理程序通过特定于请求的过滤器链来运行请求。筛选器由虚线分隔的原因是，筛选器可以在发送代理请求之前和之后运行逻辑。所有“前置”过滤器逻辑均被执行。然后发出代理请求。发出代理请求后，将运行“后”过滤器逻辑。

核心逻辑：路由转发+执行过滤连

案例

项目结构

添加pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns=".0.0"xmlns:xsi=""xsi:schemaLocation=".0.0 .0.0.xsd"><parent><artifactId>cloud2020</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>cloud-gateway-gateway9527</artifactId><dependencies><!--gateway--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-gateway</artifactId></dependency><!--eureka-client--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-client</artifactId></dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity --><dependency><groupId>com.atguigu</groupId><artifactId>cloud-api-commons</artifactId><version>1.0-SNAPSHOT</version></dependency><!--一般基础配置类--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope><optional>true</optional></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-autoconfigure</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-autoconfigure</artifactId></dependency></dependencies>
</project>

添加yml

server:port: 9527spring:application:name: cloud-gatewaycloud:gateway:discovery:locator:enabled: true #开启从注册中心动态创建路由的功能，利用微服务名进行路由routes:- id: payment_routh #payment_route    #路由的ID，没有固定规则但要求唯一，建议配合服务名#uri: http://localhost:8001          #匹配后提供服务的路由地址uri: lb://cloud-payment-service #匹配后提供服务的路由地址predicates:- Path=/payment/get/**         # 断言，路径相匹配的进行路由- id: payment_routh2 #payment_route    #路由的ID，没有固定规则但要求唯一，建议配合服务名#uri: http://localhost:8001          #匹配后提供服务的路由地址uri: lb://cloud-payment-service #匹配后提供服务的路由地址predicates:- Path=/payment/lb/**         # 断言，路径相匹配的进行路由#- After=2020-02-21T15:51:37.485+08:00[Asia/Shanghai]#- Cookie=username,zzyy#- Header=X-Request-Id, \d+  # 请求头要有X-Request-Id属性并且值为整数的正则表达式eureka:instance:hostname: cloud-gateway-serviceclient: #服务提供者provider注册进eureka服务列表内service-url:register-with-eureka: truefetch-registry: truedefaultZone: :7001/eureka

主启动类

package com.atguigu.springcloud;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloudflix.eureka.EnableEurekaClient;/*** @auther WangTianShun* @create 2020-09-11 11:02*/
@SpringBootApplication
@EnableEurekaClient
public class GateWayMain9527
{public static void main(String[] args) {SpringApplication.run(GateWayMain9527.class, args);}
}

测试

以编码的方式进行网管的路由配置

太麻烦省略

package com.atguigu.springcloud.config;import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;/*** @auther zzyy* @create 2020-02-21 11:42*/
@Configuration
public class GateWayConfig
{@Beanpublic RouteLocator customRouteLocator(RouteLocatorBuilder routeLocatorBuilder){RouteLocatorBuilder.Builder routes = routeLocatorBuilder.routes();routes.route("path_route_atguigu",r -> r.path("/guonei").uri("")).build();return routes.build();}
}

十五、Spring Config

简介：在分布式系统中，由于服务数量巨多，为了方便服务配置文件统一管理，实时更新，所以需要分布式配置中心组件。Spring Cloud Config项目是就是这样一个解决分布式系统的配置管理方案。它包含了Client和Server两个部分，server提供配置文件的存储、以接口的形式将配置文件的内容提供出去，client通过接口获取数据、并依据此数据初始化自己的应用

入门示例：

1、在github上新建一个仓库，如图所示

2、复制新建的git地址

3、在本地新建git仓库并clone

4、新建开发、生产、测试配置文件，并提交到github

参考下图：

命令：git add .

git commit

git push origin master

5、新建配置中心模块3344 cloud-config-center3344

添加依赖：

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-config-server</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

yml文件配置

server:
port: 3344
spring:
application:
name: cloud-config-center
cloud:
config:
server:
git:
skipSslValidation: true # 跳过ssl认证
uri: .git
search-paths:
- springcloud-config
label: master
eureka:
client:
service-url:
defaultZone: :7001/eureka

主启动类

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

Spring Cloud Config 有它的一套访问规则，我们通过这套规则在浏览器上直接访问就可以。

/{application}/{profile}[/{label}]
/{application}-{profile}.yml
/{label}/{application}-{profile}.yml
/{application}-{profile}.properties
/{label}/{application}-{profile}.properties

{application} 就是应用名称，对应到配置文件上来，就是配置文件的名称部分，例如我上面创建的配置文件。

{profile} 就是配置文件的版本，我们的项目有开发版本、测试环境版本、生产环境版本，对应到配置文件上来就是以 application-{profile}.yml 加以区分，例如application-dev.yml、application-sit.yml、application-prod.yml。

{label} 表示 git 分支，默认是 master 分支，如果项目是以分支做区分也是可以的，那就可以通过不同的 label 来控制访问不同的配置文件了。

访问：http://localhost:3344/config-dev.yml

结果：

config:
info: master branch,springcloud-config/config-dev.yml version=7

配置成功，但是这样还存在一个问题，就是当我们github上更新配置后，我们的服务要重新启动才能使用新的配置，否则配置无法生效。解决方案就是动态的修改配置。

使用标签:@RefreshScope

步骤：

pom文件引入actuator依赖
修改yml,暴露监控端口
```
 
```
1. #暴露监控端点
2. management:
3. endpoints:
4. web:
5. exposure:
6. include: "*"
@RefreshScope修饰控制类
cmd下执行
```
 
```
1. curl -X POST "http://localhost:3355/actuator/refresh"
3355模块重新获取配置信息

十六、Bus消息中心

1、首先配置RabbitMQ

下载erlang 地址：.3.exe 傻瓜式安装即可

下载RabbitMQ 地址：.8.2/rabbitmq-server-3.8.2.exe 傻瓜式安装即可

进入rabbitmq安装目录下的sbin目录：输入

 rabbitmq-plugins enable rabbitmq_management

双击RabbitMQ service start

浏览器输入：localhost:15672 如果出现如下页面，则安装成功

输入账号和密码：guest、guest 可以看到RabbitMQ的主界面

2、参照3355模块新建3366模块

3344模块添加新依赖：

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

3344新添yml:

rabbitmq:
host: localhost
port: 5672
username: guest
password: guest
# 暴露bus刷新配置的端点
management:
endpoints:
web:
exposure:
include: "bus-refresh"

3355、3366yml新增：

rabbitmq: #rabbitmq相关配置，15672是web管理端口，5672是mq访问端口
port: 5672
host: localhost
username: guest
password: guest
#暴露监控端点
management:
endpoints:
web:
exposure:
include: "*"

1、修改github中版本号

2、cmd 刷新3344

curl -X POST "http://localhost:3344/actuator/bus-refresh"

结果：3355、3366 都已经改变，一次修改、广播通知、到处运行。

上面是全局通知，但如果我们想定点通知该如何做呢？

定点通知：只通知3355，不通知3366

实现方法：cmd 刷新3344

curl -X POST "http://localhost:3344/actuator/bus-refresh/config-client:3355"

第十五章 SpringCloud Stream

问题：为什么要引入SpringCloud Stream

举例：对于我们Java程序员来说，可能有时要使用ActiveMQ,有时要使用RabbitMQ,甚至还有RocketMQ以及Kafka，这之间的切换似乎很麻烦，我们很难，也没有太多时间去精通每一门技术，那有没有一种新技术的诞生，让我们不再关注具体MQ的细节，自动的给我们在各种MQ内切换。

简介：Spring Cloud Stream 是一个用来为微服务应用构建消息驱动能力的框架。它可以基于 Spring Boot 来创建独立的、可用于生产的 Spring 应用程序。Spring Cloud Stream 为一些供应商的消息中间件产品提供了个性化的自动化配置实现，并引入了发布-订阅、消费组、分区这三个核心概念。通过使用 Spring Cloud Stream，可以有效简化开发人员对消息中间件的使用复杂度，让系统开发人员可以有更多的精力关注于核心业务逻辑的处理。但是目前 Spring Cloud Stream 只支持 RabbitMQ 和 Kafka 的自动化配置。

一句话：屏蔽底层消息中间件的差异，降低切换成本，统一消息的编程模型。

Binder Implementations 绑定器

通过绑定器Binder作为中间件，实现了应用程序与消息中间件细节的解耦。

Input对应消息生产者

Output对应消息消费者

入门案例

1、新建子模块

cloud-stream-rabbitmq-provider8801 消息生产模块

2、pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns=".0.0"xmlns:xsi=""xsi:schemaLocation=".0.0 .0.0.xsd"><parent><artifactId>cloud2020</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>cloud-stream-rabbitmq-provider8801</artifactId><dependencies><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.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-client</artifactId></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-stream-rabbit</artifactId></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies>
</project>

3、yml

server:port: 8801spring:application:name: cloud-stream-providercloud:stream:binders: # 在此处配置要绑定的rabbitMQ的服务信息defaultRabbit: # 表示定义的名称，用于binding的整合type: rabbit # 消息中间件类型environment: # 设置rabbitMQ的相关环境配置spring:rabbitmq:host: localhostport: 5672username: guestpassword: guestbindings: # 服务的整合处理output: # 这个名字是一个通道的名称destination: studyExchange # 表示要使用的exchange名称定义content-type: application/json # 设置消息类型，本次为json，文本则设为text/plainbinder: defaultRabbit # 设置要绑定的消息服务的具体设置eureka:client:service-url:defaultZone: :7001/eurekainstance:lease-renewal-interval-in-seconds: 2 # 设置心跳的间隔时间，默认30lease-expiration-duration-in-seconds: 5 # 超过5秒间隔，默认90instance-id: send-8801 # 主机名prefer-ip-address: true # 显示ip

更多推荐

SpringCloud(Hoxton.SR7版alibaba)初级篇

本文发布于:2024-02-11 18:18:18，感谢您对本站的认可！

本文链接:https://www.elefans.com/category/jswz/34/1682535.html

上一篇： Spring Session Corn
下一篇： postgresql RIR rule

发布评论取消回复

评论列表（有 0 条评论）

SpringCloud(Hoxton.SR7版alibaba)初级篇