Главная » ЭКСП » exception type error message internal error

exception type error message internal error

В этой статье

Ошибка 500 Internal Server Error — диагностика

Важно помнить, что эта ошибка происходит на стороне сервера. Это значит, что HTML-код, выполняемый на стороне клиента, а также JavaScript или любые другие запущенные в браузере объекты, не могут быть причиной, по которой возникает ошибка 500 Internal Server Error. Само название (Internal Server Error – ‘внутренняя ошибка сервера’) говорит о том, что ошибка происходит на сервере.

Причины возникновения ошибки

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

Основной причиной ошибки 500 может быть:

  1. Неверный синтаксис файла .htaccess. htaccess – это файл, в котором можно задавать настройки для работы с веб-сервером Apache и вносить изменения в работу сайта (управлять различными перенаправлениями, правами доступа к файлам, опциями PHP, задавать собственные страницы ошибок и т.д.). 
    Узнать больше о файле .htaccess можно в статье «Создание и настройка .htaccess».
  2. Ошибки в скриптах сайта, то есть сценариях, созданных для автоматического выполнения задач или для расширения функционала сайта.
  3. Нехватка оперативной памяти при выполнении скрипта.
  4. Ошибки в коде CMS, системы управления содержимым сайта. В 80% случаев виноваты конфликтующие плагины. 

Год хостинга в подарок при заказе лицензии 1С-Битрикс

Выбирайте надежную CMS с регулярными обновлениями системы и профессиональной поддержкой.

Заказать

Customizing Error Messages

If you want, you can always customize your error messages from the error handler. There are different ways of doing that, but we are going to show you the basic two ways.

First of all, we can assume that the AccessViolationException is thrown from our action:

[HttpGet] public IActionResult Get()
{
_logger.LogInfo(«Fetching all the Students from the storage»);

var students = DataManager.GetAllStudents(); //simulation for the data base access

throw new AccessViolationException(«Violation Exception while accessing the resource.»);

_logger.LogInfo($»Returning {students.Count} students.»);

return Ok(students);
}

Now, what we can do is modify the InvokeAsync method inside the ExceptionMiddleware.cs class by adding a specific exception checking in the additional catch block:

Learning Web API? Get our eBook ASP.NET Core Web API Best Practices and become an expert for FREE!   >> GET THE BOOK << public async Task InvokeAsync(HttpContext httpContext) { try { await _next(httpContext); } catch (AccessViolationException avEx) { _logger.LogError($"A new violation exception has been thrown: {avEx}"); await HandleExceptionAsync(httpContext, avEx); } catch (Exception ex) { _logger.LogError($"Something went wrong: {ex}"); await HandleExceptionAsync(httpContext, ex); } }

And that’s all. Now if we send another request with Postman, we are going to see in the log file that the AccessViolationException message is logged. Of course, our specific exception check must be placed before the global catch block.

With this solution, we are logging specific messages for the specific exceptions, and that can help us, as developers, a lot when we publish our application. But if we want to send a different message for a specific error, we can also modify the HandleExceptionAsync method in the same class:

private async Task HandleExceptionAsync(HttpContext context, Exception exception)
{
context.Response.ContentType = «application/json»;
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;

var message = exception switch
{
AccessViolationException => «Access violation error from the custom middleware»,
_ => «Internal Server Error from the custom middleware.»
};

await context.Response.WriteAsync(new ErrorDetails()
{
StatusCode = context.Response.StatusCode,
Message = message
}.ToString());
}

Here, we are using a switch expression pattern matching to check the type of our exception and assign the right message to the message variable. Then, we just use that variable in the WriteAsync method.

Now if we test this, we will get a log message with the Access violation message, and our response will have a new message as well:

{
«StatusCode»: 500,
«Message»: «Access violation error from the custom middleware»
}

One thing to mention here. We are using the 500 status code for all the responses from the exception middleware, and that is something we believe it should be done. After all, we are handling exceptions and these exceptions should be marked with a 500 status code. But this doesn’t have to be the case all the time. For example, if you have a service layer and you want to propagate responses from the service methods as custom exceptions and catch them inside the global exception handler, you may want to choose a more appropriate status code for the response. You can read more about this technique in our Onion Architecture article. It really depends on your project organization.

