devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Springcloud gateway网关+认证服务+token方式，入口层认证统一微服务鉴权【设计实践】_spring boot 2.7.6 spring-cloud-starter-gateway

作者：你好赵伟 | 2024-06-29 06:11:42

赞

踩

spring boot 2.7.6 spring-cloud-starter-gateway

目录

背景

实现

gateway

maven配置

yml配置

页面登录拦截配置类

白名单配置

token工具类

登录配置类

全局过滤器类

项目启动类

背景

分布式项目的单点登录分为认证服务（单点登录服务端）和业务服务（单点登录客户端）两个角色，

当访问业务服务时，认证服务客户端SDK校验一下是否有登录token，如果没有登录token，需要携带当前请求链接重定向到认证服务，认证通过后由认证服务重定向业务服务链接，实现单点登录。

gateway实现单点登录客户端功能，一般如果前后端项目是分离的，如果请求中没有携带登录token，直接返回需要认证，前后端没有分离的项目，可以做页面重定向操作。

本文主要讨论gateway的实现，认证服务需要自行实现。

实现

gateway

注册中心、配置中心用的nacos

nacos官网：home

配置可以参考：Springcloud+Druid+Mybatis+Seata+Nacos动态切换多数据源，分布式事务的实现_殷长庆的博客-CSDN博客_seata多数据源切换

maven配置

主要集成nacos注册、配置中心和gateway网关

  1.  
  2.         <dependency>
  3.             <groupId>com.alibaba.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>com.alibaba.cloud</groupId>
  8.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  9.         </dependency>
  10.         <dependency>
  11.             <groupId>org.springframework.boot</groupId>
  12.             <artifactId>spring-boot-starter-actuator</artifactId>
  13.         </dependency>
  14.         <dependency>
  15.             <groupId>org.projectlombok</groupId>
  16.             <artifactId>lombok</artifactId>
  17.             <optional>true</optional>
  18.         </dependency>
  19.  
  20.         <dependency>
  21.             <groupId>org.springframework.cloud</groupId>
  22.             <artifactId>spring-cloud-starter-gateway</artifactId>
  23.         </dependency>
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-configuration-processor</artifactId>
  27.             <optional>true</optional>
  28.         </dependency>
  29.         <!-- 转发ws协议请求 -->
  30.         <dependency>
  31.             <groupId>org.springframework.boot</groupId>
  32.             <artifactId>spring-boot-starter-websocket</artifactId>
  33.             <exclusions>
  34.                 <exclusion>
  35.                     <groupId>org.springframework.boot</groupId>
  36.                     <artifactId>spring-boot-starter-web</artifactId>
  37.                 </exclusion>
  38.             </exclusions>
  39.         </dependency>

yml配置

  1. server:
  2.   port: 8888
  3. spring:
  4.   profiles:
  5.     active: dev
  6.   application:
  7.     name: luckgateway
  8.   cloud:
  9.     nacos:
  10.       discovery:
  11.         server-addr: 127.0.0.1:8848
  12.         namespace: luck-cloud
  13.       config:
  14.         server-addr: 127.0.0.1:8848
  15.         file-extension: yaml
  16.         namespace: luck-cloud
  17.     gateway:
  18.       routes:
  19.         - id: lucksso
  20.           uri: lb://lucksso
  21.           predicates:
  22.             - Path=/lucksso/**
  23.         - id: luckbiz
  24.           uri: lb://luckbiz
  25.           predicates:
  26.             - Path=/luckbiz/**
  27.         - id: luckim
  28.           uri: lb:ws://luckim
  29.           predicates:
  30.             - Path=/luckim/**
  31.       discovery:
  32.         locator:
  33.           enabled: true #开启从注册中心动态创建路由的功能,默认false，true时网关转发的微服务链接不带path前缀
  34.           lower-case-service-id: true #使用小写服务名，默认是大写
  35.  
  36. secure:
  37.   ignore:
  38.     urls: #配置白名单路径
  39.       - "/actuator/**"
  40.       - "/lucksso/**"
  41.       - "/resources/**"
  42.   page:
  43.     urls: #配置需要登录的页面路径
  44.       - "/**"

页面登录拦截配置类

  1. package com.luck.config;
  2.  
  3. import java.util.List;
  4.  
  5. import org.springframework.boot.context.properties.ConfigurationProperties;
  6. import org.springframework.stereotype.Component;
  7.  
  8. import lombok.Data;
  9. import lombok.EqualsAndHashCode;
  10.  
  11. /**
  12.  * 页面登录拦截配置
  13.  */
  14. @Data
  15. @EqualsAndHashCode(callSuper = false)
  16. @Component
  17. @ConfigurationProperties(prefix = "secure.page")
  18. public class PageUrlsConfig {
  19. 	private List<String> urls;
  20. }

