Чем заменишь Try With Resources?

Альтернативы Try-with-Resources в Java

Тry-with-Resources (введён в Java 7) — удобный способ автоматического закрытия ресурсов (файлы, соединения, потоки). Однако существуют ситуации, когда нужна альтернатива. Рассмотрим все варианты.

Исходный код с Try-with-Resources

// Java 7+ стандартный способ
try (FileInputStream fis = new FileInputStream("file.txt");
     BufferedReader reader = new BufferedReader(new InputStreamReader(fis))) {
    
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

Альтернатива 1: Try-Finally (Java 6 и старше)

Вручную закрывать ресурсы в блоке finally. Это было стандартом до Java 7.

FileInputStream fis = null;
BufferedReader reader = null;
try {
    fis = new FileInputStream("file.txt");
    reader = new BufferedReader(new InputStreamReader(fis));
    
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (reader != null) {
        try {
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    if (fis != null) {
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Проблемы:

• Много boilerplate кода
• Легко забыть закрыть ресурс
• Вложенные try-catch в finally запутывают код
• Если исключение в close(), теряется оригинальное исключение

Альтернатива 2: Try-Finally с вспомогательным методом

Для Java 6 можно создать вспомогательный метод, чтобы уменьшить boilerplate.

private static void closeQuietly(Closeable... resources) {
    for (Closeable resource : resources) {
        if (resource != null) {
            try {
                resource.close();
            } catch (IOException e) {
                // Логировать, но не выбрасывать
                e.printStackTrace();
            }
        }
    }
}

// Использование
FileInputStream fis = null;
BufferedReader reader = null;
try {
    fis = new FileInputStream("file.txt");
    reader = new BufferedReader(new InputStreamReader(fis));
    
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    closeQuietly(reader, fis);
}

Преимущества:

• Меньше кода чем чистый try-finally
• Работает на Java 6 и старше

Недостатки:

• Всё равно не так чисто как try-with-resources

Альтернатива 3: Apache Commons IO closeQuietly

Апаче предоставляет утилиту для закрытия ресурсов.

<!-- pom.xml -->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.11.0</version>
</dependency>

import org.apache.commons.io.IOUtils;

FileInputStream fis = null;
BufferedReader reader = null;
try {
    fis = new FileInputStream("file.txt");
    reader = new BufferedReader(new InputStreamReader(fis));
    
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    IOUtils.closeQuietly(reader, fis); // не выбрасывает исключения
}

Преимущества:

• Проверенная готовая библиотека
• Меньше кода

Альтернатива 4: Guava Closer

Google Guava предоставляет класс Closer для элегантного управления ресурсами.

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.1-jre</version>
</dependency>

import com.google.common.io.Closer;

Closer closer = Closer.create();
try {
    FileInputStream fis = closer.register(new FileInputStream("file.txt"));
    BufferedReader reader = closer.register(
        new BufferedReader(new InputStreamReader(fis))
    );
    
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    closer.close(); // закроет все ресурсы в обратном порядке
}

Преимущества:

• Чище чем try-finally
• Закрывает в обратном порядке (правильно для nested ресурсов)
• Подавляет исключения при закрытии

Альтернатива 5: Callback/Strategy паттерн

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

@FunctionalInterface
public interface ResourceConsumer<T extends Closeable> {
    void consume(T resource) throws IOException;
}

public class ResourceManager {
    public static <T extends Closeable> void withResource(
        Supplier<T> supplier,
        ResourceConsumer<T> consumer) {
        T resource = null;
        try {
            resource = supplier.get();
            consumer.consume(resource);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (resource != null) {
                try {
                    resource.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

// Использование
ResourceManager.withResource(
    () -> new BufferedReader(new FileReader("file.txt")),
    reader -> {
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
    }
);

Преимущества:

• Очень чистый код на месте использования
• Управление ресурсом инкапсулировано

Альтернатива 6: Stream API (Java 8+)

Для файлов можно использовать Files.lines или Files.readAllLines.

// Вариант 1: Files.lines() — ленивая загрузка
try (Stream<String> lines = Files.lines(Paths.get("file.txt"))) {
    lines.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

// Вариант 2: Files.readAllLines() — загрузить всё
try {
    List<String> lines = Files.readAllLines(Paths.get("file.txt"));
    lines.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

// Stream API с try-with-resources (файл закроется автоматически)
try (Stream<String> lines = Files.lines(Paths.get("file.txt"))) {
    lines
        .filter(line -> !line.isEmpty())
        .map(String::toUpperCase)
        .forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

Преимущества:

• Очень функциональный подход
• Удобно для обработки коллекций
• Интегрирует управление ресурсами с обработкой

Альтернатива 7: Lambda + Custom Resource Handler (Java 8+)

Создать обёртку для любого ресурса.

public interface AutoCloseable {
    void close() throws Exception;
}

public class Resource<T extends AutoCloseable> {
    private final Supplier<T> supplier;
    
    public <R> R use(Function<T, R> consumer) {
        T resource = null;
        try {
            resource = supplier.get();
            return consumer.apply(resource);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            if (resource != null) {
                try {
                    resource.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

// Использование
new Resource<>(FileReader::new)
    .use(reader -> {
        // работа с reader
        return someValue;
    });

Альтернатива 8: Lombok @Cleanup

Если используется Lombok, есть аннотация @Cleanup.

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

import lombok.Cleanup;

public void readFile(String filename) throws IOException {
    @Cleanup FileInputStream fis = new FileInputStream(filename);
    @Cleanup BufferedReader reader = new BufferedReader(new InputStreamReader(fis));
    
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} // reader и fis закроются автоматически

Преимущества:

• Очень компактно
• Читается как обычный код

Недостатки:

• Добавляет зависимость на Lombok
• Требует обработки Lombok на этапе компиляции

Сравнительная таблица

Best Practice в 2024

// Рекомендация: используйте Try-with-Resources (Java 7+)
// Это стандарт, поддерживаемый всеми, безопасный и читаемый

try (FileInputStream fis = new FileInputStream("file.txt");
     BufferedReader reader = new BufferedReader(new InputStreamReader(fis))) {
    // работа с ресурсом
} catch (IOException e) {
    // обработка ошибок
}

// Для файлов в Java 8+ используйте Files API с try-with-resources
try (Stream<String> lines = Files.lines(Paths.get("file.txt"))) {
    lines.forEach(System.out::println);
} catch (IOException e) {
    // обработка ошибок
}

Вывод

Тry-with-Resources — это лучший и наиболее безопасный подход для управления ресурсами в современной Java. Альтернативы используются только если нужна совместимость с Java 6 (уже не поддерживается) или специфические требования проекта. Во всех новых проектах используйте try-with-resources — это безопасно, читаемо и требует минимум кода.