@ResponseStatus

As the name suggests, @ResponseStatus allows us to modify the HTTP status of our response. It can be applied in the following
places:

  • On the exception class itself
  • Along with the @ExceptionHandler annotation on methods
  • Along with the @ControllerAdvice annotation on classes

In this section, we’ll be looking at the first case only.

Let’s come back to the problem at hand which is that our error responses are always giving us the HTTP status 500 instead of a more descriptive status code.

To address this we can we annotate our Exception class with @ResponseStatus and pass in the desired HTTP response status
in its value property:

@ResponseStatus(value = HttpStatus.NOT_FOUND)publicclassNoSuchElementFoundExceptionextends RuntimeException {…}

This change will result in a much better response if we call our controller with an invalid ID:

{
«timestamp»: «2020-11-29T09:42:12.287+00:00»,
«status»: 404,
«error»: «Not Found»,
«message»: «Item with id 1 not found»,
«path»: «/product/1»
}

Another way to achieve the same is by extending the ResponseStatusException class:

publicclassNoSuchElementFoundExceptionextends ResponseStatusException {publicNoSuchElementFoundException(String message){super(HttpStatus.NOT_FOUND, message);}@Overridepublic HttpHeaders getResponseHeaders(){// return response хедерs
}}

This approach comes in handy when we want to manipulate the response хедерs, too, because we can override the getResponseHeaders() method.

@ResponseStatus, in combination with the server.error configuration properties, allows us to manipulate almost all the fields
in our Spring-defined error response payload.

But what if want to manipulate the structure of the response payload as well?

Let’s see how
we can achieve that in the next section.

Как получить больше данных о причине ошибки 

Что означает ошибка 500, мы теперь знаем. Когда она перестала быть таким загадочным персонажем, не страшно копнуть глубже — научиться определять причину ошибки. В некоторых случаях это можно сделать самостоятельно, так что обращаться за помощью к профильному специалисту не понадобится.

Отображение ошибки бывает разным. Ее внешний облик зависит от того, чем она вызвана.

Самые частые причины ошибки 500 можно распознать по тексту ошибки или внешнему виду страницы. 

  1. Сообщение Internal Server Error говорит о том, что есть проблемы с файлом .htaccess (например, виновата некорректная настройка файла). Убедиться, что .htaccess является корнем проблемы, поможет следующий прием: переименуйте файл .htaccess, добавив единицу в конце названия. Это можно сделать с помощью FTP-клиента (например, FileZilla) или файлового менеджера на вашем хостинге (в Timeweb такой есть, с ним довольно удобно работать). После изменения проверьте доступность сайта. Если ошибка больше не наблюдается, вы нашли причину.
  2. Сообщение HTTP ERROR 500 или пустая страница говорит о проблемах со скриптами сайта. В случае с пустой страницей стоит учесть, что отсутствие содержимого сайта не всегда указывает на внутреннюю ошибку сервера 500.

Давайте узнаем, что скрывается за пустой страницей, обратившись к инструментам разработчика. Эта браузерная панель позволяет получить информацию об ошибках и другие данные (время загрузки страницы, html-элементы и т.д.). 

Как открыть панель разработчика

  • Нажмите клавишу F12 (способ актуален для большинства браузеров на Windows). Используйте сочетание клавиш Cmd+Opt+J, если используете Google Chrome на macOS. Или примените комбинацию Cmd+Opt+C в случае Safari на macOS (но перед этим включите «Меню разработки» в разделе «Настройки» -> «Продвинутые»). Открыть инструменты разработчика также можно, если кликнуть правой кнопкой мыши в любом месте веб-страницы и выбрать «Просмотреть код» в контекстном меню. 
  • Откройте вкладку «Сеть» (или «Network») и взгляните на число в поле «Статус». Код ответа об ошибке 500 — это соответствующая цифра.

Причины ошибки 500
Более детальную диагностику можно провести с помощью логов.

Простыми словами: лог — это журнал, в который записывается информация об ошибках, запросах к серверу, подключениях к серверу, действиях с файлами и т.д.

