Lentidão por causa do BD

Programação Java
#1

Pessoal, estou precisando de uma ajuda…

Estou desenvolvendo uma aplicação que acessa o Banco de Dados (PostgreSQL) utilizando uma classe DAO.

Toda vez que vou fazer uma operação no banco, crio um DAO, que cria uma conexão. Executo as queries e tudo mais que deve ser feito no banco e depois fecho (conexao.close()).

A aplicação está rodando super bem, porém, como estou ainda desenvolvendo, faço vários teste. Após muitas execuções percebo que não só a aplicação como o computador em geral ficam extremamente lentos.

Abrindo o Gerenciador de Tarefas do Windows, na aba Processos, percebo que existem vários processos do Postgre executando.

Se fechei todas as conexoes, porque esses processos continuam abertos? Como faço para isso não ocorrer?

Antecipadamente agradeço a ajuda de todos.

Valew

#2

Tem como você mostrar um pouco do seu código??

Isso geralmente acontece quando as conexões não são fechadas corretamente…

#3

_Renatu

Minha classe DAO está da seguinte maneira

public class DAO {
	
	Connection conexao;
	
public DAO (){		
		try {
			Class.forName("org.postgresql.Driver");
		} catch (ClassNotFoundException e) {
			System.err.println(e.getMessage());
		}
		try {
			conexao = DriverManager.getConnection("jdbc:postgresql://localhost:5432/Livros?user=PAULOHENRIQUE&password=12503869");
		} catch (SQLException e) {
			System.err.println(e.getMessage());
		}
		
	}
/*
*Aqui vem os diversos métodos que o DAO executa, inserções, 
*selects para serem usados para popular combos etc...
*/

public static void fecharConexao (DAO dao){
	try {
		dao.conexao.close();
	} catch (SQLException e) {
		System.err.println(e.getMessage());
	}
	dao.conexao = null;
}
}

Toda vez que utilizo o DAO faço o seguinte:

DAO d = new DAO();
//d.zzzz... utilizo o DAO para as tarefas que nessecito
DAO.fecharConexao(d);

Se puder me ajudar com esse problema agradeço.

#4

Por que um construtor para a conexão e um método estático COM PARÂMETRO para seu fechamento?

Teoricamente posso usar o seguinte código que estaria correto:

DAO dao1 = new DAO();
DAO dao2 = new DAO();
DAO dao3 = new DAO();

// operações

dao2.fechaConexao(dao3);
dao1.fechaConexao(dao2);
dao3.fechaConexao(dao1);

Meio estranho não é?

Um código mais proveitoso e que pode lhe ajudar no seu problema seria:

public class BancoDeDadosDAO
  {
   Connection conexao;

   public BancoDeDadosDAO()
     {
      try
        {
         Class.forName("org.postgresql.Driver");
         conexao = DriverManager.getConnection("jdbc:postgresql://localhost:5432/Livros?user=PAULOHENRIQUE&password=12503869");
        }
      catch(ClassNotFoundException e)
        { System.err.println(e.getMessage()); }
      catch (SQLException e)
        { System.err.println(e.getMessage()); }
     }

// Aqui vem os diversos métodos que o DAO executa, inserções, 
// selects para serem usados para popular combos etc...
 
   public void fecharConexao()
     {
      try
        { conexao.close(); }
      catch (SQLException e)
        { System.err.println(e.getMessage()); }
      finally
        { conexao = null; }
     }
  }
#5

Uma coisa que torna o acesso ao banco de dados extremamente lento é ficar com esse abre, fecha, abre, fecha de conexões. O interessante seria você criar um pool de conexões, onde seriam abertas várias conexões (você pode configurar esse número) e sempre que um DAO precisasse de uma conexão ele pegaria uma já aberta no pool, através, por exemplo, de um método estático.
Com isso ganha-se muito tempo e suas transações ficam bem mais rápidas. Para implementar seu pool você pode usar o DBCP, o C3PO, entre outros.

#6

Valew pessoal… vou tentar utilizar essas dicas.

Mas independente de ser a melhor maneira, eu estou fechando as conexões corretamente não estou? Não deveria ficar vários processos abertos certo?

Mesmo assim valew pelas dicas…

#7

O PostgreSQL, em Windows, cria um processo para cada conexão, mas ele não o derruba imediatamente após encerrar a conexão, para evitar o grande overhead resultante de iniciar um processo para atender a conexão.

#8

Então nesse caso seria melhor se abrisse uma conexão quando iniciar a execução do programa e deixar ela aberta? só fechar quando encerrasse o programa?

#9