服务架构的种类以及优缺点
单体架构
定义
分布式架构
定义
微服务架构说明
概述
-
特征
单一职责：微服务拆分粒度更小，每一个服务都对应唯一的业务能力，做到单一职责
- 自治：团队独立、技术独立、数据独立，独立部署和交付
- 面向服务：服务提供统一标准的接口，与语言和技术无关
-
优点
微服务的上述特性其实是在给分布式架构制定一个标准
进一步降低服务之间的耦合度，提供服务的独立性和灵活性。做到高内聚，低耦合
缺点
-
结构体现
组件实现
SpringCloud说明概述
SpringCloud是目前国内使用最广泛的微服务框架。官网地址：https://spring.io/projects/spring-cloud。
- SpringCloud集成了各种微服务功能组件，并基于SpringBoot实现了这些组件的自动装配，从而提供了良好的开箱即用体验。
SpringCloud是微服务分布式架构的一站式==解决方案==，集成了各种优秀微服务功能组件
常见组件
SpringCloud与SpringBoot的版本关联
SpringCloud底层是依赖于SpringBoot的，并且有版本的兼容关系，如下：
SpringCloudAlibaba版本说明
Eureka相关介绍
结构体系
相关问题的解答
问题1：order-service如何得知user-service实例地址？
获取地址信息的流程如下：
- user-service服务实例启动后，将自己的信息注册到eureka-server（Eureka服务端）。这个叫服务注册
- eureka-server保存服务名称到服务实例地址列表的映射关系
- order-service根据服务名称，拉取实例地址列表。这个叫服务发现或服务拉取
问题2：order-service如何从多个user-service实例中选择具体的实例？
- order-service从实例列表中利用负载均衡算法选中一个实例地址
- 向该实例地址发起远程调用
问题3：order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？
- user-service会每隔一段时间（默认30秒）向eureka-server发起请求，报告自己状态，称为心跳
- 当超过一定时间没有发送心跳时，eureka-server会认为微服务实例故障，将该实例从服务列表中剔除
- order-service拉取服务时，就能将故障实例排除了
注意：一个微服务，既可以是服务提供者，又可以是服务消费者，因此eureka将服务注册、服务发现等功能统一封装到了eureka-client端
开发步骤
**
搭建eureka-server
创建eureka-server服务
- 在cloud-demo父工程下，创建一个子模块：
- 填写模块信息：
- 然后填写服务信息：
引入eureka依赖
引入SpringCloud为eureka提供的starter依赖：
<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-server</artifactId></dependency>
编写启动类
给eureka-server服务编写一个启动类，一定要添加一个@EnableEurekaServer注解，开启eureka的注册中心功能： ```java package cn.itcast.eureka;
import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication @EnableEurekaServer public class EurekaApplication { public static void main(String[] args) { SpringApplication.run(EurekaApplication.class, args); } }
<a name="hPyhj"></a>
#### 编写配置文件
- **编写一个application.yml文件，内容如下：**
```java
server:
port: 10086
spring:
application:
name: eureka-server
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:10086/eureka
register-with-eureka: false # 不注册自己
fetch-registry: false #不拉取服务本eureka服务中的服务信息
启动服务
- 启动微服务，然后在浏览器访问：http://127.0.0.1:10086
- 看到下面结果应该是成功了：
服务注册
引入依赖
在user-service的pom文件中，引入下面的eureka-client依赖：
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId> </dependency>配置文件
在user-service中，修改application.yml文件，添加服务名称、eureka地址：
spring: application: name: userservice eureka: client: service-url: defaultZone: http://127.0.0.1:10086/eureka instance: # 在Eureka中显示服务的ip地址 ip-address: 127.0.0.1 # 配置服务器ip地址 prefer-ip-address: true # 更倾向于使用ip,而不是host名 instance-id: ${eureka.instance.ip-address}:${server.port} # 自定义实例的id在启动类上添加注解：(SpringCloud 2.2.x版本后，此步骤可以省略掉) ```java package cn.itcast.user;
import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.mybatis.spring.annotation.MapperScan; import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
@MapperScan(“cn.itcast.user.mapper”) @SpringBootApplication @EnableDiscoveryClient public class UserApplication { public static void main(String[] args) { SpringApplication.run(UserApplication.class, args); } }
<a name="yp9zk"></a>
#### 启动多个user-service实例
- **为了演示一个服务有多个实例的场景，我们添加一个SpringBoot的启动配置，再启动一个user-service。**
- **首先，复制原来的user-service启动配置：**
- **然后，在弹出的窗口中，填写信息：**
- **现在，SpringBoot窗口会出现两个user-service启动配置：**
- **不过，第一个是8081端口，第二个是8082端口。**
- **启动两个user-service实例：**
- **查看eureka-server管理页面：**
<a name="rUgIf"></a>
### 服务发现
- **下面，我们将order-service的逻辑修改：向eureka-server拉取user-service的信息，实现服务发现。**
<a name="sTV8K"></a>
#### 引入依赖
- **之前说过，服务发现、服务注册统一都封装在eureka-client依赖，因此这一步与服务注册时一致。**
- **在order-service的pom文件中，引入下面的eureka-client依赖：**
```java
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
配置文件
- 服务发现也需要知道eureka地址，因此第二步与服务注册一致，都是配置eureka信息：
在order-service中，修改application.yml文件，添加服务名称、eureka地址：
spring: application: name: orderservice eureka: client: service-url: defaultZone: http://127.0.0.1:10086/eureka服务拉取和负载均衡
最后，我们要去eureka-server中拉取user-service服务的实例列表，并且实现负载均衡。
- 不过这些动作不用我们去做，只需要添加一些注解即可。
- 在order-service的OrderApplication中，给RestTemplate这个Bean添加一个@LoadBalanced注解：
- 修改order-service服务中的cn.itcast.order.service包下的OrderService类中的queryOrderById方法。修改访问的url路径，用服务名代替ip、端口：
spring会自动帮助我们从eureka-server端，根据userservice这个服务名称，获取实例列表，而后完成负载均衡。
Ribbon负载均衡
负载均衡原理
SpringCloud底层其实是利用了一个名为Ribbon的组件，来实现负载均衡功能的。
- SpringCloudRibbon的底层采用了一个拦截器，拦截了RestTemplate发出的请求，对地址做了修改。用一幅图来总结一下：
基本流程如下：
- 拦截我们的RestTemplate请求http://userservice/user/1
- RibbonLoadBalancerClient会从请求url中获取服务名称，也就是user-service
- DynamicServerListLoadBalancer根据user-service到eureka拉取服务列表
- eureka返回列表，localhost:8081、localhost:8082
- IRule利用内置负载均衡规则，从列表中选择一个，例如localhost:8081
RibbonLoadBalancerClient修改请求地址，用localhost:8081替代userservice，得到http://localhost:8081/user/1，发起真实请求
负载均衡策略
负载均衡的规则都定义在IRule接口中，而IRule有很多不同的实现类：
不同规则的含义如下： | 内置负载均衡规则类 | 规则描述 | | —- | —- | | RoundRobinRule | 简单轮询服务列表来选择服务器。 | | AvailabilityFilteringRule | 对以下两种服务器进行忽略： （1）在默认情况下，这台服务器如果3次连接失败，这台服务器就会被设置为“短路”状态。短路状态将持续30秒，如果再次连接失败，短路的持续时间就会几何级地增加。 （2）并发数过高的服务器。如果一个服务器的并发连接数过高，配置了AvailabilityFilteringRule规则的客户端也会将其忽略。并发连接数的上限，可以由客户端的
. | | WeightedResponseTimeRule | 为每一个服务器赋予一个权重值。服务器响应时间越长，这个服务器的权重就越小。这个规则会随机选择服务器，这个权重值会影响服务器的选择。 | | ZoneAvoidanceRule | 以区域可用的服务器为基础进行服务器的选择。使用Zone对服务器进行分类，这个Zone可以理解为一个机房、一个机架等。而后再对Zone内的多个服务做轮询。 | | BestAvailableRule | 忽略那些短路的服务器，并选择并发数较低的服务器。 | | RandomRule | 随机选择一个可用的服务器。 | | RetryRule | 重试机制的选择逻辑 |.ActiveConnectionsLimit属性进行配置。 默认的实现就是ZoneAvoidanceRule，是一种轮询方案
-
自定义负载均衡策略
通过定义IRule实现可以修改负载均衡规则，有两种方式：
代码方式：在order-service中的OrderApplication类中，定义一个新的IRule：
@Bean public IRule randomRule(){ return new RandomRule(); }配置文件方式：在order-service的OrderApplication中，添加新的配置也可以修改规则：
@Bean public IRule rule() { return new NacosRule(); }饥饿加载
Ribbon默认是采用懒加载，即第一次访问时才会去创建LoadBalanceClient，请求时间会很长。
而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，通过下面配置开启饥饿加载：
#订单服务中添加（order-service） ribbon: eager-load: enabled: true clients: userservice客户端负载均衡与服务端负载均衡
区别
知道服务端IP地址的负载均衡策略属于客户端负载均衡，代表：Ribbon
-
Nacos相关说明
认识和安装Nacos
Nacos是阿里巴巴的产品，现在是SpringCloud中的一个组件。相比Eureka功能更加丰富，在国内受欢迎程度较高。
在虚拟机中，拉取镜像
docker pull nacos/nacos-server:1.4.1基于Docker安装并启动nacos
docker run --env MODE=standalone --name nacos -d -p 8848:8848 nacos/nacos-server:1.4.1访问nacos ip:8848/nacos 默认账号密码是nacos/nacos**
服务注册到nacos
Nacos是SpringCloudAlibaba的组件，而SpringCloudAlibaba也遵循SpringCloud中定义的服务注册、服务发现规范。因此使用Nacos和使用Eureka对于微服务来说，并没有太大区别。
主要差异在于：依赖不同
-
引入依赖
在cloud-demo父工程的pom文件中的
中引入SpringCloudAlibaba的依赖： <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-alibaba-dependencies</artifactId> <version>2.2.6.RELEASE</version> <type>pom</type> <scope>import</scope> </dependency>然后在user-service和order-service中的pom文件中引入nacos-discovery依赖：
<dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId> </dependency>配置nacos地址
在user-service和order-service的application.yml中添加nacos地址：
spring: cloud: nacos: server-addr: 192.168.94.129:8848重启
重启微服务后，登录nacos管理页面，可以看到微服务信息：
服务分级
服务分级存储模型
一个服务可以有多个实例，例如我们的user-service，可以有:
- 127.0.0.1:8081
- 127.0.0.1:8082
- 127.0.0.1:8083
假如这些实例分布于全国各地的不同机房，例如：
- 127.0.0.1:8081，在上海机房
- 127.0.0.1:8082，在上海机房
- 127.0.0.1:8083，在杭州机房
Nacos就将同一机房内的实例 划分为一个集群。
也就是说，user-service是服务，一个服务可以包含多个集群，如杭州、上海，每个集群下可以有多个实例，形成分级模型，如图：
微服务互相访问时，应该尽可能访问同集群实例，因为本地访问速度更快。当本集群内不可用时，才访问其它集群。例如：
杭州机房内的order-service应该优先访问同机房的user-service。
给user-service配置集群
修改user-service的application.yml文件，添加集群配置：
spring: cloud: nacos: server-addr: 192.168.94.129:8848 discovery: cluster-name: HZ # 集群名称重启两个user-service实例后，我们可以在nacos控制台看到下面结果：
我们再次复制一个user-service启动配置，添加属性：
-Dserver.port=8083 -Dspring.cloud.nacos.discovery.cluster-name=SH配置如图所示：
同集群优先的负载均衡
默认的ZoneAvoidanceRule并不能实现根据同集群优先来实现负载均衡。因此Nacos中提供了一个NacosRule的实现，可以优先从同集群中挑选实例。
给order-service配置集群信息
- 修改order-service的application.yml文件，添加集群配置：
spring: cloud: nacos: server-addr: l192.168.94.129:8848 discovery: cluster-name: HZ # 集群名称
- 修改order-service的application.yml文件，添加集群配置：
修改负载均衡规则
实际部署中会出现这样的场景：服务器设备性能有差异，部分实例所在机器性能较好，另一些较差，我们希望性能好的机器承担更多的用户请求。
- 但默认情况下NacosRule是同集群内随机挑选，不会考虑机器的性能问题。
- 因此，Nacos提供了权重配置来控制访问频率，权重越大则访问频率越高。
- 在nacos控制台，找到user-service的实例列表，点击编辑，即可修改权重：
- 在弹出的编辑窗口，修改权重：
环境隔离
Nacos提供了namespace来实现环境隔离功能。
- nacos中可以有多个namespace
- namespace下可以有group、service等
不同namespace之间相互隔离，例如不同namespace的服务互相不可见
创建namespace
默认情况下，所有service、data、group都在同一个namespace，名为public：
- 我们可以点击页面新增按钮，添加一个namespace：
- 然后，填写表单：
- 就能在页面看到一个新的namespace：
给微服务配置namespace
- 给微服务配置namespace只能通过修改配置来实现。
例如，修改order-service的application.yml文件：
spring: cloud: nacos: server-addr: localhost:8848 discovery: cluster-name: HZ namespace: 492a7d5d-237b-46a1-a99a-fa8e98e4b0f9 # 命名空间，填ID重启order-service后，访问控制台，可以看到下面的结果：
此时访问order-service，因为namespace不同，会导致找不到userservice，控制台会报错
nacos配置中心
使用原因：
配置维护信息强
-
配置中心使用步骤
在nacos中添加配置文件
然后在弹出的表单中，填写配置信息：
注意：项目的核心配置，需要热更新的配置才有放到nacos管理的必要。基本不会变更的一些配置还是保存在微服务本地比较好。
从微服务拉取配置
- 微服务要拉取nacos中管理的配置，并且与本地的application.yml配置合并，才能完成项目启动。
- 但如果尚未读取application.yml，又如何得知nacos地址呢？
- 因此spring引入了一种新的配置文件：bootstrap.yaml文件，会在application.yml之前被读取，流程如下：
- 引入nacos-config依赖
首先，在user-service服务中，引入nacos-config的客户端依赖：
<!--nacos配置管理依赖--> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId> </dependency>添加bootstrap.yaml
- 然后，在user-service中添加一个bootstrap.yaml文件，内容如下：
```java
spring:
application:
name: userservice # 服务名称
cloud: #nacos注册中心配置内容
nacos:
discovery: server-addr: 192.168.94.129:8848 cluster-name: HZ #开发环境的区别 namespace: 73be46a4-c53c-4b10-a68f-205698afef0e #区分统一环境下的不同项目组 group: cloud_project config: server-addr: 192.168.94.129:8848 cluster-name: HZ namespace: 73be46a4-c53c-4b10-a68f-205698afef0e group: cloud_project file-extension: yml
修改日志级别，可以显示出读取的配置信息
logging: level: cn.itcast: debug com: alibaba: cloud: nacos: client: debug
- **读取nacos配置**
- **在user-service中的UserController中添加业务逻辑，读取pattern.dateformat配置：**
- **完整代码**
```java
package cn.itcast.user.web;
import cn.itcast.user.pojo.User;
import cn.itcast.user.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
@Value("${pattern.dateformat}")
private String dateformatStr;
/**
* 路径： /user/110
*
* @param id 用户id
* @return 用户
*/
@GetMapping("/{id}")
public User queryById(@PathVariable("id") Long id) {
return userService.queryById(id);
}
@GetMapping("/date")
public String queryConfigByNacos() {
return LocalDateTime.now().format(DateTimeFormatter.ofPattern(dateformatStr));
}
}
- 访问页面，得到的效果
配置热更新
方式二
- 使用@ConfigurationProperties注解代替@Value注解。
- 在user-service服务中，添加一个类，读取patterrn.dateformat属性： ```java package cn.itcast.user.config;
import lombok.Data; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component;
@Component @Data @ConfigurationProperties(prefix = “pattern”) public class PatternProperties { private String dateformat; }
- **在UserController中使用这个类代替@Value：**
- **完整代码：**
```java
package cn.itcast.user.web;
import cn.itcast.user.pojo.PatternProperties;
import cn.itcast.user.pojo.User;
import cn.itcast.user.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
@Slf4j
@RestController
@RequestMapping("/user")
//热部署注解
@RefreshScope
public class UserController {
@Autowired
private UserService userService;
//方式一
/*@Value("${pattern.dateformat}")
private String dateformatStr;*/
//方式二
@Autowired
private PatternProperties patternProperties;
/**
* 路径： /user/110
*
* @param id 用户id
* @return 用户
*/
@GetMapping("/{id}")
public User queryById(@PathVariable("id") Long id) {
return userService.queryById(id);
}
@GetMapping("/date")
public String queryConfigByNacos() {
String dateformat = patternProperties.getDateformat();
return LocalDateTime.now().format(DateTimeFormatter.ofPattern(dateformat));
}
}
多环境支持
项目开发过程中，可能会存在多种环境，并且每一种环境所设置的配置都是不同的。nacos可以同时支持多环境配置，可以满足生产环境下的需求。
- 不同的开发环境：namespace 区分
- 不同的开发组：group 区分
- 不同的项目： Data Id 区分
- 不同种类的配置：profile
只需要在nacos配置中心中根据dataId进行区分即可。dataId 完整的拼接格式如下：
${prefix}-${spring.profiles.active}.${file-extension}共享配置
在微服务开发时，多个微服务都会遇到配置相同的配置信息，在nacos中的dataid中配置与会有配置冗余的情况。
- Nacos也为各个服务提供共享配置信息，如下图：
- 读取配置先后顺序，先读取公共，后读取自己的服务配置，如图：
ps：如果服务读取公共配置时，想修改公共配置的某个信息，只需要在自己的服务配置中修改即可
服务操作步骤：
- 在nacos中添加 datasource-config.yml
在user-service和order-service的bootstrap.yml文件中添加内容
spring: cloud: nacos: config: #添加公共配置信息 shared-configs: - dataId: datasource-config.yml group: cloud_project配置持久化
nacos对于服务的配置信息保存到了自己内部的数据库：derby，一般在开发环境下需要让nacos读取外部数据库配置信息，方便后期的维护：
操作步骤：导出查询结果
- mysql中新建nacos_config数据库，并执行资料/nacos持久化下的nacos-mysql.sql
- 参考github：https://github.com/alibaba/nacos/blob/master/distribution/conf/nacos-mysql.sql
进入nacos容器
docker exec -it nacos /bin/bash修改conf目录下application.properties
spring.datasource.platform=mysql db.num=1 db.url.0=jdbc:mysql://自己的ip:3306/nacos_config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true db.user=root db.password=自己的密码记得将文件中的原有配置注释掉，要不然会和上面新增配置内容冲突，可以查考今天下发资料中的application.properties 文件。
重启nacos容器 ```java docker restart nacos
查看nacos的日志
docker logs -f nacos
- **导入配置**
注意：
- 访问nacos可以发现，配置中心中没有了配置内容，因为nacos已经连接了mysql，mysql中并没有配置文件
- 在进行配置之前一定要将潮汛结果导出
<a name="tYxDM"></a>
## Feign远程调用
<a name="pmP1G"></a>
### Feign替代RestTemplate使用步骤
<a name="XhJTI"></a>
#### 引入依赖
- **我们在order-service服务的pom文件中引入feign的依赖：**
```java
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
添加注解
- 在order-service的启动类添加注解开启Feign的功能：
编写Feign的客户端
- 在order-service中新建一个接口，内容如下： ```java package cn.itcast.order.client;
import cn.itcast.order.pojo.User; import org.springframework.cloud.openfeign.FeignClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable;
//这里value = 被调用方的服务名称(注册中心中的名称) @FeignClient(value = “userservice”) public interface UserFeignClient { @GetMapping(“/user/{id}”) User queryById(@PathVariable(“id”) Long id); }
- **这个客户端主要是基于SpringMVC的注解来声明远程调用的信息，比如：**
- **服务名称：userservice**
- **请求方式：GET**
- **请求路径：/user/{id}**
- **请求参数：Long id**
- **返回值类型：User**
- **这样，Feign就可以帮助我们发送http请求，无需自己使用RestTemplate来发送了。**
<a name="cPgSR"></a>
#### 测试
- **修改order-service中的OrderService类中的queryOrderById方法，使用Feign客户端代替RestTemplate：**
<br />
<a name="dnyXv"></a>
#### 总结：**使用Feign的步骤：**
**① 引入依赖**<br />**② 添加@EnableFeignClients注解**<br />**③ 编写FeignClient接口**<br />**④ 使用FeignClient中定义的方法代替RestTemplate**
<a name="eb6Ur"></a>
### 日志级别配置
<a name="EQQsH"></a>
#### 配置文件方式
- **基于配置文件修改feign的日志级别可以针对单个服务：**
```java
feign:
client:
config:
userservice: # 针对某个微服务的配置
loggerLevel: FULL # 日志级别
也可以针对所有服务：
feign: client: config: default: # 这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置 loggerLevel: FULL # 日志级别而日志的级别分为四种：
也可以基于Java代码来修改日志级别，先声明一个类，然后声明一个Logger.Level的对象：
public class DefaultFeignConfiguration { @Bean public Logger.Level feignLogLevel(){ return Logger.Level.BASIC; // 日志级别为BASIC } }如果要全局生效，将其放到启动类的@EnableFeignClients这个注解中：
- 如果是局部生效，则把它放到对应的@FeignClient这个注解中：
优化调用性能
- Feign底层发起http请求，依赖于其它的框架。其底层客户端实现包括：
- URLConnection：默认实现，不支持连接池
- Apache HttpClient ：支持连接池
- OKHttp：支持连接池
- 因此提高Feign的性能主要手段就是使用连接池代替默认的URLConnection。这里我们用Apache的HttpClient来演示。
引入依赖在order-service的pom文件中引入Apache的HttpClient依赖：
<!--httpClient的依赖 --> <dependency> <groupId>io.github.openfeign</groupId> <artifactId>feign-httpclient</artifactId> </dependency>配置连接池，在order-service的application.yml中添加配置：
feign: httpclient: enabled: true # 开启feign对HttpClient的支持 max-connections: 200 # 最大的连接数 max-connections-per-route: 100 # 每个路径的最大连接数接下来，在FeignClientFactoryBean中的loadBalance方法中打断点：
- Debug方式启动order-service服务，可以看到这里的client，底层就是Apache HttpClient：
总结
Feign的优化：
将Feign的Client抽取为独立模块，并且把接口有关的POJO、默认的Feign配置都放到这个模块中，提供给所有消费者使用。
- 例如，将UserClient、User、Feign的默认配置都抽取到一个feign-api包中，所有微服务引用该依赖包，即可直接使用。
实现基于抽取的最佳实践
抽取
- 首先创建一个module，命名为feign-api：
- 在feign-api中然后引入feign的starter依赖
然后，order-service中编写的UserClient、User、DefaultFeignConfiguration都复制到feign-api项目中
在order-service中使用feign-api
首先，删除order-service中的UserClient、User、DefaultFeignConfiguration类或接口。
- 将OrderApplication中的@EnableFeignClients注解删除。
在order-service的pom文件中中引入feign-api的依赖：
<dependency> <groupId>cn.itcast.demo</groupId> <artifactId>feign-api</artifactId> <version>1.0</version> </dependency>修改order-service中的所有与上述三个组件有关的导包部分，改成导入feign-api中的包
重启测试
重启后，发现服务报错了：
- 这是因为UserClient现在在cn.itcast.feign.clients包下，而order-service无@EnableFeignClients注解，也无法扫描到UserClient的Feign接口。
解决扫描包问题
这里为了让引入 feign-api 工程的项目完全忽略Feign的配置和依赖，这里可以在 feign-api 添加 springboot自动装配原理来自动的加载 Feign相关实例内容，步骤如下：
- 在 feign-api 的包下添加 FeignConfig 配置类 ```java package cn.itcast.feign.config;
import org.springframework.cloud.openfeign.EnableFeignClients; import org.springframework.context.annotation.Configuration;
/**
- *
- @Description: */ @Configuration @EnableFeignClients(basePackages = {“cn.itcast.feign.client”}) public class FeignConfig { } ```
在 feign-api 工程下添加 spring.factories 配置文件:在 feign-api 中 resource 下添加 META-INF/spring.factories 文件，并编写下面内容
org.springframework.boot.autoconfigure.EnableAutoConfiguration=cn.itcast.feign.config.FeignConfigGateway服务网关
核心功能
请求路由
- 权限控制
- 限流
- 权限控制：网关作为微服务入口，需要校验用户是是否有请求资格，如果没有则进行拦截。
- 路由和负载均衡：一切请求都必须先经过gateway，但网关不处理业务，而是根据某种规则，把请求转发到某个微服务，这个过程叫做路由。当然路由的目标服务有多个时，还需要做负载均衡。
- 限流：当请求流量过高时，在网关中按照下流的微服务能够接受的速度来放行请求，避免服务压力过大。
网关路由的流程图
Getway快速入门
创建gateway服务，引入依赖
<!--网关--> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-gateway</artifactId> </dependency> <!--nacos服务发现依赖--> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId> </dependency>编写启动类
```java package cn.itcast.gateway;
import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication public class GatewayApplication {
public static void main(String[] args) {
SpringApplication.run(GatewayApplication.class, args);
}
}
<a name="A6NP3"></a>
#### 编写基础配置和路由规则
- **创建application.yml文件，内容如下：**
```java
server:
port: 10010 # 网关端口
spring:
application:
name: gateway # 服务名称
cloud:
nacos:
server-addr: localhost:8848 # nacos地址
gateway:
routes: # 网关路由配置
- id: user-service # 路由id，自定义，只要唯一即可
# uri: http://127.0.0.1:8081 # 路由的目标地址 http就是固定地址
uri: lb://userservice # 路由的目标地址 lb就是负载均衡，后面跟服务名称
predicates: # 路由断言，也就是判断请求是否符合路由规则的条件
- Path=/user/** # 这个是按照路径匹配，只要以/user/开头就符合要求
重启测试
- 重启网关，访问http://localhost:10010/user/1时，符合/user/规则，请求转发到uri：[http://userservice/user/1**](http://userservice/user/1)**，得到了结果：**
总结
- 网关搭建步骤：
- 创建项目，引入nacos服务发现和gateway依赖
- 配置application.yml，包括服务基本信息、nacos地址、路由
- 路由配置包括：
- 路由id：路由的唯一标示
- 路由目标（uri）：路由的目标地址，http代表固定地址，lb代表根据服务名负载均衡
- 路由断言（predicates）：判断路由的规则，
- 路由过滤器（filters）：对请求或响应做处理
断言工厂使用
| 名称 | 说明 | 示例 | | —- | —- | —- | | After | 是某个时间点后的请求 | - After=2037-01-20T17:42:47.789-07:00[America/Denver] | | Before | 是某个时间点之前的请求 | - Before=2031-04-13T15:14:47.433+08:00[Asia/Shanghai] | | Between | 是某两个时间点之前的请求 | - Between=2037-01-20T17:42:47.789-07:00[America/Denver], 2037-01-21T17:42:47.789-07:00[America/Denver] | | Cookie | 请求必须包含某些cookie | - Cookie=chocolate, ch.p | | Header | 请求必须包含某些header | - Header=X-Request-Id, \d+ | | Host | 请求必须是访问某个host（域名） | - Host=.somehost.org,.anotherhost.org | | Method | 请求方式必须是指定方式 | - Method=GET,POST | | Path | 请求路径必须符合指定规则 | - Path=/red/{segment},/blue/** | | Query | 请求参数必须包含指定参数 | - Query=name, Jack或者- Query=name | | RemoteAddr | 请求者的ip必须是指定范围 | - RemoteAddr=192.168.1.1/24 | | Weight | 权重处理 |
|
局部过滤器的使用
- GatewayFilter是网关中提供的一种过滤器，可以对进入网关的请求和微服务返回的响应做处理：
请求头过滤器
需求：给所有进入userservice的请求添加一个请求头：Truth=itcast is freaking awesome!
只需要修改gateway服务的application.yml文件，添加路由过滤即可：
spring: cloud: gateway: routes: - id: user-service uri: lb://userservice predicates: - Path=/user/** filters: # 过滤器 - AddRequestHeader=Truth, Itcast is freaking awesome! # 添加请求头当前过滤器写在userservice路由下，因此仅仅对访问userservice的请求有效。
默认过滤器
如果要对所有的路由都生效，则可以将过滤器工厂写到default下。格式如下：
spring: cloud: gateway: routes: - id: user-service uri: lb://userservice predicates: - Path=/user/** default-filters: # 默认过滤项 - AddRequestHeader=Truth, Itcast is freaking awesome!总结
过滤器的作用是什么？
- 对路由的请求或响应做加工处理，比如添加请求头
- 配置在路由下的过滤器只对当前路由的请求生效
defaultFilters的作用是什么？
定义方式是实现GlobalFilter接口。
public interface GlobalFilter { /** * 处理当前请求，有必要的话通过{@link GatewayFilterChain}将请求交给下一个过滤器处理 * * @param exchange 请求上下文，里面可以获取Request、Response等信息 * @param chain 用来把请求委托给下一个过滤器 * @return {@code Mono<Void>} 返回标示当前过滤器业务结束 */ Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain); }在filter中编写自定义逻辑，可以实现下列功能：
需求：定义全局过滤器，拦截请求，判断请求的参数是否满足下面条件：
- 参数中是否有authorization，
- authorization参数值是否为admin
- 如果同时满足则放行，否则拦截
- 实现：
- 在gateway中定义一个过滤器： ```java package cn.itcast.gateway.filters;
import org.springframework.cloud.gateway.filter.GatewayFilterChain; import org.springframework.cloud.gateway.filter.GlobalFilter; import org.springframework.core.annotation.Order; import org.springframework.http.HttpStatus; import org.springframework.stereotype.Component; import org.springframework.web.server.ServerWebExchange; import reactor.core.publisher.Mono;
@Order(-1)
@Component
public class AuthorizeFilter implements GlobalFilter {
@Override
public Mono
<a name="Gvfg8"></a>
#### 过滤器执行顺序
- **请求进入网关会碰到三类过滤器：当前路由的过滤器、DefaultFilter、GlobalFilter**
- **请求路由后，会将当前路由过滤器和DefaultFilter、GlobalFilter，合并到一个过滤器链（集合）中，排序后依次执行每个过滤器：**
- **排序的规则是什么呢？**
- **每一个过滤器都必须指定一个int类型的order值，order值越小，优先级越高，执行顺序越靠前。**
- **GlobalFilter通过实现Ordered接口，或者添加@Order注解来指定order值，由我们自己指定**
- **路由过滤器和defaultFilter的order由Spring指定，默认是按照声明顺序从1递增。**
- **当过滤器的order值一样时，会按照 defaultFilter > 路由过滤器 > GlobalFilter的顺序执行。**
<a name="C0Gz6"></a>
### 跨域问题和解决
<a name="cRKbN"></a>
#### 跨域问题
- **跨域问题：浏览器禁止请求的发起者与服务端发生跨域ajax请求，请求被浏览器拦截的问题**
- **跨域的本质是浏览器的自我保护机制，保证自己的安全，进行同源策略**
- **服务器请求服务器不会出现跨域**
- **浏览器请求服务器会出现跨域**
- **同源策略**
- **协议,域名,端口三者相同纪委同源策略**
- **跨域：域名不一致就是跨域，主要包括：**
- **域名不同： **[**www.taobao.com**](https://www.taobao.com)** 和 **[**www.taobao.org**](https://www.taobao.org)** 和 **[**www.jd.com**](https://www.jd.com)** 和 miaosha.jd.com**
- **域名相同，端口不同：localhost:8080和localhost8081**
<a name="JXIqs"></a>
#### 模拟跨域问题
**创建文本demo.html。访问demo.html**
```java
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>跨域案例演示</title>
</head>
<body>
<div id="vue">
用户信息：{{user.username}} <br>
用户地址：{{user.address}}
</div>
</body>
<script type="text/javascript" src="js/jquery.min.js"></script>
<script type="text/javascript" src="js/slider.js"></script>
<script type="text/javascript" src="js/vue.js"></script>
<script type="text/javascript" src="js/axios.js"></script>
<script type="text/javascript" src="js/util.js"></script>
<script>
new Vue({
el: '#vue',
data(){
return {
user: {}
}
},
methods: {
loadData () {
axios.get('http://localhost:10010/user/3').then( (response) => {
this.user = response.data
});
}
},
created(){
this.loadData();
}
});
</script>
</html>
解决跨域问题
- 在gateway服务的application.yml文件中，添加下面的配置：
spring: cloud: gateway: # 。。。 globalcors: # 全局的跨域处理 add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题 corsConfigurations: '[/**]': allowedOrigins: "*" # 允许哪些网站的跨域请求 allowedMethods: # 允许的跨域ajax的请求方式 - "GET" - "POST" - "DELETE" - "PUT" - "OPTIONS" allowedHeaders: "*" # 允许在请求中携带的头信息 allowCredentials: true # 是否允许携带cookie maxAge: 360000 # 这次跨域检测的有效期
若有收获，就点个赞吧
0 人点赞
