You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hivemind.apache.org by Apache Wiki <wi...@apache.org> on 2005/09/26 14:28:08 UTC
[Jakarta-hivemind Wiki] Update of "HibernateSessionFactory" by Marcus Schulte
Dear Wiki user,
You have subscribed to a wiki page or wiki category on "Jakarta-hivemind Wiki" for change notification.
The following page has been changed by Marcus Schulte:
http://wiki.apache.org/jakarta-hivemind/HibernateSessionFactory
New page:
{{{
package scm.hivemind.hibernate;
import java.io.InputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Session;
import net.sf.hibernate.SessionFactory;
import net.sf.hibernate.Transaction;
import net.sf.hibernate.cfg.Configuration;
import net.sf.hibernate.tool.hbm2ddl.SchemaUpdate;
import org.apache.commons.logging.Log;
import org.apache.hivemind.ApplicationRuntimeException;
import org.apache.hivemind.Discardable;
import org.apache.hivemind.PoolManageable;
import org.apache.hivemind.Resource;
import org.apache.hivemind.ServiceImplementationFactory;
import org.apache.hivemind.ServiceImplementationFactoryParameters;
import org.apache.hivemind.events.RegistryShutdownListener;
import org.apache.hivemind.service.ThreadEventNotifier;
import scm.hivemind.statefulservice.StatefulServiceLifecycleListener;
/**
* Die Klasse HibernateSessionFactory ist eine Hivemind-ServiceImplementationFactory
* die Hibernate-Session-Proxies zur Verwendung als Hivemind-Services produziert.
*
* @author schultma
*/
public class HibernateSessionFactory
implements ServiceImplementationFactory, RegistryShutdownListener
{
private SessionFactory sessionFactory;
private Transaction transaction;
private ThreadEventNotifier threadEventNotifier;
private boolean updateSchema = false;
private boolean transactionManager = false;
protected Log log;
private String configFile;
private String jndiName;
private Properties hibProps = new Properties();
public HibernateSessionFactory( List config ) {
for ( Iterator it = config.iterator(); it.hasNext(); ) {
HibernateProperty cfgProp = (HibernateProperty) it.next();
if ( cfgProp instanceof HibernateConfigFile )
configFile = cfgProp.getName();
else
hibProps.setProperty( "hibernate."+ cfgProp.getName(),
cfgProp.getValue() );
}
}
public void init()
{
try {
log.debug( "Initializing Hibernate SessionFactory..." );
Configuration config = new Configuration() {
/* Make sure, we use the current Classloader for Configs ...
* @see net.sf.hibernate.cfg.Configuration#getConfigurationInputStream(java.lang.String)
*/
protected InputStream getConfigurationInputStream( String resource )
throws HibernateException {
InputStream stream = null;
stream = getClass().getResourceAsStream( resource );
if (stream == null) {
throw new HibernateException(resource + " not found");
}
return stream;
}
};
config.configure( configFile );
config.setProperties( hibProps );
if( updateSchema )
{
log.debug( "Updating database schema..." );
new SchemaUpdate( config ).execute( true, true );
}
sessionFactory = config.buildSessionFactory();
} catch ( Exception e ) {
throw new ApplicationRuntimeException(e);
}
}
public Object createCoreServiceImplementation
( ServiceImplementationFactoryParameters params )
{
try {
log.debug( "Creating Hibernate Session..." );
Session session = sessionFactory.openSession();
Object proxy = Proxy.newProxyInstance(
params.getInvokingModule().getClassResolver().getClassLoader(),
new Class[]{ params.getServiceInterface(),
StatefulServiceLifecycleListener.class,
Discardable.class,
PoolManageable.class },
new SessionProxy( session ) );
//threadEventNotifier.addThreadCleanupListener(new SessionCloser(session));
return proxy;
} catch ( Exception e ) {
throw new ApplicationRuntimeException(e);
}
}
public void registryDidShutdown()
{
try {
log.debug( "Closing Hibernate SessionFactory..." );
sessionFactory.close();
} catch ( HibernateException e ) {
throw new ApplicationRuntimeException(e);
}
}
public void setThreadEventNotifier(ThreadEventNotifier notifier)
{
this.threadEventNotifier = notifier;
}
public void setLog( Log log )
{
this.log = log;
}
public void setJndiName( String jn ){
jndiName = jn;
}
public void setUpdateSchema( boolean updateSchema )
{
this.updateSchema = updateSchema;
}
public boolean isTransactionManager() {
return transactionManager;
}
public void setTransactionManager( boolean showSql ) {
this.transactionManager = showSql;
}
/**
* Instanzen der Klasse SessionProxy sind Adapter für Hibernate-Sessions.
* Sie setzen die Hivemind-Lifecycle-Events
* in die richtigen Methodenaufrufe der Hibernate-Session um.
* Es werden die Service-Modelle "pooled", "threaded" und "stateful"
* unterstützt.
*/
private class SessionProxy implements InvocationHandler,
StatefulServiceLifecycleListener,
PoolManageable,
Discardable {
private Session session;
public SessionProxy( Session session ) {
log.debug("creating hibernate session proxy");
this.session = session;
try {
startTransactionIfNecessary();
} catch (HibernateException e) {
throw new ApplicationRuntimeException(e);
}
}
/* (non-Javadoc)
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
*/
public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable {
if (method.getDeclaringClass().equals(Session.class))
return method.invoke( session, args );
else if ( method.getDeclaringClass().equals(StatefulServiceLifecycleListener.class)
|| method.getDeclaringClass().equals(PoolManageable.class)
|| method.getDeclaringClass().equals(Object.class)) {
return method.invoke( this, args );
} else
throw new ApplicationRuntimeException("unable to interprete msg "
+ method.getName() );
}
public void terminateConversation() {
try {
log.debug("throwing session away");
if ( session != null && session.isOpen() ) {
endTransactionIfNecessary();
session.close();
session = null;
}
} catch ( HibernateException e ) {
throw new ApplicationRuntimeException(e);
}
}
public void resumeConversation() {
try {
log.debug("reconnecting session");
if (!session.isConnected())
session.reconnect();
startTransactionIfNecessary();
} catch ( HibernateException e ) {
throw new ApplicationRuntimeException(e);
}
}
public void pauseConversation() {
try {
log.debug("disconnecting session");
if (session.isConnected()) {
endTransactionIfNecessary();
session.disconnect();
}
} catch ( HibernateException e ) {
throw new ApplicationRuntimeException(e);
}
}
/**
* @throws HibernateException
*/
private void startTransactionIfNecessary() throws HibernateException {
if ( isTransactionManager() && transaction == null )
transaction = session.beginTransaction();
}
/**
* @throws HibernateException
*/
private void endTransactionIfNecessary() throws HibernateException {
if ( isTransactionManager() && transaction != null
&& ! transaction.wasRolledBack()
&& ! transaction.wasCommitted() ) {
transaction.commit();
transaction = null;
}
}
public String toString() {
return super.toString() + " - proxy for " + session.toString();
}
/* (non-Javadoc)
* @see org.apache.hivemind.PoolManageable#activateService()
*/
public void activateService() {
// acquire new Hibernate-Session
log.debug( "Creating Hibernate Session..." );
try {
session = getSessionFactory().openSession();
startTransactionIfNecessary();
} catch ( HibernateException e ) {
throw new ApplicationRuntimeException(e);
}
}
/* (non-Javadoc)
* @see org.apache.hivemind.PoolManageable#passivateService()
*/
public void passivateService() {
//throw away Hibernate-Session
terminateConversation();
}
/* (non-Javadoc)
* @see org.apache.hivemind.Discardable#threadDidDiscardService()
*/
public void threadDidDiscardService() {
terminateConversation();
}
}
protected SessionFactory getSessionFactory() {
return sessionFactory;
}
}
}}}
---------------------------------------------------------------------
To unsubscribe, e-mail: hivemind-cvs-unsubscribe@jakarta.apache.org
For additional commands, e-mail: hivemind-cvs-help@jakarta.apache.org