Try-With-Resources & AutoCloseable — Deep Dive

// Java 6 — verbose and error-prone
InputStream in = null;
OutputStream out = null;
try {
    in = new FileInputStream("source.txt");
    out = new FileOutputStream("dest.txt");
    byte[] buf = new byte[8192];
    int len;
    while ((len = in.read(buf)) != -1) {
        out.write(buf, 0, len);
    }
} catch (IOException e) {
    log.error("Copy failed", e);
} finally {
    // Ugly, error-prone cleanup
    if (out != null) {
        try {
            out.close();  // can throw — might mask original exception!
        } catch (IOException e) {
            log.warn("Failed to close output", e);
        }
    }
    if (in != null) {
        try {
            in.close();
        } catch (IOException e) {
            log.warn("Failed to close input", e);
        }
    }
}

// Java 7+ — clean, safe, guaranteed close
try (InputStream in = new FileInputStream("source.txt");
     OutputStream out = new FileOutputStream("dest.txt")) {

    byte[] buf = new byte[8192];
    int len;
    while ((len = in.read(buf)) != -1) {
        out.write(buf, 0, len);
    }

} catch (IOException e) {
    log.error("Copy failed", e);
}
// Both streams GUARANTEED closed, even if body throws
// Close order: out first, then in (reverse declaration order)

// AutoCloseable — more general, allows any exception
public interface AutoCloseable {
    void close() throws Exception;
}

// Closeable — I/O specific, idempotent requirement
public interface Closeable extends AutoCloseable {
    void close() throws IOException;
}

public class SuppressedExceptionDemo {

    static class FaultyResource implements AutoCloseable {
        void doWork() {
            throw new RuntimeException("Primary: work failed");
        }

        @Override
        public void close() {
            throw new RuntimeException("Secondary: close failed");
        }
    }

    public static void main(String[] args) {
        try (FaultyResource res = new FaultyResource()) {
            res.doWork();  // throws primary
        } catch (RuntimeException e) {
            System.out.println(e.getMessage());
            // Output: "Primary: work failed"

            Throwable[] suppressed = e.getSuppressed();
            for (Throwable t : suppressed) {
                System.out.println("  Suppressed: " + t.getMessage());
                // Output: "  Suppressed: Secondary: close failed"
            }
        }
    }
}

// Java 7-8: MUST declare resources in try()
try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
    // ...
}

// Java 9+: can reference effectively-final variables
BufferedReader br = new BufferedReader(new FileReader("data.txt"));
// br is effectively final (never reassigned)
try (br) {
    return br.readLine();
}
// br.close() still called automatically

// Java 9+ — useful for resources passed into methods
public void processStream(InputStream input) {
    // input is effectively final (method parameter)
    try (input) {
        byte[] data = input.readAllBytes();
        process(data);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}

// Resources closed in reverse: rs -> ps -> conn
try (Connection conn = dataSource.getConnection();
     PreparedStatement ps = conn.prepareStatement("SELECT * FROM users WHERE id = ?");
     ResultSet rs = executePrepared(ps, userId)) {

    while (rs.next()) {
        users.add(mapRow(rs));
    }
}
// Close order: rs.close() → ps.close() → conn.close()
// This is correct! Inner resources closed before outer ones.

private ResultSet executePrepared(PreparedStatement ps, long id) throws SQLException {
    ps.setLong(1, id);
    return ps.executeQuery();
}

/**
 * A distributed lock that auto-releases when try block exits.
 */
public class DistributedLock implements AutoCloseable {

    private final RedisCommands<String, String> redis;
    private final String lockKey;
    private final String lockValue;
    private volatile boolean released = false;

    private DistributedLock(RedisCommands<String, String> redis, String key, String value) {
        this.redis = redis;
        this.lockKey = key;
        this.lockValue = value;
    }

    public static DistributedLock acquire(RedisCommands<String, String> redis,
                                          String key, Duration timeout) {
        String value = UUID.randomUUID().toString();
        boolean acquired = redis.set(key, value, SetArgs.Builder.nx().ex(timeout));
        if (!acquired) {
            throw new LockAcquisitionException("Could not acquire lock: " + key);
        }
        return new DistributedLock(redis, key, value);
    }

    @Override
    public void close() {
        if (!released) {
            released = true;
            // Lua script for atomic check-and-delete
            String script = "if redis.call('get',KEYS[1]) == ARGV[1] then " +
                            "return redis.call('del',KEYS[1]) else return 0 end";
            redis.eval(script, ScriptOutputType.INTEGER,
                       new String[]{lockKey}, lockValue);
        }
    }
}

// Usage — lock auto-released even if exception occurs
try (DistributedLock lock = DistributedLock.acquire(redis, "order:123", Duration.ofSeconds(30))) {
    processOrder("123");
}  // lock.close() called automatically

// HikariCP — DataSource itself is AutoCloseable
HikariDataSource ds = new HikariDataSource(config);

// Application shutdown hook
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    if (ds != null && !ds.isClosed()) {
        ds.close();  // waits for active connections to return, then closes pool
    }
}));

// Spring Boot — DataSource is managed by the container, closed on context shutdown
// No manual close needed in Spring apps

