[Java] Gestion des exceptions

Qu'est-ce que la gestion des exceptions?

• Répondre aux erreurs qui se produisent lors de l'exécution de l'application
• Exception au sens strict: une erreur qui ne peut être exclue sous la responsabilité du développeur
• Le fichier n'existe pas
• Le DB de destination de la connexion a été arrêté
• Java doit gérer ces erreurs
• ** L'exception est le type (classe) **
• ** Représenté comme une hiérarchie de classes avec des exceptions générales en tant que classes supérieures et des exceptions dans des situations individuelles en tant que classes inférieures **

essayez ... capturez la syntaxe

• ** Try block **: traitement original
• ** catch block **: Appelé par type d'exception
• Exception levée = ** Exception levée **
• Accédez à l'objet d'exception via la ** variable d'exception spécifiée (e ou ex) **
• Puisque la portée est définie en unités de bloc, le même nom de variable (e) est OK même s'il y a plusieurs blocs catch.
• Méthode de classe d'exception
• ** getMessage () **: Obtenir un message d'erreur
• ** getLocalizedMessage () **: Obtenir un message d'erreur localisé
• ** getCause () **: Obtenez la cause de l'erreur
• ** getStackTrace () **: Récupère la trace de la pile
• ** printStackTrace () **: sortie de trace de pile

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TryBasic {

  public static void main(String[] args) {
    try {
      var in = new FileInputStream("C:/data/nothing.gif");
      var data = -1;
      while ((data = in.read()) != -1) {
        System.out.printf("%02X ", data);
      }
    //Lancer une exception FileNotFoundException dans la classe FileInputStream
    } catch (FileNotFoundException e) {
      System.out.println("Le fichier est introuvable.");
    } catch (IOException e) {
      //Accédez à l'objet d'exception via la variable d'exception spécifiée (e)
      e.printStackTrace();
    }
  }
}

Trace de la pile

• ** Historique des méthodes avant que l'exception ne se produise **
• Enregistrez dans l'ordre des appels à partir de la méthode principale, qui est le point d'entrée.
• Vérifiez si une méthode involontaire est appelée et si le processus est correct

enfin bloquer

