Quem está fechando as conexões?

Opa Arthur, tranquilo?

Devemos o trabalho árduo e ingrato de fechar os recursos ao try-with-resources. Basicamente, quando usamos o try e declaramos um recurso junto dentro parênteses, como foi o caso do ResultSet, Connection e do PreparedStatement. Garantimos que ao final do try, eles serão fechados.

try (Connection connection = new ConnectionFactory().recuperarConexao()) {
    // instanciando o DAO com a connection
    // usando o DAO
} <-- connection sera fechada aqui

Essa ferramenta é abordada é abordada nessa aula.

Espero ter ajudado. Se ficou alguma dúvida é só avisar!

Abraços e bons estudos!!

Oi Thiago, obrigado pela resposta rápida. Na verdade, isso trás uma outra dúvida sim, vamos supor a seguinte situação:

Eu preciso fazer uma transação e ela utilizará 3 classes DAO. Preciso manter a conexão aberta para que elas sejam tratadas dentro do mesmo contexto pelo SGBD. Dentro do método minhaTransação() eu chamo metodoDeOutraDAO() e maisUmOutroMetodoDeUmaOutraDAO(). Porém, quando eu terminasse o try do metodoDeOutraDAO(), isso não encerraria a conexão?

Uma solução que pensei: Ao invés de ir até o segundo método e depois voltar para o primeiro executar o terceiro e último, chamar este terceiro e último dentro do segundo, "cascateando" a transação. (Não sei se você entendeu).

Obrigado!

Olá Arthur!

Acho que entendi, me corrija se eu estiver errado! Dentro de um único método, você pretende fazer uso de 3 DAOs diferentes usando uma mesma conexão, certo?

Nesse caso, você não poderia abrir a conexão no try-with-resources e passar a conexão como argumento para a minhaTransação()? A partir daí você usa essa conexão como argumento para os DAOs que serão instanciados dentro do método. Então, suponhamos que queremos fazer duas consultas em duas tabelas diferentes e, portanto, usando dois DAOs diferentes:

public class Foo {

    public static void minhaTransacao(Connection connection) {

        ProdutoDAO produtoDAO = new ProdutoDAO(connection);
        List<Produto> listaDeProdutos = produtoDAO.listar();
        listaDeProdutos.stream().forEach(produto -> System.out.println(produto.getNome()));

        CategoriaDAO categoriaDAO = new CategoriaDAO(connection);
        List<Categoria> listaDeCategorias = categoriaDAO.listar();
        listaDeCategorias.stream().forEach(categoria -> System.out.println(categoria.getNome()));
    }
}

Testando isso, ficaria dessa forma:

public static void main(String[] args) throws SQLException {

    try(Connection connection = new ConnectionFactory().recuperarConexao()) {
            Foo.minhaTransacao(connection);
    }
}

Fiz o possível para manter o escopo dos elementos dentro da aula. Faz sentido para você fazer dessa forma?

Avisa aí se tiver qualquer dúvida!

Bons estudos!!

Thiago, era essa mesma ideia. Obrigado pela resposta!

Forte abraço, Arthur.