微服务--熟练把握网关(包罗权限认证)
目次一、网关的路由
二、网关登录的校验
2.1.鉴权思绪分析
2.2.网关过滤器
2.3 自界说过滤器
2.3.1 自界说GatewayFilter
2.3.2 自界说GlobalFilter
2.4 登陆校验
具体的实现步调:
一、在微服务中,我们在微服务的网关模块,就要进行验证。对请求的信息进行剖析。
二、拦截器获取用户
三、OpenFeign通报用户编辑
问题:我们把单体项目划分为多个微服务,在微服务之间的端口号不同,服务的名称也不同,在与前端联调的时候我们会发现一些问题。对于请求不同的数据要访问不同的入口,需要维护多个端口地址,前端无法调用nacos,无法实现更新的服务列表。我们应该怎么处置惩罚?
带着问题学习:
对于登录校验,我们只需要完成一次登录、身份校验就可以在所以的业务中获取用户的信息。而微服务拆分后,每个微服务都独立部署,这就存在一些问题?
[*]每个微服务都需要编写登录校验、用户信息的获取功能吗?
[*]当微服务之间调用时,该假如通报用户的信息?
通过本日的学习你将把握下列能力:
[*] 会利用微服务网关做请求路由
[*] 会利用微服务网关做登录身份校验
[*] 会利用Nacos实现统一配置管理
[*] 会利用Nacos实现配置热更新
[*] 第一章:网关路由,解决前端请求入口的问题。
[*] 第二章:网关鉴权,解决统一登录校验和用户信息获取的问题。
[*] 第三章:统一配置管理,解决微服务的配置文件重复和配置热更新问题。
好了,接下来我们就一起进入本日的学习吧。
一、网关的路由
1.1 什么是网关?网关就是负责数据的路由和转发以及数据安全的校验。
他就像是小区门口的大爷,当你告诉大爷,你需要找谁,大爷会对你的身份进行验证,验证成功后,大爷会帮你带路,找到你需要找的人。
[*] 网关可以做安全控制,也就是登录身份校验,校验通过才放行
[*] 通过认证后,网关再根据请求判定应该访问哪个微服务,将请求转发过去
https://i-blog.csdnimg.cn/direct/76bf5d62e7564f339c775c6bfc258220.png
对于的网站:https://spring.io/projects/spring-cloud-gateway#learn
1.2 网关的快速入门
[*] 创建网关微服务
[*] 引入SpringCloudGateway、NacosDiscovery依赖
[*] 编写启动类
[*] 配置网关路由
(1)在微服务中创建一个模块,在模块中写添加对应的依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>hmall</artifactId>
<groupId>com.heima</groupId>
<version>1.0.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>hm-gateway</artifactId>
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
</properties>
<dependencies>
<!--网关-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!--nacos discovery-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!--负载均衡-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>
</dependencies>
<build>
<finalName>${project.artifactId}</finalName>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project> (2)编写启动类
(3)配置对应的网关路由 (端口号,名称,网关路由)
server:
port: 8080
spring:
application:
name: gateway
cloud:
nacos:
server-addr: 192.168.150.101:8848
gateway:
routes:
- id: item # 路由规则id,自定义,唯一
uri: lb://item-service # 路由的目标服务,lb代表负载均衡,会从注册中心拉取服务列表
predicates: # 路由断言,判断当前请求是否符合当前规则,符合则路由到目标服务
- Path=/items/**,/search/** # 这里是以请求路径作为判断规则
- id: cart
uri: lb://cart-service
predicates:
- Path=/carts/**
- id: user
uri: lb://user-service
predicates:
- Path=/users/**,/addresses/**
- id: trade
uri: lb://trade-service
predicates:
- Path=/orders/**
- id: pay
uri: lb://pay-service
predicates:
- Path=/pay-orders/**
1.3 路由的过滤规则
spring:
cloud:
gateway:
routes:
- id: item
uri: lb://item-service
predicates:
- Path=/items/**,/search/**
[*] id:路由的唯一标示
[*] predicates:路由断言,其实就是匹配条件
[*] filters:路由过滤条件,后面讲
[*] uri:路由目标地址,lb://代表负载均衡,从注册中心获取目标微服务的实例列表,而且负载均衡选择一个访问。
这里我们重点关注predicates,也就是路由断言。SpringCloudGateway中支持的断言范例有很多:
名称
阐明
示例
After
是某个时间点后的请求
- After=2037-01-20T17:42:47.789-07:00
Before
是某个时间点之前的请求
- Before=2031-04-13T15:14:47.433+08:00
Between
是某两个时间点之前的请求
- Between=2037-01-20T17:42:47.789-07:00, 2037-01-21T17:42:47.789-07:00
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
权重处置惩罚
二、网关登录的校验
单体架构时我们只需要完成一次用户登录、身份校验,就可以在所有业务中获取到用户信息。而微服务拆分后,每个微服务都独立部署,不再共享数据。也就意味着每个微服务都需要做登录校验,这显然不可取。
2.1.鉴权思绪分析
我们的登录是基于JWT来实现的,校验JWT的算法复杂,而且需要用到秘钥。假如每个微服务都去做登录校验,这就存在着两大问题:
[*] 每个微服务都需要知道JWT的秘钥,不安全
[*] 每个微服务重复编写登录校验代码、权限校验代码,麻烦
既然网关是所有微服务的入口,统统请求都需要先经过网关。我们完全可以把登录校验的工作放到网关去做,这样之前说的问题就解决了:
[*] 只需要在网关和用户服务生存秘钥
[*] 只需要在网关开辟登录校验功能
此时,登录校验的流程如图:
https://i-blog.csdnimg.cn/direct/d94336ec370c4b4183b51abe9b838b7b.png
不过,这里存在几个问题:
[*] 网关路由是配置的,请求转发是Gateway内部代码,我们如安在转发之前做登录校验?
[*] 网关校验JWT之后,如何将用户信息通报给微服务?
[*] 微服务之间也会相互调用,这种调用不经过网关,又该如何通报用户信息?
2.2.网关过滤器
登录校验必须在请求转发到微服务之前做,否则就失去了意义。而网关的请求转发是Gateway内部代码实现的,要想在请求转发之前做登录校验,就必须了解Gateway内部工作的基本原理。
https://i-blog.csdnimg.cn/direct/0430e74e6ce141aa83d93e07e55d155b.png
如图所示:
[*] 客户端请求进入网关后由HandlerMapping对请求做判定,找到与当前请求匹配的路由规则(Route),然后将请求交给WebHandler去处置惩罚。
[*] WebHandler则会加载当前路由下需要实验的过滤器链(Filter chain),然后按照顺序逐一实验过滤器(后面称为Filter)。
[*] 图中Filter被虚线分为左右两部分,是由于Filter内部的逻辑分为pre和post两部分,分别会在请求路由到微服务之前和之后被实验。
[*] 只有所有Filter的pre逻辑都依次顺序实验通过后,请求才会被路由到微服务。
[*] 微服务返回结果后,再倒序实验Filter的post逻辑。
[*] 最终把响应结果返回。
如图中所示,最终请求转发是有一个名为NettyRoutingFilter的过滤器来实验的,而且这个过滤器是整个过滤器链中顺序最靠后的一个。假如我们可以或许界说一个过滤器,在其中实现登录校验逻辑,而且将过滤器实验顺序界说到NettyRoutingFilter之前,这就符合我们的需求了!
那么,该如何实现一个网关过滤器呢?
网关过滤器链中的过滤器有两种:
[*] GatewayFilter:路由过滤器,作用范围比较灵活,可以是任意指定的路由Route.
[*] GlobalFilter:全局过滤器,作用范围是所有路由,不可配置。
其实GatewayFilter和GlobalFilter这两种过滤器的方法签名完全一致:
/**
* 处理请求并将其传递给下一个过滤器
* @param exchange 当前请求的上下文,其中包含request、response等各种数据
* @param chain 过滤器链,基于它向下传递请求
* @return 根据返回值标记当前请求是否被完成或拦截,chain.filter(exchange)就放行了。
*/
Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain); FilteringWebHandler在处置惩罚请求时,会将GlobalFilter装饰为GatewayFilter,然后放到同一个过滤器链中,排序以后依次实验。
Gateway中内置了很多的GatewayFilter,详情可以参考官方文档:
https://docs.spring.io/spring-cloud-gateway/docs/3.1.7/reference/html/#gatewayfilter-factories
Gateway内置的GatewayFilter过滤器利用起来非常简朴,无需编码,只要在yaml文件中简朴配置即可。而且其作用范围也很灵活,配置在哪个Route下,就作用于哪个Route.
例如,有一个过滤器叫做AddRequestHeaderGatewayFilterFacotry,顾明思议,就是添加请求头的过滤器,可以给请求添加一个请求头并通报到下游微服务。
利用的利用只需要在application.yaml中这样配置:
spring:
cloud:
gateway:
routes:
- id: test_route
uri: lb://test-service
predicates:
-Path=/test/**
filters:
- AddRequestHeader=key, value # 逗号之前是请求头的key,逗号之后是value 假如想要让过滤器作用于所有的路由,则可以这样配置:
spring:
cloud:
gateway:
default-filters: # default-filters下的过滤器可以作用于所有路由
- AddRequestHeader=key, value
routes:
- id: test_route
uri: lb://test-service
predicates:
-Path=/test/** 2.3 自界说过滤器
无论是GatewayFilter还是GlobalFilter都支持自界说,只不过编码方式、利用方式略有差异。
2.3.1 自界说GatewayFilter
自界说GatewayFilter不是直接实现GatewayFilter,而是实现AbstractGatewayFilterFactory。最简朴的方式是这样的:
@Component
public class PrintAnyGatewayFilterFactory extends AbstractGatewayFilterFactory<Object> {
@Override
public GatewayFilter apply(Object config) {
return new GatewayFilter() {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
// 获取请求
ServerHttpRequest request = exchange.getRequest();
// 编写过滤器逻辑
System.out.println("过滤器执行了");
// 放行
return chain.filter(exchange);
}
};
}
} 注意:该类的名称肯定要以GatewayFilterFactory为后缀!
然后在yaml配置中这样利用:
spring:
cloud:
gateway:
default-filters:
- PrintAny # 此处直接以自定义的GatewayFilterFactory类名称前缀类声明过滤器 别的,这种过滤器还可以支持动态配置参数,不过实现起来比较复杂,示例:
@Component
public class PrintAnyGatewayFilterFactory // 父类泛型是内部类的Config类型
extends AbstractGatewayFilterFactory<PrintAnyGatewayFilterFactory.Config> {
@Override
public GatewayFilter apply(Config config) {
// OrderedGatewayFilter是GatewayFilter的子类,包含两个参数:
// - GatewayFilter:过滤器
// - int order值:值越小,过滤器执行优先级越高
return new OrderedGatewayFilter(new GatewayFilter() {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
// 获取config值
String a = config.getA();
String b = config.getB();
String c = config.getC();
// 编写过滤器逻辑
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
// 放行
return chain.filter(exchange);
}
}, 100);
}
// 自定义配置属性,成员变量名称很重要,下面会用到
@Data
static class Config{
private String a;
private String b;
private String c;
}
// 将变量名称依次返回,顺序很重要,将来读取参数时需要按顺序获取
@Override
public List<String> shortcutFieldOrder() {
return List.of("a", "b", "c");
}
// 返回当前配置类的类型,也就是内部的Config
@Override
public Class<Config> getConfigClass() {
return Config.class;
}
} 然后在yaml文件中利用:
spring:
cloud:
gateway:
default-filters:
- PrintAny=1,2,3 # 注意,这里多个参数以","隔开,将来会按照shortcutFieldOrder()方法返回的参数顺序依次复制 上面这种配置方式参数必须严酷按照shortcutFieldOrder()方法的返回参数名顺序来赋值。
还有一种用法,无需按照这个顺序,就是手动指定参数名:
spring:
cloud:
gateway:
default-filters:
- name: PrintAny
args: # 手动指定参数名,无需按照参数顺序
a: 1
b: 2
c: 3 2.3.2 自界说GlobalFilter
自界说GlobalFilter则简朴很多,直接实现GlobalFilter即可,而且也无法设置动态参数:
@Component
public class PrintAnyGlobalFilter implements GlobalFilter, Ordered {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
// 编写过滤器逻辑
System.out.println("未登录,无法访问");
// 放行
// return chain.filter(exchange);
// 拦截
ServerHttpResponse response = exchange.getResponse();
response.setRawStatusCode(401);
return response.setComplete();
}
@Override
public int getOrder() {
// 过滤器执行顺序,值越小,优先级越高
return 0;
}
} 2.4 登陆校验
https://i-blog.csdnimg.cn/direct/fe990abf7e2b4c7eb22532d8ee2b0ead.png
逻辑:
1.获取Request
2.判定是否需要拦截
3.获取请求头的tocken
4.校验而且剖析对应的token
5.假如有效获取用户的学习
6. 放行
具体的实现步调:
一、在微服务中,我们在微服务的网关模块,就要进行验证。对请求的信息进行剖析。
我们在网关服务中的filter包中界说一个AuthGlobalFilter的类:
代码如下:(生存用户到请求头中)
@Component
@RequiredArgsConstructor
@EnableConfigurationProperties(AuthProperties.class)
public class AuthGlobalFilter implements GlobalFilter, Ordered {
private final JwtTool jwtTool;
private final AuthProperties authProperties;
private final AntPathMatcher antPathMatcher = new AntPathMatcher();
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
// 1.获取Request
ServerHttpRequest request = exchange.getRequest();
// 2.判断是否不需要拦截
if(isExclude(request.getPath().toString())){
// 无需拦截,直接放行
return chain.filter(exchange);
}
// 3.获取请求头中的token
String token = null;
List<String> headers = request.getHeaders().get("authorization");
if (!CollUtils.isEmpty(headers)) {
token = headers.get(0);
}
// 4.校验并解析token
Long userId = null;
try {
userId = jwtTool.parseToken(token);
} catch (UnauthorizedException e) {
// 如果无效,拦截
ServerHttpResponse response = exchange.getResponse();
response.setRawStatusCode(401);
return response.setComplete();
}
//5.如果有效,传递用户信息
// System.out.println("userId = " + userId);
String userInfo = userId.toString();
ServerWebExchange ex = exchange.mutate()
.request(b->b.header("user-info",userInfo))
.build();
// 6.放行
return chain.filter(exchange);
}
private boolean isExclude(String antPath) {
for (String pathPattern : authProperties.getExcludePaths()) {
if(antPathMatcher.match(pathPattern, antPath)){
return true;
}
}
return false;
}
@Override
public int getOrder() {
return 0;
}
} 二、拦截器获取用户
有个工具类生存登任命户的ThreadLocal工具:以及提供了生存和获取用户的方法
public class UserContext {
private static final ThreadLocal<Long> tl = new ThreadLocal<>();
/**
* 保存当前登录用户信息到ThreadLocal
* @param userId 用户id
*/
public static void setUser(Long userId) {
tl.set(userId);
}
/**
* 获取当前登录用户信息
* @return 用户id
*/
public static Long getUser() {
return tl.get();
}
/**
* 移除当前登录用户信息
*/
public static void removeUser(){
tl.remove();
}
}
由于每个微服务都需要获取登任命户的需求,利用拦截器直接卸载common包中:
在common包中界说一个interceptor包中界说一个UserInfoInterceptor:
public class UserInfoInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
// 1.获取请求头中的用户信息
String userInfo = request.getHeader("user-info");
// 2.判断是否为空
if (StrUtil.isNotBlank(userInfo)) {
// 不为空,保存到ThreadLocal
UserContext.setUser(Long.valueOf(userInfo));
}
// 3.放行
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
// 移除用户
UserContext.removeUser();
}
} 在common中进行编写SpringMvc的配置类和配置登录的拦截器:
在config包中创建一个MvcConfig:
@Configuration
@ConditionalOnClass(DispatcherServlet.class)
public class MvcConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new UserInfoInterceptor());
}
} 不过,需要注意的是,这个配置类默认是不会见效的,由于它地点的包是com.hmall.common.config,与别的微服务的扫描包不一致,无法被扫描到,因此无法见效。
基于SpringBoot的自动装配原理,我们要将其添加到resources目次下的META-INF/spring.factories文件中:
https://i-blog.csdnimg.cn/direct/0ec11c1d1b1742409ab6326f4adc6c1b.png
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.hmall.common.config.MyBatisConfig,\
com.hmall.common.config.MvcConfig 三、OpenFeign通报用户
https://i-blog.csdnimg.cn/direct/caf59143f7384a74bfa2ec61ebfa054f.png
。但是,订单服务调用购物车时并没有通报用户信息,购物车服务无法知道当前用户是谁!
由于微服务获取用户信息是通过拦截器在请求头中读取,因此要想实现微服务之间的用户信息通报,就必须在微服务发起调用时把用户信息存入请求头。
这里要借助Feign中提供的一个拦截器接口:feign.RequestInterceptor
https://i-blog.csdnimg.cn/direct/4218c4cdb2c144b4aa9bb92fe66897e5.png
https://i-blog.csdnimg.cn/direct/1dade971d6654dcfade9aba243ddbfc0.png
在com.hmall.api.config.DefaultFeignConfig中添加一个Bean:
@Bean
public RequestInterceptor userInfoRequestInterceptor(){
return new RequestInterceptor() {
@Override
public void apply(RequestTemplate template) {
// 获取登录用户
Long userId = UserContext.getUser();
if(userId == null) {
// 如果为空则直接跳过
return;
}
// 如果不为空则放入请求头中,传递给下游微服务
template.header("user-info", userId.toString());
}
};
} 好了,如今微服务之间通过OpenFeign调用时也会通报登任命户信息了。
免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!更多信息从访问主页:qidao123.com:ToB企服之家,中国第一个企服评测及商务社交产业平台。
页:
[1]