Author: hardy.ferentschik
Date: 2008-07-29 08:24:18 -0400 (Tue, 29 Jul 2008)
New Revision: 14975

Modified:
 annotations/trunk/src/java/org/hibernate/cfg/AnnotationConfiguration.java
 annotations/trunk/src/java/org/hibernate/cfg/search/HibernateSearchEventListenerRegister.java
Log:
Deprecated HibernateSearchEventListenerRegister and moved the logic into EventListenerRegister in Search.

Modified: annotations/trunk/src/java/org/hibernate/cfg/AnnotationConfiguration.java
===================================================================
--- annotations/trunk/src/java/org/hibernate/cfg/AnnotationConfiguration.java  2008-07-28 23:10:06 UTC (rev 14974)
+++ annotations/trunk/src/java/org/hibernate/cfg/AnnotationConfiguration.java  2008-07-29 12:24:18 UTC (rev 14975)
@@(protected) @@
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
@@(protected) @@
import java.util.ResourceBundle;
import java.util.Set;
import java.util.StringTokenizer;
+
import javax.persistence.Entity;
import javax.persistence.MappedSuperclass;

@@(protected) @@
import org.hibernate.annotations.common.reflection.XClass;
import org.hibernate.cfg.annotations.Version;
import org.hibernate.cfg.annotations.reflection.EJB3ReflectionManager;
-import org.hibernate.cfg.search.HibernateSearchEventListenerRegister;
+import org.hibernate.event.EventListeners;
import org.hibernate.event.PreInsertEventListener;
import org.hibernate.event.PreUpdateEventListener;
import org.hibernate.mapping.Column;
@@(protected) @@
import org.hibernate.util.JoinedIterator;
import org.hibernate.util.ReflectHelper;
import org.hibernate.util.StringHelper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;

/**
* Similar to the {@(protected)
@@(protected) @@
@SuppressWarnings({"unchecked", "serial"})
public class AnnotationConfiguration extends Configuration {
 private Logger log = LoggerFactory.getLogger( AnnotationConfiguration.class );
+  
+  /**
+   * Class name of the class needed to enable Search.
+   */
+  private static final String SEARCH_STARTUP_CLASS = "org.hibernate.search.cfg.EventListenerRegister";
+  
+  /**
+   * Method to call to enable Search.
+   */  
+  private static final String SEARCH_STARTUP_METHOD = "enableHibernateSearch";

 static {
   Version.touch(); //touch version
@@(protected) @@
       }
     }
   }
-    HibernateSearchEventListenerRegister.enableHibernateSearch( getEventListeners(), getProperties() );
-
-
+    
+    enableHibernateSearch();
+    
   return super.buildSessionFactory();
 }

+  /**
+   * Tries to automatically register Hibernate Search event listeners by locating the
+   * appropriate bootstrap class and calling the <code>enableHibernateSearch</code> method.
+   */
+  private void enableHibernateSearch() {
+    // load the bootstrap class
+    Class searchStartupClass = null;
+    try {
+      searchStartupClass = ReflectHelper.classForName(SEARCH_STARTUP_CLASS, AnnotationConfiguration.class);  
+    } catch ( ClassNotFoundException e ) {
+      // TODO remove this together with SearchConfiguration after 3.1.0 release of Search
+      // try loading deprecated HibernateSearchEventListenerRegister
+      try {
+        searchStartupClass = ReflectHelper.classForName("org.hibernate.cfg.search.HibernateSearchEventListenerRegister", AnnotationConfiguration.class);
+      } catch ( ClassNotFoundException cnfe ) {
+        log.debug("Search not present in classpath, ignoring event listener registration.");
+        return;
+      }
+    }
+    
+    // call the method for registering the listeners
+    try {
+      Object searchStartupInstance = searchStartupClass.newInstance();
+      Method enableSearchMethod = searchStartupClass.getDeclaredMethod(SEARCH_STARTUP_METHOD,
+          EventListeners.class, Properties.class);
+      enableSearchMethod.invoke(searchStartupInstance, getEventListeners(), getProperties());
+    } catch ( InstantiationException e ) {
+      log.debug("Unable to instantiate {}, ignoring event listener registration.", SEARCH_STARTUP_CLASS);
+    } catch ( IllegalAccessException e ) {
+      log.debug("Unable to instantiate {}, ignoring event listener registration.", SEARCH_STARTUP_CLASS);
+    } catch ( NoSuchMethodException e ) {
+      log.debug("Method enableHibernateSearch() not found in {}.", SEARCH_STARTUP_CLASS);
+    } catch ( InvocationTargetException e ) {
+      log.debug("Unable to execute {}, ignoring event listener registration.", SEARCH_STARTUP_METHOD);
+    }
+  }
+
 @Override
 public AnnotationConfiguration addFile(String xmlFile) throws MappingException {
   super.addFile( xmlFile );

Modified: annotations/trunk/src/java/org/hibernate/cfg/search/HibernateSearchEventListenerRegister.java
===================================================================
--- annotations/trunk/src/java/org/hibernate/cfg/search/HibernateSearchEventListenerRegister.java  2008-07-28 23:10:06 UTC (rev 14974)
+++ annotations/trunk/src/java/org/hibernate/cfg/search/HibernateSearchEventListenerRegister.java  2008-07-29 12:24:18 UTC (rev 14975)
@@(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.
+ *
+ * @deprecated as of release 3.4.0.CR1, replaced by Hibernate Search's {@(protected)}
* @author Emmanuel Bernard
+ * @author Hardy Ferentschik
*/
+@(protected)
public class HibernateSearchEventListenerRegister {
-  private static final Logger log = LoggerFactory.getLogger( HibernateSearchEventListenerRegister.class );

+  private static final Logger log = LoggerFactory.getLogger(HibernateSearchEventListenerRegister.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";
+
+  /**
+   * @deprecated as of release 3.4.0.CR1, replaced by Hibernate Search's {@(protected))}
+   */
+  @SuppressWarnings("unchecked")
+  @Deprecated
 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",
-          HibernateSearchEventListenerRegister.class );
-      nonCollectionSearchEventListener = searchEventListenerClass;
-      //after Hibernate Core 3.2.6 and Hibernate Search 3.0.1
-      try {
-        ReflectHelper.classForName(
-            "org.hibernate.event.AbstractCollectionEvent",
-            HibernateSearchEventListenerRegister.class );
-        // Core 3.2.6 is here
-        searchEventListenerClass = ReflectHelper.classForName(
-            "org.hibernate.search.event.FullTextIndexCollectionEventListener",
-            HibernateSearchEventListenerRegister.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",
-            HibernateSearchEventListenerRegister.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,
+          HibernateSearchEventListenerRegister.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