Chained exception java это

Связанные исключения в Java

В этой статье мы очень кратко рассмотрим, что такоеException, и подробно рассмотрим связанные исключения в Java.

Проще говоря,exception — это событие, которое нарушает нормальный ход выполнения программы. Давайте теперь посмотрим, как мы можем связать исключения, чтобы получить от них лучшую семантику.

2. Связанные исключения

СвязанныйException помогает идентифицировать ситуацию, в которой одно исключение вызывает другоеException в приложении.

For instance, consider a method which throws an ArithmeticException из-за попытки деления на ноль, но фактической причиной исключения была ошибка ввода-вывода, из-за которой делитель был равен нулю. Метод выбрасываетArithmeticException вызывающей стороне. Вызывающий не может знать о фактической причинеException. В таких ситуациях используется цепочкаException.

Эта концепция была введена в JDK 1.4.

Давайте посмотрим, как в Java поддерживаются связанные исключения.

3. Throwable Класс

В классеThrowable есть конструкторы и методы для поддержки связанных исключений. Во-первых, давайте посмотрим на конструкторы.

• Throwable(Throwable cause)–Throwable имеет единственный параметр, который указывает действительную причинуException.
• Throwable(String desc, Throwable cause)– этот конструктор также принимает описаниеException с фактической причинойException.

Затем давайте посмотрим на методы, которые предоставляет этот класс:

• getCause() method — этот метод возвращает фактическую причину, связанную с текущимException.
• initCause() method — устанавливает основную причину при вызовеException.

4. пример

Теперь давайте посмотрим на пример, в котором мы зададим собственное описаниеException и создадим цепочкуException:

public class MyChainedException < public void main(String[] args) < try < throw new ArithmeticException("Top Level Exception.") .initCause(new IOException("IO cause.")); >catch(ArithmeticException ae) < System.out.println("Caught : " + ae); System.out.println("Actual cause: "+ ae.getCause()); >> >

Как и предполагалось, это приведет к:

Caught: java.lang.ArithmeticException: Top Level Exception. Actual cause: java.io.IOException: IO cause.

5. Почему цепные исключения?

Нам нужно объединить исключения, чтобы сделать журналы читабельными. Напишем два примера. Во-первых, без цепочек исключений, а во-вторых, с цепочками исключений. Позже мы сравним, как ведут себя логи в обоих случаях.

Для начала мы создадим серию исключений:

class NoLeaveGrantedException extends Exception < public NoLeaveGrantedException(String message, Throwable cause) < super(message, cause); >public NoLeaveGrantedException(String message) < super(message); >> class TeamLeadUpsetException extends Exception < // Both Constructors >

Теперь давайте начнем использовать указанные выше исключения в примерах кода.

5.1. Без цепочки

Давайте напишем пример программы без цепочки наших пользовательских исключений.

public class MainClass < public void main(String[] args) throws Exception < getLeave(); >void getLeave() throws NoLeaveGrantedException < try < howIsTeamLead(); >catch (TeamLeadUpsetException e) < e.printStackTrace(); throw new NoLeaveGrantedException("Leave not sanctioned."); >> void howIsTeamLead() throws TeamLeadUpsetException < throw new TeamLeadUpsetException("Team Lead Upset"); >>

В приведенном выше примере журналы будут выглядеть так:

com.example.chainedexception.exceptions.TeamLeadUpsetException: Team lead Upset at com.example.chainedexception.exceptions.MainClass .howIsTeamLead(MainClass.java:46) at com.example.chainedexception.exceptions.MainClass .getLeave(MainClass.java:34) at com.example.chainedexception.exceptions.MainClass .main(MainClass.java:29) Exception in thread "main" com.example.chainedexception.exceptions. NoLeaveGrantedException: Leave not sanctioned. at com.example.chainedexception.exceptions.MainClass .getLeave(MainClass.java:37) at com.example.chainedexception.exceptions.MainClass .main(MainClass.java:29)

5.2. С цепочкой

Затем давайте напишем пример с цепочкой наших пользовательских исключений:

