Author: hardy.ferentschik
Date: 2008-07-04 11:52:20 -0400 (Fri, 04 Jul 2008)
New Revision: 14874

Removed:
 annotations/trunk/src/java/org/hibernate/cfg/search/CollectionSearchConfiguration.java
Modified:
 annotations/trunk/src/java/org/hibernate/cfg/search/SearchConfiguration.java
Log:
HSEARCH-209:
* Refactored event listener configuration for Search. Moved special handling for collection since we now move to Core 3.3. Moved code from CollectionSearchConfiguration back into SearchConfiguration and deleted CollectionSearchConfiguration.

Deleted: annotations/trunk/src/java/org/hibernate/cfg/search/CollectionSearchConfiguration.java
===================================================================
--- annotations/trunk/src/java/org/hibernate/cfg/search/CollectionSearchConfiguration.java  2008-07-04 10:31:40 UTC (rev 14873)
+++ annotations/trunk/src/java/org/hibernate/cfg/search/CollectionSearchConfiguration.java  2008-07-04 15:52:20 UTC (rev 14874)
@@(protected) @@
-//$
-package org.hibernate.cfg.search;
-
-import org.hibernate.event.EventListeners;
-import org.hibernate.event.PostCollectionRecreateEventListener;
-import org.hibernate.event.PostCollectionRemoveEventListener;
-import org.hibernate.event.PostCollectionUpdateEventListener;
-
-/**
- * Enable collection event listeners for Hibernate Search
- *
- * @author Emmanuel Bernard
- */
-public class CollectionSearchConfiguration {
-  public static void enableHibernateSearch(EventListeners eventListeners, Object searchEventListener, Class searchEventListenerClass) {
-    {
-      boolean present = false;
-      PostCollectionRecreateEventListener[] listeners = eventListeners.getPostCollectionRecreateEventListeners();
-      if ( listeners != null ) {
-        for (Object eventListener : listeners) {
-          //not isAssignableFrom since the user could subclass
-          present = present || searchEventListenerClass == eventListener.getClass();
-        }
-        if ( !present ) {
-          int length = listeners.length + 1;
-          PostCollectionRecreateEventListener[] newListeners = new PostCollectionRecreateEventListener[length];
-          System.arraycopy( listeners, 0, newListeners, 0, length - 1 );
-          newListeners[length - 1] = (PostCollectionRecreateEventListener) searchEventListener;
-          eventListeners.setPostCollectionRecreateEventListeners( newListeners );
-        }
-      }
-      else {
-        eventListeners.setPostCollectionRecreateEventListeners(
-            new PostCollectionRecreateEventListener[] { (PostCollectionRecreateEventListener) searchEventListener }
-        );
-      }
-    }
-    {
-      boolean present = false;
-      PostCollectionRemoveEventListener[] listeners = eventListeners.getPostCollectionRemoveEventListeners();
-      if ( listeners != null ) {
-        for (Object eventListener : listeners) {
-          //not isAssignableFrom since the user could subclass
-          present = present || searchEventListenerClass == eventListener.getClass();
-        }
-        if ( !present ) {
-          int length = listeners.length + 1;
-          PostCollectionRemoveEventListener[] newListeners = new PostCollectionRemoveEventListener[length];
-          System.arraycopy( listeners, 0, newListeners, 0, length - 1 );
-          newListeners[length - 1] = (PostCollectionRemoveEventListener) searchEventListener;
-          eventListeners.setPostCollectionRemoveEventListeners( newListeners );
-        }
-      }
-      else {
-        eventListeners.setPostCollectionRemoveEventListeners(
-            new PostCollectionRemoveEventListener[] { (PostCollectionRemoveEventListener) searchEventListener }
-        );
-      }
-    }
-    {
-      boolean present = false;
-      PostCollectionUpdateEventListener[] listeners = eventListeners.getPostCollectionUpdateEventListeners();
-      if ( listeners != null ) {
-        for (Object eventListener : listeners) {
-          //not isAssignableFrom since the user could subclass
-          present = present || searchEventListenerClass == eventListener.getClass();
-        }
-        if ( !present ) {
-          int length = listeners.length + 1;
-          PostCollectionUpdateEventListener[] newListeners = new PostCollectionUpdateEventListener[length];
-          System.arraycopy( listeners, 0, newListeners, 0, length - 1 );
-          newListeners[length - 1] = (PostCollectionUpdateEventListener) searchEventListener;
-          eventListeners.setPostCollectionUpdateEventListeners( newListeners );
-        }
-      }
-      else {
-        eventListeners.setPostCollectionUpdateEventListeners(
-            new PostCollectionUpdateEventListener[] { (PostCollectionUpdateEventListener) searchEventListener }
-        );
-      }
-    }
-  }
-}

