o galera... um exemplo ai de como conectar a banco de dados...
bem simples e seguro...
vlw
seguinte... coloquei em 2 partes...
uma classe main... que faz uso do banco de dados: MainConcetar.class
e outra que é o objeto que se conecta: Conectar.class
[img]http://www.portaljava.com.br/home/images/tutoriais/jdbcanotherx/Conectar.class.gif[/img]
ai embaixo segue o código fonte das 2 ... é bom ler antes a de conectar
package com.pw.sql;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.DriverManager;
/**
* Created 03/03/2004
* Própriedade intelectual de ProducaoWeb.com ®.
*
* @author Tomaz Lavieri
* @version 1.0
*/
public class Conectar{
/**
* Variavel que guarda sua conexão
*/
private Connection con = null;
/**
* variavel que guarda o statement da conexão.
*/
private Statement stmt = null;
/**
* variavel que guarda o ponteiro dos registros.
*/
private ResultSet rs = null;
/**
* variavel que guarda a string sql
* "SELECT * FROM Tabela1" por exemplo pode ser usado.
*/
private String sql = "";
/**
* variavel que guarda o nome do usuário que acessa o banco.
*/
private String user = "";
/**
* variavel que guarda o password para acessar o banco de dados.
*/
private String pass = "";
/**
* url para se concetar ao banco de dados.... vamos usar de
* "jdbc:odbc:meuBD" por exemplo pode ser usado.
*/
private String url = null;
/**
* nome da classe que contém os drivres para se contectar ao DB
* ... por exemplo "sun.jdbc.odbc.JdbcOdbcDriver"
*/
private String drive = null;
/**
* Cria um objeto concatar.
* @param drive nome da classe que contem o drive para se conectar ao DB
* @param url para se conectar ao banco.
*/
public EasyConnection(String drive,String url) {
this.setUrl(url);
this.setDriveClassName(drive);
}
public EasyConnection(String drive,String url,String sql) {
this(drive,url);
this.setSQLQuery(sql);
}
/**
* Cria um objeto concatar.
* @param drive nome da classe que contem o drive para se conectar ao DB
* @param url para se conectar ao banco.
* @param user quer concetase ao banco
* @param pass de acesso ao banco de dados.
*/
public EasyConnection(String drive,String url, String user, String pass) {
this(drive,url);
this.setUser(url);
this.setPassword(pass);
}
/**
* Cria um objeto concatar.
* @param drive nome da classe que contem o drive para se conectar ao DB
* @param url para se conectar ao banco.
* @param user quer concetase ao banco
* @param pass de acesso ao banco de dados.
* @param sql string para para selecionar algo no banco.
*/
public EasyConnection(String drive,String url, String user, String pass,String sql) {
this(drive,url,user,pass);
this.setSQLQuery(sql);
}
/**
* busca a Query string SQL de conexão com o DB
* @return Query string SQL de conexão com o DB
*/
public String getSQLQuery() {
return this.sql;
}
/**
* ajusto a Query string SQL de conexão com o DB
* @param sql SQL String de conxeão.
*/
public void setSQLQuery(String sql) {
this.sql = sql;
}
/**
* URL que conecta ao banco de dados. Neste caso especifico
* um banco odbc... que pode ser um access seta na sua makina.
* @return a url para se conectar ao banco.
*/
private String getUrl() {
return url;
}
/**
* ajusta a url para conectar ao banco de dados.
* @param url retorna a url para se conectar ao banco de dados
*/
public void setUrl(String url) {
this.url = url;
}
/**
* Busca o Usuário que se conecta ao banco de dados. para maior
* segurança este método é privado, nao podendo ser acessada
* de fora o usuario, sendo apenas modificada através de
* setUser(user);
* @return Usuário que se conecta ao banco de dados.
*/
private String getUser() {
return user;
}
/**
* Ajusta o usuário do banco de dados.
* @param user nome do usuário.
*/
public void setUser(String user) {
/* ajuta o valor do novo usuário
*/
this.user = user;
}
/**
* Busca a Senha que se conecta ao banco de dados. para maior
* segurança este método é privado, nao podendo ser acessada
* de fora a senha, sendo apenas modificada através de
* setPassword(password)
* @return Senha que se conecta ao banco de dados.
*/
private String getPassword() {
return pass;
}
/**
* Ajusta a senha para acessar o banco de dados.
* @param pass nova senha.
*/
public void setPassword(String pass) {
this.pass = pass;
}
/**
* Busca o nome da classe que contém o drive para o banco de
* dados em uso. no nosso caso... está classe vem no pacote
* da sun... q é pra conectar ao Microsoft Access e outros
* ODBC.
* @return nome da classe que contém o drive para o banco de
* dados em uso
*/
private String getDriveClassName() {
return this.drive;
}
private void setDriveClassName(String driveClass) {
this.drive = driveClass;
}
/**
* Busca a conexão com o banco de dados. faz isso de forma
* segunra e só quando é xamado pela primeira vez q conecta
* ao banco. sendo assim, só ira gastar a memoria qunado for
* xamado. note que antes de se conectar ao banco... ele
* testa se a conexão já foi chamada... note também que o
* drive é carregado antes de cahamar a conexão.
* @return conexão com o banco de dados
* @throws SQLException lança uma exceção caso não consiga se
* conectar ao banco de daos - pois, quem fez o menino que o
* embale... (a exceçao deve ser tratada mais aceima).
*/
private java.sql.Connection getCon() throws SQLException
{
/* aqui ele testa se a conexão já esta criada, caso ela
* ainda não tenha sido estabelecida a conexão é iniciada
* e após o procedimento é retornada a conexão.
*/
if (con == null)
{
try
{
/* antes de tentar fazer a conexão com o banco de dados
* vc deve se carregar (ou instanciar) o drive do banco
* de dados.
*/
Class.forName(getDriveClassName()).newInstance();
/* a exceção aqui ocorre no caso da classe não ser incontrada
* para o caso da classe ser encontra e la não poder ser
* instanciada (isso ocorre se a classe for uma interface,
* ou for abstrata.)
*/
} catch (Exception ex) {ex.printStackTrace();}
/* bom aqui a conexão é estabelicada, através da url onde
* está localizado o banco de dados... a maneira de declarar
* a url vai variar de acordo com cada banco de dados.
* quase todos os exemplo mostram links na url... se vc já
* viu varios e não sabe como fazer para uma aplicação local
* é só trocar o nome da pagina por localhost ou por 127.0.0.1
*/
con = DriverManager.getConnection (getUrl(), getUser(), getPassword());
}
/* retorna a conexão com o banco de dados.
*/
return con;
}
/**
* Semelhante ao método getCon(), diferendo apenas
* pelo fato desta conexão não ficar guardada dentro do objeto,
* e por ser publica, pois o seu uso fora do objeto não emplica
* em possiveis erros dentro da classe.
* @return uma nova instancia da conexão
* @throws SQLException lança uma exceção caso não consiga se
* conectar ao banco de daos - pois, quem fez o menino que o
* embale... (a exceçao deve ser tratada mais aceima).
*/
public Connection getConNew() throws SQLException
{
try
{
/* antes de tentar fazer a conexão com o banco de dados
* vc deve se carregar (ou instanciar) o drive do banco
* de dados.
*/
Class.forName(getDriveClassName()).newInstance();
/* a exceção aqui ocorre no caso da classe não ser incontrada
* para o caso da classe ser encontra e la não poder ser
* instanciada (isso ocorre se a classe for uma interface,
* ou for abstrata.)
*/
} catch (Exception ex) {ex.printStackTrace();}
/* bom aqui a conexão é estabelicada, através da url onde
* está localizado o banco de dados... a maneira de declarar
* a url vai variar de acordo com cada banco de dados.
* quase todos os exemplo mostram links na url... se vc já
* viu varios e não sabe como fazer para uma aplicação local
* é só trocar o nome da pagina por localhost ou por 127.0.0.1
*/
return DriverManager.getConnection (getUrl(), getUser(), getPassword());
}
/**
* reinicia a conexão com o banco de dados, fechando a conexão.
* fechando-a, está só sera reaberta novamente quando o método
* getCon() for chamado.
* @throws SQLException gerada quando ocorrer algum problema ao
* tentar fechar a conexão.
*/
public void reSetCon() throws SQLException
{
/* testa se a conexão está nula, pois neste caso não há
* necessidade de fechala. Se ela estiver aberte, procede
* com o fechamento da conexão.
* note que diferente dos outros métodos, este não chama
* a conexão através de getCon().
* pois este método irá iniciar a conexão caso ela não
* esteja aberta... e nossa intenção é fechala
*/
if (con != null)
{
/* tenta fechar o statement antes de fechar a conexão.
*/
reSetStatement();
/* tenta fehcar a conexão, o que pode lançar uma
* exceção do tipo SQLException. note que esta
* exceção não está sendo tratada aki, por isso
* elta é lançada para cima. através da declaração
* que está no método throws SQLException.
*/
con.close();
/* só atribui o valor nulo a conexão no caso de ter
* conseguido fechar a conexão.
* sendo assim, garante que o método getCon() irá
* iniciar nova conexão quando for chamado.
*/
con = null;
}
}
/**
* Busca a Statement com a conexão. faz isso de forma segunra
* e só quando é xamado pela primeira vez q conecta ao banco.
* sendo assim, só ira gastar a memoria qunado for xamado. note
* que antes de se criar o Stament ... ele testa já não foi
* criado antes...
* @return Stamtement da conexão.
* @throws SQLException lança uma exceção caso não consiga se
* conectar ao banco de daos - pois, quem fez o menino que o
* embale... (a exceçao deve ser tratada mais aceima).
*/
private java.sql.Statement getStatement() throws SQLException
{
/* verifica inicialmente se o statemet ainda não está criado.
*/
if (stmt == null)
/* cria o statemnt e guarda na variavel do objeto stmt
*/
stmt = getCon().createStatement();
/*
* retorna o statement criado.
*/
return stmt;
}
/**
* Semelhante ao método getStatementNew(),
* diferenciando apenas pelo fato deste Statement
* não ficar guardada dentro do objeto, e por ser publica
* ,pois o seu uso fora do objeto não emplica em possiveis
* erros dentro da classe.
* @return Stamtement da conexão.
* @throws SQLException lança uma exceção caso não consiga se
* conectar ao banco de daos - pois, quem fez o menino que o
* embale... (a exceçao deve ser tratada mais aceima).
*/
private Statement getStatementNew() throws SQLException
{
/* retorna o statement criado.
*/
return getConNew().createStatement();
}
private void reSetStatement() throws SQLException
{
/* testa se o statement está nulo, pois neste caso não há
* necessidade de fechalo. Se ele estiver aberto, procede
* com o fechamento.
* note que diferente dos outros métodos, este não chama
* o statement através do getStatement().
* pois este método irá inicia-lo caso ele não esteja
* aberta... e nossa intenção é fecha-lo.
*/
if (stmt != null)
{
/* tenta fechar o resultSet antes de fechar o statement.
*/
reSetResultSet();
/* tenta fehcar, o que pode lançar uma
* exceção do tipo SQLException. note que esta
* exceção não está sendo tratada aki, por isso
* elta é lançada para cima. através da declaração
* que está no método throws SQLException.
*/
stmt.close();
/* só atribui o valor nulo ao Statement no caso de
* ter conseguido fechar a conexão.
* sendo assim, garante que o método getStatement()
* irá iniciar um novo quando for chamado.
*/
stmt = null;
}
}
/**
* Busca o ResultSet para um select especifico. faz isso de
* forma segunra e só quando é xamado pela primeira vez q
* conecta ao banco. sendo assim, só ira gastar a memoria
* qunado for xamado. note que antes de se criar o ResultSet
* ... ele testa já não foi criado antes...
* @return ResultSet da conexão.
* @throws SQLException lança uma exceção caso não consiga se
* conectar ao banco de daos - pois, quem fez o menino que o
* embale... (a exceçao deve ser tratada mais aceima).
*/
public java.sql.ResultSet getResultSet() throws SQLException
{
/* verifica se o resultset ainda está em branco.
*/
if (rs == null) {
/* cria um resulset para a query que esta em getSQLQuery
* e guarda ele na variavel rs.
*/
rs = getStatement().executeQuery(getSQLQuery());
}
/* retorna o resultset que está na veriavel rs.
*/
return rs;
}
/**
* Semelhante ao método getResultSet(),
* diferenciando apenas pelo fato deste Statement
* não ficar guardada dentro do objeto, e por ser publica
* ,pois o seu uso fora do objeto não emplica em possiveis
* erros dentro da classe.
* @return ResultSet da conexão.
* @throws SQLException lança uma exceção caso não consiga se
* conectar ao banco de daos - pois, quem fez o menino que o
* embale... (a exceçao deve ser tratada mais aceima).
*/
public ResultSet getResultSetNew() throws SQLException
{
/* cria um resulset para a query que esta em getSQLQuery.
*/
return getStatementNew().executeQuery(getSQLQuery());
}
public void reSetResultSet() throws SQLException
{
/* testa se o ResultSet está nulo, pois neste caso não há
* necessidade de fechala. Se ela estiver aberto, procede
* com o fechamento.
* note que diferente dos outros métodos, este não chama
* a conexão através de getResultSet().
* pois este método irá iniciar caso ele não
* esteja aberta... e nossa intenção é fechala
*/
if (rs != null)
{
/* tenta fehcar, o que pode lançar uma
* exceção do tipo SQLException. note que esta
* exceção não está sendo tratada aki, por isso
* elta é lançada para cima. através da declaração
* que está no método throws SQLException.
*/
rs.close();
/* só atribui o valor nulo a conexão no caso de ter
* conseguido fechar a conexão.
* sendo assim, garante que o método getResultSet() irá
* iniciar um novo quando for chamado.
*/
rs = null;
}
}
/**
* fecha todas os objetos abertos.
* @throws SQLException
*/
public void close() throws SQLException{
SQLException closeException = null;
if (rs != null) try {
rs.close();
rs = null;
} catch (SQLException ex) {
closeException = ex;
}
if (stmt != null) try {
stmt.close();
stmt = null;
} catch (SQLException ex) {
if (ex == null) closeException = ex;
else closeException.setNextException(ex);
}
if (con != null) try {
con.close();
con = null;
} catch (SQLException ex) {
if (ex == null) closeException = ex;
else closeException.setNextException(ex);
}
if (closeException != null) throw closeException;
}
/*
* bom c vc querem saber como ir pegando linhas apos linha do
* para pegar a proxima linha
* getResultSet().next();
* isto deve estar dentro de um try{} catch (SQLException) {}
* pois pode lançar uma exceção sql
*
* par pegar um campo especifico.
* getResultSet().getInt("nomeDoCampoInteiro");
* para o caso de um campo do tipo inteiro q tem o nome
* nomeDoCampoInteiro. para outros tipo de campos
* é só seguir o padrão... .getString();
* e assim vai...
*
*/
}
/**
* Created 04/03/2004
* Própriedade intelectual de ProducaoWeb.com ®.
*
* @author Tomaz Lavieri
* @version 1.0
*/
public class MainConcetar {
public static void main(String args[]) {
Conectar meuConector = new Conectar("sun.jdbc.odbc.JdbcOdbcDriver","jdbc:odbc:meuBD","SELECT codigo,nome,idade FROM Tabela1");
try {
/* função .next() de um resultSet retorna verdadeiro se existir
* um registro seguinte e falso caso tenham acabados os registros.
* ou seja... ele vai imprimir as linhas ate não haver mais
* registros.
*/
int i = 0;
while (meuConector.getResultSet().next()) {
i++;
/* o método .getInt(nomeDoCampoDaTabela) retorna o número
* inteiro de um campo tipo número do resultSet
*/
int codigo = meuConector.getResultSet().getInt("codigo");
/* o método .getString(nomeDoCampoDaTabela) retorna a String
* de um campo tipo String do resultSet
*/
String nome = meuConector.getResultSet().getString("nome");
int idade = meuConector.getResultSet().getInt("idade");
//aqui eu imprimo cada linha até o o resultset acabar
System.out.println("Linha "+ i +": codigo = " + codigo + ", nome = " + nome + ", idade = " + idade);
}
/* aki eu retorno o resultSet para o inicio das linhas...
* para otras pessoas poderem usa-lo
*/
meuConector.getResultSet().beforeFirst();
// =======================================================
/* ajusto uma nova String sql... para se conectar ao banco
*/
meuConector.setSQLQuery("SELECT email FROM Tabela1");
//aqui eu passo para primeira linha
meuConector.getResultSet().next();
/* porém note q aqui não há o resultado esperado
* pq o resultset continua aberto para a string sql
* setada ao criar o objeto... então... antes de
* usar o resultset com uma nova sql... vc deve
* resetar o resultset
*/
meuConector.reSetResultSet();
//agora sim... vc poderá usar o novo resultSet
while(meuConector.getResultSet().next()) {
System.out.println(meuConector.getResultSet().getString("email"));
}
meuConector.getResultSet().beforeFirst();
// =======================================================
meuConector.setSQLQuery("SELECT endereco FROM Tabela1");
/* novamente está sendo setado nova sql...
* mas o resultSet guardado la dentro continua valendo
*/
java.sql.ResultSet rs = meuConector.getResultSetNew();
/* como eu pedi um novo resultSet este saira com a
* nova sql string, a q conté o "endereco".
* e ela não modifica o result set que está dentro
* do conector.
* sendo assim...
*/
meuConector.getResultSet().next();
/* continua usando a sql lá do e-mail
* "SELECT email FROM Tabela1"
* e não a mais nova
* "SELECT endereco FROM Tabela1"
* pois o resultSet não foi resetado
*/
//prém
rs.next();
/* vai usar a sql
* "SELECT endereco FROM Tabela1",
* pois foi definido com getResultSetNew()
*/
// trata a exceção
} catch (java.sql.SQLException ex) {
//imprime a exceção
ex.printStackTrace();
} finally {
//acabou de usar... guarde
try {
meuConector.close();
} catch (java.sql.SQLException ex) {}
meuConector = null;
}
}
}
