GatewayExceptionConfig:
package com.zy.platform.getway.configure;
import com.zy.platform.getway.exception.GatewayExceptionHandler;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.web.reactive.error.ErrorWebExceptionHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.web.reactive.result.view.ViewResolver;
import java.util.Collections;
import java.util.List;
/**
* @author javachen
* @description GatewayExceptionConfig
*/
@Configuration
public class GatewayExceptionConfig {
@Primary
@Bean
@Order(Ordered.HIGHEST_PRECEDENCE)
public ErrorWebExceptionHandler errorWebExceptionHandler(ObjectProvider<List<ViewResolver>> viewResolversProvider,
ServerCodecConfigurer serverCodecConfigurer) {
GatewayExceptionHandler gatewayExceptionHandler = new GatewayExceptionHandler();
gatewayExceptionHandler.setViewResolvers(viewResolversProvider.getIfAvailable(Collections::emptyList));
gatewayExceptionHandler.setMessageWriters(serverCodecConfigurer.getWriters());
gatewayExceptionHandler.setMessageReaders(serverCodecConfigurer.getReaders());
return gatewayExceptionHandler;
}
}
GetwayErrorCodeEnum:
package com.zy.platform.getway.enums;
/**
* @author javachen
* @description 網關異常枚舉類
*/
public enum GetwayErrorCodeEnum {
/** 服務不可用 */
UNABLE_SERVER(503,"服務不可用,請檢查網絡"),
;
private final int code;
private final String desc;
GetwayErrorCodeEnum(int code, String desc){
this.code = code;
this.desc = desc;
}
public int getCode(){
return code;
}
public String getDesc(){
return desc;
}
}
AbstractExceptionHandler:
package com.zy.platform.getway.exception;
import com.zy.platform.getway.enums.GetwayErrorCodeEnum;
import org.springframework.cloud.gateway.support.NotFoundException;
import org.springframework.web.server.ResponseStatusException;
import java.util.HashMap;
import java.util.Map;
/**
* @author javachen
* @description AbstractExceptionHandler
*/
public abstract class AbstractExceptionHandler {
private static final Integer DEFAULT_ERROR_CODE = GetwayErrorCodeEnum.UNABLE_SERVER.getCode();
protected String formatMessage(Throwable ex) {
String errorMessage = null;
if (ex instanceof NotFoundException) {
String reason = ((NotFoundException) ex).getReason();
errorMessage = reason;
} else if (ex instanceof ResponseStatusException) {
ResponseStatusException responseStatusException = (ResponseStatusException) ex;
errorMessage = responseStatusException.getMessage();
} else {
errorMessage = ex.getMessage();
}
return errorMessage;
}
protected Map<String, Object> buildErrorMap(String errorMessage) {
Map<String, Object> resMap = new HashMap<>();
resMap.put("status", DEFAULT_ERROR_CODE);
resMap.put("message", GetwayErrorCodeEnum.UNABLE_SERVER.getDesc());
resMap.put("data", null);
return resMap;
}
}
GatewayExceptionHandler:
package com.zy.platform.getway.exception;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.web.reactive.error.ErrorWebExceptionHandler;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.codec.HttpMessageReader;
import org.springframework.http.codec.HttpMessageWriter;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.util.Assert;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.RequestPredicates;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.reactive.result.view.ViewResolver;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.util.Collections;
import java.util.List;
import java.util.Map;
/**
* @author javachen
* @description GatewayExceptionHandler
*/
@Slf4j
public class GatewayExceptionHandler extends AbstractExceptionHandler implements ErrorWebExceptionHandler {
private static final String TRACE_ID = "traceId";
private static final String JHJCN_BUSI_NOT_FOUND = "Unable to find instance";
private static final String JHJCN_BUSI_NOT_FOUND_ZH = "服務不可用,請檢查網絡";
private List<HttpMessageReader<?>> messageReaders = Collections.emptyList();
private List<HttpMessageWriter<?>> messageWriters = Collections.emptyList();
private List<ViewResolver> viewResolvers = Collections.emptyList();
private ThreadLocal<Map<String, Object>> exceptionHandlerResult = new ThreadLocal<>();
public void setMessageReaders(List<HttpMessageReader<?>> messageReaders) {
Assert.notNull(messageReaders, "'messageReaders' must not be null");
this.messageReaders = messageReaders;
}
public void setViewResolvers(List<ViewResolver> viewResolvers) {
this.viewResolvers = viewResolvers;
}
public void setMessageWriters(List<HttpMessageWriter<?>> messageWriters) {
Assert.notNull(messageWriters, "'messageWriters' must not be null");
this.messageWriters = messageWriters;
}
@Override
public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {
String errorMessage = super.formatMessage(ex);
if (errorMessage.equals(JHJCN_BUSI_NOT_FOUND)) {
errorMessage = JHJCN_BUSI_NOT_FOUND_ZH;
}
Map<String, Object> errorMap = super.buildErrorMap(errorMessage);
ServerHttpRequest request = exchange.getRequest();
String traceId = request.getHeaders().getFirst(TRACE_ID);
log.error("GatewayExceptionHandler request info [traceId={}] result error=[{}]", traceId, JSONObject.toJSONString(errorMap));
if (exchange.getResponse().isCommitted()) {
return Mono.error(ex);
}
exceptionHandlerResult.set(errorMap);
ServerRequest newRequest = ServerRequest.create(exchange, this.messageReaders);
return RouterFunctions.route(RequestPredicates.all(), this::renderErrorResponse).route(newRequest)
.switchIfEmpty(Mono.error(ex))
.flatMap((handler) -> handler.handle(newRequest))
.flatMap((response) -> write(exchange, response));
}
protected Mono<ServerResponse> renderErrorResponse(ServerRequest request) {
Map<String, Object> result = exceptionHandlerResult.get();
return ServerResponse.status(HttpStatus.OK)
.contentType(MediaType.valueOf(MediaType.APPLICATION_JSON_VALUE))
.body(BodyInserters.fromValue(result));
}
private Mono<? extends Void> write(ServerWebExchange exchange,
ServerResponse response) {
exchange.getResponse().getHeaders()
.setContentType(response.headers().getContentType());
return response.writeTo(exchange, new ResponseContext());
}
private class ResponseContext implements ServerResponse.Context {
@Override
public List<HttpMessageWriter<?>> messageWriters() {
return GatewayExceptionHandler.this.messageWriters;
}
@Override
public List<ViewResolver> viewResolvers() {
return GatewayExceptionHandler.this.viewResolvers;
}
}
}