Quelles sont les exceptions dans Laravel

Les exceptions dans Laravel incluent : 1. "E_ERROR" erreur d'exécution fatale, qui est irrécupérable et entraînera l'arrêt du script et l'arrêt de son exécution ; 2. "E_WARNING" avertissement d'exécution "erreur non fatale" ; 3. "E_PARSE" ; Erreur d'analyse de syntaxe de compilation ; 4. Erreur fatale "E_CORE_ERROR" qui se produit lors de l'initialisation et du démarrage ; 5. Erreur fatale de compilation "E_COMPILE_ERROR" 6. Erreur fatale "E_RECOVERABLE_ERROR" qui peut être capturée.

L'environnement d'exploitation de ce tutoriel : système Windows 7, version Laravel 9, ordinateur DELL G3.

Niveau d'exception dans Laravel

Constant	Description
E_ERROR	Erreur d'exécution fatale. Ce type d'erreur est généralement une situation irrécupérable, comme un problème causé par l'allocation de mémoire. La conséquence est que le script se termine et ne continue pas à s'exécuter.
E_WARNING	Avertissement d'exécution (erreur non fatale). Seul un message d'invite est émis, mais le script ne se termine pas.
E_PARSE	Erreur d'analyse de la syntaxe au moment de la compilation. Les erreurs d'analyse sont générées uniquement par l'analyseur.
E_NOTICE	Notification d'exécution. Indique que le script rencontre une situation qui peut apparaître comme une erreur, mais il peut également y avoir des notifications similaires dans les scripts qui peuvent s'exécuter normalement.
E_CORE_ERROR	Une erreur fatale s'est produite lors du démarrage de l'initialisation de PHP. Cette erreur est similaire à E_ERROR, mais est générée par le cœur du moteur PHP.
E_CORE_WARNING	Un avertissement (erreur non fatale) s'est produit lors du démarrage de l'initialisation de PHP. Comme E_WARNING, mais généré par le noyau du moteur PHP.
E_COMPILE_ERROR	Erreur fatale à la compilation. Similaire à E_ERROR, mais généré par le moteur de script Zend.
E_COMPILE_WARNING	Avertissement lors de la compilation (erreur non fatale). Comme E_WARNING, mais généré par le moteur de script Zend.
E_USER_ERROR	Message d'erreur généré par l'utilisateur. Similaire à E_ERROR, mais est généré par l'utilisateur à l'aide de la fonction PHP trigger_error() dans le code.
E_USER_WARNING	Message d'avertissement généré par l'utilisateur. Similaire à E_WARNING, mais est généré par l'utilisateur à l'aide de la fonction PHP trigger_error() dans le code.
E_USER_NOTICE	Informations de notification générées par l'utilisateur. Similaire à E_NOTICE, mais est généré par l'utilisateur à l'aide de la fonction PHP trigger_error() dans le code.
E_STRICT	Activez les suggestions de PHP pour les modifications de code afin de garantir la meilleure interopérabilité et la compatibilité ascendante du code.
E_RECOVERABLE_ERROR	Une erreur fatale qui peut être détectée. Cela indique qu'une erreur potentiellement dangereuse s'est produite, mais n'a pas encore laissé le moteur PHP dans un état instable. Si l'erreur n'est pas détectée par un gestionnaire défini par l'utilisateur (voir set_error_handler ()), elle deviendra un E_ERROR et le script se terminera.
E_DEPRECATED	Notification d'exécution. Lorsqu'il est activé, un avertissement sera émis concernant le code qui pourrait ne pas fonctionner correctement dans les versions futures.
E_USER_DEPRECATED	Message d'avertissement en cas de faible sortie utilisateur. Similaire à E_DEPRECATED, mais est généré par l'utilisateur à l'aide de la fonction PHP trigger_error() dans le code.
E_ALL	Message d'avertissement en cas de faible sortie utilisateur. Similaire à E_DEPRECATED, mais est généré par l'utilisateur à l'aide de la fonction PHP trigger_error() dans le code.

Gestion des exceptions Laravel

La gestion des exceptions de laravel est complétée par la classe 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');
        }
    }
}

Conversion des exceptions

La gestion des exceptions de laravel est entièrement gérée par la fonction handleException.

PHP7 implémente une interface globale jetable. L'exception d'origine et certaines erreurs implémentent cette interface et définissent la structure d'héritage des exceptions sous forme d'interfaces. En conséquence, davantage d'erreurs dans PHP7 deviennent des exceptions capturables et sont renvoyées aux développeurs. Si elles ne sont pas détectées, ce sont des erreurs. Si elles sont détectées, elles deviennent des exceptions qui peuvent être gérées dans le programme. Ces erreurs captables sont généralement des erreurs qui ne causent pas de dommages mortels au programme, comme une fonction qui n'existe pas.

En PHP7, basées sur l'exception /Error, 5 nouvelles exceptions moteur sont dérivées : ArithmeticError / AssertionError / DivisionByZeroError / ParseError / TypeError. En PHP7, l'ancien /Exception et le nouveau /Error implémentent une interface commune : /Throwable.

Par conséquent, lorsque vous rencontrez une exception de type non-Exception, vous devez d'abord la convertir en un type FatalThrowableError :

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 est une classe d'exception d'erreur dont Symfony hérite de 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

Quand un une exception est rencontrée À ce stade, la première chose que fait Laravel est d'enregistrer le journal. C'est le rôle de la fonction de rapport.

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

La classe de gestion des exceptions par défaut de laravel dans le conteneur Ioc est 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;
        }));
    }
}

Affichage de la page d'exception

Après l'enregistrement du journal, l'exception doit être convertie en page pour afficher les informations d'exception au développeur afin que la source du problème peut être consulté ：

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 a une gestion différente pour différentes exceptions, notamment HttpException, HttpResponseException, AuthorizationException, ModelNotFoundException, AuthenticationException et ValidationException. Étant donné que les exceptions spécifiques ont des exigences différentes, elles ne seront pas présentées dans cet article. Cet article continue de présenter la gestion de l'exception HttpException la plus courante :

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

Pour HttpException, différents modèles de page d'erreur seront sélectionnés en fonction de son code d'état d'erreur. S'il n'y a pas de modèle pertinent, la page d'affichage de l'exception sera construite via SymfonyResponse. :

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

【Recommandation associée :tutoriel vidéo Laravel】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!