può utilizzare contemporaneamente il pool di Hibernate e Tomcat Connection?

Question

Sto sviluppando un'applicazione Java web e utilizzare la connessione Tomcat pooling, qui è la mia impostazione:

<?xml version="1.0" encoding="UTF-8"?> 
<Context path="" docBase="" debug="5" reloadable="true" crossContext="true"> 
<Resource name="jdbc/jdbcPool" 
      auth="Container" 
      type="javax.sql.DataSource" 
      maxActive="100" 
      maxIdle="30" 
      maxWait="10000" 
      username="root" 
      password="*******" 
      driverClassName="com.mysql.jdbc.Driver" 
      url="jdbc:mysql://localhost:3306/dbname?autoReconnect=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>    
</Context> 

e il mio DAO:

public static Connection dbConnection() throws NamingException { 
     Context initContext; 
     DataSource ds = null; 
     Connection conn = null; 
     try { 
      initContext = new InitialContext(); 
      Context envContext = (Context) initContext.lookup("java:/comp/env"); 
      ds = (DataSource) envContext.lookup("jdbc/jdbcPool"); 
      conn = ds.getConnection();   
     }catch (SQLException ex){ 
      logger.error("SQLException Occurred in DAO.dbConnection() Method, Exception Message is: " + ex.getMessage(), ex); 
     } 
     catch (RuntimeException er){ 
      logger.fatal("SQLException Occurred in DAO.dbConnection() Method, Exception Message is: " + er.getMessage(), er); 
     }catch(Exception rt){ 
      logger.fatal("Exception Occurred in DAO.dbConnection() Method, Exception Message is: " + er.getMessage(), er); 
     } 
     return conn; 
    } 

voglio usare letargo così ho rifattorizziamo una certa parte del il mio codice, ora voglio sapere è possibile per me usarli entrambi nella mia applicazione (voglio dire che parte del mio codice usa ibernazione e parte usa la mia connessione DAO?) Se sì, cosa accadrà a quelle tabelle che non è mappato con l'ibernazione, ma alcune tabelle mappate hanno una relazione con loro?

Answer 1

La mia preferenza personale con l'ibernazione è di non configurarla affatto con un pool di connessioni. Questo può essere fatto semplicemente omettendo le impostazioni del pool di connessione nella nostra configurazione Hibernate e utilizzando il metodo openSession (Connection):

Connection conn = ... // get from jndi 
Session session = sessionFactory.openSession(connection); 
try{ 
    //do some work with either hte connection or the session or both 
}finally{ 
    session.close(); 
    conn.close(); 
} 

Questo ha il vantaggio che si è in controllo di cui viene utilizzato il collegamento e dove si trova assegnato e, soprattutto, dove è chiuso, questo può essere importante se si sta eseguendo una transazione utilizzando il codice hbernate e jdbc.

EDIT: su @ ChssPly76 punto sull'esclusione della gestione delle transazioni incorporate in ibernazione, e ha perfettamente ragione, l'ibernazione fornisce un ragionevole supporto per le transazioni e se un dato JTA si sincronizzerà con qualsiasi transazione in corso. In nessuna app JTA in cui occorrono sia il codice hbernate che il codice jdbc per operare nella stessa transazione jdbc, è importante assicurarsi che la sessione di ibernazione usi la stessa connessione del codice jdbc, il modo migliore per farlo è Connessione alla fabbrica della sessione. Nota che questo non esclude l'utilizzo di un oggetto transazione Hibernate:

Connection conn = ... // get from jndi 
Session session = sessionFactory.openSession(connection); 
try{ 
    Transaction tx = new Transaction(); // 
    //do some work with either hte connection or the session or both 
    tx.commit(); 
}finally{ 
    session.close(); 
    conn.close(); 
} 

funzionerà bene.

Answer 2

Suppongo che tu possa usarli insieme, ma perché dovresti? Puoi configurare Hibernate per utilizzare la tua origine dati, come invece descritto nello manual. Sarebbe qualcosa di simile:

hibernate.connection.datasource = java:/comp/env/jdbc/jdbcPool 
hibernate.dialect = org.hibernate.dialect.MySQLDialect 

Per quanto riguarda le mappature andare, "mappati" tabelle possono avere relazioni alle tabelle "non mappati" (nel database), ma queste relazioni sarà anche "mappata" (ad esempio, Hibernate ha vinto essere consapevole di loro). Quindi, se si va in questo modo, è necessario assicurarsi di non causare alcun problema di integrità referenziale mentre si tenta, per esempio, di inserire/aggiornare l'entità "mappata".