[jboss-svn-commits] JBL Code SVN: r12403 - labs/jbossesb/trunk/product/core/listeners/src/org/jboss/soa/esb/listeners/gateway.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Fri Jun 8 01:35:21 EDT 2007
Author: tcunning
Date: 2007-06-08 01:35:21 -0400 (Fri, 08 Jun 2007)
New Revision: 12403
Added:
labs/jbossesb/trunk/product/core/listeners/src/org/jboss/soa/esb/listeners/gateway/HibernateEventListener.java
Log:
bug:JBESB-434
Add event listener.
Added: labs/jbossesb/trunk/product/core/listeners/src/org/jboss/soa/esb/listeners/gateway/HibernateEventListener.java
===================================================================
--- labs/jbossesb/trunk/product/core/listeners/src/org/jboss/soa/esb/listeners/gateway/HibernateEventListener.java (rev 0)
+++ labs/jbossesb/trunk/product/core/listeners/src/org/jboss/soa/esb/listeners/gateway/HibernateEventListener.java 2007-06-08 05:35:21 UTC (rev 12403)
@@ -0,0 +1,326 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2006, JBoss Inc., and individual contributors as indicated
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.soa.esb.listeners.gateway;
+
+import java.io.Serializable;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import org.apache.log4j.Logger;
+import org.hibernate.HibernateException;
+import org.hibernate.event.*;
+import org.jboss.soa.esb.ConfigurationException;
+import org.jboss.soa.esb.helpers.ConfigTree;
+import org.jboss.soa.esb.helpers.persist.HibernateConn;
+
+import org.jboss.soa.esb.listeners.message.AbstractMessageComposer;
+import org.jboss.soa.esb.listeners.message.MessageDeliverException;
+import org.jboss.soa.esb.message.Message;
+
+/**
+ * This class is a Hibernate EventListener which implements hooks to all the available
+ * hibernate events. It's not used at the moment, but might be a way of augmenting
+ * the Hibernate Interceptor hooks which are currently implemented.
+ *
+ * @author <a href="mailto:tcunning at redhat.com">tcunning at redhat.com</a>
+ */
+public class HibernateEventListener implements
+ AutoFlushEventListener,
+ DeleteEventListener,
+ DirtyCheckEventListener,
+ EvictEventListener,
+ FlushEntityEventListener,
+ FlushEventListener,
+ InitializeCollectionEventListener,
+ LoadEventListener,
+ LockEventListener,
+ MergeEventListener,
+ PersistEventListener,
+ PostDeleteEventListener,
+ PostInsertEventListener,
+ PostLoadEventListener,
+ PostUpdateEventListener,
+ PreDeleteEventListener,
+ PreInsertEventListener,
+ PreLoadEventListener,
+ PreUpdateEventListener,
+ RefreshEventListener,
+ ReplicateEventListener,
+ SaveOrUpdateEventListener {
+
+ private static final long serialVersionUID = 7125882028251049616L;
+ protected HibernateConn m_conn;
+ protected final static Logger m_logger = Logger.getLogger(HibernateEventListener.class);
+
+ public HibernateEventListener() {
+ super();
+
+ }
+
+ protected Object doPreSend() {
+ try {
+ return queue.take();
+ } catch (InterruptedException e) {
+ m_logger.warn(" interrupted while getting event off queue " , e);
+ return null;
+ }
+ }
+
+ protected BlockingQueue<AbstractEvent> queue = new LinkedBlockingQueue<AbstractEvent>();
+
+ // Hibernate based event methods......
+
+ public void onDelete(DeleteEvent event) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+
+ if(m_logger.isDebugEnabled()) {
+ m_logger.debug(" Receiving delete event: " + event);
+ }
+ try {
+ queue.put(event);
+ } catch (InterruptedException e) {
+ m_logger.info(" Event was interrupted onDelete on adding to queue",e);
+ }
+ }
+
+ public void onSaveOrUpdate(SaveOrUpdateEvent event) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+
+ if(m_logger.isDebugEnabled()) {
+ m_logger.debug(" Receiving save or update event: " + event);
+ }
+ try {
+ queue.put(event);
+ } catch (InterruptedException e) {
+ m_logger.info(" Event was interrupted onSaveOrUpdate on adding to queue",e);
+ }
+ }
+
+ public void onLoad(LoadEvent event, LoadType type) throws HibernateException {
+ // TODO do something with the type : type.getName()
+ System.out.println("HibernateEventLister!");
+
+ if(m_logger.isDebugEnabled()) {
+ m_logger.debug(" Receiving load event: " + event);
+ }
+ try {
+ queue.put(event);
+ } catch (InterruptedException e) {
+ m_logger.info(" Event was interrupted onLoad on adding to queue",e);
+ }
+
+ }
+
+ /// hibernate message composer
+ public static class HibernateMessageComposer extends AbstractMessageComposer {
+
+ @Override
+ protected void populateMessage(Message message, Object obj) throws MessageDeliverException {
+ Object instanceObj = null;
+ String entityName = null;
+ Serializable entityId = null;
+ Object result = null;
+ EventSource source = null;
+ Serializable requestId = null;
+ String type = null;
+
+
+ if(obj instanceof DeleteEvent) {
+ DeleteEvent devent = (DeleteEvent)obj;
+ entityName = devent.getEntityName();
+ instanceObj = devent.getObject();
+ source = devent.getSession();
+ type = "delete";
+ } else if (obj instanceof SaveOrUpdateEvent) {
+ SaveOrUpdateEvent sevent = (SaveOrUpdateEvent) obj;
+ entityName = sevent.getEntityName();
+ instanceObj = sevent.getObject();
+ source = sevent.getSession();
+ entityId = sevent.getResultId();
+ requestId = sevent.getRequestedId();
+ type = "saveOrUpdate";
+ } else if (obj instanceof LoadEvent) {
+ LoadEvent levent = (LoadEvent)obj;
+ instanceObj = levent.getInstanceToLoad();
+ entityName = levent.getEntityClassName();
+ entityId = levent.getEntityId();
+ result = levent.getResult();
+ source = levent.getSession();
+ type = "load";
+ }
+
+
+
+ if(source != null)
+ message.getProperties().setProperty("eventSource",source);
+ if(instanceObj != null)
+ message.getProperties().setProperty("objectInstance",instanceObj);
+ if(entityId != null)
+ message.getProperties().setProperty("entityId",entityId);
+ if(requestId != null)
+ message.getProperties().setProperty("requestId",requestId);
+ if(entityName != null)
+ message.getProperties().setProperty("entityName",entityName);
+ if(type != null)
+ message.getProperties().setProperty("type",type);
+ }
+
+ public void setConfiguration(ConfigTree config) {
+ }
+
+ }
+
+ /**
+ * Obtain a new database connection with parameter info
+ *
+ * @return A new connection
+ * @throws ConfigurationException -
+ * if problems are encountered
+ */
+ protected HibernateConn getHibernateConn()
+ {
+ if (null == m_conn) {
+ }
+ return m_conn;
+ }
+
+ public void onDelete(DeleteEvent arg0, Set arg1) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onDelete");
+ }
+
+ public void onPostInsert (PostInsertEvent event) {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onPostInsert");
+ }
+
+ public void onDirtyCheck(DirtyCheckEvent arg0) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onDirtyCheck");
+ }
+
+ public void onEvict(EvictEvent arg0) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onEvict");
+ }
+
+ public void onFlushEntity(FlushEntityEvent arg0) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onFlushEntity");
+ }
+
+ public void onFlush(FlushEvent arg0) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onFlush");
+ }
+
+ public void onInitializeCollection(InitializeCollectionEvent arg0) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onEvict");
+ }
+
+ public void onLock(LockEvent arg0) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onLock");
+ }
+
+ public void onMerge(MergeEvent arg0) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onMerge");
+ }
+
+ public void onMerge(MergeEvent arg0, Map arg1) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onMerge");
+ }
+
+ public void onPersist(PersistEvent arg0) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onPersist");
+ }
+
+ public void onPersist(PersistEvent arg0, Map arg1) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onPersist");
+ }
+
+ public void onPostDelete(PostDeleteEvent arg0) {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onPostDelete");
+ }
+
+ public void onPostLoad(PostLoadEvent arg0) {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onPostLoad");
+ }
+
+ public void onPostUpdate(PostUpdateEvent arg0) {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onPostUpdate");
+ }
+
+ public boolean onPreDelete(PreDeleteEvent arg0) {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onPreDelete");
+ return false;
+ }
+
+ public boolean onPreInsert(PreInsertEvent arg0) {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onPreInsert");
+ return false;
+ }
+
+ public void onPreLoad(PreLoadEvent arg0) {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onPreLoad");
+ }
+
+ public boolean onPreUpdate(PreUpdateEvent arg0) {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onPreUpdate");
+ return false;
+ }
+
+ public void onRefresh(RefreshEvent arg0) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onRefresh");
+ }
+
+ public void onRefresh(RefreshEvent arg0, Map arg1) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onRefresh");
+ }
+
+ public void onReplicate(ReplicateEvent arg0) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onReplicate");
+ }
+
+ public void onAutoFlush(AutoFlushEvent arg0) throws HibernateException {
+ System.out.println("HibernateEventLister!");
+ m_logger.error("onAutoFlush");
+ }
+
+}
More information about the jboss-svn-commits
mailing list