@Controlleradvice + @exceptionhandler handles controller layer exceptions globally

Preface

For database related Spring project , We usually put Business Configure in Service layer , When a database operation fails, let Service Layer throws a runtime exception , Control layer try catch Handle ,Spring The transaction manager will roll back .

In this way , our Controller The layer has to be try-catch Service Layer of abnormal , Otherwise, some unfriendly error messages will be returned to the client . however ,Controller Each method body of the layer writes some templated try-catch Code for , It's ugly and hard to maintain , In particular, it is necessary to Service When different exceptions of layer are handled differently .

Global exception handling （ collocation @ExceptionHandler）
seeing the name of a thing one thinks of its function ,@ControllerAdvice Namely @Controller Enhanced Edition [email protected] It is mainly used to process global data , General collocation @ExceptionHandler Use . Here are the introduction .

0、 Advantages and disadvantages

advantage ： take Controller Layer exceptions and data verification exceptions are handled in a unified way , Reduce template code , Reduce the amount of coding , Improve scalability and maintainability .
shortcoming ： Can only handle Controller Layer not captured （ Throw out ） It's abnormal , about Interceptor（ Interceptor ） Layer of abnormal ,Spring Exceptions in the framework layer , There's nothing we can do .

1、 Basic usage

1）@ControllerAdvice The most common usage scenario is global exception handling . Suppose there is a file upload function in our project , And the file upload size limit is configured .

2） If the user uploads a file that exceeds the size limit , Will throw an exception , At this time, you can use the @ControllerAdvice combination @ExceptionHandler Define the global exception capture mechanism , The specific code is as follows ：

Code instructions ：

GlobalExceptionHandler Class added @ControllerAdvice annotation . When the system starts , This class will be scanned to Spring In the container .

handleException Method with @ExceptionHandler annotation , It defines Exception.class（ It could be something else Exception Subclasses of and Exception Inherited custom class of , Such as NullPointerException.class） Indicates that the method is used to process Exception（NullPointerException） Exception of type . If you want this method to handle all types of exceptions , Only need to NullPointerException Change to Exception that will do .

The parameters of the exception handling method can have exception instances 、HttpServletResponse as well as HttpServletRequest、Model etc. . The return value of the exception handling method can be a segment JSON、 One ModelAndView、 A logical view name, etc .

Use the above annotation to configure a class

/**
* Created by kinginblue on 2017/4/10.
* @ControllerAdvice + @ExceptionHandler  Achieve the overall situation  Controller  Layer exception handling 
*/
@ControllerAdvice
public class GlobalExceptionHandler {

   private static final Logger LOGGER = LoggerFactory.getLogger(GlobalExceptionHandler.class);

   /**
    *  Handle all unknowable exceptions 
    * @param e
    * @return
    */
   @ExceptionHandler(Exception.class)
   @ResponseBody
   AppResponse handleException(Exception e){
       LOGGER.error(e.getMessage(), e);

       AppResponse response = new AppResponse();
       response.setFail(" operation failed , Official account Java selected ！");
       return response;
   }

   /**
    *  Handle all business exceptions 
    * @param e
    * @return
    */
   @ExceptionHandler(BusinessException.class)
   @ResponseBody
   AppResponse handleBusinessException(BusinessException e){
       LOGGER.error(e.getMessage(), e);

       AppResponse response = new AppResponse();
       response.setFail(e.getMessage());
       return response;
   }
}

The above exception information indicates known business exceptions and unknown captured exceptions ,BusinessException It is an exception class defined by itself

public class BusinessException extends RuntimeException {
 
    public BusinessException(String message){
        super(message);
    }
}

Write a tool class , Transfer this exception message to , Throw it out

public static void isTrue(boolean expression, String error){
    if(!expression) {
        throw new BusinessException(error);
    }
}

This method is used below , Will write some exceptions you know , Judge , Throw the exception for processing .

This can be spring Self contained return body ResponseEntity, Declare and define the specific return object information , Such as this