Как вы видите, данных в логи записывается немало, поэтому они разделены по типам. За сведениями о нашей ошибке можно обратиться к логам ошибок (error_log). Обычно такие логи предоставляет служба поддержки хостинга, на котором размещен сайт. В Timeweb вы можете включить ведение логов и заказать необходимые данные в панели управления. Разобраться в полученных логах поможет статья «Чтение логов».

Handle Media Type Not Supported Exception

Spring throws HttpMediaTypeNotSupportedException, when a POST, PUT, or a PATCH endpoint on the server cannot handle the content-type sent by the client. The REST Controllers on the server specify the content type they can support. When the media type that a client sends doesn’t match, the client gets this exception back.

To demonstrate, next is an example of handling HttpMediaTypeNotSupportedException and returning a custom error response.

@ExceptionHandler(HttpMediaTypeNotSupportedException.class)
publicResponseEntity<>> handleException(
HttpMediaTypeNotSupportedExceptione) {

String provided = e.getContentType().toString();
List supported = e.getSupportedMediaTypes().stream()
.map(MimeType::toString)
.collect(Collectors.toList());

String error = provided + » is not one of the supported media types (» +
String.join(«, «, supported) + «)»;

Map errorResponse = new HashMap<>();
errorResponse.put(«error», error);
errorResponse.put(«message», e.getLocalizedMessage());
errorResponse.put(«status», HttpStatus.UNSUPPORTED_MEDIA_TYPE.toString());

returnnew ResponseEntity<>(errorResponse, HttpStatus.UNSUPPORTED_MEDIA_TYPE);
}Code language:Java(java)

As seen in the exception handler above, the instance of HttpMediaTypeNotSupportedException provides detailed information about the incorrect media type that we provided and a list of actually supported media types. Thus, we create a custom error message based on the available information.

{
«error»:»text/plain;charset=UTF-8 is not one of the supported media types (
application/octet-stream,
text/plain, application/xml,
text/xml, application/x-www-form-urlencoded,
application/*+xml,
multipart/form-data,
multipart/mixed,
application/json,
application/*+json, */*)»,
«message»:»Content type ‘text/plain;charset=UTF-8’ not supported»,
«status»:»415 UNSUPPORTED_MEDIA_TYPE»
}Code language:JSON / JSON with Comments(json)

The above snippet shows a client’s sample error response when it sends a request with an invalid media type.

Handling Errors Globally With the Custom Middleware

Let’s create a new folder named CustomExceptionMiddleware and a class ExceptionMiddleware.cs inside it.

We are going to modify that class:

public class ExceptionMiddleware
{
private readonly RequestDelegate _next;
private readonly ILoggerManager _logger;

public ExceptionMiddleware(RequestDelegate next, ILoggerManager logger)
{
_logger = logger;
_next = next;
}

public async Task InvokeAsync(HttpContext httpContext)
{
try
{
await _next(httpContext);
}
catch (Exception ex)
{
_logger.LogError($»Something went wrong: {ex}»);
await HandleExceptionAsync(httpContext, ex);
}
}

private async Task HandleExceptionAsync(HttpContext context, Exception exception)
{
context.Response.ContentType = «application/json»;
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;

await context.Response.WriteAsync(new ErrorDetails()
{
StatusCode = context.Response.StatusCode,
Message = «Internal Server Error from the custom middleware.»
}.ToString());
}
}

The first thing we need to do is to register our IloggerManager service and RequestDelegate through the dependency injection. The _next parameter of RequestDeleagate type is a function delegate that can process our HTTP requests.

After the registration process, we create the InvokeAsync() method. RequestDelegate can’t process requests without it.

If everything goes well, the _next delegate should process the request and the Get action from our controller should generate a successful response. But if a request is unsuccessful (and it is, because we are forcing an exception), our middleware will trigger the catch block and call the HandleExceptionAsync method.

In that method, we just set up the response status code and content type and return a response.

Now let’s modify our ExceptionMiddlewareExtensions class with another static method:

public static void ConfigureCustomExceptionMiddleware(this IApplicationBuilder app)
{
app.UseMiddleware();
}

In .NET 6 and above, we have to extend the WebApplication type:

Learning Web API? Get our eBook ASP.NET Core Web API Best Practices and become an expert for FREE!   >> GET THE BOOK << public static void ConfigureCustomExceptionMiddleware(this WebApplication app) { app.UseMiddleware();
}

