Conexión JDBC usando diferentes archivos

Question

Antes que nada, lamento el nombre del título, pero no sé cómo poner otro porque el inglés no es mi lengua materna.

Tengo el siguiente método para conectarse a una base de datos:

import java.sql.DriverManager; 
import java.sql.Connection; 
import java.sql.SQLException; 

public class PgConnect { 
    public void connect() { 
     Connection connection = null; 
     try { 
      connection = DriverManager.getConnection("jdbc:postgresql://pgserver:5432/db", "test","test123"); 
     } catch (SQLException e) { 
      System.out.println("Connection Failed! Check output console"); 
      e.printStackTrace(); 
      return; 
     } 
     if (connection != null) { 
      System.out.println("Connection working"); 
     } else { 
      System.out.println("Failed to make connection!"); 
     } 
    } 
} 

Y lo que hay que hacer es incluir el método de la PgConnect en el código de abajo. Básicamente lo necesito porque tengo muchos tipos de llamadas de SQL a la base de datos, y cambiarlas de esa manera sería fácil de mantener, ya que las credenciales/host estarían en un solo archivo.

creo que el cambio debería estar donde tengo el comentario

// i want to change this, for using the method on the first file. 

Por favor, corríjanme si me equivoco.

import java.sql.DriverManager; 
import java.sql.Connection; 
import java.sql.ResultSet; 
import java.sql.SQLException; 
import java.sql.Statement; 

public class ReturnResults { 

    public static void main(String[] args) { 
     Connection connection = null; 
     try { 
       // i want to change this, for using the method on the first file. 
      connection = DriverManager.getConnection("jdbc:postgresql://pgserver:5432/db", "test","test123"); 

     } catch (SQLException e) { 
      System.out.println("Connection Failed! Check output console"); 
      e.printStackTrace(); 
      return; 
     } 
     if (connection != null) { 

      String result = null; 
      String selectString = "select * from mwp.servers where env='TEST' order by server"; 
      //result ="iServer\tLabel\n"; 

      try { 

       Statement stmt = connection.createStatement(); 
       ResultSet rs = stmt.executeQuery(selectString); 

       while (rs.next()) { 

        String iEnv  = rs.getString("env"); 
        String iServer = rs.getString("iserver"); 
        String iLabel = rs.getString("label"); 
        String iTitle = rs.getString("title"); 
        String iLogin = rs.getString("login"); 

        result=iEnv+"\t"+ iServer+"\t"+iLabel+"\t"+iTitle+"\t"+iLogin; 

        System.out.println(result); 
       } 
       stmt.close(); 
       connection.close(); 

      } catch(SQLException ex) { 
       System.err.println("SQLException: " + ex.getMessage()); 
      } 

     } else { 
      System.out.println("Failed to make connection!"); 
     } 
    } 
} 

Sé cómo hacer esto en Perl, pero no tengo ninguna práctica en Java.

Answer 1

Una forma de ocultar las credenciales estaría haciendo connect una función estática regresar Connection, así:

public class PgConnect { 
    public static Connection connect() throws SQLException { 
    try { 
     Connection res = DriverManager.getConnection("jdbc:postgresql://pgserver:5432/db", "test","test123"); 
     if (res != null) { 
      System.out.println("Connection working"); 
     } else { 
      System.out.println("Failed to make connection!"); 
     } 
     return res; 
    } catch (SQLException e) { 
     System.out.println("Connection Failed! Check output console"); 
     e.printStackTrace(); 
     throw e; 
    } 
} 

}

A continuación, puede utilizar de esta manera:

try { 
    connection = PgConnect.connect(); 
} catch (SQLException e) { 
    System.out.println("Connection Failed! Check output console"); 
    e.printStackTrace(); 
    return; 
} 

Answer 2

Haga su connect() método static y luego se le puede llamar como esto

Connection con = PgConnect.connect(); 

también editar la forma de conectarse a Connection, porque hay que volver Connection no void.

