spring cloud gatewayソース解析(1)全体の流れ
11213 ワード
会社は自分のゲートウェイをします.そこで、まずgithubのissueを通して、そしてgatewayのソースコードをもう一度見ました.このように会社の需要は解決しました.動的ルート、マルチ緯度制限ストリーム、記録要求パラメータ、およびリターンパラメータ(変更可能)を含む.まずゲートウェイに入るようにお願いします.まずHttpWebHandler Adapter類に入るようにお願いします.
@Override
public Mono handle(ServerHttpRequest request, ServerHttpResponse response) {
ServerWebExchange exchange = createExchange(request, response);
//getDelegate() ExceptionHandlingWebHandler,
return getDelegate().handle(exchange)
.onErrorResume(ex -> handleFailure(request, response, ex))
.then(Mono.defer(response::setComplete));
}
protected ServerWebExchange createExchange(ServerHttpRequest request, ServerHttpResponse response) {
// DefaultServerWebExchange ServerWebExchange, ， ，
return new DefaultServerWebExchange(request, response, this.sessionManager,
getCodecConfigurer(), getLocaleContextResolver(), this.applicationContext);
} getDelegate().handle(exchange) DefaultWebFilterChain
public class DefaultWebFilterChain implements WebFilterChain {
private final List filters;
private final WebHandler handler;
private final int index;
·······
@Override
public Mono filter(ServerWebExchange exchange) {
return Mono.defer(() -> {
if (this.index < this.filters.size()) {// WebFilter
WebFilter filter = this.filters.get(this.index);
// new DefaultWebFilterChain filter ,
WebFilterChain chain = new DefaultWebFilterChain(this, this.index + 1);
return filter.filter(exchange, chain);
}
else {//
return this.handler.handle(exchange);
}
});
}
} this.handler.handle(exchange), DispatcherHandler
public class DispatcherHandler implements WebHandler, ApplicationContextAware {
····
@Nullable
//HandlerMapping ， spring webflux HandlerFunction，
controller， ， SimpleUrlHandlerMapping 404
, HandlerFunction，controller，
， ( RoutePredicateHandlerMapping order)
private List handlerMappings;
@Nullable
private List handlerAdapters;
@Nullable
//
private List resultHandlers;
·····
public DispatcherHandler(ApplicationContext applicationContext) {
initStrategies(applicationContext);
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) {
initStrategies(applicationContext);
}
// , list
protected void initStrategies(ApplicationContext context) {
Map mappingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
context, HandlerMapping.class, true, false);
ArrayList mappings = new ArrayList<>(mappingBeans.values());
AnnotationAwareOrderComparator.sort(mappings);
this.handlerMappings = Collections.unmodifiableList(mappings);
Map adapterBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
context, HandlerAdapter.class, true, false);
this.handlerAdapters = new ArrayList<>(adapterBeans.values());
AnnotationAwareOrderComparator.sort(this.handlerAdapters);
Map beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
context, HandlerResultHandler.class, true, false);
this.resultHandlers = new ArrayList<>(beans.values());
AnnotationAwareOrderComparator.sort(this.resultHandlers);
}
@Override
public Mono handle(ServerWebExchange exchange) {
if (logger.isDebugEnabled()) {
ServerHttpRequest request = exchange.getRequest();
logger.debug("Processing " + request.getMethodValue() + " request for [" + request.getURI() + "]");
}
if (this.handlerMappings == null) {
return Mono.error(HANDLER_NOT_FOUND_EXCEPTION);
}
return Flux.fromIterable(this.handlerMappings)
//handlerMappings handler,
.concatMap(mapping -> mapping.getHandler(exchange))
// ，next()
.next()
.switchIfEmpty(Mono.error(HANDLER_NOT_FOUND_EXCEPTION))
.flatMap(handler -> invokeHandler(exchange, handler))
.flatMap(result -> handleResult(exchange, result));
}
private Mono invokeHandler(ServerWebExchange exchange, Object handler) {
if (this.handlerAdapters != null) {
for (HandlerAdapter handlerAdapter : this.handlerAdapters) {
if (handlerAdapter.supports(handler)) {// handler ，
hadler
return handlerAdapter.handle(exchange, handler);
}
}
}
return Mono.error(new IllegalStateException("No HandlerAdapter: " + handler));
}
private Mono handleResult(ServerWebExchange exchange, HandlerResult result) {
return getResultHandler(result).handleResult(exchange, result)
.onErrorResume(ex -> result.applyExceptionHandler(ex).flatMap(exceptionResult ->
// handleResult
getResultHandler(exceptionResult).handleResult(exchange, exceptionResult)));
}
private HandlerResultHandler getResultHandler(HandlerResult handlerResult) {
if (this.resultHandlers != null) {
for (HandlerResultHandler resultHandler : this.resultHandlers) {
if (resultHandler.supports(handlerResult)) {
return resultHandler;
}
}
}
throw new IllegalStateException("No HandlerResultHandler for " + handlerResult.getReturnValue());
}
}
handlerAdapter.handle(exchange, handler);
SimpleHandlerAdapter
public class SimpleHandlerAdapter implements HandlerAdapter {
@Override
public boolean supports(Object handler) {
return WebHandler.class.isAssignableFrom(handler.getClass());
}
@Override
public Mono handle(ServerWebExchange exchange, Object handler) {
WebHandler webHandler = (WebHandler) handler;
// handler ， FilteringWebHandler
Mono mono = webHandler.handle(exchange);
return mono.then(Mono.empty());
}
}
FilteringWebHandler ：
public class FilteringWebHandler implements WebHandler {
protected static final Log logger = LogFactory.getLog(FilteringWebHandler.class);
private final List globalFilters;
// GatewayAutoConfiguration bean, GlobalFilter
public FilteringWebHandler(List globalFilters) {
this.globalFilters = loadFilters(globalFilters);
}
// GlobalFilter GatewayFilter
private static List loadFilters(List filters) {
return filters.stream()
.map(filter -> {
GatewayFilterAdapter gatewayFilter = new GatewayFilterAdapter(filter);
if (filter instanceof Ordered) {
int order = ((Ordered) filter).getOrder();
return new OrderedGatewayFilter(gatewayFilter, order);
}
return gatewayFilter;
}).collect(Collectors.toList());
}
/* TODO: relocate @EventListener(RefreshRoutesEvent.class)
void handleRefresh() {
this.combinedFiltersForRoute.clear();
}*/
@Override
public Mono handle(ServerWebExchange exchange) {
// ServerWebExchange
Route route = exchange.getRequiredAttribute(GATEWAY_ROUTE_ATTR);
//
List gatewayFilters = route.getFilters();
List combined = new ArrayList<>(this.globalFilters);
//
combined.addAll(gatewayFilters);
//
AnnotationAwareOrderComparator.sort(combined);
if (logger.isDebugEnabled()) {
logger.debug("Sorted gatewayFilterFactories: "+ combined);
}
return new DefaultGatewayFilterChain(combined).filter(exchange);
}
private static class DefaultGatewayFilterChain implements GatewayFilterChain {
private final int index;
private final List filters;
public DefaultGatewayFilterChain(List filters) {
this.filters = filters;
this.index = 0;
}
private DefaultGatewayFilterChain(DefaultGatewayFilterChain parent, int index) {
this.filters = parent.getFilters();
this.index = index;
}
public List getFilters() {
return filters;
}
@Override
public Mono filter(ServerWebExchange exchange) {
return Mono.defer(() -> {
if (this.index < filters.size()) {
// WebFilter , new DefaultGatewayFilterChain filter ，
//
GatewayFilter filter = filters.get(this.index);
DefaultGatewayFilterChain chain = new DefaultGatewayFilterChain(this, this.index + 1);
return filter.filter(exchange, chain);
} else {
return Mono.empty(); // complete
}
});
}
}
private static class GatewayFilterAdapter implements GatewayFilter {
private final GlobalFilter delegate;
public GatewayFilterAdapter(GlobalFilter delegate) {
this.delegate = delegate;
}
@Override
public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {
return this.delegate.filter(exchange, chain);
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("GatewayFilterAdapter{");
sb.append("delegate=").append(delegate);
sb.append('}');
return sb.toString();
}
}
}