Finally, let’s use this method in the Configure method in the Startup class:

//app.ConfigureExceptionHandler(logger);
app.ConfigureCustomExceptionMiddleware();

Great.

Now let’s inspect the result again:

custom handler middleware

There we go. Our custom middleware is implemented in a couple of steps.

@ControllerAdvice

Why is it called «Controller Advice»?

The term ‘Advice’ comes from Aspect-Oriented Programming (AOP) which allows us to inject cross-cutting code (called «advice») around existing methods. A controller advice allows us to intercept and modify the return values of controller methods, in our case to handle exceptions.

Controller advice classes allow us to apply exception handlers to more than one or all controllers in our application:

@ControllerAdvicepublicclassGlobalExceptionHandlerextends ResponseEntityExceptionHandler {publicstaticfinal String TRACE =»trace»;@Value(«${reflectoring.trace:false}»)privateboolean printStackTrace;@Override@ResponseStatus(HttpStatus.UNPROCESSABLE_ENTITY)protected ResponseEntityhandleMethodArgumentNotValid(
MethodArgumentNotValidException ex,
HttpHeaders хедерs,
HttpStatus status,
WebRequest request
){//Body omitted as it’s similar to the method of same name
// in ProductController example…
//…..
}@ExceptionHandler(ItemNotFoundException.class)@ResponseStatus(HttpStatus.NOT_FOUND)public ResponseEntityhandleItemNotFoundException(
ItemNotFoundException itemNotFoundException,
WebRequest request
){//Body omitted as it’s similar to the method of same name
// in ProductController example…
//…..
}@ExceptionHandler(RuntimeException.class)@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)public ResponseEntityhandleAllUncaughtException(
RuntimeException exception,
WebRequest request
){//Body omitted as it’s similar to the method of same name
// in ProductController example…
//…..
}//….
@Overridepublic ResponseEntityhandleExceptionInternal(
Exception ex,
Object body,
HttpHeaders хедерs,
HttpStatus status,
WebRequest request){return buildErrorResponse(ex,status,request);}}

The bodies of the handler functions and the other support code are omitted as they’re almost
identical to the code we saw in the @ExceptionHandler section. Please find the full code in the Github Repo’s
classGlobalExceptionHandler .

A couple of things are new which we will talk about in a while. One major difference here is that these handlers will handle exceptions thrown by all the controllers
in the application and not just ProductController.

If we want to selectively apply or limit the scope of the controller advice to a particular controller, or a package, we can use the properties provided by the annotation:

  • @ControllerAdvice(«com.reflectoring.controller»): we can pass a package name or list of package names in the annotation’s value
    or basePackages parameter. With this, the controller advice will only handle exceptions of this package’s controllers.
  • @ControllerAdvice(annotations = Advised.class): only controllers marked with the @Advised annotation will be handled
    by the controller advice.

Find other parameters in the annotation docs@ControllerAdvice .

ResponseEntityExceptionHandler

ResponseEntityExceptionHandler is a convenient base class for controller advice classes. It provides
exception handlers for internal Spring exceptions. If we don’t extend it, then all the exceptions will be redirected to DefaultHandlerExceptionResolver
which returns a ModelAndView object. Since we are on the mission to shape our own error response, we don’t want that.

As you can see we have overridden two of the ResponseEntityExceptionHandler methods:

  • handleMethodArgumentNotValid(): in the @ExceptionHandler section we have implemented a handler for it ourselves. In here we have only
    overridden its behavior.
  • handleExceptionInternal(): all the handlers in the ResponseEntityExceptionHandler use this function to build the
    ResponseEntity similar to our buildErrorResponse(). If we don’t override this then the clients will receive only the HTTP status
    in the response хедер but since we want to include the HTTP status in our response bodies as well, we have overridden the method.

Handling NoHandlerFoundException Requires a Few Extra Steps

This exception occurs when you try to call an API that doesn’t exist in the system. Despite us implementing its handler
via ResponseEntityExceptionHandler class the exception is redirected to DefaultHandlerExceptionResolver.

To redirect the exception to our advice we need to set a couple of properties in the the properties file: spring.mvc.throw-exception-if-no-handler-found=true and spring.web.resources.add-mappings=false

Credit: Stackoverflow user mengchengfeng.

