Was sind die Ausnahmen in Laravel?

Zu den Ausnahmen in Laravel gehören: 1. „E_ERROR“ schwerwiegender Laufzeitfehler, der nicht behebbar ist und dazu führt, dass das Skript beendet wird und nicht weiter ausgeführt wird; 2. „E_WARNING“ Laufzeitwarnung „nicht schwerwiegender Fehler“; 4. Schwerwiegender Fehler „E_CORE_ERROR“, der während der Initialisierung und beim Start auftritt. 5. Schwerwiegender Fehler „E_RECOVERABLE_ERROR“, der erfasst werden kann.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, Laravel 9-Version, DELL G3-Computer.

Ausnahmestufe in Laravel

Konstante	Beschreibung
E_ERROR	Schwerwiegender Laufzeitfehler. Bei dieser Art von Fehler handelt es sich im Allgemeinen um eine nicht behebbare Situation, beispielsweise um ein Problem, das durch die Speicherzuweisung verursacht wird. Die Folge ist, dass das Skript beendet wird und nicht weiter ausgeführt wird.
E_WARNING	Laufzeitwarnung (nicht schwerwiegender Fehler). Es wird nur eine Eingabeaufforderung angezeigt, das Skript wird jedoch nicht beendet.
E_PARSE	Syntaxparsingfehler bei der Kompilierung. Parsing-Fehler werden nur vom Parser generiert.
E_NOTICE	Laufzeitbenachrichtigung. Zeigt an, dass das Skript auf eine Situation stößt, die möglicherweise als Fehler erscheint. Es kann jedoch auch zu ähnlichen Benachrichtigungen in Skripten kommen, die normal ausgeführt werden können.
E_CORE_ERROR	Schwerwiegender Fehler ist beim Start der PHP-Initialisierung aufgetreten. Dieser Fehler ähnelt E_ERROR, wird jedoch vom Kern der PHP-Engine generiert.
E_CORE_WARNING	Warnung (nicht schwerwiegender Fehler) ist beim Start der PHP-Initialisierung aufgetreten. Wie E_WARNING, aber vom PHP-Engine-Kern generiert.
E_COMPILE_ERROR	Schwerwiegender Fehler bei der Kompilierung. Ähnlich wie E_ERROR, aber von der Zend-Skript-Engine generiert.
E_COMPILE_WARNING	Kompilierungszeitwarnung (nicht schwerwiegender Fehler). Wie E_WARNING, aber von der Zend-Skript-Engine generiert.
E_USER_ERROR	Benutzergenerierte Fehlermeldung. Ähnlich wie E_ERROR, wird jedoch vom Benutzer mithilfe der PHP-Funktion trigger_error() im Code generiert.
E_USER_WARNING	Benutzergenerierte Warnmeldung. Ähnlich wie E_WARNING, wird jedoch vom Benutzer mithilfe der PHP-Funktion trigger_error() im Code generiert.
E_USER_NOTICE	Vom Benutzer generierte Benachrichtigungsinformationen. Ähnlich wie E_NOTICE, wird jedoch vom Benutzer mithilfe der PHP-Funktion trigger_error() im Code generiert.
E_STRICT	Aktivieren Sie PHPs Vorschläge für Codeänderungen, um die beste Interoperabilität und Vorwärtskompatibilität des Codes sicherzustellen.
E_RECOVERABLE_ERROR	Ein schwerwiegender Fehler, der abgefangen werden kann. Es weist darauf hin, dass ein potenziell gefährlicher Fehler aufgetreten ist, die PHP-Engine jedoch noch nicht in einem instabilen Zustand ist. Wenn der Fehler nicht von einem benutzerdefinierten Handler abgefangen wird (siehe set_error_handler ()), wird er zu E_ERROR und das Skript wird beendet.
E_DEPRECATED	Laufzeitbenachrichtigung. Wenn diese Option aktiviert ist, wird eine Warnung vor Code ausgegeben, der in zukünftigen Versionen möglicherweise nicht ordnungsgemäß funktioniert.
E_USER_DEPRECATED	Warnmeldung für geringe Benutzerausgabe. Ähnlich wie E_DEPRECATED, wird jedoch vom Benutzer mithilfe der PHP-Funktion trigger_error() im Code generiert.
E_ALL	Warnmeldung für geringe Benutzerausgabe. Ähnlich wie E_DEPRECATED, wird jedoch vom Benutzer mithilfe der PHP-Funktion trigger_error() im Code generiert.

