[hibernate-commits] Hibernate SVN: r14975 - in annotations/trunk/src/java/org/hibernate/cfg: search and 1 other directory.
hibernate-commits at lists.jboss.org
hibernate-commits at lists.jboss.org
Tue Jul 29 08:24:18 EDT 2008
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)
@@ -5,6 +5,7 @@
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;
@@ -18,6 +19,7 @@
import java.util.ResourceBundle;
import java.util.Set;
import java.util.StringTokenizer;
+
import javax.persistence.Entity;
import javax.persistence.MappedSuperclass;
@@ -36,7 +38,7 @@
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;
@@ -47,10 +49,10 @@
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 {@link Configuration} object but handles EJB3 and Hibernate
@@ -62,6 +64,16 @@
@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
@@ -855,12 +867,49 @@
}
}
}
- 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)
@@ -1,154 +1,227 @@
-//$
+// $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 {@link org.hibernate.search.cfg.EventListenerBoostrap}
* @author Emmanuel Bernard
+ * @author Hardy Ferentschik
*/
+ at Deprecated
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 {@link org.hibernate.search.cfg.EventListenerRegister#enableHibernateSearch(EventListeners, Properties)}
+ */
+ @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;
+ }
}
More information about the hibernate-commits
mailing list