Some Points to Keep in Mind when Using @ControllerAdvice

  • To keep things simple always have only one controller advice class in the project. It’s good to have a single repository of
    all the exceptions in the application. In case you create multiple controller advice, try to utilize the basePackages or annotations properties
    to make it clear what controllers it’s going to advise.
  • Spring can process controller advice classes in any order unless we have annotated it with the @Order annotation. So, be mindful when you write a catch-all handler if you have more than one controller advice. Especially
    when you have not specified basePackages or annotations in the annotation.

Spring Boot’s Default Exception Handling Mechanism

Let’s say we have a controller named ProductController whose getProduct(…) method is throwing a NoSuchElementFoundException runtime exception when a Product with a given id is not found:

@RestController@RequestMapping(«/product»)publicclassProductController{privatefinal ProductService productService;//constructor omitted for brevity…
@GetMapping(«/{id}»)public Response getProduct(@PathVariable String id){// this method throws a «NoSuchElementFoundException» exception
return productService.getProduct(id);}}

If we call the /product API with an invalid id the service will throw a NoSuchElementFoundException runtime exception and we’ll get the
following response:

{
«timestamp»: «2020-11-28T13:24:02.239+00:00»,
«status»: 500,
«error»: «Internal Server Error»,
«message»: «»,
«path»: «/product/1»
}

We can see that besides a well-formed error response, the payload is not giving us any useful information. Even the message
field is empty, which we might want to contain something like “Item with id 1 not found”.

Let’s start by fixing the error message issue.

Spring Boot provides some properties with which we can add the exception message, exception class, or even a stack trace
as part of the response payload:

server:
error:
include-message: alwaysinclude-binding-errors: alwaysinclude-stacktrace: on_trace_paraminclude-exception: false

Using these Spring Boot server properties in our application.yml we can alter the error response to some extent.

Now if we call the /product API again with an invalid id we’ll get the following response:

{
«timestamp»: «2020-11-29T09:42:12.287+00:00»,
«status»: 500,
«error»: «Internal Server Error»,
«message»: «Item with id 1 not found»,
«path»: «/product/1»
}

Note that we’ve set the property include-stacktrace to on_trace_param which means that only if we include the trace param in the URL (?trace=true), we’ll get a stack trace in the response payload:

{
«timestamp»: «2020-11-29T09:42:12.287+00:00»,
«status»: 500,
«error»: «Internal Server Error»,
«message»: «Item with id 1 not found»,
«trace»: «io.reflectoring.exception.exception.NoSuchElementFoundException: Item with id 1 not found…»,
«path»: «/product/1»
}

We might want to keep the value of include-stacktrace flag to never, at least in production, as it might reveal the internal
workings of our application.

Moving on! The status and error message — 500 — indicates that something is wrong with our server code but actually it’s a client error because the client provided an invalid id.

Our current status code doesn’t correctly reflect that. Unfortunately, this is as far as we can go with the server.error configuration properties, so we’ll have to look at the annotations that Spring Boot offers.

2. Solution 1: the Controller-Level @ExceptionHandler

The first solution works at the @Controller level. We will define a method to handle exceptions and annotate that with @ExceptionHandler:

public class FooController{

//…
@ExceptionHandler({ CustomException1.class, CustomException2.class })
public void handleException() {
//
}
}

This approach has a major drawback: The @ExceptionHandler annotated method is only active for that particular Controller, not globally for the entire application. Of course, adding this to every controller makes it not well suited for a general exception handling mechanism.

We can work around this limitation by having all Controllers extend a Base Controller class.

However, this solution can be a problem for applications where, for whatever reason, that isn’t possible. For example, the Controllers may already extend from another base class, which may be in another jar or not directly modifiable, or may themselves not be directly modifiable.

Next, we’ll look at another way to solve the exception handling problem — one that is global and doesn’t include any changes to existing artifacts such as Controllers.

Handle Request Body Not Readable Exception

Now we will see an example of handling HttpMessageNotReadableException and returning a custom error response. The HttpMessageNotReadableException occurs when the request body is missing or is unreadable.

