Что передает интерфейс Closeable

Интерфейс Closeable в Java

Closeable — это интерфейс, который определяет контракт для объектов, которые должны быть закрыты и освобождены после использования. Это необходимо для правильного управления ресурсами, такими как файлы, соединения с БД, сетевые сокеты и потоки.

Сигнатура интерфейса

public interface Closeable extends AutoCloseable {
    void close() throws IOException;
}

Ключевые моменты:

• Extends AutoCloseable — наследует от более общего интерфейса
• close() — единственный метод, который должен быть реализован
• IOException — может выбросить исключение при закрытии

Разница между Closeable и AutoCloseable

// AutoCloseable — более общий интерфейс
public interface AutoCloseable {
    void close() throws Exception;  // может выбросить любое исключение
}

// Closeable — более специализированный, для I/O операций
public interface Closeable extends AutoCloseable {
    void close() throws IOException;  // выбрасывает IOException
}

Практическое использование: работа с файлами

// ПЛОХО — утечка ресурсов
public void readFile(String filename) throws IOException {
    FileInputStream fis = new FileInputStream(filename);
    byte[] data = fis.readAllBytes();
    fis.close();
}

// ХОРОШО — автоматическое закрытие
public void readFile(String filename) throws IOException {
    try (FileInputStream fis = new FileInputStream(filename)) {
        byte[] data = fis.readAllBytes();
        System.out.println("Прочитано: " + data.length + " байт");
    }
}

Try-with-resources (TWR) конструкция

Try-with-resources — это синтаксис Java, который автоматически закрывает ресурсы, реализующие Closeable или AutoCloseable:

import java.io.*;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        try (FileReader reader = new FileReader("file.txt")) {
            int ch;
            while ((ch = reader.read()) != -1) {
                System.out.print((char) ch);
            }
        } catch (IOException e) {
            System.err.println("Ошибка чтения: " + e.getMessage());
        }
    }
    
    public static void copyFile(String source, String destination) {
        try (
            FileInputStream fis = new FileInputStream(source);
            FileOutputStream fos = new FileOutputStream(destination)
        ) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Создание собственного класса, реализующего Closeable

public class DatabaseConnection implements Closeable {
    private Connection connection;
    private boolean isClosed = false;
    
    public DatabaseConnection(String url) throws SQLException {
        this.connection = DriverManager.getConnection(url);
    }
    
    public void executeQuery(String sql) throws SQLException {
        if (isClosed) {
            throw new IllegalStateException("Соединение закрыто");
        }
        Statement stmt = connection.createStatement();
        stmt.execute(sql);
    }
    
    @Override
    public void close() throws IOException {
        if (!isClosed) {
            try {
                if (connection != null && !connection.isClosed()) {
                    connection.close();
                }
            } catch (SQLException e) {
                throw new IOException("Ошибка при закрытии соединения", e);
            } finally {
                isClosed = true;
            }
        }
    }
}

public class DatabaseExample {
    public static void main(String[] args) {
        try (DatabaseConnection conn = new DatabaseConnection("jdbc:mysql://localhost/db")) {
            conn.executeQuery("SELECT * FROM users");
        } catch (IOException e) {
            System.err.println("Ошибка подключения: " + e.getMessage());
        }
    }
}

Примеры классов, реализующих Closeable

// Файловые потоки
FileInputStream fis = new FileInputStream("file.txt");
FileOutputStream fos = new FileOutputStream("file.txt");
FileReader reader = new FileReader("file.txt");
FileWriter writer = new FileWriter("file.txt");

// Буферизованные потоки
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedReader br = new BufferedReader(reader);

// Сериализация
ObjectOutputStream oos = new ObjectOutputStream(fos);
ObjectInputStream ois = new ObjectInputStream(fis);

// ZIP файлы
ZipOutputStream zos = new ZipOutputStream(fos);
ZipInputStream zis = new ZipInputStream(fis);

// Сокеты
Socket socket = new Socket("localhost", 8080);
ServerSocket serverSocket = new ServerSocket(8080);

// Соединения с БД
Connection conn = DriverManager.getConnection(url);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT ...");

// Scanner
Scanner scanner = new Scanner(System.in);
Scanner fileScanner = new Scanner(new File("file.txt"));

Обработка исключений при закрытии

public class CloseableResourceExample implements Closeable {
    private Resource resource;
    
    public CloseableResourceExample() {
        this.resource = new Resource();
    }
    
    @Override
    public void close() throws IOException {
        try {
            resource.close();
        } catch (Exception e) {
            throw new IOException("Ошибка при закрытии ресурса", e);
        }
    }
}

try (CloseableResourceExample resource = new CloseableResourceExample()) {
    // работаем с ресурсом
} catch (IOException e) {
    Throwable[] suppressed = e.getSuppressed();
    for (Throwable th : suppressed) {
        System.err.println("Подавленное исключение: " + th);
    }
}

Практический пример: REST Client

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiClient implements Closeable {
    private final HttpClient client;
    
    public ApiClient() {
        this.client = HttpClient.newHttpClient();
    }
    
    public String fetchData(String url) throws IOException, InterruptedException {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .GET()
            .build();
        
        try {
            HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
            );
            return response.body();
        } catch (Exception e) {
            throw new IOException("Ошибка запроса", e);
        }
    }
    
    @Override
    public void close() throws IOException {
        // Освобождение ресурсов
    }
}

public class Main {
    public static void main(String[] args) {
        try (ApiClient client = new ApiClient()) {
            String data = client.fetchData("https://api.example.com/data");
            System.out.println(data);
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Когда реализовать Closeable

public class FileProcessingService implements Closeable {
    private FileInputStream fileStream;
    private BufferedReader reader;
    
    public FileProcessingService(String filename) throws IOException {
        this.fileStream = new FileInputStream(filename);
        this.reader = new BufferedReader(new InputStreamReader(fileStream));
    }
    
    public String readLine() throws IOException {
        return reader.readLine();
    }
    
    @Override
    public void close() throws IOException {
        if (reader != null) {
            reader.close();
        }
        if (fileStream != null) {
            fileStream.close();
        }
    }
}

public static void processFile(String filename) {
    try (FileProcessingService service = new FileProcessingService(filename)) {
        String line;
        while ((line = service.readLine()) != null) {
            System.out.println(line);
        }
    } catch (IOException e) {
        System.err.println("Ошибка обработки файла");
    }
}

Ключевые выводы

• Closeable — интерфейс для объектов, которые должны освобождать ресурсы
• close() — единственный метод, выбрасывает IOException
• Try-with-resources — автоматически вызывает close()
• Используй TWR вместо try-finally для безопасности
• Реализуй Closeable, если твой класс управляет ресурсами
• Правильное закрытие ресурсов — критично для production приложений

Это один из самых важных интерфейсов для предотвращения утечек ресурсов!