public static Connection connect() throws SQLException { 
    try { 
     Connection con = DriverManager.getConnection("jdbc:postgresql://pgserver:5432/db", "test","test123"); 
     // ... 
     return con; 
    } 
    catch (SQLException e) { 
     e.printStackTrace(); 
     return null; 
    } 

También hay otro enfoque más limpio. Aquí hay un ejemplo de mi viejo proyecto.

private static DataSource getOracleDBConnection() throws NamingException { 
     Context c = new InitialContext(); 
     return (DataSource) c.lookup("java:comp/env/OracleDBConnection"); 
    } 

    public static Connection getOracleDatabaseConnection() { 

     Connection conn = null; 
     try { 
      conn = OracleDAOFactory.getOracleDBConnection().getConnection(); 
     } 
     catch (NamingException ex) { 
      Logger.getLogger(OracleDAOFactory.class.getName()).log(Level.SEVERE, null, ex); 
     } 
     catch (SQLException ex) { 
      Logger.getLogger(OracleDAOFactory.class.getName()).log(Level.SEVERE, null, ex); 
     } 
     return conn; 
    } 

estoy usando NetBeans así que no sé cómo son capaces de hacer esto en otros entornos de desarrollo, pero cuando se presiona ALT+Insert, no se le mostrará pequeño menú y se puede elegir "Usar base de datos .. . " y cree automáticamente solo con unos pocos clics su Connection a la base de datos.

Answer 3

Puede utilizar el método especificado anteriormente, en lugar de devolver void devolver la conexión:

public class PgConnect { 
    //changing the method declaration to return a Connection 
    public Connection connect() { 
     Connection connection = null; 
     try { 
      connection = DriverManager.getConnection("jdbc:postgresql://pgserver:5432/db", "test","test123"); 
     } catch (SQLException e) { 
      System.out.println("Connection Failed! Check output console"); 
      e.printStackTrace(); 
      return null; 
     } 
     if (connection != null) { 
      System.out.println("Connection working"); 
     } else { 
      System.out.println("Failed to make connection!"); 
     } 
     return connection; 
    } 
} 



public class ReturnResults { 

    public static void main(String[] args) { 
     Connection connection = null; 
     PgConnect oPgConnect; 
     try { 
     //this is where you call your method object... 
     oPgConnect = new PgConnect(); 
     //once created, you call the method to get the connection... 
     connection = oPgConnect.connect(); 
     //after get the connection, keep with the method logic... 
     if (connection != null) { 
      //your logic code... 
     } 
    } 
} 

Answer 4

Según tengo entendido, al que desea llamar el método de connect()PgConnect.java en ReturnResults.java para que pueda utilizar el objeto Connection.

Usted puede hacer 2 cosas -

1. Puede ampliar la PgConnect.java en ReturnResults.java como public class ReturnResults extends PgConnect y luego usar el método connect.
2. Puede hacer que su clase PgConnect sea estática y usarla como PgConnect.connect() en la clase ReturnResults.

Answer 5

¿Está diciendo que desea obtener una conexión en su propia función, por lo que puede llamar cada vez que necesita hacer una llamada sql? Parece que eso es lo que estás pidiendo disculpas si estoy fuera de la base ....

Pero si es lo que estás preguntando, entonces estás en el camino correcto ya que esto es una cosa estándar que hacer ...

¿Por qué no pruebas esto? He intentado no solo darte una respuesta sino que te he preparado algunas prácticas recomendadas para que comiences y te hagas la vida más fácil. .... (Supongo que PGConnect.java está en el mismo paquete, si no resolver su dirección en consecuencia. Un montón de otras publicaciones en SO lo describirá. Es algo básico en Java/la mayoría de los lenguajes de programación.) Actualice su primera archivo para que se vea así, observe que estoy haciendo que la función consiga que Connection sea estática y paso las excepciones al método de llamada, esto es para que podamos manejar esas excepciones caso por caso. Prefiero incluso pasarlos fuera de la capa de datos para que pueda tener buenos informes de errores en su aplicación, pero eso depende mucho de cómo diseñe esa aplicación.

package DatabaseCodePackage; //name you package something descriptive, its your call place both files into this package. 

import java.sql.DriverManager; 
import java.sql.Connection; 
import java.sql.SQLException; 

public class PgConnect { 

    public static Connection getConnection(String username, String password) throws SQLException 
    { 
     return DriverManager.getConnection("jdbc:postgresql://pgserver:5432/db", username, password); 
    } 

actualización el segundo archivo a algo como esto .... Escribir directamente SQL en JDBC es muy dicouraged si está utilizando cualquiera de los valores de búsqueda dinámica, que supongo que finalmente va a hacer, ya que casi todas las aplicaciones se haz eso en alguna parte ver http://docs.oracle.com/javase/tutorial/jdbc/basics/prepared.html Estados preparados preparados. He reescrito tu SQL para usar una declaración preparada.

package DatabaseCodePackage; //name you package something descriptive, its your call place both files into this package. 

import java.sql.DriverManager; 
import java.sql.Connection; 
import java.sql.ResultSet; 
import java.sql.SQLException; 
import java.sql.Statement; 


public class ReturnResults { 

public static void main(String[] args) { 

    Stirng result = null; 
    try{ 
     result = selectAllWithEnv("TEST"); 

     // I catch exceptions here because i like to let exception pass entirely out of the 
     // data layer, this way the control logic calling for the database information can decide what to do when it 
     // cant get the information it wants. This is especailly good in a MVC type project. 
    } catch (NullPointerException npe){ 
     result = "Connection Failed! Check output console : " + e.getMessage(); 
     e.printStackTrace(); 
     return; 
    } catch (SQLException e) { 
     result = "SQL failure! Check output console : " + e.getMessage(); 
     e.printStackTrace(); 
     return; 
    } finally { 
     System.out.println(result); 
    } 
} 

public static String selectAllWithEnv(String var) throws SQLException, NullPointerException { 
    String SQL = "select * from mwp.servers where env=? order by server"; 
    Connection connection = null; 
    StringBuilder sb = new StringBuiler(); 
    try { 
     connection = PgConnect.getConnection(); 
     PreparedStatement ps = connection.prepareStatement(SQL); 
     ps.setObject(1, var); 
     ResuletSet rs = ps.executeQuery(); 

     while (rs.next()) { 

      String iEnv  = rs.getString("env"); 
      String iServer = rs.getString("iserver"); 
      String iLabel = rs.getString("label"); 
      String iTitle = rs.getString("title"); 
      String iLogin = rs.getString("login"); 

      sb.append(iEnv + "\t" + iServer + "\t" + iLabel + "\t" + iTitle + "\t" + iLogin + "\n"); 
     } 
    } finally { 
     connection.close(); 
    } 
    return sb.toString(); 
} 

Observe también puse el con.close() en un bloque final. SIEMPRE SIEMPRE SIEMPRE haz esto. Si terminas lanzando un excpetion en el bloque try, esto asegurará que se llame. Si no lo haces, tendrás una conexión que permanecerá viva por mucho tiempo y esto puede tener un impacto muy negativo en el rendimiento. Si está trabajando en un entorno empresarial y no lo hace, es probable que tenga DBA en su caso en algún momento por no matar las conexiones de su aplicación. El stmt.close() es redundante en el con.close() si no está utilizando múltiples declaraciones en la misma conexión, por lo que no hay ninguna razón para invocarlo al llamar al con.close()