/*
* oConexion.java
*
* Created on 21 de marzo de 2005, 14:30
*
* To change this template, choose Tools | Options and locate the template under
* the Source Creation and Management node. Right-click the template and choose
* Open. You can then make changes to the template in the Source Editor.
*/
package bbdd;
/**
*
* @author Administrador
*/
import org.hibernate.*;
import org.hibernate.cfg.Configuration;
import org.apache.commons.logging.*;
import exceptions.bbddExceptions;
import bbdd.dao.UsuariosDAO;
import javax.naming.*;
public class oConexion {
private static Log log = LogFactory.getLog(oConexion.class);
private static Configuration configuration;
private static SessionFactory sessionFactory;
private static final ThreadLocal threadSession = new ThreadLocal();
private static final ThreadLocal threadTransaction = new ThreadLocal();
private static final ThreadLocal threadInterceptor = new ThreadLocal();
// Crea una sesion desde el archivo por defecto
static {
try {
sessionFactory = new Configuration().configure().buildSessionFactory();
// We could also let Hibernate bind it to JNDI:
// configuration.configure().buildSessionFactory()
} catch (Throwable ex) {
// We have to catch Throwable, otherwise we will miss
// NoClassDefFoundError and other subclasses of Error
log.error("Building SessionFactory failed.", ex);
throw new ExceptionInInitializerError(ex);
}
}
/**
* Devuelve la sesion creada por la clase.
*
* @return SessionFactory
*/
public static SessionFactory getSessionFactory() {
/* Instead of a static variable, use JNDI:
SessionFactory sessions = null;
try {
Context ctx = new InitialContext();
String jndiName = "java:hibernate/HibernateFactory";
sessions = (SessionFactory)ctx.lookup(jndiName);
} catch (NamingException ex) {
throw new bbddExceptions(ex);
}
return sessions;
*/
return sessionFactory;
}
/**
* Devuelve la configuracion por defecto de hibernate.
*
* @return Configuration
*/
public static Configuration getConfiguration() {
return configuration;
}
/**
* Reconstruye la conexion con los parametros por defecto.
*
*/
public static void rebuildSessionFactory()
throws bbddExceptions {
synchronized(sessionFactory) {
try {
sessionFactory = getConfiguration().buildSessionFactory();
} catch (Exception ex) {
throw new bbddExceptions(ex);
}
}
}
/**
* Reconstruye la conexion con los parametros dados.
*
* @param cfg
*/
public static void rebuildSessionFactory(Configuration cfg)
throws bbddExceptions {
synchronized(sessionFactory) {
try {
sessionFactory = cfg.buildSessionFactory();
configuration = cfg;
} catch (Exception ex) {
throw new bbddExceptions(ex);
}
}
}
/**
* Retrieves the current Session local to the thread.
* <p/>
* If no Session is open, opens a new Session for the running thread.
*
* @return Session
*/
public static Session getSession()
throws bbddExceptions {
Session s = (Session) threadSession.get();
try {
if (s == null) {
log.debug("Abriendo nueva sesion para este proceso.");
if (getInterceptor() != null) {
log.debug("Usando el interceptor: " + getInterceptor().getClass());
s = getSessionFactory().openSession(getInterceptor());
} else {
s = getSessionFactory().openSession();
}
threadSession.set(s);
}
} catch (HibernateException ex) {
throw new bbddExceptions(ex);
}
return s;
}
/**
* Closes the Session local to the thread.
*/
public static void closeSession()
throws bbddExceptions {
try {
Session s = (Session) threadSession.get();
threadSession.set(null);
if (s != null && s.isOpen()) {
log.debug("Cerrando sesion para el proceso.");
s.close();
}
} catch (HibernateException ex) {
throw new bbddExceptions(ex);
}
}
/**
* Comienzo de una transaccion en la BBDD.
*/
public static void beginTransaction()
throws bbddExceptions {
Transaction tx = (Transaction) threadTransaction.get();
try {
if (tx == null) {
log.debug("Comenzando nueva transaccion en la bbdd para el proceso.");
tx = getSession().beginTransaction();
threadTransaction.set(tx);
}
} catch (HibernateException ex) {
throw new bbddExceptions(ex);
}
}
/**
* Guarda cambios en la bbdd.
*/
public static void commitTransaction()
throws bbddExceptions {
Transaction tx = (Transaction) threadTransaction.get();
try {
if ( tx != null && !tx.wasCommitted()
&& !tx.wasRolledBack() ) {
log.debug("Guardando cambios en la bbdd para este proceso.");
tx.commit();
}
threadTransaction.set(null);
} catch (HibernateException ex) {
rollbackTransaction();
throw new bbddExceptions(ex);
}
}
/**
* Rollback de los cambios en la bbdd.
*/
public static void rollbackTransaction()
throws bbddExceptions {
Transaction tx = (Transaction) threadTransaction.get();
try {
threadTransaction.set(null);
if ( tx != null && !tx.wasCommitted() && !tx.wasRolledBack() ) {
log.debug("Intentando realizar rollback de la bbdd para este proceso.");
tx.rollback();
}
} catch (HibernateException ex) {
throw new bbddExceptions(ex);
} finally {
closeSession();
}
}
/**
* Reconecta la sesion del hibernate al proceso.
*
* @param session The Hibernate Session to be reconnected.
*/
public static void reconnect(Session session)
throws bbddExceptions {
try {
session.reconnect();
threadSession.set(session);
} catch (HibernateException ex) {
throw new bbddExceptions(ex);
}
}
/**
* Disconnect and return Session from current Thread.
*
* @return Session the disconnected Session
*/
public static Session disconnectSession()
throws bbddExceptions {
Session session = getSession();
try {
threadSession.set(null);
if (session.isConnected() && session.isOpen())
session.disconnect();
} catch (HibernateException ex) {
throw new bbddExceptions(ex);
}
return session;
}
/**
* Register a Hibernate interceptor with the current thread.
* <p>
* Every Session opened is opened with this interceptor after
* registration. Has no effect if the current Session of the
* thread is already open, effective on next close()/getSession().
*/
public static void registerInterceptor(Interceptor interceptor) {
threadInterceptor.set(interceptor);
}
private static Interceptor getInterceptor() {
Interceptor interceptor = (Interceptor) threadInterceptor.get();
return interceptor;
}
}
Thanks a lot.
Login
FAQ
Search