// Per-request pattern — connection returned to pool on close()
public List<User> findAll() {
    try (Connection conn = dataSource.getConnection();
         Statement stmt = conn.createStatement();
         ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {

        List<User> users = new ArrayList<>();
        while (rs.next()) {
            users.add(mapRow(rs));
        }
        return users;
    } catch (SQLException e) {
        throw new DataAccessException("Query failed", e);
    }
    // conn.close() returns connection to pool (NOT actual TCP close)
}

// Safe — if constructor throws, no resource to close
try (Connection conn = getConnection()) {  // returns null!
    conn.prepareStatement(sql);  // NullPointerException
}
// conn is null → close() is NOT called (spec says: skip if null)
// But NPE in the body is the real bug

// BAD — manually closing AND try-with-resources closes it
try (InputStream in = new FileInputStream("data.txt")) {
    process(in);
    in.close();  // WRONG — will be closed again at end of try block
}
// in.close() called TWICE — safe for Closeable (idempotent), but
// NOT guaranteed safe for all AutoCloseable implementations!

// COMPILE ERROR in Java 7/8
BufferedReader br = new BufferedReader(new FileReader("f.txt"));
try (br) { }  // Error: resource must be declared in try header
// Fixed in Java 9+ (effectively-final variables)

// DANGER — if BufferedInputStream constructor throws, fis is leaked
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("x.txt"))) {
    // ...
}
// If BufferedInputStream constructor throws (e.g., invalid arg),
// FileInputStream was already opened but won't be closed!

// SAFE — declare each resource separately
try (FileInputStream fis = new FileInputStream("x.txt");
     BufferedInputStream bis = new BufferedInputStream(fis)) {
    // ...
}
// fis is closed even if BufferedInputStream constructor fails

try (Resource res = new Resource()) {
    res.doWork();
}

Resource res = new Resource();
Throwable primaryEx = null;
try {
    res.doWork();
} catch (Throwable t) {
    primaryEx = t;
    throw t;
} finally {
    if (res != null) {
        if (primaryEx != null) {
            try {
                res.close();
            } catch (Throwable suppressed) {
                primaryEx.addSuppressed(suppressed);  // attach, don't mask!
            }
        } else {
            res.close();  // no primary exception — close normally
        }
    }
}

public Optional<User> findById(long id) {
    String sql = "SELECT id, name, email FROM users WHERE id = ?";
    try (Connection conn = dataSource.getConnection();
         PreparedStatement ps = conn.prepareStatement(sql)) {

        ps.setLong(1, id);
        try (ResultSet rs = ps.executeQuery()) {
            if (rs.next()) {
                return Optional.of(new User(rs.getLong("id"),
                                            rs.getString("name"),
                                            rs.getString("email")));
            }
        }
        return Optional.empty();

    } catch (SQLException e) {
        throw new DataAccessException("findById failed for id=" + id, e);
    }
}

// Reading all lines (small files)
try (Stream<String> lines = Files.lines(Path.of("server.log"))) {
    long errorCount = lines.filter(l -> l.contains("ERROR")).count();
    log.info("Found {} errors", errorCount);
}
// Stream<String> implements AutoCloseable — closes underlying file handle

// Writing with BufferedWriter
try (BufferedWriter writer = Files.newBufferedWriter(
        Path.of("output.csv"), StandardCharsets.UTF_8,
        StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) {

    writer.write("id,name,email");
    writer.newLine();
    for (User u : users) {
        writer.write(u.toCsv());
        writer.newLine();
    }
}

// HttpClient itself is NOT AutoCloseable (shared, long-lived)
// But InputStream from response body IS
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.example.com/data"))
        .build();

HttpResponse<InputStream> response = client.send(request,
        HttpResponse.BodyHandlers.ofInputStream());

try (InputStream body = response.body()) {
    JsonNode json = objectMapper.readTree(body);
    return json.get("result").asText();
}

public class CloseableLock implements AutoCloseable {
    private final Lock lock;

    public CloseableLock(Lock lock) {
        this.lock = lock;
        this.lock.lock();  // acquire on construction
    }

    @Override
    public void close() {
        lock.unlock();  // release on close
    }

    public static CloseableLock acquire(Lock lock) {
        return new CloseableLock(lock);
    }
}

// Usage — no more try-finally for lock/unlock
private final Lock lock = new ReentrantLock();

public void transferFunds(Account from, Account to, BigDecimal amount) {
    try (CloseableLock l = CloseableLock.acquire(lock)) {
        from.debit(amount);
        to.credit(amount);
    }  // lock.unlock() guaranteed
}

// Spring manages connections internally — you never see try-with-resources
// But under the hood, JdbcTemplate does exactly this pattern
@Repository
public class UserRepository {
    private final JdbcTemplate jdbc;

    public List<User> findActive() {
        return jdbc.query("SELECT * FROM users WHERE active = true",
            (rs, rowNum) -> new User(rs.getLong("id"), rs.getString("name")));
        // JdbcTemplate handles: getConnection → prepareStatement → executeQuery
        //                       → close ResultSet → close Statement → close Connection
    }
}