@ExceptionHandler(HttpMessageNotReadableException.class)
publicResponseEntity<>> handleException(
HttpMessageNotReadableExceptione) throwsIOException{

Map errorResponse = new HashMap<>();
errorResponse.put(«message», e.getLocalizedMessage());
errorResponse.put(«status», HttpStatus.BAD_REQUEST.toString());

returnnew ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
}Code language:Java(java)

Handle Bad Request Exceptions

The Bad Request errors are the Client errors where the client’s request doesn’t meet the requirements of the target server. This section will see how to handle Bad Request exceptions and provide a custom or detailed error response.

Type Mismatch Exceptions

The Type Mismatch Exceptions occur when Spring Controller cannot map the request parameters, path variables, or хедер values into controller method arguments. This section covers handling of MethodArgumentTypeMismatchException and TypeMismatchException.

Spring throws MethodArgumentTypeMismatchException when the controller argument doesn’t have a required type. On the other hand, Spring throws TypeMismatchException when there is a type mismatch while setting Bean properties. Also, both of these exceptions instances provide a detailed error message that we can use to prepare the Error object.

To demonstrate that, next is an example of Handling MethodArgumentTypeMismatchException and TypeMismatchException and returning a detailed error message in Controller Advice.

@ExceptionHandler({
MethodArgumentTypeMismatchException.class,
TypeMismatchException.class
})
publicResponseEntity<>> handleException(TypeMismatchExceptione) {
Map errorResponse = new HashMap<>();

errorResponse.put(«message», e.getLocalizedMessage());
errorResponse.put(«status», HttpStatus.BAD_REQUEST.toString());
returnnew ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
}Code language:Java(java)

Note that the controller advice catches both exceptions; however, the method arguments accept an exception of type TypeMismatchException because it is the parent of the other exception.

Next, the snippet shows a detailed error message when we call a rest endpoint with an incompatible path variable leading to MethodArgumentTypeMismatchException.

{
«httpStatus»: «BAD_REQUEST»,
«message»:
«Failed to convert value of type ‘java.lang.String’
to required type ‘java.lang.Long’; nested exception
is java.lang.NumberFormatException: For input
string: «Jack»»
}Code language:JSON / JSON with Comments(json)

Bean Validation Exceptions

The Bean Validation exceptions occur when the contents of the request do not pass the provided validations.

The BindException occurs when the binding errors are fatal. While the MethodArgumentNotValidException occurs when validations specified by @Valid fail. Note that the MethodArgumentNotValidException is a subclass of BindException. Thus, we can handle them using the same Spring REST API’s exception handler.

@ExceptionHandler({
BindException.class,
MethodArgumentNotValidException.class
})
publicResponseEntity<>> handleException(BindExceptione) {

List errors = new ArrayList<>();
e.getFieldErrors()
.forEach(err -> errors.add(err.getField() + «: » + err.getDefaultMessage()));
e.getGlobalErrors()
.forEach(err -> errors.add(err.getObjectName() + «: » + err.getDefaultMessage()));

Map errorResponse = new HashMap<>();
errorResponse.put(«error», errors);

errorResponse.put(«message», e.getLocalizedMessage());
errorResponse.put(«status», HttpStatus.BAD_REQUEST.toString());
returnnew ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
}Code language:Java(java)Here we have created a List to represent individual binding errors and add that to the response Map. Instead, we can add a List field to the Error class we created in the previous section and populate the list with individual errors.

Murtuza Ranapurwala


Written By:

Ошибка 500 Internal Server Error — устранение на популярных платформах

Многие пользователи устанавливают на свой сервер популярные CMS-системы, такие как WordPress, Joomla, Drupal и они не должны вызывать ошибку 500, если всё настроено правильно. Однако она всё равно всплывает – из-за несовместимости версий, некачественных установок или сбоя прав доступа на сервере.

Вот некоторые распространённые проблемы, которые могут вызывать подобную ошибку в часто используемых CMS:

  • Если вы только что обновили движок до новой версии, вероятно, обновление прошло с ошибками и необходимо провести его повторно. Скорее всего, на сайте разработчика есть инструкции, как это правильно сделать.
  • Если вы только что активировали новый плагин или новую тему, стоит попробовать отменить эти изменения. Даже профессионально написанные плагины могут конфликтовать с другими и вызывать 500 Internal Server Error nginx
  • Если вы обновляли CMS, старые плагины и темы могут быть с ней несовместимы. Единственное, что можно сделать в таком случае — отключать их по очереди, пока ошибка 500 не исчезнет.
  • Неправильно заданные права доступа на сервере или ошибки в файле .htaccess. Серверу не удаётся получить доступ к скриптам, файлам и другим ресурсам, поэтому он выдаёт ошибку.

