Połączenie JDBC przy użyciu różnych plików

Question

Po pierwsze przepraszam za nazwę tytułu, ale nie wiem, jak wstawić inną, ponieważ angielski nie jest moim ojczystym językiem.

Mam następujący sposób, aby połączyć się z bazą danych:

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

i co należy zrobić to m.in. metodę z PgConnect w poniższym kodzie. Zasadniczo potrzebuję tego, ponieważ mam wiele typów wywołań SQL do bazy danych, a zmiana tego w ten sposób byłaby łatwa do utrzymania, ponieważ poświadczenia/host byłyby tylko na jednym pliku.

Uważam, że zmiany powinny być tam, gdzie mam komentarz

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

Proszę mnie poprawić jeśli się mylę.

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

Wiem, jak to zrobić w Perlu, ale nie mam żadnej praktyki w Javie.

Answer 1

Jednym ze sposobów, aby ukryć poświadczenia będzie co connect funkcją statycznego powrocie Connection coś takiego:

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

}

Następnie można go używać tak:

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

Answer 2

Dodać metodę staticconnect() a następnie można nazwać jak ten

Connection con = PgConnect.connect(); 

edytować również metoda łączenia się Connection, bo trzeba wrócić Connection nie 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; 
    } 

Istnieje również inne, czystsze podejście. Oto przykład z mojego starego projektu.

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

Używam NetBeans więc nie wiem, jak jesteś w stanie to zrobić w innych IDE, ale po naciśnięciu ALT+Insert nie będzie udostępniana trochę menu i można wybrać „Użyj bazy .. . " i tworzyć automatycznie za pomocą kilku kliknięć swoją Connection do bazy danych.

Answer 3

Możesz użyć metody podanej powyżej, zamiast powrotu void zwróć połączenie:

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

Jak rozumiem, chcesz wywołać metodę z PgConnect.javaconnect() do ReturnResults.java, dzięki czemu można korzystać z obiektu Connection.

można zrobić 2 rzeczy -

1. Można rozszerzyć PgConnect.java w ReturnResults.java jak public class ReturnResults extends PgConnect a następnie użyć metody connect.
2. Możesz uczynić swoją klasę PgConnect statyczną i używać jej jako klasy PgConnect.connect() w klasie ReturnResults.

Answer 5

Mówisz, że chcesz wyciągnąć połączenie do własnej funkcji, aby można było wywoływać go za każdym razem, gdy trzeba wykonać wywołanie sql? Wygląda na to, że o to pytasz, przepraszam, jeśli jestem poza bazą ...

Ale jeśli to jest to, o co pytasz, jesteś na dobrej drodze, ponieważ jest to standardowa rzecz ...

Dlaczego nie próbujesz tego, Ive starał się nie tylko dać ci odpowiedź, ale przygotował cię z najlepszymi praktykami, które pomogą ci zacząć i ułatwią Ci życie. .... (Zakładam, że PGConnect.java znajduje się w tym samym pakiecie, jeśli nie rozwiąże to twojego adresu.) Wiele innych wpisów na SO opisze to. Jest to podstawowa kwestia w java/większości języków programowania.) Zaktualizuj swój pierwszy plik wygląda tak, zauważ, że robię funkcję, aby uzyskać połączenie statyczne i przekazuję wyjątki do metody wywołującej, jest to tak, że możemy obsługiwać te wyjątki na podstawie poszczególnych przypadków. Wolę nawet przekazać je z warstwy danych, aby móc poprawnie raportować błędy w aplikacji, ale jest to bardzo zależne od sposobu zaprojektowania tej aplikacji.

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

Aktualizacja drugi plik do czegoś takiego .... bezpośrednio wpisując SQL do JDBC jest wysoce dicouraged jeśli używasz żadnych dynamicznych wartości wyszukiwania, które zakładam, że ewentualny zrobi, ponieważ prawie każda aplikacja będzie zrób to gdzieś. patrz http://docs.oracle.com/javase/tutorial/jdbc/basics/prepared.html Używane przygotowane oświadczenia. Przerobiłem twój SQL, aby użyć przygotowanej statystyki.

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

Zauważcie również, że wstawiłem con.close() w ostatecznym bloku. ZAWSZE ZAWSZE ZAWSZE rób to. Jeśli w końcu rzucisz blokadę w bloku try, zapewni to, że zostanie wywołana. Jeśli tego nie zrobisz, będziesz mieć połączenie, które pozostanie żywe przez bardzo długi czas i może to mieć bardzo negatywny wpływ na wydajność. Jeśli pracujesz w środowisku przedsiębiorstwa, a ty tego nie robisz, prawdopodobnie będziesz miał na swoim koncie DBA na wypadek, gdybyś nie zabił twoich połączeń z aplikacjami. stmt.close() jest zbędny na con.close() jeśli nie używasz wielu statments tego samego związku, więc nie ma powodu, aby zadzwonić, że podczas wywoływania con.close()