Considerando que meu sistema não vai ter muitos acessos simultâneos (o que acho que descarta a estratégia de usar pool de conexões), qual é a melhor estrutura?
Cada DAO deve ter uma conexão com o banco? Ou devo usar uma única conexão para todos os acessos (conexão singleton)?
Ou cada método das DAOs vai fazer a própria conexão?
Como decidir isso?
Obrigado desde já!
oi,
se o seu sistema vai ter muitas conexões é uma boa idéia você usar um pool de conexões e não um singleton, que servidor você vai usar??
abs
bom, se for especifico ja pensou em usar o Hibernate(eu pessoalmente nao gosto) ?..Ou pode criar um DAO mesmo com pool (usa o gerenciador de pool da apache é muito bom), simples e rapido…cria uma interface pra sua regra de negocio e pronto…
abs
[quote=André Fonseca]oi,
se o seu sistema vai ter muitas conexões é uma boa idéia você usar um pool de conexões e não um singleton, que servidor você vai usar??
abs[/quote]
Então, é um sistema bem particular, não vai ter muitos acessos.
Pretendo usar o Tomcat.
[quote=guilhermevh]bom, se for especifico ja pensou em usar o Hibernate(eu pessoalmente nao gosto) ?..Ou pode criar um DAO mesmo com pool (usa o gerenciador de pool da apache é muito bom), simples e rapido…cria uma interface pra sua regra de negocio e pronto…
abs[/quote]
Pois é, já pensei no Hibernate, mas não quero usá-lo agora. É meu primeiro sistema web e queria aprender primeiro como as coisas funcionam, sem usar frameworks e seus arquivos de configuração. Além disso, já tenho muito código implementado com JDBC.
O pool não seria um exagero para um sistema bem particular com poucos acessos?
pode ser um DAO sem pool…mas isso vai pra aprendizado também, estou fazendo o meu TCC para a faculdade, se eu tivesse feito esse modulo antes, ao invés de sempre fazer um sisteminha de conexão para cada projeto e tal acho que teria rendido mais…não sei…mas acho que se você está com essa dúvida acredito que você queria uma coisa bem feita :D…
Oi Leandro,
Desculpe, eu achei que o seu sistema iria ter muitos acessos. No seu caso eu também acho mais fácil você ter uma classe que gera a conexão e DAO´s específicos de cada objeto.
Algo assim
[code]class FabricaConexoes {
private Connection con;
public static Connection getConexao() {
if (connection = null) {
return DriverManager.getConnection(“url”,“senha”,“password”);
}
else {
return conn;
}
}
}
MeuObjetoDao {
private Connection conn = FabricaConexoes.getConexao()
}
[/code]
pode ser um DAO sem pool…mas isso vai pra aprendizado também, estou fazendo o meu TCC para a faculdade, se eu tivesse feito esse modulo antes, ao invés de sempre fazer um sisteminha de conexão para cada projeto e tal acho que teria rendido mais…não sei…mas acho que se você está com essa dúvida acredito que você queria uma coisa bem feita :D…[/quote]
Eu realmente quero uma coisa bem feita rs
Mas “bem feito” pra mim, nesse caso, é a melhor solução em termos de desempenho e manutenção. Como o sistema é pequeno, acho que não compensaria usar um pool de conexões. Eu nunca fiz um na verdade, mas IMAGINO que não seja a solução mais “light” né…
[quote=André Fonseca]Oi Leandro,
Desculpe, eu achei que o seu sistema iria ter muitos acessos. No seu caso eu também acho mais fácil você ter uma classe que gera a conexão e DAO´s específicos de cada objeto.
Algo assim
[code]class FabricaConexoes {
private Connection con;
public static Connection getConexao() {
if (connection = null) {
return DriverManager.getConnection(“url”,“senha”,“password”);
}
else {
return conn;
}
}
}
MeuObjetoDao {
private Connection conn = FabricaConexoes.getConexao()
}
[/code][/quote]
Acho que vou fazer algo tipo isso mesmo. Fiquei em dúvida se seria melhor usar uma única conexão (singleton) ou criar uma conexão para cada acesso ao banco. Eu não sei se criar uma para cada acesso é um processo custoso, mas como não vão ter muitos acessos, acho que questão de desempenho aqui não seria crítico.
[quote=leandrocm86]Considerando que meu sistema não vai ter muitos acessos simultâneos (o que acho que descarta a estratégia de usar pool de conexões), qual é a melhor estrutura?
Cada DAO deve ter uma conexão com o banco? Ou devo usar uma única conexão para todos os acessos (conexão singleton)?
Ou cada método das DAOs vai fazer a própria conexão?
Como decidir isso?
Obrigado desde já![/quote]
Conexão singleton não existe. Se fizer isso vai-se dar mal.
Use um DataSource que é uma interface padrão do JDBC para obter suas conexões. Implemente o seu ou use o que o driver do seu banco disponibiliza. Deixe ele gerenciar as conexões como ele quiser.
Quem precisar de uma conexão obtém-a do DataSource.
Não se esqueça que todo o acesso deve ser tranacional e a coneção sempre deve ser fechada após o fim da transação invocando connection.close().
[quote=sergiotaborda]
Conexão singleton não existe. Se fizer isso vai-se dar mal.
Use um DataSource que é uma interface padrão do JDBC para obter suas conexões. Implemente o seu ou use o que o driver do seu banco disponibiliza. Deixe ele gerenciar as conexões como ele quiser.
Quem precisar de uma conexão obtém-a do DataSource.
Não se esqueça que todo o acesso deve ser tranacional e a coneção sempre deve ser fechada após o fim da transação invocando connection.close(). [/quote]
:?: “Deixe ele gerenciar as conexão como ele quiser”.Que estratégias de uma exceção gerada pela JVM, eu posso adotar em caso o o servidor esteja fora do ar.
:arrow:Situação, Java.io.FileNotFoundException must be caught, or it must be declared int the throws clause of this method ???
[quote=Marcio Duran][quote=sergiotaborda]
Conexão singleton não existe. Se fizer isso vai-se dar mal.
Use um DataSource que é uma interface padrão do JDBC para obter suas conexões. Implemente o seu ou use o que o driver do seu banco disponibiliza. Deixe ele gerenciar as conexões como ele quiser.
Quem precisar de uma conexão obtém-a do DataSource.
Não se esqueça que todo o acesso deve ser tranacional e a coneção sempre deve ser fechada após o fim da transação invocando connection.close(). [/quote]
:?: “Deixe ele gerenciar as conexão como ele quiser”.Que estratégias de uma exceção gerada pela JVM, eu posso adotar em caso o o servidor esteja fora do ar.
:arrow:Situação, Java.io.FileNotFoundException must be caught, or it must be declared int the throws clause of this method ???[/quote]
Vc nunca usou o DataSource, certo ?
O dataSource tem um método getConnection que lança SQLExceptino quando algo dá errado. É essa exceção que vc tem que tratar.
Apenas essa. Não tem relação com FileNotFoundException
Oi Leandro
Se você vai usar o Tomcat eu sugiro você usar o próprio pool dele, não é difícil e vale a pena aprender, dá uma olhada aqui qualquer coisa posta no tópico
Abs
[quote=sergiotaborda]
Vc nunca usou o DataSource, certo ?
O dataSource tem um método getConnection que lança SQLExceptino quando algo dá errado. É essa exceção que vc tem que tratar.
Apenas essa. Não tem relação com FileNotFoundException [/quote]
O pacote java.io contém classes que facilitam o armazenamento e a recuperação de informações de um determinado dispositivo, que pode ser a memória, disco ou a rede.
:arrow: Java.io.FileNotFoundException, essa excecção poderia vir a ser gerada por situações que não fosse diretamenta relacionada a dataSource, entretanto poderia ser um agente externo ou físico, então eu fiz essa suposição por considerar outras variáveis.
[size=18]; )[/size]
Pronto, já implementei. Acho que ficou bem simples e clean, do jeito que eu precisava.
André, achei melhor não mexer com o pool pelo menos por enquanto, porque a aplicação será realmente simples, poucos acessos.
A estrutura foi a seguinte:
Classe DAO abstrata:
public abstract class DAO
{
private static String url;
private static String username;
private static String password;
private static String driver;
private static Boolean dadosNull = true;
protected DAO()
{
if(dadosNull)
{
url = "jdbc:mysql://localhost:3306/panacea";
username = "root";
password = "root123";
driver = "com.mysql.jdbc.Driver";
dadosNull = false;
try
{
Class.forName(driver);
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
}
}
protected Connection getConnection() throws SQLException
{
return DriverManager.getConnection(url, username, password);
}
}Para cada entidade do domínio haverá uma classe de persistência correspondente que extende DAO.
Os métodos das subclasses DAO que farão as conexões (uma em cada chamada de método), invocando o getConnection da superclasse, sendo que esses métodos também ficam responsáveis por fechar posteriormente as conexões.
Em resumo: Uma conexão para cada acesso ao banco, com os dados do banco encapsulados numa superclasse e setados somente na primeira vez que uma subclasse for instanciada. Futuramente esses dados serão carregados por um arquivo properties.
O que acharam?
você poderia utilizar o IBATIS para não escrever tanto código da API JDBC. utilize-o em conjunto com o Spring.
Você está utilizando um container, portanto, utilize um dataSource do container e não se preocupe como ele implementa um pool.
Deixe o tomcat resolver isso pra você.
Além do que, criar um dataSource no tomcat é simples e rápido.
[]'s
Leandro,
Para utilizar o pool de conexões do tomcat
Altere o arquivo context.xml do diretório /conf onde está instalado o Tomcat para adicionar uma linha semelhante a que está abaixo:
Você poderia colocar um context.xml apenas no META-INF da aplicação, neste caso o pool seria disponivel apenas para a aplicação, no caso acima todas as aplicações no webapps podem usar o pool
No caso acima eu coloquei os parâmetros para oracle
Para usar basta fazer assim
String nome = request.getParamenter("nome");
InitialContext ctx = new InitialContext();
DataSource db = (DataSource)ctx.lookup("java:comp/env/jdbc/banco");
Connection conn = db.getConnection();
Statement stm = conn.createStatement();
stm.executeUpdate("update meubanco.minha_tabela set nome='"+nome+"' where idade=32");
Entendeu? qualquer dúvida posta aqui
Abs