Когда причиной, по которой возникает ошибка 500 Internal Server Error являются скрипты и плагины, лучше всего искать ответы на сайтах их разработчиков.

4. Solution 3: @ControllerAdvice

Spring 3.2 brings support for a global @ExceptionHandler with the @ControllerAdvice annotation.

This enables a mechanism that breaks away from the older MVC model and makes use of ResponseEntity along with the type safety and flexibility of @ExceptionHandler:

@ControllerAdvice
public class RestResponseEntityExceptionHandler
extends ResponseEntityExceptionHandler {

@ExceptionHandler(value
= { IllegalArgumentException.class, IllegalStateException.class })
protected ResponseEntityhandleConflict(
RuntimeException ex, WebRequest request) {
String bodyOfResponse = «This should be application specific»;
return handleExceptionInternal(ex, bodyOfResponse,
new HttpHeaders(), HttpStatus.CONFLICT, request);
}
}

The@ControllerAdvice annotation allows us to consolidate our multiple, scattered @ExceptionHandlers from before into a single, global error handling component.

The actual mechanism is extremely simple but also very flexible:

  • It gives us full control over the body of the response as well as the status code.
  • It provides mapping of several exceptions to the same method, to be handled together.
  • It makes good use of the newer RESTful ResposeEntity response.

One thing to keep in mind here is to match the exceptions declared with @ExceptionHandler to the exception used as the argument of the method.

If these don’t match, the compiler will not complain — no reason it should — and Spring will not complain either.

However, when the exception is actually thrown at runtime, the exception resolving mechanism will fail with:

java.lang.IllegalStateException: No suitable resolver for argument [0] [type=…] HandlerMethod details: …

Introduction

Spring Boot provides us tools to handle exceptions beyond simple ‘try-catch’ blocks. To use these tools, we apply a couple of annotations
that allow us to treat exception handling as a cross-cutting concern:

  • @ResponseStatus
  • @ExceptionHandler
  • @ControllerAdvice

Before jumping into these annotations we will first look at how Spring handles exceptions thrown by our web controllers — our last line of defense for catching an exception.

We will also look at some configurations provided by Spring Boot to modify the default behavior.

We’ll identify the challenges we face while doing that, and then we will try to overcome those using these annotations.

Handle HTTP Request Method Not Supported Exception

The HttpMethodNotSupportedException occurs when the HTTP endpoint on the REST API does not support the HTTP request method. Let’s write an exception handler for HttpMethodNotSupportedException and return a detailed error message.

@ExceptionHandler(HttpRequestMethodNotSupportedException.class)
publicResponseEntity<>> handleException(
HttpRequestMethodNotSupportedExceptione) throwsIOException{
Map errorResponse = new HashMap<>();
String provided = e.getMethod();
List supported = Arrays.asList(e.getSupportedMethods());

String error = provided + » is not one of the supported Http Methods (» +
String.join(«, «, supported) + «)»;
errorResponse.put(«error», error);
errorResponse.put(«message», e.getLocalizedMessage());
errorResponse.put(«status», HttpStatus.METHOD_NOT_ALLOWED.toString());

returnnew ResponseEntity<>(errorResponse, HttpStatus.METHOD_NOT_ALLOWED);
}Code language:Java(java)

As seen in the exception handler above, the exception instance provides detailed information about the provided HTTP Method and an array of Supported HTTP Methods. We use it to form a clear error message.

{
«error»: «GET is not one of the supported Http Methods (POST)»,
«message»: «Request method ‘GET’ not supported»,
«status»: «405 METHOD_NOT_ALLOWED»
}Code language:JSON / JSON with Comments(json)

The snippet showed an example response when the client attempted to execute a GET endpoint, while the REST API supports only POST.

Ошибка 500 Internal Server Error — устранение на стороне серверных скриптов

Что такое ошибка доступа 403 и как ее исправить?

