Préface
En train d'apprendre Java, je crois que tout le monde a appris le chapitre sur les exceptions, et je ne parlerai pas des caractéristiques de base et de l'utilisation des exceptions ici. Qu'est-ce qu'une exception? Je ne sais pas comment tout le monde le comprend. Ma compréhension est très simple, c'est-à-dire des situations anormales. Par exemple, je suis un homme maintenant, mais j'ai quelque chose d'unique aux femmes. À mon avis, c'est définitivement une anomalie et je ne peux pas le supporter. Je crois que tout le monde peut comprendre et l'utiliser correctement.
Cependant, si le traitement et l'utilisation des exceptions de base optiques sont insuffisants, il n'est pas effrayant de se produire en travail. Parfois, il est nécessaire d'utiliser des exceptions pour stimuler le traitement de l'entreprise. Par exemple: lorsque vous utilisez une base de données avec des contraintes uniques, si une données en double est insérée, elle peut être traitée en capturant l'exception de contrainte unique DuplicatekeyException. À l'heure actuelle, l'état correspondant peut être jeté à la couche d'appel dans la couche de serveur, et la couche supérieure la traitera en fonction de l'état correspondant. Par conséquent, les exceptions sont donc une méthode de conduite pour l'entreprise.
Certaines personnes sortiront l'exception après avoir attrapé l'exception. Je me demande si des étudiants prudents ont remarqué quelque chose. Quelle est l'exception de sortie?
Voici une exception courante:
java.lang.arithmeticexception: / par zéro sur serre Sun.Reflect.delegatingMethodAccessOrimpl.invoke (déléguantMethodAccessOrimp.java:25) sur java.lang.reflect.method.invoke (méthode.java:597) sur org.junit.runners.model.frameworkmethod 1.RUNRELFLECLIVIVECALL (FrameworkMethoD.java: RENREFLECLEFLECT sur org.junit.internal.runners.model.reflectivecallable.run (réflevisalable.java:15) à org.junit.runners.model.frameworkMeth.invokeExplosively (frameworkmethod.java:41) à la org.junit.internal.runners.statements.invokemethod.evaluate (invokemethod.java:20) à org.junit.runners.blockjunit4classrunner.runchild (blockJunit4classrunner.java:76) à org.junit.runners.blockjunit4classrunner.runchild (blockjunit4classrunner.java:50) sur org.junit.runners.parentrunner 3,Run (parentrunner.java:193) à org.junit.runners.parentrunner 1,schedulaire (Parentrunner.java:52) à 1, org.junit.runners.parentrunner.runchildren (parentrunner.java:191) sur org.junit.runners.parentrunner.access $ 000 (parentrunner.java:42) à org.junit.runners.parentrunner 2e evaluate (parentrunner.java:184) à 2 $. org.junit.runners.parentrunner.run (parentrunner.java:236) sur org.junit.runner.junitcore.run (Junitcore.java:157) à com.intellij.junit4 com.intellij.rt.execution.junit.ideatestrunner $ répéter com.intellij.rt.execution.junit.junitstarter.main (Junitstarter.java:70)
Une exception du pointeur nul:
java.lang.nullpointerException sur Greenhouse.ExceptionStest.TestesException (exceptiontest.java:16) sur sun.reflect.nativemethodaccessorimpl.invoke0 (méthode native) à sun.reflect.nativemethodaccessorimpl.invoke (nativemethodaccessorimpl.java:39) Sun.Reflect.delegatingMethodAccessOrimpl.invoke (déléguantMethodAccessOrimp.java:25) sur java.lang.reflect.method.invoke (méthode.java:597) sur org.junit.runners.model.frameworkmethod 1.RUNRELFLECLIVIVECALL (FrameworkMethoD.java: RENREFLECLEFLECT sur org.junit.internal.runners.model.reflectivecallable.run (réflevisalable.java:15) à org.junit.runners.model.frameworkMeth.invokeExplosively (frameworkmethod.java:41) à la org.junit.internal.runners.statements.invokemethod.evaluate (invokemethod.java:20) à org.junit.runners.blockjunit4classrunner.runchild (blockJunit4classrunner.java:76) à org.junit.runners.blockjunit4classrunner.runchild (blockjunit4classrunner.java:50) sur org.junit.runners.parentrunner 3,Run (parentrunner.java:193) à org.junit.runners.parentrunner 1,schedulaire (Parentrunner.java:52) à 1, org.junit.runners.parentrunner.runchildren (parentrunner.java:191) sur org.junit.runners.parentrunner.access $ 000 (parentrunner.java:42) à org.junit.runners.parentrunner 2e evaluate (parentrunner.java:184) à 2 $. org.junit.runners.parentrunner.run (parentrunner.java:236) sur org.junit.runner.junitcore.run (Junitcore.java:157) à com.intellij.junit4 com.intellij.rt.execution.junit.ideatestrunner $ répéter com.intellij.rt.execution.junit.junitstarter.main (Junitstarter.java:70)
Avez-vous trouvé une fonctionnalité selon laquelle la sortie de l'exception est l'emplacement où l'exception se produit avec précision, et de nombreux appels de processus d'exécution sont imprimés plus tard. D'où vient cette information? Ces informations sont obtenues à partir de la pile. Lors de l'impression du journal d'exception, ces informations d'appel seront obtenues à partir de la pile. Il est bien sûr bon de pouvoir localiser avec précision les exceptions, mais parfois lorsque nous considérons les performances du programme et certaines exigences, nous n'avons parfois pas besoin d'imprimer complètement ces informations et d'obtenir les informations correspondantes à partir de la pile d'appels de méthode, qui est la consommation de performances. Pour certains programmes avec des exigences de performance élevées, nous pouvons complètement améliorer les performances du programme dans cet aspect.
Alors, comment éviter de diffuser ces informations de pile? Ensuite, les exceptions personnalisées peuvent résoudre ce problème:
Tout d'abord, l'exception automatique doit hériter de RuntimeException, puis réécrire la méthode FillinStackTrace et ToString. Par exemple, je définis une exception AppException ci-dessous:
package com.green.monitor.common.exception; import java.text.messageFormat; / ** * Classe d'exception personnalisée * / classe publique AppException étend RuntimeException {private booléen issucess = false; clé de chaîne privée; Informations sur les chaînes privées; public appexception (string key) {super (key); this.key = key; this.info = key; } public AppException (String Key, String Message) {super (messageFormat.Format ("{0} [{1}]", key, message)); this.key = key; this.info = message; } public appexception (message de chaîne, clé de chaîne, info à chaîne) {super (message); this.key = key; this.info = info; } public booléen issucess () {return issucess; } public String getKey () {return key; } public void setKey (string key) {this.key = key; } public String getInfo () {return info; } public void setInfo (chaîne info) {this.info = info; } @Override public Throwable FillinStackTrace () {Renvoie ceci; } @Override public String toString () {return MessageFormat.Format ("{0} [{1}]", this.key, this.info); }}Alors pourquoi réécrire FillinstackTrace et les méthodes de tostring? Voyons d'abord quel est le code source.
classe publique RuntimeException étend une exception {statique finale finale SerialVersionUID = -7034897190745766939l; / ** construit une nouvelle exception d'exécution avec <code> null </code> comme son * message de détail. La cause n'est pas initialisée et peut par la suite être * initialisée par un appel à {@link #initcause}. * / public runtimeException () {super (); } / ** construit une nouvelle exception d'exécution avec le message de détail spécifié. * La cause n'est pas initialisée et peut être initialisée par un * appel à {@link #initcause}. * * Message @param Le message détaillé. Le message détaillé est enregistré pour * la récupération ultérieure par la méthode {@link #getMessage ()}. * / public runtimeException (message de chaîne) {super (message); } / ** * Construit une nouvelle exception d'exécution avec le message de détail spécifié et * Cause. <p> Notez que le message détaillé associé à * <code> Cause </code> est <i> pas </i> incorporé automatiquement dans * le message détaillé de cette exception d'exécution. * * Message @param Le message détaillé (qui est enregistré pour la récupération ultérieure * par la méthode {@link #getMessage ()}). * @param Cause la cause (qui est enregistrée pour la récupération ultérieure par la méthode * {@link #getcause ()}). (Une valeur <tt> null </tt> est * autorisée et indique que la cause est inexistante ou * inconnue.) * @Since 1.4 * / public runtimeException (message de chaîne, cause thrognable) {super (message, cause); } / ** Construction d'une nouvelle exception d'exécution avec la cause spécifiée et un * message détaillé de <Tt> (cause == null? Null: cause.toString ()) </tt> * (qui contient généralement le message de classe et de détail de * <tt> cause </tt>). Ce constructeur est utile pour les exceptions d'exécution * qui ne sont guère plus que des emballages pour les autres lotsables. * * @param Cause la cause (qui est enregistrée pour la récupération ultérieure par la méthode * {@link #getcause ()}). (Une valeur <tt> null </tt> est * autorisée et indique que la cause est inexistante ou * inconnue.) * @Since 1.4 * / public runtimeException (cause thrognable) {super (cause); }}RuntimeException hérite d'exception, mais il appelle uniquement la méthode de la classe parent et ne fait aucune autre opération. Alors, continuons à voir ce qui se passe à l'exception?
L'exception de classe publique étend Throwable {static final long SerialVersionUID = -3387516993124229948l; / ** * construit une nouvelle exception avec <code> null </code> comme message de détail. * La cause n'est pas initialisée et peut ensuite être initialisée par un * appel à {@link #initcause}. * / public exception () {super (); } / ** * construit une nouvelle exception avec le message de détail spécifié. La * cause n'est pas initialisée et peut ensuite être initialisée par * un appel à {@link #initcause}. * * Message @param Le message détaillé. Le message détaillé est enregistré pour * la récupération ultérieure par la méthode {@link #getMessage ()}. * / Exception publique (message de chaîne) {super (message); } / ** * Construit une nouvelle exception avec le message de détail spécifié et * Cause. <p> Notez que le message détaillé associé à * <code> Cause </code> est <i> pas </i> incorporé automatiquement dans * Message détaillé de cette exception. * * Message @param Le message détaillé (qui est enregistré pour la récupération ultérieure * par la méthode {@link #getMessage ()}). * @param Cause la cause (qui est enregistrée pour la récupération ultérieure par la méthode * {@link #getcause ()}). (A <TT> NULL </TT> La valeur est * autorisée et indique que la cause est inexistante ou * inconnue.) * @Since 1.4 * / Exception publique (message de chaîne, cause lancable) {super (message, cause); } / ** * Construit une nouvelle exception avec la cause spécifiée et un détail * Message de <Tt> (Cause == NULL? NULL: Cause.ToString ()) </TT> (qui * contient généralement le message de classe et de détail de <TT> Cause </TT>). * Ce constructeur est utile pour des exceptions qui ne sont guère plus que * les emballages pour d'autres lance-thorloques (par exemple, {@link * java.security.priviledAcactionException}). * * @param Cause la cause (qui est enregistrée pour la récupération ultérieure par la méthode * {@link #getcause ()}). (Une valeur <tt> null </tt> est * autorisée et indique que la cause est inexistante ou * inconnue.) * @Since 1.4 * / Exception publique (cause jetable) {super (cause); }}Comme on peut le voir à partir du code source, la méthode de la classe parent est également appelée directement dans l'exception. Comme RuntimeException, je n'ai rien fait. Alors jetons un coup d'œil à ce qui se passe dans Throwable:
classe publique Throwable implémente Serializable {public thrownable (String Message) {fillInstackTrace (); DetailMessage = Message; } / ** * remplit la trace de pile d'exécution. Cette méthode enregistre dans cette information d'objet * <code> Throwable </code> sur l'état actuel des cadres de pile pour le thread actuel. * * @return une référence à cette instance <code> throwable </code>. * @see java.lang.throwable # printStackTrace () * / public synchronisé natif synchronisé fillInstackTrace (); / ** * fournit un accès de programmation aux informations de trace de pile imprimées par * {@link #printstacktrace ()}. Renvoie un tableau d'éléments de trace de pile, * chacun représentant une trame de pile. L'élément zeroth du tableau * (en supposant que la longueur du tableau est non nul) représente le haut de la pile *, qui est la dernière invocation de la méthode dans la séquence. En règle générale, * c'est le moment où ce jetable a été créé et lancé. * Le dernier élément du tableau (en supposant que la longueur du tableau est non nul) * représente le bas de la pile, qui est la première invocation de méthode * dans la séquence. * * <p> Certaines machines virtuelles peuvent, dans certaines circonstances, omettre une * ou plusieurs cadres de pile de la trace de pile. Dans le cas extrême, * une machine virtuelle qui n'a aucune information de trace de pile concernant * ce jetable est autorisé à renvoyer un tableau de longueur zéro à partir de cette méthode *. D'une manière générale, le tableau renvoyé par cette méthode contiendra * un élément pour chaque trame qui serait imprimée par * <Tt> printstacktrace </tt>. * * @return un tableau d'éléments de trace de pile représentant la trace de pile * concernant ce jetable. * @Since 1.4 * / public stackTraceElement [] getStackTrace () {return (stackTraceElement []) getOrStackTrace (). Clone (); } private synchronisé stackTraceElement [] getOrStackTrace () {// initialiser la trace de pile S'il s'agit du premier appel de cette méthode if (stackTrace == null) {int Depth = getStackTraceSpth (); stackTrace = new StackTraceElement [Depth]; pour (int i = 0; i <de profondeur; i ++) stackTrace [i] = getStackTraceElement (i); } return stackTrace; } / ** * Renvoie le nombre d'éléments dans la trace de pile (ou 0 si la trace de pile * n'est pas disponible). * * Package-Protection pour une utilisation par SharedSecrets. * / natif int getStackTracePth (); / ** * Renvoie l'élément spécifié de la trace de pile. * * Package-Protection pour une utilisation par SharedSecrets. * * @param index index de l'élément à retourner. * @throws indexoutofboundSException if <tt> index <0 || * index> = getStackTraceSepth () </tt> * / stackTraceElement natif getStackTraceElement (int index); / ** * Renvoie une brève description de ce jetable. * Le résultat est la concaténation de: * <ul> * <li> la {@linkplain class # # getName () name} de la classe de cet objet * <li> ":" (un côlon et un espace) * <li> Le résultat de l'invocation de cet objet {@link #getLocalizedMessage} * Méthode * </ul> * if <TT> <TT> NULL </TT>, alors juste * le nom de classe est renvoyé. * * @return une représentation de chaîne de ce jetable. * / public String toString () {String s = getClass (). getName (); Message de chaîne = getLocalizedMessage (); return (message! = null)? (S + ":" + Message): S; }D'après le code source, il est presque au-dessus de la fin du jetable. La méthode FillInstackTrace () est une méthode native. Cette méthode appellera la langue C sous-jacente, renverra un objet jetable, la méthode de tostring et renvoie une brève description du jetable. Dans la méthode GetStackTrace et GetOrStackTrace, la méthode native GetStackTraceElement est appelée. Cette méthode renvoie les informations de l'élément de pile spécifié, ce processus doit donc consommer des performances. Ensuite, nous pouvons réécrire la méthode TOSTRING et la méthode FillinStackTrace dans les exceptions personnalisées et la sortir directement sans obtenir d'informations d'exception à partir de la pile. Ce n'est relativement pas aussi "lourd" pour le système et le programme, et c'est un très bon moyen d'optimiser les performances. Alors, à quoi cela ressemble-t-il si une exception personnalisée se produit? Veuillez voir ci-dessous:
@Test public void testException () {try {String str = null; System.out.println (str.charat (0)); } catch (exception e) {lancer une nouvelle appexception ("000001", "exception du pointeur nul"); }}Ensuite, lorsque l'exception est anormale, le système imprimera nos informations d'exception personnalisées:
000001 [Exception du pointeur nul] Processus terminé avec le code de sortie -1
Par conséquent, il est particulièrement concis et optimise les performances du programme système, ce qui rend le programme moins "lourd", de sorte que le système avec des exigences de performance spéciaux est nécessaire. Dépêchez-vous et personnalisez votre propre exception!
Résumer
Ce qui précède est l'intégralité du contenu de cet article. J'espère que le contenu de cet article a une certaine valeur de référence pour l'étude ou le travail de chacun. Si vous avez des questions, vous pouvez laisser un message pour communiquer. Merci pour votre soutien à wulin.com.