Laravel-Ausnahmebehandlung

Die Ausnahmebehandlung von Laravel wird durch die Klasse IlluminateFoundationBootstrapHandleExceptions::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');
        }
    }
}

Ausnahmekonvertierung

Die Ausnahmebehandlung von Laravel wird vollständig von der Funktion handleException übernommen.

PHP7 implementiert eine globale ausführbare Schnittstelle. Die ursprüngliche Ausnahme und einige Fehler implementieren diese Schnittstelle und definieren die Vererbungsstruktur von Ausnahmen in Form von Schnittstellen. Dadurch werden mehr Fehler in PHP7 zu abfangbaren Ausnahmen und werden an Entwickler zurückgegeben. Wenn sie nicht abgefangen werden, handelt es sich um Fehler. Wenn sie abgefangen werden, werden sie zu Ausnahmen, die innerhalb des Programms behandelt werden können. Bei diesen abfangbaren Fehlern handelt es sich in der Regel um Fehler, die dem Programm keinen schwerwiegenden Schaden zufügen, beispielsweise eine nicht vorhandene Funktion.

In PHP7 werden 5 neue Engine-Ausnahmen basierend auf der /Error-Ausnahme abgeleitet: ArithmeticError / AssertionError / DivisionByZeroError / ParseError / TypeError. In PHP7 implementieren sowohl die alte /Exception als auch die neue /Error eine gemeinsame Schnittstelle: /Throwable.

Wenn Sie also auf eine Ausnahme vom Typ „Nicht-Ausnahme“ stoßen, müssen Sie diese zunächst in einen Typ „FatalThrowableError“ konvertieren:

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 ist eine Fehlerausnahmeklasse, die Symfony von ErrorException erbt:

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

Wenn ein Es ist eine Ausnahme aufgetreten. Zu diesem Zeitpunkt zeichnet Laravel zunächst das Protokoll auf. Dies ist die Rolle der Berichtsfunktion.

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

laravels Standard-Ausnahmebehandlungsklasse im Ioc-Container ist IlluminateFoundationExceptionsHandler:

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;
        }));
    }
}

Anzeige der Ausnahmeseite

Nach dem Aufzeichnen des Protokolls muss die Ausnahme in eine Seite konvertiert werden, um dem Entwickler die Ausnahmeinformationen anzuzeigen, damit die Quelle Das Problem kann angezeigt werden:

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);
    }
}

Laravel behandelt verschiedene Ausnahmen unterschiedlich, einschließlich HttpException, HttpResponseException, AuthorizationException, ModelNotFoundException, AuthenticationException und ValidationException. Da bestimmte Ausnahmen ihre eigenen unterschiedlichen Anforderungen haben, werden sie in diesem Artikel nicht speziell vorgestellt. In diesem Artikel wird weiterhin die Behandlung der häufigsten Ausnahme HttpException vorgestellt:

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);
    }
}

Für HttpException werden je nach Fehlerstatuscode unterschiedliche Fehlerseitenvorlagen ausgewählt. Wenn keine relevante Vorlage vorhanden ist, wird die Ausnahmeseite über SymfonyResponse erstellt :

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);
}

【Verwandte Empfehlung:Laravel-Video-Tutorial】

Das obige ist der detaillierte Inhalt vonWas sind die Ausnahmen in Laravel?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!