• Le dernier bloc à exécuter avec ou sans exceptions
• Traitement des ressources utilisées dans le bloc try, etc.
• Enfin un seul bloc

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TryFinally {

  public static void main(String[] args) {
    FileInputStream in = null;
    try {
      in = new FileInputStream("C:/data/nothing.gif");
      var data = -1;
      while ((data = in.read()) != -1) {
        System.out.printf("%02X ", data);
      }
    } catch (FileNotFoundException e) {
      System.out.println("Le fichier est introuvable.");
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      //Fermeture de dossier avec ou sans exception
      try {
        if (in != null) {
          in.close();
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}

syntaxe try-with-resource

• Recommandé car c'est plus simple que d'essayer ... enfin la syntaxe
• ** Vraiment inutile car les ressources sont automatiquement libérées lorsque le bloc try est quitté! ** **
• Remarque:
• ** Implémentez l'interface AutoCloseable ** * Reader/Writer/InputStream/OutputStream/Connection/Statement/ResultSet
• ** Modifications de l'ordre de lancement des ressources **
• Dans la syntaxe conventionnelle try ... finally, la ressource était vivante au moment du bloc catch
• Dans try-with-resource, la ressource est libérée lorsque le bloc try est quitté.
• ** Portée de ressources différente **
• La syntaxe try ...
• Dans try-with-resource, la portée est limitée à sous le bloc try (dans Java 9 ou version ultérieure, les ressources déclarées en dehors du bloc try peuvent être citées) * var input = new FileInputStream(...) * try(input){...}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TryWithResources {

//Déclaration de ressource au début du bloc
  public static void main(String[] args) {
    try (var in = new FileInputStream("C:/data/hogee.gif")) {
      var data = -1;
      while ((data = in.read()) != -1) {
        System.out.printf("%02X ", data);
      }
    //Libération automatique des ressources lors de la sortie du bloc try
    } catch (FileNotFoundException e) {
      System.out.println("Fichier non trouvé.");
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Structure hiérarchique des classes d'exceptions

• Du point de vue de la hiérarchie de classes, toutes les classes d'exceptions / erreurs appartiennent à une arborescence hiérarchique avec ** Classe Throwable ** comme sommet.
• ** Classe d'erreur **: Erreur fatale ---- ** [Pas de gestion des exceptions] **
• Les erreurs subordonnées sont des ** exceptions d'erreur **
• IOErrer: erreur d'E / S grave, VirtualMachineError: échec au niveau de la machine virtuelle
• ** Classe d'exception ** ‥ ‥ ‥ ‥ ‥ ‥ ‥ ‥ ‥ ‥ ‥
• ** Classe RuntimeException ** ---- ** [Traitement des exceptions facultatif] **
• Les erreurs subordonnées sont des ** exceptions non contrôlées ** (= exceptions d'exécution)
• IllegalArgumentException: argument illégal, NullPointerException: l'objet est nul
• Les autres erreurs subordonnées sont des ** exceptions d'inspection **
• FileNotFoundException: le fichier n'existe pas, SQLException: problème lors de l'accès à la base de données

Remarques sur la gestion des exceptions

• ** Ne pas attraper avec exception **
• catch (Exception e) intercepte toutes les exceptions
• IOException FileNotFoundException plus spécifique
• ** Utilisez la multi-capture **
• Faites de même pour plusieurs exceptions
• Exception 1 | Exception 2 (dans les deux cas)
• ** ordre de bloc catch **
• S'il y en a plusieurs, la première description est prioritaire
• ** Écrivez d'abord les exceptions les plus faibles, les exceptions les plus élevées plus tard **

//Prise multiple
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class TryMulti {

  public static void main(String[] args) {
    try {
      var in = new FileInputStream("C:/data/nasi.gif");
      var data = -1;
      while ((data = in.read()) != -1) {
        System.out.printf("%02X ", data);
      }
      var uri = new URI( "https://www.neko.example.com");
      System.out.println(uri.toString());
    //Prise multiple
    } catch (IOException | URISyntaxException e) {
      System.out.println("Impossible d'accéder au fichier.");
      e.printStackTrace();
    }
  }
}

Lancer une exception

• En plus de lancer des bibliothèques standard ** Les développeurs peuvent lancer **
• Vous pouvez passer n'importe quel objet d'exception avec `throw exception object '
• ** Déclarez les exceptions qui peuvent être levées dans la clause throws **
• throw: lancer une exception
• throws: Déclaré dans la méthode / le constructeur

public FileInputStream(File file) throws FileNotFoundException{
//Abréviation

Exception lancer l'attention

• ** Ne lancez pas d'exception **
• ** Sélectionnez correctement les exceptions cochées / non cochées **
• Utilisez des ** exceptions standard ** autant que possible
• ** NullPointerException **: l'objet est nul
• ** IndexOutOfBoundsException **: l'index du tableau est hors de portée
• ** UnsupportedOperationException **: l'opération de requête n'est pas prise en charge
• ** IllegalArgumentException **: Problème avec l'argument passé à la méthode
• ** IllegalStateException **: méthode appelée lorsqu'elle n'est pas dans l'état prévu
• ** ArithmeticException **: Une condition exceptionnelle se produit dans le calcul
• ** NumberFormatException **: format numérique incorrect
• méthode privée utilise ** instruction assert **
• Exception AssertionError lorsque l'expression conditionnelle est fausse
• Fonctionne uniquement lorsque l'option -ea est spécifiée dans la commande java

public class AssertBasic {
  private static double getTrapezoidArea(double upper, double lower, double height) {
    //Une exception se produit lorsque l'argument est égal ou inférieur à 0
    assert upper > 0 && lower > 0 && height > 0;
    return (upper + lower) * height / 2;
  }
  public static void main(String[] args) {
    System.out.println(AssertBasic.getTrapezoidArea(-2, 4, 0));
  }
}

Relance d'exception

• Ne pas traiter sur place ** Laisser le processus à l'appelant **
• Fondamentalement, au lieu d'un traitement individuel sur place, un traitement individuel doit être appelé et le flux de l'application elle-même doit être contrôlé.
• Le type d'exception peut être jugé judicieusement (Java7 ~)
• Seul le type d'exception peut être déclaré avec des lancers
• Pas besoin de multi-prises

public class TryRethrow {
//MySampleException,La méthode de relance peut se produire dans MyLibException
  public static void rethrow(boolean flag) throws MySampleException, MyLibException {
    try {
      if (flag) {
        throw new MySampleException();
      } else {
        throw new MyLibException();
      }
    //Recevoir avec le type d'exception et relancer tel quel
    } catch (Exception e) {
      throw e;
    }
  }
}

Exception de traduction

• ** Collectez les exceptions individuelles une fois, regroupez-les en tant qu'exceptions d'applications de niveau supérieur et relancez **
• Les exceptions peuvent être regroupées en exceptions spécifiques à l'application
• L'appelant ne doit pas être conscient des exceptions individuelles, ** doit être conscient des exceptions de niveau supérieur **
• Pour obtenir la cause d'origine de l'exception supérieure traduite ** méthode getCause **
  • var ex = e.getCause();

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Paths;

//Il vous suffit de connaître MySampleException en tant qu'exception de traduction
public class UseTrans {
  public void readHttpPages() throws MySampleException {
    try (var reader = Files.newBufferedReader(Paths.get("C:/data/link.txt"))) {
      var line = "";
      while ((line = reader.readLine()) != null) {
        var client = HttpClient.newHttpClient();
        var req = HttpRequest.newBuilder().uri(URI.create(line)).build();
        var res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
      }
    } catch (IOException | InterruptedException e) {
      throw new MySampleException(e);
    }
  }
}

Classe d'exception propriétaire

• Les classes d'exception peuvent être définies dans l'application
• ** Exception d'héritage (classe dérivée) **
• ** Remplacement du constructeur **
• Redéfinissez le constructeur défini par Exception et appelez super OK
• Des exceptions avec des implémentations uniques de champs et de méthodes sont possibles

//Inherit Exception (classe dérivée)
public class MySampleException extends Exception {
  //Remplacer le constructeur
  public MySampleException() {
    super();
  }
  public MySampleException(String message) {
    super(message);
  }
  public MySampleException(String message, Throwable cause) {
    super(message, cause);
  }
  public MySampleException(Throwable cause) {
    super(cause);
  }
}