Datenbankanfragen mit Hibernate extrem langsam

timmy443 · **Joined:** Wed Nov 29, 2006 9:48 am **Posts:** 8

Hallo,

ich habe ein Problem mit der Konfiguration von meinem (ersten) hibernate-Projekt. Queries sind extrem langsam: simple Query, die etwa 300 Datensätze liefern sollte dauert bis zu 30s. Das aber nur, wenn ich eine Datenbank anspreche, die auf einem Webserver läuft. Anfragen an mein localhost System werden absolut normal abgearbeitet. "Normale" SQL anfragen an den Server werden schnell abgearbeitet, daher vermute ich, dass ein Konfigurationsfehler vorliegt.

Ich verwende einen ConnectionProvider. Die Klasse sieht folgendermaßen aus:

Code:

public class POConnectionProvider implements ConnectionProvider {
   
   private MysqlDataSource ds = null;
   private Properties props = null;
   
   public void configure(Properties p) throws HibernateException {
      props = p;
   }

   public Connection getConnection() throws SQLException {
      Connection con = null;
      try{
         con = getPoolingDataSource().getConnection();
      }
      catch(Exception e){
         e.printStackTrace();
      }
      
      return con;
   }

   public Connection getJDBCConn() throws SQLException {
      return getPoolingDataSource().getConnection();
   }
   
   public void closeConnection(Connection conn) throws SQLException {
      conn.close();
   }

   public void close() throws HibernateException {
   }

   public boolean supportsAggressiveRelease() {
      return false;
   }
   
   
   private MysqlDataSource getPoolingDataSource() {
      if (ds == null) {
         String username = props.getProperty("hibernate.connection.username");
         String pass = props.getProperty("hibernate.connection.password");
           ds = new MysqlDataSource();
           ds.setServerName(Constants.getServerName());
           ds.setDatabaseName(Constants.getDataBaseName());
           ds.setPort(Constants.getConnectionPort());
           ds.setUser(username);
           ds.setPassword(pass);
      return ds;
   }
}

Und eine Klasse HibernateUtil, die die einzelnen Sessions liefern soll:

Code:

public class HibernateUtil {

   private static SessionFactory factory = null;
   private static ThreadLocal session = new ThreadLocal();

   public static void createSession(String login, String pass) 
   throws ExceptionInInitializerError {
      try {
         Configuration cfg = new Configuration().configure("/projekt/pfad/hibernate.cfg.xml");
         cfg.setProperty("hibernate.connection.username",login);
         cfg.setProperty("hibernate.connection.password",pass);
         cfg.setProperty(Environment.CONNECTION_PROVIDER, "projekt.pfad.POConnectionProvider");

         POConnectionProvider cp = new POConnectionProvider();

         factory = cfg.buildSessionFactory();

         s.close();
      } catch (Throwable ex) {
         ex.printStackTrace();
      }
   }
   
   public static Session currentSession() {
        Session s = (Session) session.get();
        if (s == null) {
            s = factory.openSession();
            session.set(s);
        }
        return s;
    }

    public static Session openSession() {
       return factory.openSession();
    }
 