白名单配置

  1. package com.luck.config;
  2.  
  3. import java.util.List;
  4.  
  5. import org.springframework.boot.context.properties.ConfigurationProperties;
  6. import org.springframework.stereotype.Component;
  7.  
  8. import lombok.Data;
  9. import lombok.EqualsAndHashCode;
  10.  
  11. /**
  12.  * 白名单配置
  13.  */
  14. @Data
  15. @EqualsAndHashCode(callSuper = false)
  16. @Component
  17. @ConfigurationProperties(prefix = "secure.ignore")
  18. public class IgnoreUrlsConfig {
  19. 	private List<String> urls;
  20. }

token工具类

token的获取和校验工具

  1. package com.luck.config;
  2.  
  3. import org.apache.commons.lang3.StringUtils;
  4. import org.springframework.http.HttpCookie;
  5. import org.springframework.http.server.reactive.ServerHttpRequest;
  6. import org.springframework.web.server.ServerWebExchange;
  7.  
  8. /**
  9.  * 登录token工具类
  10.  */
  11. public class LoginTokenUtil {
  12. 	/** 登录服务地址 */
  13. 	public static final String LOGIN_PATH = "/lucksso/login?servers=";
  14. 	/** 登录成功后的回调接口地址 */
  15. 	public static final String LOGIN_CALLBACK_PATH = "/sso/login";
  16. 	/** 登录成功后的回调接口的token参数名称 */
  17. 	public static final String LOGIN_CALLBACK_TOKEN = "token";
  18. 	/** 登录成功后的回调接口的回调地址参数名称 */
  19. 	public static final String LOGIN_CALLBACK_URL = "url";
  20.  
  21. 	/** 登录成功后的token名称 */
  22. 	public static final String LOGIN_TOKEN_NAME = "luckToken";
  23.  
  24. 	/**
  25. 	 * 获取登录token
  26. 	 * @param exchange 上下文
  27. 	 * @return
  28. 	 */
  29. 	public static String getLoginToken(ServerWebExchange exchange) {
  30.  
  31. 		if (null == exchange) {
  32. 			return null;
  33. 		}
  34.  
  35. 		ServerHttpRequest request = exchange.getRequest();
  36.  
  37. 		String loginToken = request.getHeaders().getFirst(LOGIN_TOKEN_NAME);
  38.  
  39. 		if (StringUtils.isBlank(loginToken)) {
  40. 			Object token = exchange.getAttribute(LOGIN_TOKEN_NAME);
  41. 			if (null != token) {
  42. 				loginToken = (String) token;
  43. 			}
  44. 		}
  45.  
  46. 		if (StringUtils.isBlank(loginToken)) {
  47. 			loginToken = request.getQueryParams().getFirst(LOGIN_TOKEN_NAME);
  48. 		}
  49.  
  50. 		if (StringUtils.isBlank(loginToken)) {
  51. 			HttpCookie loginCookie = request.getCookies().getFirst(LOGIN_TOKEN_NAME);
  52. 			if (null != loginCookie) {
  53. 				loginToken = loginCookie.getValue();
  54. 			}
  55. 		}
  56.  
  57. 		return loginToken;
  58. 	}
  59.  
  60. 	/**
  61. 	 * 校验登录token是否有效
  62. 	 * @param loginToken 登录token
  63. 	 * @return
  64. 	 */
  65. 	public static boolean validateLoginToken(String loginToken) {
  66. 		if (StringUtils.isNoneBlank(loginToken)) {
  67. 			// do something
  68. 			return true;
  69. 		}
  70. 		return false;
  71. 	}
  72.  
  73. }

登录配置类