Modified: annotations/trunk/src/java/org/hibernate/cfg/search/SearchConfiguration.java
===================================================================
--- annotations/trunk/src/java/org/hibernate/cfg/search/SearchConfiguration.java  2008-07-04 10:31:40 UTC (rev 14873)
+++ annotations/trunk/src/java/org/hibernate/cfg/search/SearchConfiguration.java  2008-07-04 15:52:20 UTC (rev 14874)
@@(protected) @@
-//$
+// $Id:$
package org.hibernate.cfg.search;

import java.util.Properties;
-import java.lang.reflect.Method;

-import org.hibernate.util.ReflectHelper;
import org.hibernate.AnnotationException;
+import org.hibernate.event.EventListeners;
+import org.hibernate.event.PostCollectionRecreateEventListener;
+import org.hibernate.event.PostCollectionRemoveEventListener;
+import org.hibernate.event.PostCollectionUpdateEventListener;
+import org.hibernate.event.PostDeleteEventListener;
import org.hibernate.event.PostInsertEventListener;
import org.hibernate.event.PostUpdateEventListener;
-import org.hibernate.event.PostDeleteEventListener;
-import org.hibernate.event.EventListeners;
+import org.hibernate.util.ReflectHelper;
+import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.slf4j.Logger;

/**
- * Helper methods initializing Hibernate Search event listeners
- *
+ * Helper methods initializing Hibernate Search event listeners.
+ *
* @author Emmanuel Bernard
+ * @author Hardy Ferentschik
*/
public class SearchConfiguration {
-  private static final Logger log = LoggerFactory.getLogger( SearchConfiguration.class );

+  private static final Logger log = LoggerFactory.getLogger(SearchConfiguration.class);
+
+  /**
+   * Class name of the class needed to enable Search.
+   */
+  private static final String FULL_TEXT_INDEX_EVENT_LISTENER_CLASS = "org.hibernate.search.event.FullTextIndexEventListener";
+
+  @SuppressWarnings("unchecked")
 public static void enableHibernateSearch(EventListeners eventListeners, Properties properties) {
-    //add search events if the jar is available
-    boolean enableSearchListeners = !"false".equalsIgnoreCase( properties.getProperty( "hibernate.search.autoregister_listeners" ) );
-    boolean enableCollectionSearchListeners = false;
-    Class searchEventListenerClass = null;
-    Class nonCollectionSearchEventListener = null;
-    try {
-      searchEventListenerClass = ReflectHelper.classForName(
-          "org.hibernate.search.event.FullTextIndexEventListener",
-          SearchConfiguration.class );
-      nonCollectionSearchEventListener = searchEventListenerClass;
-      //after Hibernate Core 3.2.6 and Hibernate Search 3.0.1
-      try {
-        ReflectHelper.classForName(
-            "org.hibernate.event.AbstractCollectionEvent",
-            SearchConfiguration.class );
-        // Core 3.2.6 is here
-        searchEventListenerClass = ReflectHelper.classForName(
-            "org.hibernate.search.event.FullTextIndexCollectionEventListener",
-            SearchConfiguration.class );
-        // Search 3.0.1 is here
-        enableCollectionSearchListeners = true;
-
-      }
-      catch (ClassNotFoundException e) {
-        //collection listeners not present
-        log.debug( "Hibernate Search collection listeners not present " +
-            "(upgrate to Hibernate Core 3.2.6 and above and Hibernate Search 3.0.1 and above)" );
-      }
+    // check whether search is explicitly enabled - if so there is nothing
+    // to do
+    String enableSearchListeners = properties.getProperty( "hibernate.search.autoregister_listeners" );
+    if("false".equalsIgnoreCase(enableSearchListeners )) {
+      log.info("Property hibernate.search.autoregister_listeners is set to false." +
+          " No attempt will be made to register Hibernate Search event listeners.");
+      return;
   }
-    catch (ClassNotFoundException e) {
-      //search is not present
-      log.debug( "Search not present in classpath, ignoring event listener registration" );
+    
+    // add search events if the jar is available and class can be loaded
+    Class searchEventListenerClass = attemptToLoadSearchEventListener();
+    if ( searchEventListenerClass == null ) {
+      log.info("Unable to find {} on the classpath. Hibernate Search is not enabled.", FULL_TEXT_INDEX_EVENT_LISTENER_CLASS);
+      return;
   }
-    if ( enableSearchListeners && searchEventListenerClass != null ) {
-      //TODO so much duplication
-      Object searchEventListener;
-      try {
-        searchEventListener = searchEventListenerClass.newInstance();
+    
+    Object searchEventListener = instantiateEventListener(searchEventListenerClass);
+    
+    //TODO Generalize this. Pretty much the same code all the time. Reflecetion?
+    {
+      boolean present = false;
+      PostInsertEventListener[] listeners = eventListeners
+          .getPostInsertEventListeners();
+      if (listeners != null) {
+        for (Object eventListener : listeners) {
+          // not isAssignableFrom since the user could subclass
+          present = present
+              || searchEventListenerClass == eventListener
+                  .getClass();
+        }
+        if (!present) {
+          int length = listeners.length + 1;
+          PostInsertEventListener[] newListeners = new PostInsertEventListener[length];
+          System.arraycopy(listeners, 0, newListeners, 0, length - 1);
+          newListeners[length - 1] = (PostInsertEventListener) searchEventListener;
+          eventListeners.setPostInsertEventListeners(newListeners);
+        }
+      } else {
+        eventListeners
+            .setPostInsertEventListeners(new PostInsertEventListener[] { (PostInsertEventListener) searchEventListener });
     }
-      catch (Exception e) {
-        throw new AnnotationException( "Unable to load Search event listener", e );
+    }
+    {
+      boolean present = false;
+      PostUpdateEventListener[] listeners = eventListeners
+          .getPostUpdateEventListeners();
+      if (listeners != null) {
+        for (Object eventListener : listeners) {
+          // not isAssignableFrom since the user could subclass
+          present = present
+              || searchEventListenerClass == eventListener
+                  .getClass();
+        }
+        if (!present) {
+          int length = listeners.length + 1;
+          PostUpdateEventListener[] newListeners = new PostUpdateEventListener[length];
+          System.arraycopy(listeners, 0, newListeners, 0, length - 1);
+          newListeners[length - 1] = (PostUpdateEventListener) searchEventListener;
+          eventListeners.setPostUpdateEventListeners(newListeners);
+        }
+      } else {
+        eventListeners
+            .setPostUpdateEventListeners(new PostUpdateEventListener[] { (PostUpdateEventListener) searchEventListener });
     }
-      {
-        boolean present = false;
-        PostInsertEventListener[] listeners = eventListeners.getPostInsertEventListeners();
-        if ( listeners != null ) {
-          for (Object eventListener : listeners) {
-            //not isAssignableFrom since the user could subclass
-            present = present ||
-                searchEventListenerClass == eventListener.getClass() ||
-                ( enableCollectionSearchListeners && nonCollectionSearchEventListener == eventListener.getClass() );
-          }
-          if ( !present ) {
-            int length = listeners.length + 1;
-            PostInsertEventListener[] newListeners = new PostInsertEventListener[length];
-            System.arraycopy( listeners, 0, newListeners, 0, length - 1 );
-            newListeners[length - 1] = (PostInsertEventListener) searchEventListener;
-            eventListeners.setPostInsertEventListeners( newListeners );
-          }
+    }
+    {
+      boolean present = false;
+      PostDeleteEventListener[] listeners = eventListeners
+          .getPostDeleteEventListeners();
+      if (listeners != null) {
+        for (Object eventListener : listeners) {
+          // not isAssignableFrom since the user could subclass
+          present = present
+              || searchEventListenerClass == eventListener
+                  .getClass();
       }
-        else {
-          eventListeners.setPostInsertEventListeners(
-              new PostInsertEventListener[] { (PostInsertEventListener) searchEventListener }
-          );
+        if (!present) {
+          int length = listeners.length + 1;
+          PostDeleteEventListener[] newListeners = new PostDeleteEventListener[length];
+          System.arraycopy(listeners, 0, newListeners, 0, length - 1);
+          newListeners[length - 1] = (PostDeleteEventListener) searchEventListener;
+          eventListeners.setPostDeleteEventListeners(newListeners);
       }
+      } else {
+        eventListeners
+            .setPostDeleteEventListeners(new PostDeleteEventListener[] { (PostDeleteEventListener) searchEventListener });
     }
-      {
-        boolean present = false;
-        PostUpdateEventListener[] listeners = eventListeners.getPostUpdateEventListeners();
-        if ( listeners != null ) {
-          for (Object eventListener : listeners) {
-            //not isAssignableFrom since the user could subclass
-            present = present ||
-                searchEventListenerClass == eventListener.getClass() ||
-                ( enableCollectionSearchListeners && nonCollectionSearchEventListener == eventListener.getClass() );
-          }
-          if ( !present ) {
-            int length = listeners.length + 1;
-            PostUpdateEventListener[] newListeners = new PostUpdateEventListener[length];
-            System.arraycopy( listeners, 0, newListeners, 0, length - 1 );
-            newListeners[length - 1] = (PostUpdateEventListener) searchEventListener;
-            eventListeners.setPostUpdateEventListeners( newListeners );
-          }
+    }    
+    {
+      boolean present = false;
+      PostCollectionRecreateEventListener[] listeners = eventListeners.getPostCollectionRecreateEventListeners();
+      if ( listeners != null ) {
+        for (Object eventListener : listeners) {
+          //not isAssignableFrom since the user could subclass
+          present = present || searchEventListenerClass == eventListener.getClass();
       }
-        else {
-          eventListeners.setPostUpdateEventListeners(
-              new PostUpdateEventListener[] { (PostUpdateEventListener) searchEventListener }
-          );
+        if ( !present ) {
+          int length = listeners.length + 1;
+          PostCollectionRecreateEventListener[] newListeners = new PostCollectionRecreateEventListener[length];
+          System.arraycopy( listeners, 0, newListeners, 0, length - 1 );
+          newListeners[length - 1] = (PostCollectionRecreateEventListener) searchEventListener;
+          eventListeners.setPostCollectionRecreateEventListeners( newListeners );
       }
     }
-      {
-        boolean present = false;
-        PostDeleteEventListener[] listeners = eventListeners.getPostDeleteEventListeners();
-        if ( listeners != null ) {
-          for (Object eventListener : listeners) {
-            //not isAssignableFrom since the user could subclass
-            present = present ||
-                searchEventListenerClass == eventListener.getClass() ||
-                ( enableCollectionSearchListeners && nonCollectionSearchEventListener == eventListener.getClass() );
-          }
-          if ( !present ) {
-            int length = listeners.length + 1;
-            PostDeleteEventListener[] newListeners = new PostDeleteEventListener[length];
-            System.arraycopy( listeners, 0, newListeners, 0, length - 1 );
-            newListeners[length - 1] = (PostDeleteEventListener) searchEventListener;
-            eventListeners.setPostDeleteEventListeners( newListeners );
-          }
+      else {
+        eventListeners.setPostCollectionRecreateEventListeners(
+            new PostCollectionRecreateEventListener[] { (PostCollectionRecreateEventListener) searchEventListener }
+        );
+      }
+    }
+    {
+      boolean present = false;
+      PostCollectionRemoveEventListener[] listeners = eventListeners.getPostCollectionRemoveEventListeners();
+      if ( listeners != null ) {
+        for (Object eventListener : listeners) {
+          //not isAssignableFrom since the user could subclass
+          present = present || searchEventListenerClass == eventListener.getClass();
       }
-        else {
-          eventListeners.setPostDeleteEventListeners(
-              new PostDeleteEventListener[] { (PostDeleteEventListener) searchEventListener }
-          );
+        if ( !present ) {
+          int length = listeners.length + 1;
+          PostCollectionRemoveEventListener[] newListeners = new PostCollectionRemoveEventListener[length];
+          System.arraycopy( listeners, 0, newListeners, 0, length - 1 );
+          newListeners[length - 1] = (PostCollectionRemoveEventListener) searchEventListener;
+          eventListeners.setPostCollectionRemoveEventListeners( newListeners );
       }
     }
-      if (enableCollectionSearchListeners) {
-        try {
-          Class collectionSearchConfigurationClass = ReflectHelper.classForName(
-            "org.hibernate.cfg.search.CollectionSearchConfiguration",
-            SearchConfiguration.class );
-          Method method = collectionSearchConfigurationClass.getDeclaredMethod( "enableHibernateSearch",
-              EventListeners.class, Object.class, Class.class );
-          method.invoke( null, eventListeners, searchEventListener, searchEventListenerClass );
+      else {
+        eventListeners.setPostCollectionRemoveEventListeners(
+            new PostCollectionRemoveEventListener[] { (PostCollectionRemoveEventListener) searchEventListener }
+        );
+      }
+    }
+    {
+      boolean present = false;
+      PostCollectionUpdateEventListener[] listeners = eventListeners.getPostCollectionUpdateEventListeners();
+      if ( listeners != null ) {
+        for (Object eventListener : listeners) {
+          //not isAssignableFrom since the user could subclass
+          present = present || searchEventListenerClass == eventListener.getClass();
       }
-        catch (Exception e) {
-          throw new AnnotationException( "Unable to load Search event listener", e );
+        if ( !present ) {
+          int length = listeners.length + 1;
+          PostCollectionUpdateEventListener[] newListeners = new PostCollectionUpdateEventListener[length];
+          System.arraycopy( listeners, 0, newListeners, 0, length - 1 );
+          newListeners[length - 1] = (PostCollectionUpdateEventListener) searchEventListener;
+          eventListeners.setPostCollectionUpdateEventListeners( newListeners );
       }
     }
+      else {
+        eventListeners.setPostCollectionUpdateEventListeners(
+            new PostCollectionUpdateEventListener[] { (PostCollectionUpdateEventListener) searchEventListener }
+        );
+      }
+    }    
+  }
+
+  /**
+   * Tries to load Hibernate Search event listener.
+   *
+   * @return An event listener instance in case the jar was available.
+   */
+  @SuppressWarnings("unchecked")
+  private static Class attemptToLoadSearchEventListener() {
+    Class searchEventListenerClass = null;
+    try {
+      searchEventListenerClass = ReflectHelper.classForName(
+          FULL_TEXT_INDEX_EVENT_LISTENER_CLASS,
+          SearchConfiguration.class);
+    } catch (ClassNotFoundException e) {
+      log
+          .debug("Search not present in classpath, ignoring event listener registration.");
   }
+    return searchEventListenerClass;
 }
+
+  @SuppressWarnings("unchecked")
+  private static Object instantiateEventListener(Class clazz) {
+    Object searchEventListener = null;
+    try {
+      searchEventListener = clazz.newInstance();
+    } catch (Exception e) {
+      throw new AnnotationException(
+          "Unable to load Search event listener", e);
+    }
+    return searchEventListener;
+  }
}

_______________________________________________
hibernate-commits mailing list
hibernate-commits@(protected)
https://lists.jboss.org/mailman/listinfo/hibernate-commits