    public static void closeSession() {
        Session s = (Session) session.get();
        if (s != null)
            s.close();
        session.set(null);
    }
}

Die hibernate.cfg.xml:

Code:

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.bytecode.use_reflection_optimizer">false</property>
        <property name="hibernate.connection.driver_class">org.gjt.mm.mysql.Driver</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.transaction.factory_class">org.hibernate.transaction.JDBCTransactionFactory</property>

--hier sind dann noch die Mappings
    </session-factory>
</hibernate-configuration>

Initialisieren usw. ist alles kein Problem, nur die Geschwindigkeit der Abfragen ist wie gesagt zu langsam.

Unten habe ich noch die Auszüge vom log4j system mitgepostet.

Da ich mit meinem Latein am Ende bin (ich versuche jetzt schon seit zwei Monaten das Problem in den Griff zu kriegen), hoffe ich sehr, dass mir irgendjemand hier helfen kann.

Vielen Dank im Voraus!

Hibernate version: 3.1.3

Name and version of the database you are using: MySQL 4.1

The generated SQL (show_sql=true):

Auszüge vom log4j System

Code:

22:41,578  INFO Environment:479 - Hibernate 3.1.3
22:41,578  INFO Environment:509 - hibernate.properties not found
22:41,578  INFO Environment:525 - using CGLIB reflection optimizer
22:41,593  INFO Environment:555 - using JDK 1.4 java.sql.Timestamp handling

//Hier die Mappings, die keine Probleme bereiten

22:42,593  INFO ConnectionProviderFactory:72 - Initializing connection provider: .path.POConnectionProvider
22:43,140  INFO SettingsFactory:77 - RDBMS: MySQL, version: 4.1.10a
22:43,140  INFO SettingsFactory:78 - JDBC driver: MySQL-AB JDBC Driver, version: mysql-connector-java-3.1.12 ( $Date: 2005-11-17 15:53:48 +0100 (Thu, 17 Nov 2005) $, $Revision$ )
22:43,156  INFO Dialect:103 - Using dialect: org.hibernate.dialect.MySQLDialect
22:43,171  INFO TransactionFactoryFactory:34 - Transaction strategy: org.hibernate.transaction.JDBCTransactionFactory
22:43,187  INFO TransactionManagerLookupFactory:33 - No TransactionManagerLookup configured (in JTA environment, use of read-write or transactional second-level cache is not recommended)
22:43,187  INFO SettingsFactory:125 - Automatic flush during beforeCompletion(): disabled
22:43,187  INFO SettingsFactory:129 - Automatic session close at end of transaction: disabled
22:43,187  INFO SettingsFactory:136 - JDBC batch size: 15
22:43,187  INFO SettingsFactory:139 - JDBC batch updates for versioned data: disabled
22:43,187  INFO SettingsFactory:144 - Scrollable result sets: enabled
22:43,187  INFO SettingsFactory:152 - JDBC3 getGeneratedKeys(): enabled
22:43,187  INFO SettingsFactory:160 - Connection release mode: auto
22:43,187  INFO SettingsFactory:184 - Maximum outer join fetch depth: 2
22:43,187  INFO SettingsFactory:187 - Default batch fetch size: 1
22:43,187  INFO SettingsFactory:191 - Generate SQL with comments: disabled
22:43,187  INFO SettingsFactory:195 - Order SQL updates by primary key: disabled
22:43,187  INFO SettingsFactory:338 - Query translator: org.hibernate.hql.ast.ASTQueryTranslatorFactory
22:43,187  INFO ASTQueryTranslatorFactory:24 - Using ASTQueryTranslatorFactory
22:43,187  INFO SettingsFactory:203 - Query language substitutions: {}
22:43,187  INFO SettingsFactory:209 - Second-level cache: enabled
22:43,187  INFO SettingsFactory:213 - Query cache: disabled
22:43,203  INFO SettingsFactory:325 - Cache provider: org.hibernate.cache.EhCacheProvider
22:43,203  INFO SettingsFactory:228 - Optimize cache for minimal puts: disabled
22:43,203  INFO SettingsFactory:237 - Structured second-level cache entries: disabled
22:43,218  INFO SettingsFactory:264 - Statistics: disabled
22:43,218  INFO SettingsFactory:268 - Deleted entity synthetic identifier rollback: disabled
22:43,218  INFO SettingsFactory:283 - Default entity-mode: pojo
22:43,265  INFO SessionFactoryImpl:154 - building session factory
22:43,265  WARN Configurator:126 - No configuration found. Configuring ehcache from ehcache-failsafe.xml found in the classpath: jar:file:/Pfad/ehcache-1.1.jar!/ehcache-failsafe.xml
22:44,031  INFO SessionFactoryObjectFactory:82 - Not binding factory to JNDI, no JNDI name configured

LaLiLuna · **Posted:** Tue Dec 05, 2006 6:59 am

Vielleicht ein Routing Problem oder ein Problem der Namensauflösung.

Ansonsten fällt mir auf,
dass Du einen anderen MySQL Treiber verwendest als ich kenne. Ich würde mir auch nicht unbedingt einen eigenen Pool schreiben sondern bestehende Lösungen verwenden. Fast jeder Application Server bietet einen conneciton pool an.

Das initialisieren in Deinen HibernateUtil brauchst Du nicht in eine Funktion zu packen, sondern kannst es in einem Static Block belassen. Dann wird Hibernate schon beim Starten initialisiert.

timmy443 · **Joined:** Wed Nov 29, 2006 9:48 am **Posts:** 8

erst mal danke für die schnelle Antwort!

Ich habe das ganze gerade mit dem neueste MySql Datenbanktreiber versucht und statt org.gjt.mm.mysql.Driver die Klasse com.mysql.jdb.Driver, dass Problem bleibt das gleiche.

Ich glaube nicht, dass ein problem mit der Namensauflösung besteht. Die IP des Servers statt dem Servernamen anzugeben hilft leider auch nicht.

Wie sieht der Code aus, wenn ich einen vorgefertigten ConnectionPool verwende?

LaLiLuna · **Posted:** Tue Dec 05, 2006 7:24 am

Das kommt auf den SErver an. Schau mal in die Dokumentation zu Deinem Applikationsserver.

Hier ein Beispiel aus meinem Buch für Tomcat

Code:

<?xml version='1.0' encoding='utf-8'?>
<Context path="TomcatDeployment" debug="1" reloadable="true"
docBase='${catalina.home}/server/webapps/TomcatDeployment'>
<Resource name="jdbc/TestDB" auth="Container" type="javax.sql.DataSource"
maxActive="30" maxIdle="10" maxWait="4000"
username="postgres" password="p" driverClassName="org.postgresql.Driver"
url="jdbc:postgresql://localhost:5432/learninghibernate"/>
</Context>

hibernate.xml

Code:

<property name="connection.datasource">java:comp/env/jdbc/TestDB</property>

[/code]

timmy443 · **Joined:** Wed Nov 29, 2006 9:48 am **Posts:** 8

Eigentlich wollte ich auf den Einsatz von TomCat verzichten um das Projekt so einfach wie möglich zu halten. Gibt es nichts in meiner Konfiguration was grob falsch ist oder zumindest darauf hindeutet, wo der Fehler liegt?

LaLiLuna · **Posted:** Wed Dec 06, 2006 10:34 am

Stellst Du Fragen von lokal an einen Webserver?

timmy443 · **Joined:** Wed Nov 29, 2006 9:48 am **Posts:** 8

Ja, genau.

LaLiLuna · **Posted:** Wed Dec 06, 2006 12:13 pm

Vergleiche mal die Performance mit einer einfchen JDBC Anfrage gegen die 300 Datensätze. Das würde zumindest zeigen, ob das Problem Hibernate spezifisch ist.

Workaround könnte ein Cache sein eh-cache z.B.

timmy443 · **Joined:** Wed Nov 29, 2006 9:48 am **Posts:** 8

Die Performance über JDBC ist völlig ok, für die 300 Datensätze etwa eine sekunde. Ich habe das ganze Projekt gerade umstrukturiert und komplett über JDBC laufen lassen, was zwar viel schreibarbeit war, aber ordentlich zu funktionieren scheint. Da es sich auch nur um eine Datenbank mit max. 15 Tabellen handelt bin ich am überlegen, ob ich es nicht dann dabei belassen soll.