实现单点登录客户端核心逻辑，根据请求判断有没有登录token，可以从请求头获取或者cookie、链接参数获取，如果没有则重定向到认证服务，认证服务实现登录逻辑，回调网关接口，完成登录

  1. package com.luck.config;
  2.  
  3. import java.io.UnsupportedEncodingException;
  4. import java.net.URI;
  5. import java.net.URLDecoder;
  6. import java.net.URLEncoder;
  7. import java.util.List;
  8.  
  9. import org.apache.commons.lang3.StringUtils;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.context.annotation.Bean;
  12. import org.springframework.context.annotation.Configuration;
  13. import org.springframework.http.HttpHeaders;
  14. import org.springframework.http.HttpStatus;
  15. import org.springframework.http.server.reactive.ServerHttpRequest;
  16. import org.springframework.http.server.reactive.ServerHttpResponse;
  17. import org.springframework.util.AntPathMatcher;
  18. import org.springframework.util.PathMatcher;
  19. import org.springframework.web.server.ServerWebExchange;
  20. import org.springframework.web.server.WebFilter;
  21. import org.springframework.web.server.WebFilterChain;
  22.  
  23. import reactor.core.publisher.Mono;
  24.  
  25. @Configuration
  26. public class LoginConfig {
  27. 	/** 路由匹配器 */
  28. 	public static PathMatcher pathMatcher = new AntPathMatcher();
  29. 	/** 白名单 */
  30. 	@Autowired
  31. 	private IgnoreUrlsConfig ignoreUrlsConfig;
  32. 	/** 拦截名单 */
  33. 	@Autowired
  34. 	private PageUrlsConfig pageUrlsConfig;
  35.  
  36. 	@FunctionalInterface
  37. 	public interface LoginFunction {
  38. 		public Mono<Void> run();
  39. 	}
  40.  
  41. 	@Bean
  42. 	public WebFilter getSsoLoginFilter() {
  43. 		return new WebFilter() {
  44.  
  45. 			@Override
  46. 			public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
  47. 				try {
  48. 					ServerHttpRequest request = exchange.getRequest();
  49. 					String path = request.getPath().toString();
  50. 					if (LoginTokenUtil.LOGIN_CALLBACK_PATH.equals(path)) {
  51. 						String loginToken = request.getQueryParams().getFirst(LoginTokenUtil.LOGIN_CALLBACK_TOKEN);
  52. 						String loginUrl = request.getQueryParams().getFirst(LoginTokenUtil.LOGIN_CALLBACK_URL);
  53. 						if (StringUtils.isAnyBlank(loginToken, loginUrl)) {
  54. 							throw new RuntimeException("参数错误!");
  55. 						}
  56. 						String url = URLDecoder.decode(loginUrl, "UTF-8");
  57. 						boolean validateLoginToken = LoginTokenUtil.validateLoginToken(loginToken);
  58. 						if (validateLoginToken) {
  59. 							ServerHttpResponse response = exchange.getResponse();
  60. 							response.setStatusCode(HttpStatus.SEE_OTHER);// 校验成功，重定向
  61. 							response.getHeaders().set(HttpHeaders.LOCATION, url);
  62. 							return exchange.getResponse().setComplete();
  63. 						}
  64. 						// 校验失败，抛异常或者重新执行登录
  65. 						// redirectSSO(exchange, request, url);
  66. 						throw new RuntimeException("token校验失败!");
  67. 					}
  68. 					String loginToken = LoginTokenUtil.getLoginToken(exchange);
  69. 					Mono<Void> result = null;
  70. 					if (StringUtils.isNoneBlank(loginToken)) {
  71. 						boolean hasLogin = LoginTokenUtil.validateLoginToken(loginToken);
  72. 						if (!hasLogin) {
  73. 							result = redirectSSO(exchange, request, path);
  74. 						} else {
  75. 							return chain.filter(exchange);
  76. 						}
  77. 					} else {
  78. 						result = redirectSSO(exchange, request, path);
  79. 					}
  80. 					if (null != result) {
  81. 						return result;
  82. 					}
  83. 					throw new RuntimeException("token校验失败!");
  84. 				} catch (Exception e) {
  85. 					exchange.getResponse().getHeaders().set("Content-Type", "application/json; charset=utf-8");
  86. 					return exchange.getResponse().writeWith(Mono.just(exchange.getResponse().bufferFactory().wrap(e.getMessage().getBytes())));
  87. 				}
  88. 			}
  89.  
  90. 			/**
  91. 			 * 调单点登录
  92. 			 * @param exchange 上下文
  93. 			 * @param request 请求
  94. 			 * @param path 请求地址
  95. 			 * @return
  96. 			 */
  97. 			private Mono<Void> redirectSSO(ServerWebExchange exchange, ServerHttpRequest request, String path) {
  98. 				Mono<Void> result = match(pageUrlsConfig.getUrls(), ignoreUrlsConfig.getUrls(), path, () -> {
  99. 					if (isPage(path)) {
  100. 						URI uri = request.getURI();
  101. 						String url = "/";
  102. 						try {
  103. 							url = LoginTokenUtil.LOGIN_PATH // 登录服务地址
  104. 									+ URLEncoder.encode(uri.getScheme() + "://" + uri.getAuthority() // gateway服务（http://gateway）
  105. 											+ LoginTokenUtil.LOGIN_CALLBACK_PATH + "?" + LoginTokenUtil.LOGIN_CALLBACK_URL + "=" // gateway回调地址参数 http://gateway/sso/login?url=
  106. 											+ URLEncoder.encode(uri.toString(), "UTF-8"), "UTF-8");// 登录成功重定向地址
  107. 						} catch (UnsupportedEncodingException e1) {
  108. 							e1.printStackTrace();
  109. 						}
  110. 						ServerHttpResponse response = exchange.getResponse();
  111. 						response.setStatusCode(HttpStatus.SEE_OTHER);
  112. 						response.getHeaders().set(HttpHeaders.LOCATION, url);
  113. 						exchange.getResponse().getHeaders().set("Content-Type", "text/plain; charset=utf-8");
  114. 						return exchange.getResponse().setComplete();
  115. 					}
  116. 					return null;
  117. 				});
  118. 				return result;
  119. 			}
  120.  
  121. 		};
  122. 	}
  123.  
  124. 	/**
  125. 	 * 判断请求是不是页面请求
  126. 	 * @param path 请求路径
  127. 	 * @return
  128. 	 */
  129. 	private boolean isPage(String path) {
  130. 		return true;
  131. 	}
  132.  
  133. 	/**
  134. 	 * 路由匹配 (并指定排除匹配符)，如果匹配成功则执行认证函数 
  135. 	 * @param patterns 路由匹配符集合
  136. 	 * @param excludePatterns 要排除的路由匹配符集合
  137. 	 * @param path 请求链接
  138. 	 * @param function 要执行的方法 
  139. 	 */
  140. 	public Mono<Void> match(List<String> patterns, List<String> excludePatterns, String path, LoginFunction function) {
  141. 		if (isMatchCurrURI(patterns, path)) {
  142. 			if (isMatchCurrURI(excludePatterns, path) == false) {
  143. 				return function.run();
  144. 			}
  145. 		}
  146. 		return null;
  147. 	}
  148.  
  149. 	/**
  150. 	 * 路由匹配 (使用当前URI) 
  151. 	 * @param patterns 路由匹配符集合 
  152. 	 * @param path 被匹配的路由  
  153. 	 * @return 是否匹配成功 
  154. 	 */
  155. 	public boolean isMatchCurrURI(List<String> patterns, String path) {
  156. 		return isMatch(patterns, path);
  157. 	}
  158.  
  159. 	/**
  160. 	 * 路由匹配   
  161. 	 * @param patterns 路由匹配符集合 
  162. 	 * @param path 被匹配的路由  
  163. 	 * @return 是否匹配成功 
  164. 	 */
  165. 	public boolean isMatch(List<String> patterns, String path) {
  166. 		for (String pattern : patterns) {
  167. 			if (isMatch(pattern, path)) {
  168. 				return true;
  169. 			}
  170. 		}
  171. 		return false;
  172. 	}
  173.  
  174. 	/**
  175. 	 * 路由匹配
  176. 	 * @param pattern 路由匹配符 
  177. 	 * @param path 被匹配的路由  
  178. 	 * @return 是否匹配成功 
  179. 	 */
  180. 	public boolean isMatch(String pattern, String path) {
  181. 		return pathMatcher.match(pattern, path);
  182. 	}
  183. }