public class MainClass < public void main(String[] args) throws Exception < getLeave(); >public getLeave() throws NoLeaveGrantedException < try < howIsTeamLead(); >catch (TeamLeadUpsetException e) < throw new NoLeaveGrantedException("Leave not sanctioned.", e); >> public void howIsTeamLead() throws TeamLeadUpsetException < throw new TeamLeadUpsetException("Team lead Upset."); >>

Наконец, давайте посмотрим на журналы, полученные с цепочкой исключений:

Exception in thread "main" com.example.chainedexception.exceptions .NoLeaveGrantedException: Leave not sanctioned. at com.example.chainedexception.exceptions.MainClass .getLeave(MainClass.java:36) at com.example.chainedexception.exceptions.MainClass .main(MainClass.java:29) Caused by: com.example.chainedexception.exceptions .TeamLeadUpsetException: Team lead Upset. at com.example.chainedexception.exceptions.MainClass .howIsTeamLead(MainClass.java:44) at com.example.chainedexception.exceptions.MainClass .getLeave(MainClass.java:34) . 1 more

Мы можем легко сравнить показанные журналы и сделать вывод, что связанные исключения приводят к более чистым журналам.

6. Заключение

В этой статье мы рассмотрели концепцию связанных исключений.

Реализации всех примеров можно найти вthe Github project — это проект на основе Maven, поэтому его должно быть легко импортировать и запускать как есть.

Источник

Сцепленные исключения

Начиная с J2SE 1.4, в подсистему исключений было добавлено новое средство: сцепленные исключения (chained exceptions). Это средство позволяет ассоциировать с одним исключением другое исключение. Второе исключение описывает причину появления первого. Например, представьте ситуацию, когда метод возбуждает исключение ArithmeticException, поскольку была предпринята попытка деления на ноль Однако реальная причина проблемы заключается в ошибке ввода-вывода, что приводит к неправильному делению. И хотя метод должен возбуждать ArithmeticException, так как произошла именно эта ошибка, вы можете также позволить вызывающему коду узнать о том, что в основе лежит ошибка ввода-вывода. Сцепленные исключения позволяют справиться с этой, а также с любой другой ситуацией, в которой присутствуют уровни исключений.

Чтобы разрешить сцепленные исключения, были добавлены два конструктора и два метода к Throwable.

Ниже показаны конструкторы.

Throwable(Throwable causeExc)
Throwable(String msg, Throwable causeExc)

В первой форме causeExc — это исключение, послужившее причиной текущего исключения. Если такого нет, возвращается null. Метод initCauseO ассоциирует causeExc с вызывающим исключением и возвращает ссылку на исключение. То есть вы можете вызвать initCause () только однажды для каждого объекта-исключения. Более того, если исключение-причина было установлено конструктором, то вы не можете установить его заново методом initCause ().

Вообще говоря, initCause () используется для установки причины унаследованного класса исключения, которое не поддерживает эти два дополнительных конструктора.

Вот пример, демонстрирующий применение механизма сцепленных исключений:

// Демонстрация сцепленных исключений.
class ChainExcDemo static void demoprocО // создать исключение
NullPointerException е = new NullPointerException(«верхний уровень»);
// добавить причину
е.initCause(new ArithmeticException(«причина»));
throw е;
>
public static void main(String args[]) try demoproc();
>
catch(NullPointerException e) // отобразить исключение верхнего уровня
System.out.println(«Перехвачено: » + е) ;
// отобразить исключение-причину
System.out.println(«Исходная причина: » + е. getCause О) ;
>
>
>

Эта программа создает следующий вывод:

Перехвачено: java.lang.NullPointerException: верхний уровень
Исходная причина: java.lang.ArithmeticException: причина

В этом примере исключением верхнего уровня является NullPointerException. К нему добавлено исключение-причина — ArithmeticException. Когда исключение возбуждается из demoproc(), оно перехватывается в main (). Затем исключение верхнего уровня отображается, а за ним следует исключение, лежащее в основе, которое извлекается методом getCause ().

Сцепленные исключения могут вкладываться на любую глубину. То есть исключение-причина может иметь собственную причину. Но имейте в виду, что слишком длинные цепочки сцепленных исключений, скорее всего, свидетельствуют о плохом дизайне.

