cloud-fegin&gateway
服务治理、服务注册、服务发现
1.学习目标
- 服务拆分以后,修改配置。完成热部署。
- 换一个方式远程调用=Feign (跨nacos 集群调用)
- gateway服务网关 32 种 断言
- 是个什么东西、运行原理
- 基本配置操作
2.Feign远程调用
2.0 为什么要学Feign
先来看我们以前利用RestTemplate发起远程调用的代码:
存在下面的问题:
-
代码可读性差,编程体验不统一
-
参数复杂URL难以维护
Feign是一个声明式的http客户端,官方地址:https://github.com/OpenFeign/feign
其作用就是帮助我们优雅的实现http请求的发送,解决上面提到的问题。
2.1.Feign替代RestTemplate
1)引入依赖
我们在order-service服务的pom文件中引入feign的依赖:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
2)添加注解
在order-service的启动类添加注解开启Feign的功能@EnableFeignClients:
3)编写Feign的客户端
在order-service中新建一个接口,内容如下:
package com.gaohe.order.client;
import com.gaohe.order.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
// 指定服务名称
@FeignClient("userservice")
public interface UserClient {
//指定映射接口和注解
@GetMapping("/user/{id}")
User findById(@PathVariable("id") Long id);
}
这个客户端主要是基于SpringMVC的注解来声明远程调用的信息,比如:
- 服务名称:userservice
- 请求方式:GET
- 请求路径:/user/{id}
- 请求参数:Long id
- 返回值类型:User
这样,Feign就可以帮助我们发送http请求,无需自己使用RestTemplate来发送了。
4)测试
修改order-service中的OrderService类中的queryOrderById方法,使用Feign客户端代替RestTemplate:
@Autowired
private UserClient userClient;
public Order queryOrderById(Long orderId) {
// 1.查询订单
Order order = orderMapper.findById(orderId);
//3.远程调用查询
User user = userClient.findById(order.getUserId());
//4.赋值
order.setUser(user);
// 4.返回
return order;
}
是不是看起来优雅多了。
5)总结
使用Feign的步骤:
① 引入依赖
② 添加@EnableFeignClients注解
③ 编写FeignClient接口
④ 使用FeignClient中定义的方法代替RestTemplate
2.2.自定义配置
Feign可以支持很多的自定义配置,如下表所示:
一般我们需要配置的就是日志级别。
类型 | 作用 | 说明 |
---|---|---|
feign.Logger.Level | 修改日志级别 | 包含四种不同的级别:NONE、BASIC、HEADERS、FULL |
feign.codec.Decoder | 响应结果的解析器 | http远程调用的结果做解析,例如解析json字符串为java对象 |
feign.codec.Encoder | 请求参数编码 | 将请求参数编码,便于通过http请求发送 |
feign. Contract | 支持的注解格式 | 默认是SpringMVC的注解 |
feign. Retryer | 失败重试机制 | 请求失败的重试机制,默认是没有,不过会使用Ribbon的重试 |
一般情况下,默认值就能满足我们使用,如果要自定义时,只需要创建自定义的@Bean覆盖默认Bean即可。
下面以日志为例来演示如何自定义配置。
日志的级别分为四种:
- NONE:不记录任何日志信息,这是默认值。
- BASIC:仅记录请求的方法,URL以及响应状态码和执行时间
- HEADERS:在BASIC的基础上,额外记录了请求和响应的头信息
- FULL:记录所有请求和响应的明细,包括头信息、请求体、元数据。
2.2.1.配置文件方式(重点掌握)
基于配置文件修改feign的日志级别可以针对单个服务:
feign:
client:
config:
userservice: # 针对某个微服务的配置
loggerLevel: FULL # 日志级别
也可以针对所有服务:
feign:
client:
config:
default: # 这里用default就是全局配置,如果是写服务名称,则是针对某个微服务的配置
loggerLevel: FULL # 日志级别
而日志的级别分为四种:
- NONE:不记录任何日志信息,这是默认值。
- BASIC:仅记录请求的方法,URL以及响应状态码和执行时间
- HEADERS:在BASIC的基础上,额外记录了请求和响应的头信息
- FULL:记录所有请求和响应的明细,包括头信息、请求体、元数据。
2.2.2.Java代码方式(了解)
也可以基于Java代码来修改日志级别,先声明一个类,然后声明一个Logger.Level的对象:
@Configuration
public class DefaultFeignConfiguration {
@Bean
public Logger.Level feignLogLevel(){
return Logger.Level.BASIC; // 日志级别为BASIC
}
}
如果要全局生效,将其放到启动类的@EnableFeignClients这个注解中:
@EnableFeignClients(defaultConfiguration = DefaultFeignConfiguration.class)
如果是局部生效,则把它放到对应的@FeignClient这个注解中:
@FeignClient(value = "userservice", configuration = DefaultFeignConfiguration.class)
-
feign缓存支持(springcache框架)
-
Spring
@RefreshScope
支持 (开启了才支持) -
feign支持OAuth2 支持(搭建oauth2框架)
2.3.Feign使用优化
Feign底层发起http请求,依赖于其它的框架。其底层客户端实现包括:
-
URLConnection:默认实现,不支持连接池
-
Apache HttpClient :支持连接池
-
OKHttp:支持连接池
因此提高Feign的性能主要手段就是
1.使用连接池代替默认的URLConnection
2.日志级别,最好用basic或none
这里我们用Apache的HttpClient来演示。
1)引入依赖
在order-service的pom文件中引入Apache的HttpClient依赖:
<!--httpClient的依赖 -->
<dependency>
<groupId>io.github.openfeign</groupId>
<artifactId>feign-httpclient</artifactId>
</dependency>
2)配置连接池
在order-service的application.yml中添加配置:
feign:
client:
config:
default: # default全局的配置
loggerLevel: BASIC # 日志级别,BASIC就是基本的请求和响应信息
httpclient:
enabled: true # 开启feign对HttpClient的支持
max-connections: 200 # 最大的连接数
max-connections-per-route: 50 # 每个路径的最大连接数
接下来,在中的loadBalance方法中打断点:
Debug方式启动order-service服务,可以看到这里的client,底层就是Apache HttpClient:
Druid\redis连接池\feign连接池…
设计模式:动态代理(JDK)、装饰者模式、适配器模式
总结Feign的优化:
1.日志级别 尽量用basic
2.使用HttpClient或OKHttp代替URLConnection
① 引入feign-httpClient依赖
② 配置文件开启httpClient功能,设置连接池参数
必须要会的三个面试问题?
- 为什么要用feign?
- 好处:
- 代码解耦 2. 自定义配置 3. 连接池调优 4. 他可以和spring其他框架无缝衔接 5. 学习成本很低(springmvc接口规范)
- 使用:
- feign 请求响应格式配置(开启了才支持)
- feign缓存支持(springcache框架)
- Spring
@RefreshScope
支持 (开启了才支持) - feign支持OAuth2 支持(搭建oauth2框架)
2.4.最佳实践
所谓最近实践,就是使用过程中总结的经验,最好的一种使用方式。
自行观察可以发现,Feign的客户端与服务提供者的controller代码非常相似:
feign客户端:
UserController:
有没有一种办法简化这种重复的代码编写呢?
2.4.1.继承方式(了解)
一样的代码可以通过继承来共享:
1)定义一个API接口,利用定义方法,并基于SpringMVC注解做声明
2)Feign客户端和Controller都集成改接口
public interface UserAPI{
@GetMapping("/user/{id}")
User findById(@PathVarible("id")Long id);
}
@FeginClient(value="user-service")
public interface UserClient extends UserAPI{}
@RestController
public class UserController implements UserAPI{
@Override
public User findById(@PathVarible("id")Long id){
...
}
}
优点:
- 简单
- 实现了代码共享
缺点:
-
服务提供方、服务消费方紧耦合
-
参数列表中的注解映射并不会继承,因此Controller中必须再次声明方法、参数列表、注解
2.4.2.抽取方式(重点)
将Feign的Client抽取为独立模块,并且把接口有关的POJO、默认的Feign配置都放到这个模块中,提供给所有消费者使用。
例如,将UserClient、User、Feign的默认配置都抽取到一个feign-api包中,所有微服务引用该依赖包,即可直接使用。
2.4.3.实现基于抽取的最佳实践
1)抽取
首先创建一个module,命名为feign-api:
项目结构:
在feign-api中然后引入feign的starter依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
然后把order-service中编写的UserClient、User、DefaultFeignConfiguration都复制到feign-api项目中
2)在order-service中使用feign-api
首先,删除order-service中的UserClient、User、DefaultFeignConfiguration等类或接口。
在order-service的pom文件中中引入feign-api的依赖:
<dependency>
<groupId>com.gaohe.demo</groupId>
<artifactId>feign-api</artifactId>
<version>1.0</version>
</dependency>
修改order-service中的所有与上述三个组件有关的导包部分,改成导入feign-api中的包
3)重启测试
重启后,发现服务报错了:
这是因为UserClient现在在com.gaohe.feign.clients包下,
而order-service的@EnableFeignClients注解是在com.gaohe.order包下,不在同一个包,无法扫描到UserClient。
4)解决扫描包问题
方式一:
指定Feign应该扫描的包:
@EnableFeignClients(basePackages = "com.itgaohe.fegin.clients")
方式二:
指定需要加载的Client接口:
@EnableFeignClients(clients = {UserClient.class})
总结:
- 创建feign接口模块。
- 引入openFeign依赖。
- 编写相关pojo和clients。
- 消费者模块 引入 feign jar 启动类加入指定扫描类 扫描feign接口。
feign优化:
1. 动态代理
2. 装饰者
3.Gateway服务网关
3.1.为什么需要网关
Spring Cloud Gateway 是 Spring Cloud 的一个全新项目,该项目是基于 Spring 5.0,Spring Boot 2.0 和 Project Reactor 等响应式编程和事件流技术开发的网关,它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。
Gateway网关是我们服务的守门神,所有微服务的统一入口。
网关的核心功能特性:
- 请求路由
- 权限控制
- 限流
- 流控(金丝雀发布,蓝绿发布)
- 熔断
- 黑白名单
- 日志记录
- 用户授权
- 高强服务器
蓝绿发布:是不停老版本,部署新版本然后进行测试。确认OK后将流量切到新版本,然后老版本同时也升级到新版本。
金丝雀发布:在原有版本可用的情况下,同时部署一个新版本应用作为「金丝雀」服务器来测试新版本的性能和表现,以保障整体系统稳定的情况下,尽早发现、调整问题
熔断机制
熔断机制是应对雪崩效应的一种微服务链路保护机制。我们在各种场景下都会接触到熔断这两个字。高压电路中,如果某个地方的电压过高,熔断器就会熔断,对电路进行保护。股票交易中,如果股票指数过高,也会采用熔断机制,暂停股票的交易。同样,在微服务架构中,熔断机制也是起着类似的作用。当扇出链路的某个微服务不可用或者响应时间太长时,会进行服务的降级,进而熔断该节点微服务的调用,快速返回错误的响应信息。当检测到该节点微服务调用响应正常后,恢复调用链路。
在Spring Cloud框架里,熔断机制通过Hystrix实现。Hystrix会监控微服务间调用的状况,当失败的调用到一定阈值,缺省是5秒内20次调用失败,就会启动熔断机制。熔断机制的注解是@HystrixCommand,Hystrix会找有这个注解的方法,并将这类方法关联到和熔断器连在一起的代理上。当前,@HystrixCommand仅当类的注解为@Service或@Component时才会发挥作用。
架构图:
身份认证和权限校验:网关作为微服务入口,需要校验用户是是否有请求资格,如果没有则进行拦截。
服务路由和负载均衡:一切请求都必须先经过gateway,但网关不处理业务,而是根据某种规则,把请求转发到某个微服务,这个过程叫做路由。当然路由的目标服务有多个时,还需要做负载均衡。
请求限流:当请求流量过高时,在网关中按照下流的微服务能够接受的速度来放行请求,避免服务压力过大。
在SpringCloud中网关的实现包括两种:
- gateway
- zuul
Zuul是基于Servlet的实现,属于阻塞式编程。而SpringCloudGateway则是基于Spring5中提供的WebFlux,属于响应式编程的实现,具备更好的性能。
3.2.gateway快速入门
下面,我们就演示下网关的基本路由功能。基本步骤如下:
- 创建SpringBoot工程gateway,引入网关依赖
- 编写启动类
- 编写基础配置和路由规则yml
- 启动网关服务进行测试
1)创建gateway服务,引入依赖
创建服务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>
2)编写启动类
package com.gaohe.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);
}
}
3)编写基础配置和路由规则
创建application.yml文件,内容如下:
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://user-service #路由的目标地址 lb就是负载均衡 后面跟着服务名
predicates: #路由断言 也就是判断请求是否符合路由规则的条件
- Path=/user/** #这个是按照路径匹配 只要以/user/开头就符合要求
- id: order-service # 路由微服务的id 自定义
uri: lb://order-service #路由的目标地址 lb就是负载均衡 后面跟着服务名
predicates: #路由断言 也就是判断请求是否符合路由规则的条件
- Path=/order/** #这个是按照路径匹配 只要以/user/开头就符合要求
我们将符合Path
规则的一切请求,都代理到 uri
参数指定的地址。
本例中,我们将 /user/**
开头的请求,代理到lb://userservice
,lb是负载均衡,根据服务名拉取服务列表,实现负载均衡。
4)重启测试
重启网关,访问http://localhost:10010/user/1时,符合/user/**
规则,请求转发到uri:http://userservice/user/1,得到了结果:
5)网关路由的流程图
整个访问的流程如下:
总结:
网关搭建步骤:
-
创建项目,引入nacos服务发现和gateway依赖
-
配置application.yml,包括服务基本信息、nacos地址、路由
路由配置包括:
-
路由id:路由的唯一标示
-
路由目标(uri):路由的目标地址,http代表固定地址,lb代表根据服务名负载均衡
-
路由断言(predicates):判断路由的规则
-
路由过滤器(filters):对请求或响应做处理
接下来,就重点来学习路由断言和路由过滤器的详细知识
3.3.断言工厂
应用场景:
- 确保代码的正确性
- 确保环境的正确性
我们在配置文件中写的断言规则只是字符串,这些字符串会被Predicate Factory读取并处理,转变为路由判断的条件
例如Path=/user/**是按照路径匹配,这个规则是由
org.springframework.cloud.gateway.handler.predicate.PathRoutePredicateFactory
类来处理的,像这样的断言工厂在SpringCloudGateway还有十几个:
名称 | 说明 | 示例 |
---|---|---|
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 | 权重处理 |
测试:
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/开头就符合要求
- After=2037-01-20T17:42:47.789-07:00[America/Denver]
- id: order-service
uri: lb://orderservice
predicates:
- Path=/order/** # 这个是按照路径匹配,只要以/user/开头就符合要求
# - After=2037-01-20T17:42:47.789-07:00[America/Denver]
我们只需要掌握Path这种路由工程就可以了。
3.4.过滤器工厂
GatewayFilter是网关中提供的一种过滤器,可以对进入网关的请求和微服务返回的响应做处理:
1.路由过滤器-指定服务的路由器
2.默认过滤器-全局的默认路由器
3.全局过滤器-自定义的业务路由器
3.4.1.路由过滤器的种类
Spring提供了31种不同的路由过滤器工厂。例如:
名称 | 说明 |
---|---|
AddRequestHeader | 给当前请求添加一个请求头 |
RemoveRequestHeader | 移除请求中的一个请求头 |
AddResponseHeader | 给响应结果中添加一个响应头 |
RemoveResponseHeader | 从响应结果中移除有一个响应头 |
RequestRateLimiter | 限制请求的流量 |
3.4.2.路由过滤器-请求头过滤器
下面我们以AddRequestHeader 为例来讲解。
需求:给所有进入userservice的请求添加一个请求头:token,itgaohe
只需要修改gateway服务的application.yml文件,添加路由过滤即可:
spring:
cloud:
gateway:
routes:
- id: user-service
uri: lb://userservice
predicates:
- Path=/user/**
filters: #路由过滤器
- AddRequestHeader=tou,itgaohe # 添加请求头 : 格式 k,v
当前过滤器写在userservice路由下,因此仅仅对访问userservice的请求有效。
测试:
UserController
@GetMapping("/{id}")
public User queryById(@PathVariable("id") Long id, HttpServletRequest request) {
System.out.println(request.getHeader("tou"));//获取请求头
return userService.queryById(id);
}
//或者
@GetMapping("/{id}")
public User queryById(@PathVariable("id") Long id,@RequestHeader(value = "tou", required = false) String tou) {
System.out.println("tou = " + tou);
return userService.queryById(id);
}
重启服务
分别访问
网关路径:http://127.0.0.1:10010/user/1
常规路径:http://127.0.0.1:8081/user/1
看控制台打印的数据
3.4.3.默认过滤器
如果要对所有的路由都生效,则可以将过滤器工厂写到default下。格式如下:
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/开头就符合要求
# - After=2037-01-20T17:42:47.789-07:00[America/Denver]
filters: # 过滤器
- AddRequestHeader=tou,itgaohe
default-filters: # 默认过滤项
- AddRequestHeader=tou2,itgaohe22 # 添加请求头
default-filters级别跟路由routes一个级别
UserController
@GetMapping("/{id}")
public User queryById(@PathVariable("id") Long id,
@RequestHeader(value = "tou", required = false) String tou,
@RequestHeader(value = "tou2", required = false) String tou2) {
System.err.println("tou = " + tou);
System.err.println("tou2 = " + tou2);
return userService.queryById(id);
}
测试 看控制台打印的内容
3.4.4.总结
过滤器的作用是什么?
① 对路由的请求或响应做加工处理,比如添加请求头
② 配置在路由下的过滤器只对当前路由的请求生效
defaultFilters的作用是什么?
① 对所有路由都生效的过滤器
3.4.5.全局过滤器
上一节学习的过滤器,网关提供了31种,但每一种过滤器的作用都是固定的。如果我们希望拦截请求,做自己的业务逻辑则没办法实现。
需求:定义全局过滤器,拦截请求,判断请求的参数是否满足下面条件:
-
参数中是否有auth,
-
auth参数值是否为admin
如果同时满足则放行,否则拦截
3.4.5.1.全局 GlobalFilter过滤器作用
全局过滤器的作用也是处理一切进入网关的请求和微服务响应,与GatewayFilter的作用一样。区别在于GatewayFilter通过配置定义,处理逻辑是固定的;而GlobalFilter的逻辑需要自己写代码实现。
定义方式是实现GlobalFilter接口。
public interface GlobalFilter {
/**
* 处理当前请求,有必要的话通过{@link GatewayFilterChain}将请求交给下一个过滤器处理
* @param exchange 请求上下文,里面可以获取Request、Response等信息
* @param chain 用来把请求委托给下一个过滤器
* @return {@code Mono<Void>} 返回标示当前过滤器业务结束
*/
Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);
}
在filter中编写自定义逻辑,可以实现下列功能:
- 登录状态判断
- 权限校验
- 请求限流等
3.4.5.2.自定义全局过滤器
需求:定义全局过滤器,拦截请求,判断请求的参数是否满足下面条件:
-
参数中是否有auth,
-
auth参数值是否为admin
如果同时满足则放行,否则拦截
实现:
在gateway中定义一个过滤器:
package com.itgaohe.filter;
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;
//1.实现 接口 重写filter
//2. 写业务
//3. spring管理
@Order(-1)
//注解@Order或者接口Ordered的作用是定义Spring IOC容器中Bean的执行顺序的优先级,而不是定义Bean的加载顺序,Bean的加载顺序不受@Order或Ordered接口的影响。值越小拥有越高的优先级,可为负数。@Order(-1)优先于@Order(0) @Order(1)优先于@Order(2)
@Component
public class AuthFilter implements GlobalFilter {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
// 1.获取请求参数
MultiValueMap<String, String> params = exchange.getRequest().getQueryParams();
// 2.获取auth参数
String auth = params.getFirst("auth");
// 3.校验
if ("admin".equals(auth)) {
// 放行
return chain.filter(exchange);
}
// 4.拦截
// 4.1.禁止访问,设置状态码
exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);
// 4.2.结束处理
return exchange.getResponse().setComplete();
}
}
测试
重启 gateway网关模块
分别访问
http://127.0.0.1:10010/user/1 //无权限访问
http://127.0.0.1:10010/user/1?auth=admin //可以进入
3.4.5.3 拦截器回顾
在user-service模块
AuthInterceptor
@Component
public class AuthInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//获取头
String tou = request.getHeader("tou");
if ("itgaohe".equals(tou)){
return true;
}
//失败
System.out.println("请遵纪守法,访问失败");
response.setStatus(302);
response.setContentType("text/html;charset=utf-8");
response.getWriter().write("请遵纪守法,访问失败");
return false;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
}
}
SpringMvcConfig
@Configuration
@EnableWebMvc
public class SpringMvcConfig implements WebMvcConfigurer {
@Autowired
private AuthInterceptor authInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(authInterceptor).addPathPatterns("/**");
}
}
重启服务 访问
http://127.0.0.1:10010/user/1?auth=admin
只有经过网关的+拦截器识别到了请求头中的信息 才能放行。其他都无法进入
3.4.6.过滤器执行顺序
请求进入网关会碰到三类过滤器:当前路由过滤器、DefaultFilter、GlobalFilter
使用方式:所有服务默认配置–官方提供的配置–自定义的规则
请求路由后,会将当前路由过滤器和DefaultFilter、GlobalFilter,合并到一个过滤器链(集合)中,排序后依次执行每个过滤器:
排序的规则是什么呢?
- 每一个过滤器都必须指定一个int类型的order值,order值越小,优先级越高,执行顺序越靠前。
- GlobalFilter通过实现Ordered接口,或者添加@Order注解来指定order值,由我们自己指定
- 路由过滤器和defaultFilter的order由Spring指定,默认是按照声明顺序从1递增。
- 当过滤器的order值一样时,会按照 defaultFilter > 路由过滤器 > GlobalFilter的顺序执行。
详细内容,可以查看源码:
org.springframework.cloud.gateway.route.RouteDefinitionRouteLocator#getFilters()
方法是先加载defaultFilters,然后再加载某个route的filters,然后合并。
org.springframework.cloud.gateway.handler.FilteringWebHandler#handle()
方法会加载全局过滤器,与前面的过滤器合并后根据order排序,组织过滤器链
3.5.跨域问题(重要)
3.5.1.模拟跨域问题
案例:采用axios发送请求获得数据
1.创建模块 web-server
2.添加依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
3.application.yml
server:
port: 81
4.导入 文件 static
5.boot启动类
@SpringBootApplication
public class WebApplication {
public static void main(String[] args) {
SpringApplication.run(WebApplication.class, args);
}
}
6.启动访问 81端口 点击发送 后台报错
从localhost:81访问localhost:10010,端口不同,显然是跨域的请求。
3.5.2.什么是跨域问题
跨域:域名不一致就是跨域,主要包括:
-
域名不同: www.taobao.com 和 www.taobao.org 和 www.jd.com 和 miaosha.jd.com
-
域名相同,端口不同:localhost:8080和localhost8081
跨域问题:浏览器禁止请求的发起者与服务端发生跨域ajax请求,请求被浏览器拦截的问题
解决方案:CORS,这个以前应该学习过,这里不再赘述了。不知道的小伙伴可以查看https://www.ruanyifeng.com/blog/2016/04/cors.html
在浏览器中,
3.5.3 跨域问题处理-同源策略
同源策略是一种约定,浏览器最核心也最基本的安全功能,为了保护本地数据不被JavaScript代码获取回来的数据污染,因此拦截的是客户端发出的请求回来的数据接收,即请求发送了,服务器响应了,但是无法被浏览器接收。如果缺少了同源策略,则浏览器的正常功能可能都会受到影响。
可以说Web是构建在同源策略基础之上的,浏览器只是针对同源策略的一种实现。
协议+域名+端口号 三者相同,可以视为在一个域,即是同源的.同源策略
Cookie, localStorage等存储内容
3.5.4.解决跨域问题
在gateway服务的application.yml文件中,添加下面的配置:
spring:
cloud:
gateway:
globalcors: # 全局的跨域处理
add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题
corsConfigurations:
'[/**]':
allowedOrigins: # 允许哪些网站的跨域请求
- "http://localhost:8080"
- "http://localhost:9000"
- "http://localhost:81"
allowedMethods: # 允许的跨域ajax的请求方式
- "GET"
- "POST"
- "DELETE"
- "PUT"
- "OPTIONS"
allowedHeaders: "*" # 允许在请求中携带的头信息
allowCredentials: true # 是否允许携带cookie
maxAge: 360000 # 这次跨域检测的有效期
总结:
配置中心
-
springboot配置文件你知道哪几种?他们的执行顺序是什么?
项目外配置文件(nacos配置文件)>aplication-dev.properties >application.properties aplication.yaml >aplication.yml>bootstrap.yaml -- 为什么bootstrap.yaml最后生效呢? bootstrap.yml 由父Spring ApplicationContext加载,承接上下文。 bootstrap.yml 可以理解成系统级别的一些参数配置,这些参数一般是不会变动的。 由里向外加载,所以最外层的最后被加载,会覆盖里层的属性
-
哪个配置文件可以实现热部署或云配置? bootstrap.yaml
-
热部署配置文件的生效顺序是什么?
- tips: 云userserver-dev.yaml 云userserver.yaml 本地application.yaml
-
热部署同步实现方式有几种,分别是什么?
- 2种: @RefreshScope @ConfigurationProperties(prefix = “pattern”)
feign
必须要会的三个面试问题?
-
为什么要用feign?
- restTemplete( 1. 侵入式开发 2. 配置复杂 3.优化不方便 )
-
好处:1. 代码解耦 2. 自定义配置 3. 连接池调优 4. 他可以和spring其他框架无缝衔接
-
- 学习成本很低(springmvc接口规范)
-
-
使用:
- feign 请求响应格式配置(开启了才支持)
- feign缓存支持(springcache框架)
- Spring
@RefreshScope
支持 (开启了才支持) - feign支持OAuth2 支持(搭建oauth2框架)
-
Feign的优化:
1.日志级别 尽量用basic
2.使用HttpClient或OKHttp代替URLConnection
① 引入feign-httpClient依赖
② 配置文件开启httpClient功能,设置连接池参数
网关geteway
- 请求路由 - 权限控制 - 负载均衡
- 限流 - 流控(金丝雀发布,蓝绿发布)
- 熔断 - 黑白名单
- 日志记录 - 用户授权 - 高强服务器
网关重要概念:
-
断言?
-
过滤器?默认的 路由 全局
-
过滤器链执行顺序
-
- 每一个过滤器都必须指定一个int类型的order值,**order值越小,优先级越高,执行顺序越靠前**。 - GlobalFilter通过实现Ordered接口,或者添加@Order注解来指定order值,由我们自己指定 - 路由过滤器和defaultFilter的order由Spring指定,默认是按照声明顺序从1递增。 - 当过滤器的order值一样时,会按照 defaultFilter > 路由过滤器 > GlobalFilter的顺序执行。
跨域访问
什么叫跨域
- 域名不同
- 域名相同、端口不同