全局过滤器类

主要是为网关转发请求时添加登录token

  1. package com.luck.config;
  2.  
  3. import org.springframework.cloud.gateway.filter.GatewayFilterChain;
  4. import org.springframework.cloud.gateway.filter.GlobalFilter;
  5. import org.springframework.http.server.reactive.ServerHttpRequest;
  6. import org.springframework.stereotype.Component;
  7. import org.springframework.web.server.ServerWebExchange;
  8.  
  9. import reactor.core.publisher.Mono;
  10.  
  11. /**
  12.  * 全局过滤器，添加登录token请求头
  13.  */
  14. @Component
  15. public class ForwardAuthFilter implements GlobalFilter {
  16. 	@Override
  17. 	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
  18. 		ServerHttpRequest request = exchange//
  19. 				.getRequest()//
  20. 				.mutate()//
  21. 				.header(LoginTokenUtil.LOGIN_TOKEN_NAME, LoginTokenUtil.getLoginToken(exchange))//
  22. 				.build();//
  23. 		ServerWebExchange newExchange = exchange.mutate().request(request).build();
  24. 		return chain.filter(newExchange);
  25. 	}
  26. }

项目启动类

  1. package com.luck;
  2.  
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
  6.  
  7. @EnableDiscoveryClient
  8. @SpringBootApplication
  9. public class GatewayApplication {
  10.  
  11. 	public static void main(String[] args) {
  12. 		SpringApplication.run(GatewayApplication.class, args);
  13. 	}
  14.  
  15. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/768448
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号