Sobre classe conexão

package locadora;

/**
 *
 * @author 
 */


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.
     */
    Conectar(){
    }
    Conectar(String Sql){
      /**
     * Cria um objeto Conectar.
     * @O driver é padrão do sistema ("sun.jdbc.odbc.JdbcOdbcDriver")
     * @E a Url tambem ("jdbc:odbc:Locadora") 
     * @Banco Access
     */
        this.setUrl("jdbc:odbc:Locadora"); // padrao do sistema Locadora
        this.setDriveClassName("sun.jdbc.odbc.JdbcOdbcDriver"); // padrao do sistema Locadora
        this.setSQLQuery(Sql);
        //this.setUser(""); nao contem usuario
        //this.setPassword(Pass); nao contem password
    }
    Conectar(String Drive,String url){
        this.setUrl(url);
        this.setDriveClassName(Drive);
    }
    Conectar(String Drive,String Url,String Sql){
        this.setDriveClassName(Drive);
        this.setUrl(Url);
        this.setSQLQuery(Sql);
    }
    Conectar(String Drive,String Url ,String User, String Pass){
        this.setDriveClassName(Drive);
        this.setUrl(Url);
        this.setUser(User);
        this.setPassword(Pass);
    }
    Conectar(String Drive,String Url ,String User, String Pass,String Sql){
        this.setDriveClassName(Drive);
        this.setUrl(Url);
        this.setUser(User);
        this.setPassword(Pass);
        this.setSQLQuery(sql);
    }

    public void EasyConnection(String Drive,String Url) {
        this.setUrl(Url);
        this.setDriveClassName(Drive);
    }
    public void EasyConnection(String Drive,String Url,String Sql) {
        this.setDriveClassName(Drive);
        this.setUrl(Url);
        this.setSQLQuery(Sql);
    }
    public void EasyConnection(String Drive,String Url, String User, String Pass) {
        this.setDriveClassName(Drive);
        this.setUrl(Url);
        this.setUser(User);
        this.setPassword(Pass);
    }
    public void EasyConnection(String Drive,String Url, String User, String Pass,String Sql) {
        this.setDriveClassName(Drive);
        this.setUrl(Url);
        this.setUser(User);
        this.setPassword(Pass);
        this.setSQLQuery(Sql);
    }
    public void EasyConnection(String Sql) {
     /**
     * Cria um objeto Conectar.
     * @O driver é padrão do sistema ("sun.jdbc.odbc.JdbcOdbcDriver")
     * @E a Url tambem ("jdbc:odbc:Locadora") 
     * @Banco Access
     */
        this.setUrl("jdbc:odbc:Locadora"); // padrao do sistema Locadora
        this.setSQLQuery(Sql);
        this.setDriveClassName("sun.jdbc.odbc.JdbcOdbcDriver"); // padrao do sistema Locadora
        //this.setUser(""); nao contem usuario
        //this.setPassword(Pass); nao contem password

    }

    public void setSQLQuery(String Sql) {
      this.sql = Sql;
    }
    public void setUrl(String Url) {
        this.url = Url;
    }
    public void setUser(String User) {
      this.user = User;
    }
    public void setPassword(String Passw) {
      this.pass = Passw;
    }
    public void setDriveClassName(String driveClass) {
        this.drive = driveClass;
    }


    private String getUrl() {
      return url;
    }
    private String getDrive() {
      return drive;
    }
    public String getSQLQuery() {
      return this.sql;
    }
    private String getUser() {
      return user;
    }
    private String getPassword() {
      return pass;
    }
    private String getDriveClassName() {
      return this.drive;
    }


    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...
     *
     */
}