Другой причиной по которой может возникнуть ошибка 500 Internal Server Error может стать разработка и тестирование собственных скриптов.

Чтобы справиться с такой ошибкой, попробуйте следующие решения:

  • Настройка прав на сервере: часто неверная настройка прав доступа к файлу или папке приводит к тому, что сервером выдаётся ошибка 500 Internal Server Error. Из-за того, что ему не удаётся запустить скрипт. Выясните, какие права должны быть настроены, и выставьте их соответствующим образом.
  • Превышено время ожидания: возможно, истекло время ожидания ответа от PHP или другого серверного скрипта. Это происходит из-за того, что недоступен определённый ресурс или коде была допущена ошибка, запускающая бесконечный цикл.
  • Превышено время ожидания соединения с сервером: если сервер был занят, перезагружался или потерял соединение, скрипт может выдать ошибку 500 Internal Server Error. Возможно, в следующий раз ошибки не будет. Но если ошибка появляется при тестировании, велика вероятность того, что она встретится и пользователям.
  • Ошибки в файле .htaccess: в некоторых случаях ошибку 500 может вызывать код, прописанный в файле .htaccess.
  • Ошибки в скрипте: если ошибку выдаёт скрипт, можете запросить у него подробную информацию об ошибке. К примеру, в PHP можно включить вывод ошибок на экран или в лог-файл, добавив директиву display_errors. По умолчанию среда выполнения может скрывать ошибки, но это не очень удобно для отладки программы.

Попросите помощи у системного администратора

Ошибка 504 Gateway Time Out — что значит почему она возникает и как ее исправить?

В некоторых случаях у разработчиков нет полного контроля над сервером.

Если скрипт запускается на сервере сторонней организации, она может помочь вам в следующем:

  • Предоставить документацию о своём сервере и возможных причинах ошибки 500. В зависимости от используемой операционной системы и настройки оборудования, данная ошибка может возникать по разным причинам.
  • Попросите службу поддержки хостинга посмотреть лог-файлы с ошибками — системный администратор сможет определить, был ли сервер во время возникновения ошибки загружен или вовсе «упал».

Return Error Message Using Custom Error Object

Let’s create a class representing the error message and the status code. We will return an instance of that in case of errors.

Next is the Error class representing the status code and a String message. We use a couple of Lombok annotations that introduce regular getter and setter methods and a constructor using the final fields.

Custom Response Error Class

@Data@RequiredArgsConstructorpublicclassError{
privatefinal HttpStatus httpStatus;
privatefinal String message;
}Code language:Java(java)

Now that we have an error model created, we will use it to return a detailed error message from Controller Advice.

@ExceptionHandler(StudentNotFoundException.class)
publicResponseEntity handleException(StudentNotFoundExceptione) {
Error error = new Error(HttpStatus.NOT_FOUND, e.getLocalizedMessage());
returnnew ResponseEntity<>(error, error.getHttpStatus());
}Code language:Java(java)

The exception handler returns an instance of the Error class populated with the exception message and HTTP Status Code.

Now, we can throw our Not Found Exception with a custom error message.

thrownew StudentNotFoundException(«Student service failed, studentId : » + studentId);Code language:Java(java)

When the REST API cannot find the requested resource, we get a detailed error as a response.

{
«httpStatus»: «NOT_FOUND»,
«message»: «Student service failed, studentId : Jack»
}Code language:JSON / JSON with Comments(json)

Guide to Spring Data REST Validators

Quick and practical guide to Spring Data REST Validators Read more →

Custom Error Message Handling for REST API

Implement a Global Exception Handler for a REST API with Spring. Read more →

Spring MVC Custom Validation

Learn how to build a custom validation annotation and use it in Spring MVC. Read more →

Источники

  • https://www.internet-technologies.ru/articles/oshibka-500-internal-server-error.html
  • https://timeweb.com/ru/community/articles/chto-takoe-oshibka-500-i-kogda-ona-voznikaet
  • https://code-maze.com/global-error-handling-aspnetcore/
  • https://reflectoring.io/spring-boot-exception-handling/
  • https://www.amitph.com/spring-rest-api-custom-error-messages/
  • https://www.baeldung.com/exception-handling-for-rest-with-spring
[свернуть]
Решите Вашу проблему!


×
Adblock
detector