Wie richte ich eine dauerhafte Verbindung mit einem DB-Server mit Java ein?

Question

Also ich versuche, eine Java-Anwendung zu optimieren, die die Java-SQL-Bibliothek zum Lesen und Schreiben von einem Remote-SQL-Server verwendet. (Dies ist für ein Projekt).

Wir sind beschränkt auf die folgenden Bibliotheken:

com.mysql.* 
java.io.* 
java.lang.* 
java.sql.* 
java.text.* 
java.util.* 
javax.sql.* 

Und wir haben einen 8 MB großen Speicherlimit auf unserer JVM.

Die Art und Weise, wie der Code gerade eingerichtet wird, für jede Funktion, die auf die Datenbank zugreifen muss, wird eine neue Verbindung erstellt und geschlossen. zum Beispiel:

public static void Read() 
{ 
    Connection connection = NULL; 
    try { 
     connection = DriverManager.getConnection(EnvManager.getDbUrl()); 
     Statement statement = connection.createStatement(); 

    statement.setFetchSize(Integer.MIN_VALUE); 

     ******* FUNCTION ******** 
    }finally { 
    if(connection != null) { 
     try { 
     connection.close(); 
     } catch (Exception e) { 
     } 
    } 
} 

    public static void Write() 
{ 
    Connection connection = NULL; 
    try { 
     connection = DriverManager.getConnection(EnvManager.getDbUrl()); 
     Statement statement = connection.createStatement(); 
    statement.setFetchSize(Integer.MIN_VALUE); 

     ******* FUNCTION ******** 
    }finally { 
    if(connection != null) { 
     try { 
     connection.close(); 
     } catch (Exception e) { 
     } 
    } 
} 

etc ...

Ich versuche, eine dauerhafte Verbindung zu setzen, so dass ich entweder im Verbindungsobjekt passieren kann, das heißt

... 
... 
Connection connection = NULL; 
try { 
    connection = DriverManager.getConnection(EnvManager.getDbUrl()); 
Read(connection); 
Write(connection); 

}finally { 
    if(connection != null) { 
     try { 
     connection.close(); 
     } catch (Exception e) { 
     } 
    } 
... 
... 

Wenn jedoch Ich versuche dies zu tun, wenn ich versuche, eine große Datei in die Datenbank zu schreiben und sie dann zu lesen (alles über 5 MB), wirft meine JVM immer wieder Fehler auf, dass der Speicher knapp wird.

Meine Frage ist im Grunde, was passiert, wenn Sie ein einzelnes Verbindungsobjekt erstellen und es in eine Funktion weiterleiten? Es scheint, als ob es bei jedem Einsatz irgendwie wächst oder repliziert.

ich auf dieser Website angesehen:

http://benjchristensen.com/2008/05/27/mysql-jdbc-memory-usage-on-large-resultset/

dem ich die statement.setFetchSize(Integer.MIN_VALUE); Funktion vorgeschlagen, um die JVM Pufferung das gesamte Ergebnis im Speicher standardmäßig zu beschneiden, aber das half nicht.

Irgendwelche Ideen auf, wie man dieses Problem beheben würde, würde sehr geschätzt werden, danke.

Answer 1

Wenn Sie denselben Objektverweis an andere Methoden übergeben, sollte nichts repliziert werden. Sie übergeben einfach einen Verweis auf das Objekt. Was passiert, ist, dass Sie Ihre Statements oder PreparedStatements wahrscheinlich nicht jedes Mal schließen, wenn Sie SQL ausführen.

Sie müssen alle Ressourcen schließen, die Ressourcen verbrauchen, nachdem Sie die Abfrage beendet haben. Hier ist ein Beispiel

public void Read() { 
    Connection conn = null; 
    Statement statement = null; 
    ResultSet rs = null; 

    try { 
     connection = DriverManager.getConnection(EnvManager.getDbUrl()); 
     statment = connection.createStatement(); 
     statement.setFetchSize(Integer.MIN_VALUE); 

     // Do more stuff, iterate to ResultSet etc... 
    } catch (SQLException ex) { 
     // Exception handling stuff 
     ... 
    } finally { 
     if (rs != null) { 
      try { 
       rs.close(); 
      } catch (SQLException e) { /* ignored */} 
     } 
     if (statment != null) { 
      try { 
       statment.close(); 
      } catch (SQLException e) { /* ignored */} 
     } 
     if (conn != null) { 
      try { 
       conn.close(); 
      } catch (SQLException e) { /* ignored */} 
     } 
    } 
} 

Answer 2

Wahrscheinlich müssen Sie die Anweisungen in Read() und Write() schließen. Ressourcen, die diesen Objekten zugeordnet sind (in diesem Fall die zum Lesen/Schreiben der Dateidaten verwendeten Puffer), werden erst freigegeben, wenn sie geschlossen sind. Das Schließen der Verbindung schließt automatisch die Anweisung, die damit erstellt wurde, aber wenn Sie die Verbindung offen halten möchten, müssen Sie die Anweisung schließen, wenn Sie damit fertig sind.