Author: epbernard Date: 2008-02-10 14:56:04 -0500 (Sun, 10 Feb 2008) New Revision: 14325 Added: annotations/trunk/src/java/org/hibernate/cfg/search/ annotations/trunk/src/java/org/hibernate/cfg/search/CollectionSearchConfiguration.java annotations/trunk/src/java/org/hibernate/cfg/search/SearchConfiguration.java Modified: annotations/trunk/src/java/org/hibernate/cfg/AnnotationConfiguration.java Log: ANN-695 add HSearch collection event listeners Modified: annotations/trunk/src/java/org/hibernate/cfg/AnnotationConfiguration.java =================================================================== --- annotations/trunk/src/java/org/hibernate/cfg/AnnotationConfiguration.java 2008-02-07 03:51:18 UTC (rev 14324) +++ annotations/trunk/src/java/org/hibernate/cfg/AnnotationConfiguration.java 2008-02-10 19:56:04 UTC (rev 14325) @@ -40,11 +40,13 @@ 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.SearchConfiguration; import org.hibernate.event.PostDeleteEventListener; import org.hibernate.event.PostInsertEventListener; import org.hibernate.event.PostUpdateEventListener; import org.hibernate.event.PreInsertEventListener; import org.hibernate.event.PreUpdateEventListener; +import org.hibernate.event.EventListeners; import org.hibernate.mapping.Column; import org.hibernate.mapping.Join; import org.hibernate.mapping.PersistentClass; @@ -821,104 +823,13 @@ } } } + SearchConfiguration.enableHibernateSearch( getEventListeners(), getProperties() ); - //add search events if the jar is available - boolean enableSearchListeners = !"false".equalsIgnoreCase( getProperty( "hibernate.search.autoregister_listeners" ) ); - Class searchEventListenerClass = null; - try { - searchEventListenerClass = ReflectHelper.classForName( - "org.hibernate.search.event.FullTextIndexEventListener", - AnnotationConfiguration.class ); - } - catch (ClassNotFoundException e) { - //search is not present - log.debug( "Search not present in classpath, ignoring event listener registration" ); - } - if ( enableSearchListeners && searchEventListenerClass != null ) { - //TODO so much duplication - Object searchEventListener; - try { - searchEventListener = searchEventListenerClass.newInstance(); - } - catch (Exception e) { - throw new AnnotationException( "Unable to load Search event listener", e ); - } - { - boolean present = false; - PostInsertEventListener[] listeners = getEventListeners().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]; - for (int i = 0; i < length - 1; i++) { - newListeners[i] = listeners[i]; - } - newListeners[length - 1] = (PostInsertEventListener) searchEventListener; - getEventListeners().setPostInsertEventListeners( newListeners ); - } - } - else { - getEventListeners().setPostInsertEventListeners( - new PostInsertEventListener[] { (PostInsertEventListener) searchEventListener } - ); - } - } - { - boolean present = false; - PostUpdateEventListener[] listeners = getEventListeners().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]; - for (int i = 0; i < length - 1; i++) { - newListeners[i] = listeners[i]; - } - newListeners[length - 1] = (PostUpdateEventListener) searchEventListener; - getEventListeners().setPostUpdateEventListeners( newListeners ); - } - } - else { - getEventListeners().setPostUpdateEventListeners( - new PostUpdateEventListener[] { (PostUpdateEventListener) searchEventListener } - ); - } - } - { - boolean present = false; - PostDeleteEventListener[] listeners = getEventListeners().getPostDeleteEventListeners(); - 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; - PostDeleteEventListener[] newListeners = new PostDeleteEventListener[length]; - for (int i = 0; i < length - 1; i++) { - newListeners[i] = listeners[i]; - } - newListeners[length - 1] = (PostDeleteEventListener) searchEventListener; - getEventListeners().setPostDeleteEventListeners( newListeners ); - } - } - else { - getEventListeners().setPostDeleteEventListeners( - new PostDeleteEventListener[] { (PostDeleteEventListener) searchEventListener } - ); - } - } - } + return super.buildSessionFactory(); } + //not a public API public ReflectionManager getReflectionManager() { return reflectionManager; Added: annotations/trunk/src/java/org/hibernate/cfg/search/CollectionSearchConfiguration.java =================================================================== --- annotations/trunk/src/java/org/hibernate/cfg/search/CollectionSearchConfiguration.java (rev 0) +++ annotations/trunk/src/java/org/hibernate/cfg/search/CollectionSearchConfiguration.java 2008-02-10 19:56:04 UTC (rev 14325) @@ -0,0 +1,83 @@ +//$ +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 } + ); + } + } + } +} Added: annotations/trunk/src/java/org/hibernate/cfg/search/SearchConfiguration.java =================================================================== --- annotations/trunk/src/java/org/hibernate/cfg/search/SearchConfiguration.java (rev 0) +++ annotations/trunk/src/java/org/hibernate/cfg/search/SearchConfiguration.java 2008-02-10 19:56:04 UTC (rev 14325) @@ -0,0 +1,154 @@ +//$ +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.PostInsertEventListener; +import org.hibernate.event.PostUpdateEventListener; +import org.hibernate.event.PostDeleteEventListener; +import org.hibernate.event.EventListeners; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * Helper methods initializing Hibernate Search event listeners + * + * @author Emmanuel Bernard + */ +public class SearchConfiguration { + private static Log log = LogFactory.getLog( SearchConfiguration.class ); + + 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)" ); + } + } + catch (ClassNotFoundException e) { + //search is not present + log.debug( "Search not present in classpath, ignoring event listener registration" ); + } + if ( enableSearchListeners && searchEventListenerClass != null ) { + //TODO so much duplication + Object searchEventListener; + try { + searchEventListener = searchEventListenerClass.newInstance(); + } + catch (Exception e) { + throw new AnnotationException( "Unable to load Search event listener", e ); + } + { + 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 ); + } + } + else { + eventListeners.setPostInsertEventListeners( + new PostInsertEventListener[] { (PostInsertEventListener) 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 ); + } + } + else { + eventListeners.setPostUpdateEventListeners( + new PostUpdateEventListener[] { (PostUpdateEventListener) searchEventListener } + ); + } + } + { + 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.setPostDeleteEventListeners( + new PostDeleteEventListener[] { (PostDeleteEventListener) searchEventListener } + ); + } + } + 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 ); + } + catch (Exception e) { + throw new AnnotationException( "Unable to load Search event listener", e ); + } + } + } + } +}