What are the exceptions in laravel

Exceptions in laravel include: 1. "E_ERROR" fatal runtime error, which is unrecoverable and will cause the script to terminate and not continue running; 2. "E_WARNING" runtime warning "non-fatal error"; 3. "E_PARSE" compile-time syntax parsing error; 4. "E_CORE_ERROR" fatal error that occurs during initialization and startup; 5. "E_COMPILE_ERROR" fatal compile-time error; 6. "E_RECOVERABLE_ERROR" fatal error that can be captured.

The operating environment of this tutorial: Windows 7 system, Laravel 9 version, DELL G3 computer.

Exception level in laravel

Laravel exception handling

Laravel's exception handling is completed by the class \Illuminate\Foundation\Bootstrap\HandleExceptions::class:

class HandleExceptions
{
    public function bootstrap(Application $app)
    {
        $this->app = $app;

        error_reporting(-1);

        set_error_handler([$this, 'handleError']);

        set_exception_handler([$this, 'handleException']);

        register_shutdown_function([$this, 'handleShutdown']);

        if (! $app->environment('testing')) {
            ini_set('display_errors', 'Off');
        }
    }
}

Exception conversion

Laravel's exception handling is all handled by the function handleException.

PHP7 implements a global throwable interface. The original Exception and some Errors implement this interface, and define the inheritance structure of exceptions in the form of interfaces. As a result, more Errors in PHP7 become catchable Exceptions and are returned to developers. If they are not caught, they are Errors. If they are caught, they become Exceptions that can be handled within the program. These catchable Errors are usually Errors that do not cause fatal harm to the program, such as a function that does not exist.

In PHP7, based on /Error exception, 5 new engine exceptions are derived: ArithmeticError / AssertionError / DivisionByZeroError / ParseError / TypeError. In PHP7, both the old /Exception and the new /Error implement a common interface: /Throwable.

Therefore, when encountering an exception of non-Exception type, you must first convert it into a FatalThrowableError type:

public function handleException($e)
{
    if (! $e instanceof Exception) {
        $e = new FatalThrowableError($e);
    }

    $this->getExceptionHandler()->report($e);

    if ($this->app->runningInConsole()) {
        $this->renderForConsole($e);
    } else {
        $this->renderHttpResponse($e);
    }
}

FatalThrowableError is an error exception class that Symfony inherits \ErrorException:

class FatalThrowableError extends FatalErrorException
{
    public function __construct(\Throwable $e)
    {
        if ($e instanceof \ParseError) {
            $message = 'Parse error: '.$e->getMessage();
            $severity = E_PARSE;
        } elseif ($e instanceof \TypeError) {
            $message = 'Type error: '.$e->getMessage();
            $severity = E_RECOVERABLE_ERROR;
        } else {
            $message = $e->getMessage();
            $severity = E_ERROR;
        }

        \ErrorException::__construct(
            $message,
            $e->getCode(),
            $severity,
            $e->getFile(),
            $e->getLine()
        );

        $this->setTrace($e->getTrace());
    }
}

Exception Log

When encountering an abnormal situation, the first thing laravel does is to record the log. This is the role of the report function.

protected function getExceptionHandler()
{
    return $this->app->make(ExceptionHandler::class);
}

laravel's default exception handling class in the Ioc container is Illuminate\Foundation\Exceptions\Handler:

class Handler implements ExceptionHandlerContract
{
    public function report(Exception $e)
    {
        if ($this->shouldntReport($e)) {
            return;
        }
        try {
            $logger = $this->container->make(LoggerInterface::class);
        } catch (Exception $ex) {
            throw $e; // throw the original exception
        }
        $logger->error($e);
    }
    protected function shouldntReport(Exception $e)
    {
        $dontReport = array_merge($this->dontReport, [HttpResponseException::class]);
        return ! is_null(collect($dontReport)->first(function ($type) use ($e) {
            return $e instanceof $type;
        }));
    }
}

Exception page display

Record log After that, it is necessary to convert the exception into a page to display the exception information to the developer in order to check the source of the problem:

protected function renderHttpResponse(Exception $e)
{
    $this->getExceptionHandler()->render($this->app['request'], $e)->send();
}
class Handler implements ExceptionHandlerContract
{
    public function render($request, Exception $e)
    {
        $e = $this->prepareException($e);
        if ($e instanceof HttpResponseException) {
            return $e->getResponse();
        } elseif ($e instanceof AuthenticationException) {
            return $this->unauthenticated($request, $e);
        } elseif ($e instanceof ValidationException) {
            return $this->convertValidationExceptionToResponse($e, $request);
        }
        return $this->prepareResponse($request, $e);
    }
}

For different exceptions, laravel has different processing, roughly including HttpException, HttpResponseException, AuthorizationException, ModelNotFoundException , AuthenticationException, ValidationException. Since specific different exceptions have their own different needs, this article will not specifically introduce them. This article continues to introduce the handling of the most common exception HttpException:

protected function prepareResponse($request, Exception $e)
{
    if ($this->isHttpException($e)) {
        return $this->toIlluminateResponse($this->renderHttpException($e), $e);
    } else {
        return $this->toIlluminateResponse($this->convertExceptionToResponse($e), $e);
    }
}
protected function renderHttpException(HttpException $e)
{
    $status = $e->getStatusCode();
    view()->replaceNamespace('errors', [
        resource_path('views/errors'),
        __DIR__.'/views',
    ]);
    if (view()->exists("errors::{$status}")) {
        return response()->view("errors::{$status}", ['exception' => $e], $status, $e->getHeaders());
    } else {
        return $this->convertExceptionToResponse($e);
    }
}

For HttpException, different error page templates will be selected according to its error status code. If there is no relevant template, it will be sent through SymfonyResponse Construct exception display page:

protected function convertExceptionToResponse(Exception $e)
{
    $e = FlattenException::create($e);
    $handler = new SymfonyExceptionHandler(config('app.debug'));
    return SymfonyResponse::create($handler->getHtml($e), $e->getStatusCode(), $e->getHeaders());
}
protected function toIlluminateResponse($response, Exception $e)
{
    if ($response instanceof SymfonyRedirectResponse) {
        $response = new RedirectResponse($response->getTargetUrl(), $response->getStatusCode(), $response->headers->all());
    } else {
        $response = new Response($response->getContent(), $response->getStatusCode(), $response->headers->all());
    }
    return $response->withException($e);
}

[Related recommendations: laravel video tutorial]

The above is the detailed content of What are the exceptions in laravel. For more information, please follow other related articles on the PHP Chinese website!