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.

Economize memória com o padrão Flyweight

Quando desenvolvemos jogos é muito comum termos diversas entidades do mesmo tipo em um cenário, como inimigos, projéteis, nuvens, efeitos etc. Criar sempre novos objetos para cada entidade que surge na tela é algo custoso para JVM, tanto em performance quanto em uso de memória.

Para minimizar o uso desnecessário de recursos da máquina ou dispositivo, nós podemos utilizar o padrão Flyweight, na qual se encarregaria de criar apenas um único objeto em memória e compartilhá-lo pelo resto do jogo ou aplicação. A idéia é simples mas os ganhos são consideráveis!

Para exemplificar bem o uso deste padrão de projeto, nós da TriadWorks escrevemos um post sobre o assunto com direito a exemplos! Vale a pena dar uma olhada e ver se esse padrão se encaixa no seu projeto!

Para não perder nenhum post no blog dos instrutores da TriadWorks, você pode se inscrever na nossa página (fica no rodapé!) e receber um email sempre que um novo post for lançado! Ah! Nós estamos tentando blogar toda segunda-feira pela manhã, então fica de olho!