Unified handling and interception of exception exceptions of vertx

Introduce

Vertx Unified exception interception processing

1. maven Project dependence

<dependency>
	<groupId>io.vertx</groupId>
	<artifactId>vertx-web</artifactId>
</dependency>
<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
</dependency>
<dependency>
	<groupId>com.lance.common</groupId>
	<artifactId>vertx-common-core</artifactId>
	<version>0.0.1-SNAPSHOT</version>
</dependency>

2. Unified exception definition

public class AbsException extends RuntimeException {
	public AbsException() {
	}

	public AbsException(String message) {
		super(message);
	}

	public AbsException(String message, Throwable cause) {
		super(message, cause);
	}

	public AbsException(Throwable cause) {
		super(cause);
	}

	public AbsException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
	}
}
public class ServiceException extends AbsException {
	private final static String DEFAULT_FAIL_CODE = "-1";
	private final static String DEFAULT_MESSAGE = "failure";
	@Getter
	private final String code;

	private ServiceException(String code, String message, Throwable cause) {
		super(message, cause);
		this.code = code;
	}

	public static ServiceException of(String code) {
		return new ServiceException(code, DEFAULT_MESSAGE, null);
	}

	public static ServiceException of(Throwable cause) {
		return new ServiceException(DEFAULT_FAIL_CODE, DEFAULT_MESSAGE, cause);
	}

	public static ServiceException of(String message, Throwable cause) {
		return new ServiceException(DEFAULT_FAIL_CODE, message, cause);
	}

	public static ServiceException of(String code, String message) {
		return new ServiceException(code, message, null);
	}

	public static ServiceException of(String code, String message, Throwable cause) {
		return new ServiceException(code, message, cause);
	}

	public static ServiceException of(IResultCode errorCode) {
		return new ServiceException(errorCode.getCode(), errorCode.getMessage(), null);
	}
}

3. Exception unified interception implementation

@Slf4j
public final class DefaultExceptionHandler implements Handler<RoutingContext> {

	private DefaultExceptionHandler() {

	}

	@Override
	public void handle(RoutingContext ctx) {
		Throwable throwable = ctx.failure();
		log.error("===> Default exception fail: ", throwable);

		if (throwable instanceof NullPointerException) {
			ctx.json(R.fail(" Null pointer exception error ."));
			return;
		}

		if (throwable instanceof ServiceException) {
			ServiceException ex = (ServiceException) throwable;
			ctx.json(R.fail(ex.getCode(), ex.getMessage()));
			return;
		}

		//  Define other exception types 
		// .......

		ctx.json(R.fail(ResultCode.FAILURE));
	}

	public static DefaultExceptionHandler of() {
		return new DefaultExceptionHandler();
	}
}

4. Exception unified interception configuration

// Unified exception handling interception 
mainRouter.route().last().failureHandler(DefaultExceptionHandler.of());

5. Full address of the project

Vertx And Exception Exception unified processing interception Github Address

Vertx And Exception Exception unified processing interception Gitee Address