Les exceptions - 1ère partie

• Par Emacs
• 11 commentaires
• 24218 lectures
• RSS -  Atom

Le mécanisme des exceptions a été introduit à PHP dans sa version 5 en complément de son nouveau modèle orienté objet. Au même titre qu'en Java, C++, Action Script 3 ou bien Visual Basic (pour ne citer que ces langages de programmation), les exceptions permettent de simplifier, personnaliser et d'organiser la gestion des « erreurs » dans un programme informatique. Ici le mot « erreurs » ne signifie pas « bug », qui est un comportement anormal de l'application développée, mais plutôt « cas exceptionnel » à traiter différemment dans le déroulement du programme. Etudions donc comment fonctionnent les exceptions.

Nous introduirons dans un premier temps la classe native Exception de PHP 5. Puis nous étudierons comment lancer et attraper des exceptions dans un programme. A partir de là, nous serons capables d'étendre le modèle Exception pour développer des exceptions dérivées et de types différents. Enfin, nous aborderons la notion de gestion évènementielle des exceptions au moyen du handler d'exception natif de php.

La classe native Exception

Comme nous l'avons déjà expliqué dans les précédents tutoriels du chapitre de programmation orientée objet, PHP dispose depuis sa version 5 d'un modèle objet semblable à celui de Java. Pour agrémenter ce nouveau moteur, l'équipe de développement de PHP a intégré en natif une classe Exception. Cette classe très particulière permet au développeur de simplifier le traitement des cas exceptionnels susceptibles d'apparaître pendant l'exécution d'un programme en générant des objets de type Exception. En fin de compte, retenez qu'une exception n'est rien de plus qu'un objet (instance d'une classe). Le listing ci-après présente le code de la classe Exception.

Code source de la classe native Exception (extrait de la documentation officielle de PHP)
<?php
 
class Exception 
{
  protected $message = 'exception inconnu'; // message de l'exception
  protected $code = 0;                      // code de l'exception défini par l'utilisateur
  protected $file;                          // nom du fichier source de l'exception
  protected $line;                          // ligne de la source de l'exception
 
  function __construct(string $message=NULL, int code=0);
 
  final function getMessage();              // message de l'exception
  final function getCode();                 // code de l'exception
  final function getFile();                 // nom du fichier source
  final function getLine();                 // ligne du fichier source
  final function getTrace();                // un tableau de backtrace()
  final function getTraceAsString();        // chaîne formattée de trace
 
  /* Remplacable */
  function __toString();                    // chaîne formatée pour l'affichage
}
?>

Nous identifions ici très clairement 4 parties distinctes qui composent cette classe Exception. Le premier bloc de code déclare les 4 données membres (attributs) de la classe en visibilité protégée. Respectivement, ces attributs enregistrent le message d'erreur, son code, le fichier source concerné et la ligne à laquelle l'erreur a été générée dans le programme.

Puis vient la déclaration du constructeur de la classe qui prend 2 paramètres facultatifs. Le premier est le message d'erreur et le second le code d'erreur.

La troisième partie du corps de la classe concerne la déclaration de 6 méthodes accesseur qu'il est impossible de redéfinir par héritage. Cette restriction est représentée par le mot-clé final. Ces méthodes permettent respectivement de récupérer le message d'erreur, son code d'erreur, le fichier source concerné, la ligne de l'erreur dans le fichier, et la pile des appels.

Enfin, nous découvrons la déclaration de la méthode magique __toString() qui pourra être rédéfinie ensuite par héritage. Cette méthode particulière, lorsqu'elle est surchargée, permet de spécifier de quelle manière on décide de représenter l'état en cours de l'objet sous forme de chaine de caractères.

Générer, lancer et attraper des exceptions à travers le programme

Générer une exception

La création d'une exception est réalisée par l'appel au constructeur de la classe native Exception. Le code ci-dessous illustre cette étape.

<?php
 
  // Création de l'objet Exception
  $e = new Exception('Une erreur s\'est produite');
 
  // Affiche le message d'erreur
  echo $e->getMessage();
?>

Remarquez la simplicité. La première ligne créer l'objet de type Exception ($e) et assigne automatiquement le message d'erreur dans le constructeur. La seconde ligne de code affiche le message d'erreur enregistré sur la sortie standard.

Note [1] : en développement informatique, les programmeurs ont pris l'habitude de nommer une exception uniquement avec la lettre miniscule "e". C'est à la fois une convention de nommage et une bonne pratique très largement répandue. Toutefois, aucune règle n'oblige les développeurs à l'adopter.

Note [2] : la classe native Exception est chargée automatiquement par PHP, c'est pourquoi il n'est pas nécessaire d'avoir recours à un quelconque import avant de pouvoir l'utiliser.

Lancer une exception à travers le programme

Notre code précédent nous a permis de générer des exceptions. En l'état, ce script ne nous sert strictement à rien puisqu'une exception n'est utile que si elle est créée lorsqu'un évènement exceptionnel se déroule pendant l'exécution du programme. Par exemple : une requête SQL qui échoue, un fichier impossible à ouvrir, une valeur d'un formulaire inattendue pour un champ...

Lorsqu'un tel évènement se produit, c'est que quelque chose d'inhabituel s'est passé. Par conséquent, la poursuite de l'exécution du programme doit être interrompue et signaler l'incident. C'est là qu'interviennent réllement les exceptions. Pour réaliser cette opération, le programme doit automatiquement « lancer » (retenez le vocabulaire de la POO) une exception. Le lancement d'une exception provoque immédiatement l'interruption du déroulement normal du programme

Le lancement d'une exception à travers le programme est réalisée grâce au mot-clé « throw ».

