Memo @restcontrolleradvice and exception interception class example

import com.mine.ResponseMO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.validation.BindException;
import org.springframework.validation.ObjectError;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.ArrayList;
import java.util.List;

/**
 *  Unified exception handling base class 
 */
@RestControllerAdvice
public class GlobalExceptionHandler {

    protected Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     *  Judge whether it is dev Environmental Science 
     */
    protected boolean dev;

    /**
     *  Global exception 
     *
     * @param e
     * @return
     */
    @ExceptionHandler(value = {Exception.class, RuntimeException.class})
    public ResponseMO defaultErrorHandler(Exception e) {
        logger.error(e.getMessage(), e);
        String debugInfo = null;
        if (dev) {
            debugInfo = e.toString();
        }
        return ResponseMO.error(" There was an internal error , Please contact the Administrator ", debugInfo);
    }


    /**
     *  Parameter verification exception 
     *
     * @param e
     * @return
     */
    @ExceptionHandler({MethodArgumentNotValidException.class, BindException.class
            , MissingServletRequestParameterException.class})
    public ResponseMO methodArgumentNotValidException(Exception e) {
        if (logger.isDebugEnabled()) {
            logger.info(e.getMessage(), e);
        }

        // Parameter missing exception 
        if (e instanceof MissingServletRequestParameterException) {
            MissingServletRequestParameterException exception = (MissingServletRequestParameterException) e;
            String message = exception.getParameterName() + " Can't be empty ";
            return ResponseMO.error(message);
        }

        List<ObjectError> allErrors = new ArrayList<>();
        if (e instanceof BindException) {
            allErrors = ((BindException) e).getBindingResult().getAllErrors();
        } else if (e instanceof MethodArgumentNotValidException) {
            allErrors = ((MethodArgumentNotValidException) e).getBindingResult().getAllErrors();
        }
        StringBuffer errors = new StringBuffer();
        for (ObjectError allError : allErrors) {
            errors.append(allError.getDefaultMessage());
            break;
        }

        String debugInfo = null;
        if (dev) {
            debugInfo = e.toString();
        }

        return ResponseMO.error(errors.toString(), debugInfo);
    }

    /**
     *  The request method does not support exception 
     *
     * @param e
     * @return
     */
    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
    public ResponseMO methodNotSupported(HttpRequestMethodNotSupportedException e) {
        if (logger.isDebugEnabled()) {
            logger.debug(e.getMessage(), e);
        }
        String message = " I won't support it " + e.getMethod() + " Request access ";

        String debugInfo = null;
        if (dev) {
            debugInfo = e.toString();
        }
        return ResponseMO.error(message, debugInfo);
    }

    /**
     *  The requested content does not support 
     *
     * @param e
     * @return
     */
    @ExceptionHandler(HttpMediaTypeNotSupportedException.class)
    public ResponseMO httpMediaTypeNotSupportedException(HttpMediaTypeNotSupportedException e) {
        if (logger.isDebugEnabled()) {
            logger.debug(e.getMessage(), e);
        }
        String message = " I won't support it '" + e.getContentType() + "' Content ";

        String debugInfo = null;
        if (dev) {
            debugInfo = e.toString();
        }
        return ResponseMO.error(message, debugInfo);
    }
}