Java中@SneakyThrows 注解的应用场景

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.24</version>
    <scope>provided</scope>
</dependency>

import lombok.SneakyThrows;
import java.io.FileInputStream;
import java.io.InputStream;

public class SneakyThrowsBasicExample {

    // 使用@SneakyThrows无需声明throws子句
    @SneakyThrows
    public void readFile(String fileName) {
        // FileInputStream的构造函数会抛出FileNotFoundException（checked异常）
        InputStream is = new FileInputStream(fileName);
        // ... 处理文件
        is.close();
    }

    // 传统方式需要声明throws子句
    public void readFileTraditional(String fileName) throws java.io.FileNotFoundException {
        InputStream is = new FileInputStream(fileName);
        // ... 处理文件
    }

    public static void main(String[] args) {
        SneakyThrowsBasicExample example = new SneakyThrowsBasicExample();
        
        // 调用使用@SneakyThrows的方法，无需处理异常
        example.readFile("example.txt");
        
        // 调用传统方法必须处理异常或声明抛出
        try {
            example.readFileTraditional("example.txt");
        } catch (java.io.FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

import lombok.SneakyThrows;
import java.io.IOException;
import java.sql.SQLException;

public class SneakyThrowsSpecificExample {

    // 只对IOException使用SneakyThrows
    @SneakyThrows(IOException.class)
    public void handleExceptions() {
        // IOException会被SneakyThrows处理
        throw new IOException("IO错误");
        
        // 如果取消下面这行注释，编译器会要求处理SQLException
        // throw new SQLException("数据库错误");
    }
    
    // 可以指定多个异常类型
    @SneakyThrows({IOException.class, SQLException.class})
    public void handleMultipleExceptions() {
        if (System.currentTimeMillis() % 2 == 0) {
            throw new IOException("IO错误");
        } else {
            throw new SQLException("数据库错误");
        }
    }
}

import lombok.SneakyThrows;
import java.io.File;
import java.io.FileInputStream;
import java.util.Arrays;
import java.util.List;

public class SneakyThrowsFunctionalExample {

    public static void main(String[] args) {
        List<String> files = Arrays.asList("file1.txt", "file2.txt", "file3.txt");
        
        // 使用传统方式需要在lambda中处理异常，代码臃肿
        files.forEach(fileName -> {
            try {
                FileInputStream fis = new FileInputStream(new File(fileName));
                // 处理文件
                fis.close();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
        
        // 使用@SneakyThrows的方法作为方法引用，代码更简洁
        files.forEach(SneakyThrowsFunctionalExample::processFile);
    }
    
    // 使用@SneakyThrows注解处理checked异常
    @SneakyThrows
    private static void processFile(String fileName) {
        FileInputStream fis = new FileInputStream(new File(fileName));
        // 处理文件
        fis.close();
    }
}

import lombok.SneakyThrows;
import org.junit.Test;
import java.net.URL;

public class SneakyThrowsTestExample {

    // 测试方法中使用@SneakyThrows简化异常处理
    @Test
    @SneakyThrows
    public void testUrlConnection() {
        URL url = new URL("https://example.com");
        // URL.openConnection()会抛出IOException
        var connection = url.openConnection();
        connection.connect();
        // 执行测试断言...
    }
}

import lombok.SneakyThrows;

// 模板方法类
abstract class Template {
    // 模板方法，定义算法骨架
    public final void execute() {
        setup();
        try {
            doWork();
        } finally {
            cleanup();
        }
    }
    
    protected void setup() {}
    
    // 抽象方法，由子类实现
    protected abstract void doWork();
    
    protected void cleanup() {}
}

// 具体实现类
class FileProcessingTemplate extends Template {
    @Override
    @SneakyThrows // 无需在父类声明异常
    protected void doWork() {
        // 可能抛出IOException等checked异常
        throw new java.io.IOException("文件处理出错");
    }
}

public class SneakyThrowsTemplateExample {
    public static void main(String[] args) {
        Template template = new FileProcessingTemplate();
        template.execute();
    }
}

import lombok.SneakyThrows;
import java.io.BufferedReader;
import java.io.FileReader;

/**
 * 文件处理工具类
 * 使用@SneakyThrows简化异常处理，但仍保持良好的代码文档
 */
public class SneakyThrowsBestPractice {

    /**
     * 读取文件内容并返回
     * 
     * @param filePath 文件路径
     * @return 文件内容
     * @throws java.io.FileNotFoundException 如果文件不存在
     * @throws java.io.IOException 如果读取文件时发生错误
     */
    @SneakyThrows
    public String readFileContent(String filePath) {
        // 与try-with-resources配合使用，确保资源正确释放
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            StringBuilder content = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                content.append(line).append("\n");
            }
            return content.toString();
        }
    }
    
    public static void main(String[] args) {
        SneakyThrowsBestPractice util = new SneakyThrowsBestPractice();
        
        try {
            String content = util.readFileContent("example.txt");
            System.out.println(content);
        } catch (java.io.IOException e) {
            // 在上层适当位置处理异常
            System.err.println("处理文件时出错: " + e.getMessage());
            e.printStackTrace();
        }
    }
}