Spring Обработка исключений службы загрузки REST

Ответ 1

Новый ответ (2016-04-20)

Использование Spring Boot 1.3.1.RELEASE

Новый шаг 1. Легко и менее навязчиво добавить следующие свойства в application.properties:

spring.mvc.throw-exception-if-no-handler-found=true
spring.resources.add-mappings=false

Намного проще, чем модифицировать существующий экземпляр DispatcherServlet (как показано ниже)! - JO '

При работе с полным RESTful-приложением очень важно отключить автоматическое сопоставление статических ресурсов, поскольку, если вы используете конфигурацию Spring Boot для обработки статических ресурсов, обработчик ресурсов будет обрабатывать запрос (он был упорядочен последним и сопоставлен с /** это означает, что он выбирает любые запросы, которые не были обработаны каким-либо другим обработчиком в приложении), поэтому сервлет диспетчера не имеет возможности вызвать исключение.

Новый ответ (2015-12-04)

Использование Spring Boot 1.2.7.RELEASE

Новый шаг 1 - я нашел гораздо менее навязчивый способ установки флага "throExceptionIfNoHandlerFound". Замените приведенный ниже код замены DispatcherServlet (шаг 1) следующим образом в классе инициализации вашего приложения:

@ComponentScan()
@EnableAutoConfiguration
public class MyApplication extends SpringBootServletInitializer {
    private static Logger LOG = LoggerFactory.getLogger(MyApplication.class);
    public static void main(String[] args) {
        ApplicationContext ctx = SpringApplication.run(MyApplication.class, args);
        DispatcherServlet dispatcherServlet = (DispatcherServlet)ctx.getBean("dispatcherServlet");
        dispatcherServlet.setThrowExceptionIfNoHandlerFound(true);
    }

В этом случае мы устанавливаем флаг в существующем DispatcherServlet, который сохраняет любую автоконфигурацию средой Spring Boot.

Еще одна вещь, которую я нашел - аннотация @EnableWebMvc смертельно опасна для Spring Boot. Да, эта аннотация позволяет, например, перехватывать все исключения контроллера, как описано ниже, но также убивает МНОГО полезной автоматической конфигурации, которую обычно обеспечивает Spring Boot. Используйте эту аннотацию с особой осторожностью при использовании Spring Boot.

Оригинальный ответ:

После долгих исследований и отслеживания решений, опубликованных здесь (спасибо за помощь!) И немалого количества трассировки времени исполнения в коде Spring, я наконец-то нашел конфигурацию, которая будет обрабатывать все исключения (не ошибки, а чтение). в том числе 404 с.

Шаг 1 - скажите SpringBoot прекратить использование MVC для ситуаций "обработчик не найден". Мы хотим, чтобы Spring генерировал исключение, а не возвращал клиенту перенаправление представления на "/error". Для этого вам нужно иметь запись в одном из ваших классов конфигурации:

// NEW CODE ABOVE REPLACES THIS! (2015-12-04)
@Configuration
public class MyAppConfig {
    @Bean  // Magic entry 
    public DispatcherServlet dispatcherServlet() {
        DispatcherServlet ds = new DispatcherServlet();
        ds.setThrowExceptionIfNoHandlerFound(true);
        return ds;
    }
}

Недостатком этого является то, что он заменяет сервлет диспетчера по умолчанию. Для нас это пока не проблема, без каких-либо побочных эффектов или проблем с выполнением. Если вы собираетесь делать что-то еще с сервлетом-диспетчером по другим причинам, это место для них.

Шаг 2 - Теперь, когда весенняя загрузка выдает исключение, когда обработчик не найден, это исключение может быть обработано любым другим в унифицированном обработчике исключений:

@EnableWebMvc
@ControllerAdvice
public class ServiceExceptionHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(Throwable.class)
    @ResponseBody
    ResponseEntity<Object> handleControllerException(HttpServletRequest req, Throwable ex) {
        ErrorResponse errorResponse = new ErrorResponse(ex);
        if(ex instanceof ServiceException) {
            errorResponse.setDetails(((ServiceException)ex).getDetails());
        }
        if(ex instanceof ServiceHttpException) {
            return new ResponseEntity<Object>(errorResponse,((ServiceHttpException)ex).getStatus());
        } else {
            return new ResponseEntity<Object>(errorResponse,HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @Override
    protected ResponseEntity<Object> handleNoHandlerFoundException(NoHandlerFoundException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
        Map<String,String> responseBody = new HashMap<>();
        responseBody.put("path",request.getContextPath());
        responseBody.put("message","The URL you have reached is not in service at this time (404).");
        return new ResponseEntity<Object>(responseBody,HttpStatus.NOT_FOUND);
    }
    ...
}

Имейте в виду, что я думаю, что аннотация "@EnableWebMvc" здесь важна. Кажется, что ничего из этого не работает без него. И это - ваше загрузочное приложение Spring теперь будет перехватывать все исключения, в том числе 404, в вышеприведенном классе обработчиков, и вы можете делать с ними как угодно.

И последнее замечание - похоже, нет способа заставить его ловить ошибочные ошибки. У меня есть дурацкая идея использовать аспекты для отлова ошибок и превращения их в исключения, с которыми затем может справиться приведенный выше код, но у меня еще не было времени на самом деле попытаться реализовать это. Надеюсь, это кому-нибудь поможет.

Любые комментарии/исправления/улучшения будут оценены.

Ответ 2

С помощью Spring Загрузились 1.4+ новые классные классы для упрощения обработки исключений, которые помогают удалить шаблонный код.

Для обработки исключений предусмотрен новый @RestControllerAdvice, это комбинация @ControllerAdvice и @ResponseBody. Вы можете удалить @ResponseBody по методу @ExceptionHandler при использовании этой новой аннотации.

то есть.

@RestControllerAdvice
public class GlobalControllerExceptionHandler {

    @ExceptionHandler(value = { Exception.class })
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public ApiErrorResponse unknownException(Exception ex, WebRequest req) {
        return new ApiErrorResponse(...);
    }
}

Для обработки 404 ошибок добавление аннотации @EnableWebMvc и следующее к application.properties было достаточно:
spring.mvc.throw-exception-if-no-handler-found=true

Вы можете найти и поиграть с источниками здесь:
https://github.com/magiccrafter/spring-boot-exception-handling

Ответ 3

Я думаю, что ResponseEntityExceptionHandler соответствует вашим требованиям. Пример кода для HTTP 400:

@ControllerAdvice
public class MyExceptionHandler extends ResponseEntityExceptionHandler {

  @ResponseStatus(value = HttpStatus.BAD_REQUEST)
  @ExceptionHandler({HttpMessageNotReadableException.class, MethodArgumentNotValidException.class,
      HttpRequestMethodNotSupportedException.class})
  public ResponseEntity<Object> badRequest(HttpServletRequest req, Exception exception) {
    // ...
  }
}

Вы можете проверить этот пост

Ответ 4

Как насчет этого кода? Я использую резервное сопоставление запросов, чтобы уловить ошибки 404.

@Controller
@ControllerAdvice
public class ExceptionHandlerController {

    @ExceptionHandler(Exception.class)
    public ModelAndView exceptionHandler(HttpServletRequest request, HttpServletResponse response, Exception ex) {
        //If exception has a ResponseStatus annotation then use its response code
        ResponseStatus responseStatusAnnotation = AnnotationUtils.findAnnotation(ex.getClass(), ResponseStatus.class);

        return buildModelAndViewErrorPage(request, response, ex, responseStatusAnnotation != null ? responseStatusAnnotation.value() : HttpStatus.INTERNAL_SERVER_ERROR);
    }

    @RequestMapping("*")
    public ModelAndView fallbackHandler(HttpServletRequest request, HttpServletResponse response) throws Exception {
        return buildModelAndViewErrorPage(request, response, null, HttpStatus.NOT_FOUND);
    }

    private ModelAndView buildModelAndViewErrorPage(HttpServletRequest request, HttpServletResponse response, Exception ex, HttpStatus httpStatus) {
        response.setStatus(httpStatus.value());

        ModelAndView mav = new ModelAndView("error.html");
        if (ex != null) {
            mav.addObject("title", ex);
        }
        mav.addObject("content", request.getRequestURL());
        return mav;
    }

}

Ответ 5

Хотя это более старый вопрос, я хотел бы поделиться своими мыслями по этому поводу. Я надеюсь, что это будет полезно для некоторых из вас.

В настоящее время я создаю REST API, который использует Spring Boot 1.5.2.RELEASE с Spring Framework 4.3.7.RELEASE. Я использую подход Java Config (в отличие от конфигурации XML). Кроме того, мой проект использует глобальный механизм обработки исключений с использованием аннотации @RestControllerAdvice (см. Ниже ниже).

У моего проекта те же требования, что и у вас: я хочу, чтобы мой REST API возвращал HTTP 404 Not Found с сопутствующей полезной нагрузкой JSON в ответе HTTP клиенту API, когда он пытается отправить запрос на несуществующий URL. В моем случае полезная нагрузка JSON выглядит следующим образом (что явно отличается от Spring Boot по умолчанию, кстати):

{
    "code": 1000,
    "message": "No handler found for your request.",
    "timestamp": "2017-11-20T02:40:57.628Z"
}

Я наконец заставил это работать. Вот основные задачи, которые вам нужно сделать вкратце:

• Убедитесь, что NoHandlerFoundException если клиенты API вызывают URLS, для которых не существует метода-обработчика (см. Шаг 1 ниже).
• Создайте пользовательский класс ошибок (в моем случае ApiError), который содержит все данные, которые должны быть возвращены клиенту API (см. Шаг 2).
• Создайте обработчик исключений, который реагирует на NoHandlerFoundException и возвращает правильное сообщение об ошибке клиенту API (см. Шаг 3).
• Напишите для него тест и убедитесь, что он работает (см. Шаг 4).

Хорошо, теперь к деталям:

Шаг 1. Настройте application.properties

Мне пришлось добавить следующие два параметра конфигурации в файл проекта application.properties:

spring.mvc.throw-exception-if-no-handler-found=true
spring.resources.add-mappings=false

Это обеспечивает NoHandlerFoundException в тех случаях, когда клиент пытается получить доступ к URL-адресу, для которого не существует метода контроллера, который мог бы обработать запрос.

Шаг 2. Создание класса для ошибок API

Я сделал класс, похожий на предложенный в этой статье в блоге Eugen Paraschiv. Этот класс представляет ошибку API. Эта информация отправляется клиенту в теле ответа HTTP в случае ошибки.

public class ApiError {

    private int code;
    private String message;
    private Instant timestamp;

    public ApiError(int code, String message) {
        this.code = code;
        this.message = message;
        this.timestamp = Instant.now();
    }

    public ApiError(int code, String message, Instant timestamp) {
        this.code = code;
        this.message = message;
        this.timestamp = timestamp;
    }

    // Getters and setters here...
}

Шаг 3: Создание/настройка глобального обработчика исключений

Я использую следующий класс для обработки исключений (для простоты я удалил операторы импорта, регистрационный код и некоторые другие, не относящиеся к делу части кода):

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(NoHandlerFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public ApiError noHandlerFoundException(
            NoHandlerFoundException ex) {

        int code = 1000;
        String message = "No handler found for your request.";
        return new ApiError(code, message);
    }

    // More exception handlers here ...
}

Шаг 4: Написать тест

Я хочу убедиться, что API всегда возвращает правильные сообщения об ошибках вызывающему клиенту, даже в случае сбоя. Таким образом, я написал такой тест:

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SprintBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureMockMvc
@ActiveProfiles("dev")
public class GlobalExceptionHandlerIntegrationTest {

    public static final String ISO8601_DATE_REGEX =
        "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$";

    @Autowired
    private MockMvc mockMvc;

    @Test
    @WithMockUser(roles = "DEVICE_SCAN_HOSTS")
    public void invalidUrl_returnsHttp404() throws Exception {
        RequestBuilder requestBuilder = getGetRequestBuilder("/does-not-exist");
        mockMvc.perform(requestBuilder)
            .andExpect(status().isNotFound())
            .andExpect(jsonPath("$.code", is(1000)))
            .andExpect(jsonPath("$.message", is("No handler found for your request.")))
            .andExpect(jsonPath("$.timestamp", RegexMatcher.matchesRegex(ISO8601_DATE_REGEX)));
    }

    private RequestBuilder getGetRequestBuilder(String url) {
        return MockMvcRequestBuilders
            .get(url)
            .accept(MediaType.APPLICATION_JSON);
    }

@ActiveProfiles("dev") может быть удалена. Я использую его только потому, что работаю с разными профилями. RegexMatcher - это пользовательский инструмент сравнения Hamcrest, который я использую для лучшей обработки полей меток времени. Вот код (я нашел его здесь):

public class RegexMatcher extends TypeSafeMatcher<String> {

    private final String regex;

    public RegexMatcher(final String regex) {
        this.regex = regex;
    }

    @Override
    public void describeTo(final Description description) {
        description.appendText("matches regular expression='" + regex + "'");
    }

    @Override
    public boolean matchesSafely(final String string) {
        return string.matches(regex);
    }

    // Matcher method you can call on this matcher class
    public static RegexMatcher matchesRegex(final String string) {
        return new RegexMatcher(regex);
    }
}

Некоторые дополнительные заметки с моей стороны:

• Во многих других публикациях в StackOverflow люди предлагали установить аннотацию @EnableWebMvc. Это не было необходимым в моем случае.
• Этот подход хорошо работает с MockMvc (см. Тест выше).

Ответ 6

По умолчанию Spring Boot дает json информацию об ошибке.

curl -v localhost:8080/greet | json_pp
[...]
< HTTP/1.1 400 Bad Request
[...]
{
   "timestamp" : 1413313361387,
   "exception" : "org.springframework.web.bind.MissingServletRequestParameterException",
   "status" : 400,
   "error" : "Bad Request",
   "path" : "/greet",
   "message" : "Required String parameter 'name' is not present"
}

Он также работает для всех типов ошибок сопоставления запросов. Проверьте эту статью http://www.jayway.com/2014/10/19/spring-boot-error-responses/

Если вы хотите создать журнал для NoSQL. Вы можете создать @ControllerAdvice, где вы будете регистрировать его, а затем повторно выбросить исключение. В документации есть пример https://spring.io/blog/2013/11/01/exception-handling-in-spring-mvc

Ответ 7

Для контроллеров REST я бы рекомендовал использовать Zalando Problem Spring Web.

https://github.com/zalando/problem-spring-web

Если Spring Boot стремится внедрить некоторую автоконфигурацию, эта библиотека делает больше для обработки исключений. Вам просто нужно добавить зависимость:

<dependency>
    <groupId>org.zalando</groupId>
    <artifactId>problem-spring-web</artifactId>
    <version>LATEST</version>
</dependency>

И затем определите одну или несколько характеристик рекомендаций для своих исключений (или используйте предоставленные по умолчанию)

public interface NotAcceptableAdviceTrait extends AdviceTrait {

    @ExceptionHandler
    default ResponseEntity<Problem> handleMediaTypeNotAcceptable(
            final HttpMediaTypeNotAcceptableException exception,
            final NativeWebRequest request) {
        return Responses.create(Status.NOT_ACCEPTABLE, exception, request);
    }

}

Затем вы можете определить совет контроллера для обработки исключений как:

@ControllerAdvice
class ExceptionHandling implements MethodNotAllowedAdviceTrait, NotAcceptableAdviceTrait {

}

Ответ 8

@RestControllerAdvice - это новая функция Spring Framework 4.3 для обработки исключений с помощью RestfulApi с помощью комплексного решения проблемы:

 package com.khan.vaquar.exception;

import javax.servlet.http.HttpServletRequest;

import org.owasp.esapi.errors.IntrusionException;
import org.owasp.esapi.errors.ValidationException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.NoHandlerFoundException;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.khan.vaquar.domain.ErrorResponse;

/**
 * Handles exceptions raised through requests to spring controllers.
 **/
@RestControllerAdvice
public class RestExceptionHandler {

    private static final String TOKEN_ID = "tokenId";

    private static final Logger log = LoggerFactory.getLogger(RestExceptionHandler.class);

    /**
     * Handles InstructionExceptions from the rest controller.
     * 
     * @param e IntrusionException
     * @return error response POJO
     */
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler(value = IntrusionException.class)
    public ErrorResponse handleIntrusionException(HttpServletRequest request, IntrusionException e) {       
        log.warn(e.getLogMessage(), e);
        return this.handleValidationException(request, new ValidationException(e.getUserMessage(), e.getLogMessage()));
    }

    /**
     * Handles ValidationExceptions from the rest controller.
     * 
     * @param e ValidationException
     * @return error response POJO
     */
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler(value = ValidationException.class)
    public ErrorResponse handleValidationException(HttpServletRequest request, ValidationException e) {     
        String tokenId = request.getParameter(TOKEN_ID);
        log.info(e.getMessage(), e);

        if (e.getUserMessage().contains("Token ID")) {
            tokenId = "<OMITTED>";
        }

        return new ErrorResponse(   tokenId,
                                    HttpStatus.BAD_REQUEST.value(), 
                                    e.getClass().getSimpleName(),
                                    e.getUserMessage());
    }

    /**
     * Handles JsonProcessingExceptions from the rest controller.
     * 
     * @param e JsonProcessingException
     * @return error response POJO
     */
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler(value = JsonProcessingException.class)
    public ErrorResponse handleJsonProcessingException(HttpServletRequest request, JsonProcessingException e) {     
        String tokenId = request.getParameter(TOKEN_ID);
        log.info(e.getMessage(), e);
        return new ErrorResponse(   tokenId,
                                    HttpStatus.BAD_REQUEST.value(), 
                                    e.getClass().getSimpleName(),
                                    e.getOriginalMessage());
    }

    /**
     * Handles IllegalArgumentExceptions from the rest controller.
     * 
     * @param e IllegalArgumentException
     * @return error response POJO
     */
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler(value = IllegalArgumentException.class)
    public ErrorResponse handleIllegalArgumentException(HttpServletRequest request, IllegalArgumentException e) {
        String tokenId = request.getParameter(TOKEN_ID);
        log.info(e.getMessage(), e);
        return new ErrorResponse(   tokenId,
                                    HttpStatus.BAD_REQUEST.value(), 
                                    e.getClass().getSimpleName(), 
                                    e.getMessage());
    }

    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler(value = UnsupportedOperationException.class)
    public ErrorResponse handleUnsupportedOperationException(HttpServletRequest request, UnsupportedOperationException e) {
        String tokenId = request.getParameter(TOKEN_ID);
        log.info(e.getMessage(), e);
        return new ErrorResponse(   tokenId,
                                    HttpStatus.BAD_REQUEST.value(), 
                                    e.getClass().getSimpleName(), 
                                    e.getMessage());
    }

    /**
     * Handles MissingServletRequestParameterExceptions from the rest controller.
     * 
     * @param e MissingServletRequestParameterException
     * @return error response POJO
     */
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler(value = MissingServletRequestParameterException.class)
    public ErrorResponse handleMissingServletRequestParameterException( HttpServletRequest request, 
                                                                        MissingServletRequestParameterException e) {
        String tokenId = request.getParameter(TOKEN_ID);
        log.info(e.getMessage(), e);
        return new ErrorResponse(   tokenId,
                                    HttpStatus.BAD_REQUEST.value(), 
                                    e.getClass().getSimpleName(), 
                                    e.getMessage());
    }

    /**
     * Handles NoHandlerFoundExceptions from the rest controller.
     * 
     * @param e NoHandlerFoundException
     * @return error response POJO
     */
    @ResponseStatus(HttpStatus.NOT_FOUND)
    @ExceptionHandler(value = NoHandlerFoundException.class)
    public ErrorResponse handleNoHandlerFoundException(HttpServletRequest request, NoHandlerFoundException e) {
        String tokenId = request.getParameter(TOKEN_ID);
        log.info(e.getMessage(), e);
        return new ErrorResponse(   tokenId,
                                    HttpStatus.NOT_FOUND.value(), 
                                    e.getClass().getSimpleName(), 
                                    "The resource " + e.getRequestURL() + " is unavailable");
    }

    /**
     * Handles all remaining exceptions from the rest controller.
     * 
     * This acts as a catch-all for any exceptions not handled by previous exception handlers.
     * 
     * @param e Exception
     * @return error response POJO
     */
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    @ExceptionHandler(value = Exception.class)
    public ErrorResponse handleException(HttpServletRequest request, Exception e) {
        String tokenId = request.getParameter(TOKEN_ID);
        log.error(e.getMessage(), e);
        return new ErrorResponse(   tokenId,
                                    HttpStatus.INTERNAL_SERVER_ERROR.value(), 
                                    e.getClass().getSimpleName(), 
                                    "An internal error occurred");
    }   

}

Ответ 9

Решение с dispatcherServlet.setThrowExceptionIfNoHandlerFound(true); и @EnableWebMvc @ControllerAdvice работал у меня с Spring Boot 1.3.1, пока не работал над 1.2.7

Ответ 10

Для людей, которые хотят ErrorController в соответствии с кодом состояния http, вы можете использовать способ ErrorController:

@Controller
public class CustomErrorController extends BasicErrorController {

    public CustomErrorController(ServerProperties serverProperties) {
        super(new DefaultErrorAttributes(), serverProperties.getError());
    }

    @Override
    public ResponseEntity error(HttpServletRequest request) {
        HttpStatus status = getStatus(request);
        if (status.equals(HttpStatus.INTERNAL_SERVER_ERROR)){
            return ResponseEntity.status(status).body(ResponseBean.SERVER_ERROR);
        }else if (status.equals(HttpStatus.BAD_REQUEST)){
            return ResponseEntity.status(status).body(ResponseBean.BAD_REQUEST);
        }
        return super.error(request);
    }
}

ResponseBean здесь - мое пользовательское pojo для ответа.