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

Lombok — это библиотека Java, которая упрощает написание кода Java с помощью аннотаций. Среди них аннотация @SneakyThrows — это инструмент, предоставляемый Lombok для упрощения обработки исключений.

Роль аннотации @SneakyThrows

Основная функция аннотации @SneakyThrows — преобразовать проверенные исключения в методах в непроверяемые исключения, тем самым избегая необходимости явно объявлять их в сигнатуре метода или явно фиксировать и обрабатывать эти исключения внутри тела метода. Это может упростить код и улучшить его читаемость и удобство сопровождения.

В частности, когда метод украшен аннотацией @SneakyThrows, Lombok будет выполнять операции с байт-кодом метода во время компиляции и обертывать проверенное исключение, созданное внутри метода, в непроверяемое исключение (обычно RuntimeException или другой подкласс) перед его созданием. Таким образом, вам не нужно явно обрабатывать эти проверенные исключения при вызове метода.

Использование @SneakyThrows

import lombok.SneakyThrows;  
import java.io.FileInputStream;  
import java.io.IOException;  
  
public class SneakyThrowsExample {  
  
    public static void main(String[] args) {  
        try {  
            readFile();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
    @SneakyThrows(IOException.class)  
    public static void readFile() {  
        FileInputStream fis = new FileInputStream("somefile.txt");  
        int data = fis.read();  
        while (data != -1) {  
            System.outut.print((char) data);  
            data = fis.read();  
        }  
        fis.close();  
    }  
}

В этом примере метод readFile вызывает метод чтения FileInputStream, который заявляет, что может вызвать исключение IOException. Мы используем аннотацию @SneakyThrows(IOException.class), чтобы избежать объявления этого исключения в сигнатуре метода readFile.

Скомпилированный код примерно эквивалентен следующему:

public class SneakyThrowsExample {  
    public SneakyThrowsExample() {  
    }  
  
    public static void main(String[] args) {  
        try {  
            readFile();  
        } catch (Exception var1) {  
            var1.printStackTrace();  
        }  
    }  
  
    public static void readFile() {  
        try {  
            FileInputStream fis = new FileInputStream("somefile.txt");  
            int data;  
            while ((data = fis.read()) != -1) {  
                System.out.print((char)data);  
            }  
  
            fis.close();  
        } catch (IOException var2) {  
            throw Lombok.sneakyThrow(var2);  
        }  
    }  
  
    // Эта часть представляет собой вспомогательный метод, созданный Lombok для «скрытого» бросания аномальных объектов.  
    private static RuntimeException sneakyThrow(Throwable t) {  
        if (t == null) throw new NullPointerException("t");  
        return (RuntimeException) Lombok.<RuntimeException>sneakyThrow0(t);  
    }  
  
    // Используйте @SuppressWarnings для подавления предупреждений компиляции.  
    @SuppressWarnings("unchecked")  
    private static <T extends Throwable> T sneakyThrow0(Throwable t) throws T {  
        throw (T) t; // На самом деле преобразование типов здесь недопустимо во время выполнения, но компилирующий компилятор позволяет записать его вот так  
    }  
}

Следует отметить, что приведенный выше код не является реальным кодом, сгенерированным Lombok, а является концептуальным примером, объясняющим, как работает @SneakyThrows. Lombok фактически изменяет байт-код напрямую, вместо того, чтобы вставлять дополнительный код Java. Кроме того, методы snackyThrow и snackyThrow0 не написаны пользователями, а являются частью библиотеки Lombok.

Почему приведенный выше код не выполняет прямое приведение?

Прямое приведение здесь невозможно, поскольку система типов Java не позволяет приводить произвольный Throwable к RuntimeException или другому конкретному проверяемому типу исключения. Это приведет к ошибке во время компиляции. Однако, используя дженерики и небезопасные преобразования (которые здесь на самом деле безопасны), Lombok обходит это ограничение, позволяя генерировать исключения любого типа во время выполнения, не объявляя их в сигнатуре метода.

В реальной разработке вам не нужно писать такие методы, как SneakyThrow или SneakyThrow0, Lombok автоматически обработает эти низкоуровневые детали. Вам нужно использовать аннотацию @SneakyThrows только для метода, который вы хотите «скрытно» вызвать исключение.

Принцип реализации аннотации @SneakyThrows

Принцип реализации аннотации @SneakyThrows в основном включает в себя процессор аннотации Java и операции с байт-кодом. Конкретно,Lombok зарегистрирует собственный обработчик аннотаций при компиляции.,Этот процессор сканирует исходный код Lombokannotation.,И обрабатывать эти аннотации соответствующим образом.

Для аннотации @SneakyThrows процессор аннотаций Lombok найдет метод, измененный аннотацией, и изменит байт-код метода. Основные изменения включают удаление предложения throws из сигнатуры метода и вставку соответствующего байт-кода в тело метода для переноса и генерации исключений.

В частности, Lombok сгенерирует новый метод, который имеет ту же сигнатуру метода, что и метод, измененный аннотацией @SneakyThrows, но внутри тела метода будет захватывать все проверенные исключения, которые могут быть выброшены, и обертывать эти исключения в новое непроверяемое исключение (обычно RuntimeException или его подкласс) перед его созданием.

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

Сценарии использования аннотации @SneakyThrows

Аннотация @SneakyThrows подходит для сценариев, в которых вы не хотите явно объявлять проверенные исключения в сигнатуре метода, а также не хотите явно фиксировать и обрабатывать эти исключения внутри тела метода. Например, при написании некоторых классов инструментов или библиотек мы можем захотеть передать ответственность за обработку исключений вызывающему объекту вместо того, чтобы обрабатывать их внутри класса инструмента или библиотеки. В настоящее время вы можете использовать аннотацию @SneakyThrows для упрощения кода.

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

Подвести итог

Аннотация @SneakyThrows — это инструмент, предоставляемый Lombok для упрощения обработки исключений. Он преобразует проверенные исключения в методах в непроверенные исключения с помощью операций с байт-кодом, тем самым устраняя необходимость явно объявлять их в сигнатуре метода или явно фиксировать и обрабатывать эти исключения внутри тела метода. Хотя аннотация @SneakyThrows может упростить код, вам необходимо тщательно продумать стратегию обработки исключений при ее использовании, чтобы избежать непредвиденных ситуаций.

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