Сцепленные исключения не являются вещью, совершенно необходимой в каждой программе. Однако в случаях, когда информация об исключении-причине таки нужна, они представляют собой элегантное решение.

Источник

Chained Exceptions

An application often responds to an exception by throwing another exception. In effect, the first exception causes the second exception. It can be very helpful to know when one exception causes another. Chained Exceptions help the programmer do this.

The following are the methods and constructors in Throwable that support chained exceptions.

Throwable getCause() Throwable initCause(Throwable) Throwable(String, Throwable) Throwable(Throwable)

The Throwable argument to initCause and the Throwable constructors is the exception that caused the current exception. getCause returns the exception that caused the current exception, and initCause sets the current exception’s cause.

The following example shows how to use a chained exception.

In this example, when an IOException is caught, a new SampleException exception is created with the original cause attached and the chain of exceptions is thrown up to the next higher level exception handler.

Accessing Stack Trace Information

Now let’s suppose that the higher-level exception handler wants to dump the stack trace in its own format.

Definition: A stack trace provides information on the execution history of the current thread and lists the names of the classes and methods that were called at the point when the exception occurred. A stack trace is a useful debugging tool that you’ll normally take advantage of when an exception has been thrown.

The following code shows how to call the getStackTrace method on the exception object.

catch (Exception cause) < StackTraceElement elements[] = cause.getStackTrace(); for (int i = 0, n = elements.length; i < n; i++) < System.err.println(elements[i].getFileName() + ":" + elements[i].getLineNumber() + ">> " + elements[i].getMethodName() + "()"); > >

Logging API

The next code snippet logs where an exception occurred from within the catch block. However, rather than manually parsing the stack trace and sending the output to System.err() , it sends the output to a file using the logging facility in the java.util.logging package.

try < Handler handler = new FileHandler("OutFile.log"); Logger.getLogger("").addHandler(handler); >catch (IOException e) < Logger logger = Logger.getLogger("package.name"); StackTraceElement elements[] = e.getStackTrace(); for (int i = 0, n = elements.length; i < n; i++) < logger.log(Level.WARNING, elements[i].getMethodName()); >>

Источник

Java Guides

The chained exception feature allows you to associate another exception with an exception. This second exception describes the cause of the first exception.

For example, imagine a situation in which a method throws an ArithmeticException because of an attempt to divide by zero. However, the actual cause of the problem was that an I/O error occurred, which caused the divisor to be set improperly. Although the method must certainly throw an ArithmeticException, since that is the error that occurred, you might also want to let the calling code know that the underlying cause was an I/O error. Chained exceptions let you handle this, and any other situation in which layers of exceptions exist. This concept was introduced in JDK 1.4.

Throwable Class

Throwable class has some constructors and methods to support chained exceptions. Firstly, let’s look at the constructors.

1. Throwable(Throwable cause) – Throwable has a single parameter, which specifies the actual cause of an Exception.
2. Throwable(String desc, Throwable cause) – this constructor accepts an Exception description with the actual cause of an Exception as well.

• getCause() method – This method returns the actual cause associated with the current Exception.
• initCause() method – It sets an underlying cause with invoking Exception.

Java Chained Exceptions Example

// Demonstrate exception chaining. class ChainExcDemo < static void demoproc() < // create an exception NullPointerException e = new NullPointerException("top layer"); // add a cause e.initCause(new ArithmeticException("cause")); throw e; > public static void main(String args[]) < try < demoproc(); >catch (NullPointerException e) < // display top level exception System.out.println("Caught: " + e); // display cause exception System.out.println("Original cause: " + e.getCause()); > > >

Caught: java.lang.NullPointerException: top layer Original cause: java.lang.ArithmeticException: cause 

In this example, the top-level exception is NullPointerException. To it is added a cause exception, ArithmeticException. When the exception is thrown out of demoproc( ) method, it is caught by main( ). There, the top-level exception is displayed, followed by the underlying exception, which is obtained by calling getCause( ).

Chained exceptions can be carried on to whatever depth is necessary. Thus, the cause exception can, itself, have a cause. Be aware that overly long chains of exceptions may indicate poor design.

Chained exceptions are not something that every program will need. However, in cases in which knowledge of an underlying cause is useful, they offer an elegant solution.

Источник