Exemple de lancement d'une Exception à travers le programme
<?php
 
  $password = 'Toto';
  if('Emacs' !== $password) {
    throw new Exception('Votre password est incorrect !');
  }
 
  // Cette ligne ne sera jamais exécutée
  // car une exception est lancée pour interrompre
  // l'exécution normale du programme
  echo 'Bonjour Emacs'; 
?>

L'utilisation du mot-clé throw permet de stopper l'exécution du programme et rediriger l'exception à travers ce dernier. La commande echo() quant à elle ne sera jamais exécutée. Le mot de passe $password n'étant pas égal à la chaine 'Emacs', l'exception est automatiquement générée puis lancée.

Note [1] : remarquez que l'exception généréese fait à la volée. Du fait qu'elle est automatiquement renvoyée auprogramme, nul besoin de stocker l'objet créé dans une variable.

Note [2] : les exceptions peuvent également être lancées depuis l'intérieur d'une classe.

Cet exemple est encore loin d'être exploitable en l'état. En effet, l'exception qui est lancée au programme est ici perdue pour toujours. Comme si l'on avait oublié de stocker dans une variable le résultat retourné par une fonction. Nous avons déclaré au tout début de ce cours que les exceptions devaient permettre de traiter différemment les cas exceptionnels survenant au cours d'un programme. Pour cela, il est nécessaire de pouvoir « intercepter / attraper » l'exception générée pour appliquer le traitement adéquat. C'est là qu'intervient le bloc try / catch.

Intercepter / attraper une exception générée

Comme en Java, AS 3, VB, C++... PHP dispose d'une structure conditionnelle capable d'intercepter les exceptions en plein vol afin de permettre d'appliquer des traitements particuliers. Il s'agit donc des blocs try { } catch() { }. Cette structure particulière se présente de la manière suivante :

Structure conditionnelle try { } catch() { }
<?php
 
  try {
    // Liste d'actions à appeller
    // Ces actions peuvent potentiellement
    // lancer des exceptions à travers le programme
  }
  catch(Exception $e)
  {
    // Bloc des actions spéciales lorsqu'une
    // exception $e de type Exception est levée
  }
?>

Le bloc try « essaie » d'exécuter le script entre les deux premières accollades. Si une exception est lancée dans ce bloc, elle est immédiatement « attraper » dans le bloc catch() et les traitements particuliers sont exécutés à la place.

Concrètement cela donne le listing ci-après avec notre exemple précédent :

Exemple d'interception d'une exception
<?php
 
  try {
 
    $password = 'Toto';
 
    if('Emacs' !== $password) {
      throw new Exception('Votre password est incorrect !');
    }
 
    echo 'Bonjour Emacs';
  }
  catch(Exception $e)
  {
    echo 'L\'erreur suivante a été générée : '."\n";
    echo $e->getMessage();
  }
?>

En exécutant ce code, nous découvrons que c'est le code du bloc catch() qui a été exécuté car l'exception lancée dans le bloc try { } a été interceptée en plein vol.

Note [1] : lorsqu'une exception est levée, elle remonte dans le programme et est interceptée par le premier bloc try {} catch() {} englobant qu'elle rencontre. Si aucun bloc try {} catch() {} n'entoure l'exception, alors l'objet sera perdu et l'exécution du programme interrompue.

Note [2] : nous verrons plus loin dans ce tutoriel que nous pouvons appliquer plusieurs bloc catch() sous le bloc try {} afin d'identifier chaque type d'exception potentiellement générée.

Bien sûr, il est possible d'imbriquer les blocs try { } catch() { } comme il est naturellement possible d'imbriquer les blocs if(). Notre exemple peut-être amélioré de la manière suivante :

Exemple d'utilisation de bloc try { } catch() { } imbriqués
<?php
 
  $login = 'Titi';
  $password = 'Toto';
 
  try {
 
    if('Hello' !== $login) {
      throw new Exception('Votre login est incorrect !');
    }
 
    try {
 
      if('Emacs' !== $password) {
        throw new Exception('Votre password est incorrect !');
      }
 
      echo 'Bonjour Emacs';
    }
    catch(Exception $e)
    {
      echo 'L\'erreur suivante a été générée : '."\n";
      echo $e->getMessage();
    }
  }
  catch(Exception $e)
  {
    echo 'L\'erreur suivante a été générée : '."\n";
    echo $e->getMessage();
  }
?>

Dans cet exemple, la valeur du login est d'abord testée. Comme la valeur du login est incorrecte, une exception est lancée à travers le programme, et c'est le bloc catch() le plus bas qui l'intercepte et exécute le traitement associé. Si maintenant nous remplissons correctement la variable $login, alors le premier bloc try est passé puis l'exception du second bloc try est lancée. Cette dernière est alors interceptée dans le bloc catch() associé pour exécuter le traitement adéquat de l'erreur.

Cet exemple n'est cependant pas très pertinent car il ne profite pas véritablement de toute la puissance des exceptions. La seconde partie de ce cours montre pas à pas comment concevoir des exceptions typées et personnalisées, et comment profiter de celles-ci pour simplifier et optimiser le code.

Introduction à la seconde partie de ce tutoriel

Dans la suite de ce cours, nous étudierons comment rendre l'utilisation des exceptions pertinentes en créant nos propres classes d'exception personnalisées. Nous aurons recours au concept de l'héritage, pilier majeur dans la méthodologie de l'approche orientée objet. Enfin, nous présenterons un aspect pratique de PHP qui permet d'intercepter toutes les exceptions à volée et d'exécuter automatiquement une fonction de callback (de rappel) pour simplifier et centraliser leur traitement.