Connessione JDBC utilizzando file diversi

Question

Prima di tutto mi dispiace per il nome del titolo, ma non so come inserirne un altro dato che l'inglese non è la mia lingua madre.

Ho il seguente metodo per connettersi a un database:

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!"); 
     } 
    } 
} 

E quello che devo fare è includere il metodo dal PgConnect nel seguente codice. Fondamentalmente ho bisogno di questo perché ho molti tipi di chiamate SQL al database, e cambiarlo in quel modo sarebbe facile da mantenere, dal momento che le credenziali/host sarebbero su un solo file.

Credo che il cambiamento dovrebbe essere dove ho il commento

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

favore correggetemi se sbaglio.

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!"); 
     } 
    } 
} 

So come farlo su Perl, ma non ho alcuna pratica in Java.

Answer 1

Un modo per nascondere le credenziali sarebbe fare connect una funzione statica di ritorno Connection, in questo modo:

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; 
    } 
} 

}

È quindi possibile utilizzare in questo modo:

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

Answer 2

Fai la tua connect() metodo static e poi si può chiamare in questo modo

Connection con = PgConnect.connect(); 

anche modificare il metodo di connessione a Connection, perché è necessario tornare Connection non 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; 
    } 

Inoltre, esiste un altro approccio più pulito. Ecco un esempio del mio vecchio progetto.

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; 
    } 

sto usando NetBeans in modo che io non so come si è in grado di fare questo in altri IDE, ma quando si preme ALT+Insert, non verrà mostrata piccolo menu e si può scegliere "Usa il database .. . " e crea automaticamente con pochi clic il tuo Connection nel database.

Answer 3

È possibile utilizzare il metodo specificato in precedenza, invece di restituire void restituire la connessione:

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

quanto ho capito, si desidera chiamare il metodo connect() da PgConnect.java in ReturnResults.java in modo da poter utilizzare l'oggetto Connection.

Si può fare 2 cose -

1. È possibile estendere il PgConnect.java in ReturnResults.java come public class ReturnResults extends PgConnect e quindi utilizzare il metodo connect.
2. È possibile impostare la classe PgConnect statica e utilizzarla come PgConnect.connect() nella classe ReturnResults.

Answer 5

Stai dicendo che vuoi tirare fuori una connessione nella sua funzione, così puoi chiamarla ogni volta che devi effettuare una chiamata sql? Sembra che sia quello che chiedi scusa se sono fuori base ...

Ma se è quello che stai chiedendo, allora sei sulla strada giusta poiché questa è una cosa standard da fare ...

Perché non lo provi, Ive ha cercato non solo di darti una risposta, ma ti ha impostato alcune buone pratiche per iniziare e renderti la vita più facile. .... (presumo che PGConnect.java si trovi nello stesso pacchetto, se non risolve il tuo indirizzo di conseguenza. Un sacco di altri post su SO lo descriveranno. È una cosa di base in Java/la maggior parte dei linguaggi di programmazione.) Aggiorna il tuo primo file per assomigliare a questo, notare che sto facendo la funzione per ottenere la connessione statica e sto passando le eccezioni al metodo di chiamata, questo è così che possiamo gestire tali eccezioni caso per caso. Preferisco persino passarli completamente dal livello dati in modo da poter avere una buona segnalazione degli errori nell'applicazione, ma dipende molto da come si progetta quell'applicazione.

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); 
    } 

Aggiornare il secondo file a qualcosa di simile .... direttamente digitando SQL in JDBC è altamente dicouraged se si utilizza tutti i valori di ricerca dinamici, che presumo si eventuale farà, dal momento che quasi ogni applicazione sarà fallo da qualche parte vedi http://docs.oracle.com/javase/tutorial/jdbc/basics/prepared.html Dichiarazioni preparate usate. Ho riscritto il tuo SQL per usare una dichiarazione preparata.

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(); 
} 

noti inoltre ho messo il con.close() in un blocco finally. SEMPRE SEMPRE SEMPRE. Se finisci di lanciare un'emissione nel blocco try, questo assicurerà che venga chiamato. Se non lo fai, avrai una connessione che rimarrà in vita per tempi molto lunghi e questo può avere un impatto molto negativo sulle prestazioni. Se stai lavorando in un ambiente aziendale e non lo fai, probabilmente avrai DBA sul tuo caso a un certo punto per non uccidere le connessioni delle applicazioni. Lo è ridondante su con.close() se non si utilizzano più valori sulla stessa connessione, quindi non vi è alcun motivo per chiamarlo quando si chiama con.close()