@ExceptionHandler(JyspException.class)
    public ResponseEntity<ExceptionResult> handleException(JyspException e) {
        return ResponseEntity.status(e.getExceptionEnum().getCode())
                .body(new ExceptionResult(e.getExceptionEnum()));
    }

Custom exceptions

@Getter
@AllArgsConstructor
@NoArgsConstructor
public class JyspException extends RuntimeException{
    private ExceptionEnum exceptionEnum;
}

Enumerate your exception information classes

@Getter
@NoArgsConstructor
@AllArgsConstructor
public enum ExceptionEnum {
    /**
     *  Wrong user name or password 
     */
    INVALID_USERNAME_PASSWORD(400, " Wrong user name or password ！"),

    /**
     *  Failed to save user name 
     */
    SAVE_USER_ERROR(400, " Failed to save user name ！"),
    
    /**
     *  Role saving failed 
     */
    CREAT_ROLE_ERROR(500," Role saving failed ");

    private int code;
    private String msg;
}

The above example uses enumeration to manage several known exceptions

among @ExceptionHandler(Exception.class) Exception returned , You can also customize exceptions , My uses enumerations to handle , It can also be handled in code , How the abnormal information comes from , It is the exception you encounter when writing code , you throws Way to throw out , Then use your own exception information , Throw it into the control layer , Handle through the global exception handling class , Friendly throw to the front , For example, an exception is thrown through code processing

@Service
public class DogService {
 
    @Transactional
    public Dog update(Dog dog){ 
        // some database options 
        //  Simulated dog's new name conflicts with other dog's name 
        BSUtil.isTrue(false, " Dog names have been used ..."); 
        // update database dog info 
        return dog;
    } 
}

This anomaly is something you can expect , But there are some anomalies you can't predict , Or missing , Then the following method will be used to friendly prompt the front end

@ExceptionHandler(Exception.class)
    ResponseEntity<ExceptionResult> handleException(Exception e) {
        log.error(e.getMessage(), e);
        ExceptionResult response = new ExceptionResult();
        response.setStatus(500);
        response.setMsg(" operation failed !");
        return ResponseEntity.ok(response);
    }

Code instructions

Logger Log all exceptions .

@ExceptionHandler(BusinessException.class) That's right BusinessException Handling of business exceptions , And get the error prompt in the business exception , Return to the client after construction .

@ExceptionHandler(Exception.class) That's right Exception Exception handling , Play the role of revealing the bottom , No matter Controller There is something unexpected in the code executed by the layer , All return unified error prompts to the client .

remarks ： above GlobalExceptionHandler Just go back to Json To the client , Greater play space needs to be done according to the needs .

Reference resources ：https://blog.csdn.net/asd051377305/article/details/104773800

Copyright notice ： This article is an original blog article , follow CC 4.0 BY-SA Copyright agreement , For reprint, please attach the original source link and this statement .

https://blog.csdn.net/qq_41134142/article/details/110400896

official account “Java selected ” The published content indicates the source of , All rights reserved （ Those whose copyright cannot be verified or whose source is not indicated all come from the Internet , Reprinted , The purpose of reprinting is to convey more information , The copyright belongs to the original author . If there is any infringement , Please contact the , The author will delete the first time ！

Many people have asked recently , Is there any readers Communication group ！ The way to join is simple , official account Java selected , reply “ Add group ”, You can join the group ！

Java Interview questions （ Wechat applet ）：3000+ The road test questions , contain Java Basics 、 Concurrent 、JVM、 Threads 、MQ series 、Redis、Spring series 、Elasticsearch、Docker、K8s、Flink、Spark、 Architecture design, etc , Brush questions online at any time ！

------ Special recommendation ------

Special recommendation ： Focus on the most cutting-edge information and technology sharing , Official account for preparing for overtaking on curves and various open source projects and efficient software ,「 Big coffee notes 」, Focus on finding good things , It's worth your attention . Click the official account card below to follow .

If the article helps , Click to see , Forward! ！