Controle Transaciona Programatico

OO no mundo real: evite vazamento de conexões com controle transacional programático

No último Javou (evento da JavaCE) o prof. Alexandre Martins comentou na sua palestra que um dev junior conseguiu derrubar por alguns minutos o sistema de previdência social da Dataprev. Estou falando do principal sistema da empresa… muito louco não?

Sabe como? Ele esqueceu de colocar essa linha de código aqui:

conexao.close();  // fecha conexão com o banco

Simmm! Ele esqueceu de fechar uma conexão com o banco de dados! Se você não sabe, uma conexão é um recurso muito caro e, para piorar, é muito limitado; todo banco tem um limite de conexões que podem ser abertas, se esse limite estourar já era, a aplicação não consegue mais conversar com o banco!

(Eu nem culpo esse dev junior, até porque eu já fiz algo parecido em alguns sistemas… mas não conta pra ninguém, tá?)

Mas como ele poderia ter evitado?

A boa prática diz que todo recurso caro que for aberto deve sempre ser fechado quando não for mais utilizado. Uma boa maneira de fazer isso é através do bloco try-catch-finally do Java:

Connection conexao = null;
try {
    conexao = ConnectionFactory.getConnection();
    // logica de negócio

} catch (SQLException e) {
    // trata erro
} finally {
    conexao.close(); // fecha conexão com o banco
}

O problema é que repetir esse código em todo o sistema é muito frágil, cedo ou tarde alguém esquece e termina com o sistema fora do ar. Aí já viu né, é justa causa…

E se eu te dissesse que tem uma maneira mais elegante de resolver isso usando OO? É o que chamamos de controle transacional programático e traz diversos benefícios para qualquer sistema, entre eles a garantia que toda conexão com o banco é fechada!

Pra te ajudar a entender do que estou falando, eu bloguei sobre o assunto:

[Post] Controle Transacional Programático em Sistemas Legados

Após ler esse artigo eu te garanto que você vai levar o controle de conexões e transações na sua aplicação mais a sério, seja seu sistema legado ou mais moderno com JPA e Hibernate.

Qual controle transacional usar com Spring: AOP ou @Transactional ?

Sempre que iniciamos um novo projeto com Spring precisamos decidir qual estratégia de controle transacional utilizar. Normalmente acabamos optando pelo controle transacional declarativo em vez do programático, no entanto, temos ainda que decidir se iremos seguir uma das estratégias: AOP ou @Transactional.

Mas quais os benefícios de uma abordagem ou de outra? Quais as desvantagens de utilizar AOP? E a anotação @Transactional? Para sanar estas dúvidas, o blog dos desenvolvedores da TriadWorks acaba de publicar mais um artigo, com o tema Controle transacional declarativo com Spring: AOP ou @Transactional. O post apresenta os prós e contras de cada abordagem, o que pode ajudar arquitetos e desenvolvedores mais seniores a tomar uma decisão mais consciente!

Eu já trabalhei com as duas abordagens, e por esse motivo prefiro trabalhar com o uso da anotação @Transactional, pois o código fica mais explicito e ainda consigo fazer o desenvolvedores da equipe pensarem sobre o fluxo das transações dentro da aplicação. E você, qual abordagem prefere?