Author: epbernard Date: 2010-10-14 13:30:18 -0400 (Thu, 14 Oct 2010) New Revision: 20833 Added: search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/MutableSearchFactoryState.java search/trunk/hibernate-search/src/main/java/org/hibernate/search/spi/internals/SearchFactoryImplementorWithShareableState.java search/trunk/hibernate-search/src/main/java/org/hibernate/search/spi/internals/SearchFactoryState.java Removed: search/trunk/hibernate-search/src/main/java/org/hibernate/search/spi/internals/StateSearchFactoryImplementor.java Modified: search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/ImmutableSearchFactory.java search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/MutableSearchFactory.java search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/SearchFactoryBuilder.java Log: HSEARCH-555 Properly expose as public API the SearchFactoryBuilder Create a SearchFactoryState to decouple the builder from the ImmutableSearchFactory Make SearchFactoryState be a super interface of the contract describing SearchFactoryImplementor with shareable state Modified: search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/ImmutableSearchFactory.java =================================================================== --- search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/ImmutableSearchFactory.java 2010-10-14 12:58:00 UTC (rev 20832) +++ search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/ImmutableSearchFactory.java 2010-10-14 17:30:18 UTC (rev 20833) @@ -34,6 +34,8 @@ import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.search.Similarity; +import org.hibernate.search.spi.internals.SearchFactoryImplementorWithShareableState; +import org.hibernate.search.spi.internals.SearchFactoryState; import org.slf4j.Logger; import org.hibernate.annotations.common.AssertionFailure; @@ -65,7 +67,6 @@ import org.hibernate.search.spi.WorkerBuildContext; import org.hibernate.search.spi.internals.DirectoryProviderData; import org.hibernate.search.spi.internals.PolymorphicIndexHierarchy; -import org.hibernate.search.spi.internals.StateSearchFactoryImplementor; import org.hibernate.search.stat.Statistics; import org.hibernate.search.stat.StatisticsImpl; import org.hibernate.search.stat.StatisticsImplementor; @@ -79,7 +80,7 @@ * * @author Emmanuel Bernard */ -public class ImmutableSearchFactory implements StateSearchFactoryImplementor, WorkerBuildContext { +public class ImmutableSearchFactory implements SearchFactoryImplementorWithShareableState, WorkerBuildContext { static { Version.touch(); @@ -110,22 +111,22 @@ private final Map<DirectoryProvider, LuceneIndexingParameters> dirProviderIndexingParams; private final String indexingStrategy; - public ImmutableSearchFactory(SearchFactoryBuilder cfg) { - this.analyzers = cfg.analyzers; - this.backendQueueProcessorFactory = cfg.backendQueueProcessorFactory; - this.cacheBitResultsSize = cfg.cacheBitResultsSize; - this.configurationProperties = cfg.configurationProperties; - this.dirProviderData = cfg.dirProviderData; - this.dirProviderIndexingParams = cfg.dirProviderIndexingParams; - this.documentBuildersIndexedEntities = cfg.documentBuildersIndexedEntities; - this.documentBuildersContainedEntities = cfg.documentBuildersContainedEntities; - this.errorHandler = cfg.errorHandler; - this.filterCachingStrategy = cfg.filterCachingStrategy; - this.filterDefinitions = cfg.filterDefinitions; - this.indexHierarchy = cfg.indexHierarchy; - this.indexingStrategy = cfg.indexingStrategy; - this.readerProvider = cfg.readerProvider; - this.worker = cfg.worker; + public ImmutableSearchFactory(SearchFactoryState state) { + this.analyzers = state.getAnalyzers(); + this.backendQueueProcessorFactory = state.getBackendQueueProcessorFactory(); + this.cacheBitResultsSize = state.getCacheBitResultsSize(); + this.configurationProperties = state.getConfigurationProperties(); + this.dirProviderData = state.getDirectoryProviderData(); + this.dirProviderIndexingParams = state.getDirectoryProviderIndexingParams(); + this.documentBuildersIndexedEntities = state.getDocumentBuildersIndexedEntities(); + this.documentBuildersContainedEntities = state.getDocumentBuildersContainedEntities(); + this.errorHandler = state.getErrorHandler(); + this.filterCachingStrategy = state.getFilterCachingStrategy(); + this.filterDefinitions = state.getFilterDefinitions(); + this.indexHierarchy = state.getIndexHierarchy(); + this.indexingStrategy = state.getIndexingStrategy(); + this.readerProvider = state.getReaderProvider(); + this.worker = state.getWorker(); this.statistics = new StatisticsImpl( this ); String enableStats = configurationProperties.getProperty( Environment.GENERATE_STATS ); if ( "true".equalsIgnoreCase( enableStats ) ) { Modified: search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/MutableSearchFactory.java =================================================================== --- search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/MutableSearchFactory.java 2010-10-14 12:58:00 UTC (rev 20832) +++ search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/MutableSearchFactory.java 2010-10-14 17:30:18 UTC (rev 20833) @@ -47,7 +47,7 @@ import org.hibernate.search.spi.SearchFactoryIntegrator; import org.hibernate.search.spi.internals.DirectoryProviderData; import org.hibernate.search.spi.internals.PolymorphicIndexHierarchy; -import org.hibernate.search.spi.internals.StateSearchFactoryImplementor; +import org.hibernate.search.spi.internals.SearchFactoryImplementorWithShareableState; import org.hibernate.search.stat.Statistics; import org.hibernate.search.stat.StatisticsImplementor; import org.hibernate.search.store.DirectoryProvider; @@ -60,16 +60,16 @@ * * @author Emmanuel Bernard */ -public class MutableSearchFactory implements StateSearchFactoryImplementor, SearchFactoryIntegrator { +public class MutableSearchFactory implements SearchFactoryImplementorWithShareableState, SearchFactoryIntegrator { //a reference to the same instance of this class is help by clients and various HSearch services //when changing the SearchFactory internals, only the underlying delegate should be changed. //the volatile ensure that the state is replicated upong underlying factory switch. - private volatile StateSearchFactoryImplementor delegate; + private volatile SearchFactoryImplementorWithShareableState delegate; //lock to be acquired every time the underlying searchFactory is rebuilt private final Lock mutating = new ReentrantLock(); - void setDelegate(StateSearchFactoryImplementor delegate) { + void setDelegate(SearchFactoryImplementorWithShareableState delegate) { this.delegate = delegate; } @@ -77,6 +77,10 @@ return delegate.getBackendQueueProcessorFactory(); } + public void setBackendQueueProcessorFactory(BackendQueueProcessorFactory backendQueueProcessorFactory) { + delegate.setBackendQueueProcessorFactory(backendQueueProcessorFactory); + } + public Map<String, FilterDef> getFilterDefinitions() { return delegate.getFilterDefinitions(); } Added: search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/MutableSearchFactoryState.java =================================================================== --- search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/MutableSearchFactoryState.java (rev 0) +++ search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/MutableSearchFactoryState.java 2010-10-14 17:30:18 UTC (rev 20833) @@ -0,0 +1,180 @@ +package org.hibernate.search.impl; + +import org.apache.lucene.analysis.Analyzer; +import org.hibernate.search.backend.BackendQueueProcessorFactory; +import org.hibernate.search.backend.LuceneIndexingParameters; +import org.hibernate.search.backend.Worker; +import org.hibernate.search.engine.DocumentBuilderContainedEntity; +import org.hibernate.search.engine.DocumentBuilderIndexedEntity; +import org.hibernate.search.engine.FilterDef; +import org.hibernate.search.exception.ErrorHandler; +import org.hibernate.search.filter.FilterCachingStrategy; +import org.hibernate.search.reader.ReaderProvider; +import org.hibernate.search.spi.internals.DirectoryProviderData; +import org.hibernate.search.spi.internals.PolymorphicIndexHierarchy; +import org.hibernate.search.spi.internals.SearchFactoryState; +import org.hibernate.search.store.DirectoryProvider; + +import java.util.Map; +import java.util.Properties; + +/** + * Shared factory state + * + * @author Emmanuel Bernard + */ +public class MutableSearchFactoryState implements SearchFactoryState { + private Map<Class<?>, DocumentBuilderContainedEntity<?>> documentBuildersContainedEntities; + private Map<DirectoryProvider<?>, DirectoryProviderData> directoryProviderData; + private Map<Class<?>, DocumentBuilderIndexedEntity<?>> documentBuildersIndexedEntities; + private String indexingStrategy; + private Worker worker; + private ReaderProvider readerProvider; + private BackendQueueProcessorFactory backendQueueProcessorFactory; + private Map<String, FilterDef> filterDefinitions; + private FilterCachingStrategy filterCachingStrategy; + private Map<String, Analyzer> analyzers; + private int cacheBitResultsSize; + private Properties configurationProperties; + private ErrorHandler errorHandler; + private PolymorphicIndexHierarchy indexHierarchy; + private Map<DirectoryProvider, LuceneIndexingParameters> directoryProviderIndexingParams; + + public void copyStateFromOldFactory(SearchFactoryState oldFactoryState) { + indexingStrategy = oldFactoryState.getIndexingStrategy(); + documentBuildersIndexedEntities = oldFactoryState.getDocumentBuildersIndexedEntities(); + documentBuildersContainedEntities = oldFactoryState.getDocumentBuildersContainedEntities(); + directoryProviderData = oldFactoryState.getDirectoryProviderData(); + worker = oldFactoryState.getWorker(); + readerProvider = oldFactoryState.getReaderProvider(); + backendQueueProcessorFactory = oldFactoryState.getBackendQueueProcessorFactory(); + filterDefinitions = oldFactoryState.getFilterDefinitions(); + filterCachingStrategy = oldFactoryState.getFilterCachingStrategy(); + analyzers = oldFactoryState.getAnalyzers(); + cacheBitResultsSize = oldFactoryState.getCacheBitResultsSize(); + configurationProperties = oldFactoryState.getConfigurationProperties(); + errorHandler = oldFactoryState.getErrorHandler(); + indexHierarchy = oldFactoryState.getIndexHierarchy(); + directoryProviderIndexingParams = oldFactoryState.getDirectoryProviderIndexingParams(); + } + + public Map<Class<?>, DocumentBuilderContainedEntity<?>> getDocumentBuildersContainedEntities() { + return documentBuildersContainedEntities; + } + + public Map<DirectoryProvider<?>, DirectoryProviderData> getDirectoryProviderData() { + return directoryProviderData; + } + + public Map<Class<?>, DocumentBuilderIndexedEntity<?>> getDocumentBuildersIndexedEntities() { + return documentBuildersIndexedEntities; + } + + public String getIndexingStrategy() { + return indexingStrategy; + } + + public Worker getWorker() { + return worker; + } + + public ReaderProvider getReaderProvider() { + return readerProvider; + } + + public BackendQueueProcessorFactory getBackendQueueProcessorFactory() { + return backendQueueProcessorFactory; + } + + public Map<String, FilterDef> getFilterDefinitions() { + return filterDefinitions; + } + + public FilterCachingStrategy getFilterCachingStrategy() { + return filterCachingStrategy; + } + + public Map<String, Analyzer> getAnalyzers() { + return analyzers; + } + + public int getCacheBitResultsSize() { + return cacheBitResultsSize; + } + + public Properties getConfigurationProperties() { + return configurationProperties; + } + + public ErrorHandler getErrorHandler() { + return errorHandler; + } + + public PolymorphicIndexHierarchy getIndexHierarchy() { + return indexHierarchy; + } + + public Map<DirectoryProvider, LuceneIndexingParameters> getDirectoryProviderIndexingParams() { + return directoryProviderIndexingParams; + } + + public void setDocumentBuildersContainedEntities(Map<Class<?>, DocumentBuilderContainedEntity<?>> documentBuildersContainedEntities) { + this.documentBuildersContainedEntities = documentBuildersContainedEntities; + } + + public void setDirectoryProviderData(Map<DirectoryProvider<?>, DirectoryProviderData> directoryProviderData) { + this.directoryProviderData = directoryProviderData; + } + + public void setDocumentBuildersIndexedEntities(Map<Class<?>, DocumentBuilderIndexedEntity<?>> documentBuildersIndexedEntities) { + this.documentBuildersIndexedEntities = documentBuildersIndexedEntities; + } + + public void setIndexingStrategy(String indexingStrategy) { + this.indexingStrategy = indexingStrategy; + } + + public void setWorker(Worker worker) { + this.worker = worker; + } + + public void setReaderProvider(ReaderProvider readerProvider) { + this.readerProvider = readerProvider; + } + + public void setBackendQueueProcessorFactory(BackendQueueProcessorFactory backendQueueProcessorFactory) { + this.backendQueueProcessorFactory = backendQueueProcessorFactory; + } + + public void setFilterDefinitions(Map<String, FilterDef> filterDefinitions) { + this.filterDefinitions = filterDefinitions; + } + + public void setFilterCachingStrategy(FilterCachingStrategy filterCachingStrategy) { + this.filterCachingStrategy = filterCachingStrategy; + } + + public void setAnalyzers(Map<String, Analyzer> analyzers) { + this.analyzers = analyzers; + } + + public void setCacheBitResultsSize(int cacheBitResultsSize) { + this.cacheBitResultsSize = cacheBitResultsSize; + } + + public void setConfigurationProperties(Properties configurationProperties) { + this.configurationProperties = configurationProperties; + } + + public void setErrorHandler(ErrorHandler errorHandler) { + this.errorHandler = errorHandler; + } + + public void setIndexHierarchy(PolymorphicIndexHierarchy indexHierarchy) { + this.indexHierarchy = indexHierarchy; + } + + public void setDirectoryProviderIndexingParams(Map<DirectoryProvider, LuceneIndexingParameters> directoryProviderIndexingParams) { + this.directoryProviderIndexingParams = directoryProviderIndexingParams; + } +} Modified: search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/SearchFactoryBuilder.java =================================================================== --- search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/SearchFactoryBuilder.java 2010-10-14 12:58:00 UTC (rev 20832) +++ search/trunk/hibernate-search/src/main/java/org/hibernate/search/impl/SearchFactoryBuilder.java 2010-10-14 17:30:18 UTC (rev 20833) @@ -36,8 +36,9 @@ import java.util.Set; import java.util.concurrent.locks.ReentrantLock; -import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.search.Similarity; +import org.hibernate.search.spi.internals.SearchFactoryImplementorWithShareableState; +import org.hibernate.search.spi.internals.SearchFactoryState; import org.slf4j.Logger; import org.hibernate.annotations.common.reflection.MetadataProvider; @@ -59,7 +60,6 @@ import org.hibernate.search.backend.BackendQueueProcessorFactory; import org.hibernate.search.backend.LuceneIndexingParameters; import org.hibernate.search.backend.UpdatableBackendQueueProcessorFactory; -import org.hibernate.search.backend.Worker; import org.hibernate.search.backend.WorkerFactory; import org.hibernate.search.backend.configuration.ConfigurationParseHelper; import org.hibernate.search.cfg.SearchConfiguration; @@ -77,13 +77,11 @@ import org.hibernate.search.filter.ShardSensitiveOnlyFilter; import org.hibernate.search.jmx.IndexControl; import org.hibernate.search.jmx.JMXRegistrar; -import org.hibernate.search.reader.ReaderProvider; import org.hibernate.search.reader.ReaderProviderFactory; import org.hibernate.search.spi.WorkerBuildContext; import org.hibernate.search.spi.WritableBuildContext; import org.hibernate.search.spi.internals.DirectoryProviderData; import org.hibernate.search.spi.internals.PolymorphicIndexHierarchy; -import org.hibernate.search.spi.internals.StateSearchFactoryImplementor; import org.hibernate.search.store.DirectoryProvider; import org.hibernate.search.store.DirectoryProviderFactory; import org.hibernate.search.store.optimization.OptimizerStrategy; @@ -92,7 +90,7 @@ import org.hibernate.search.util.ReflectionHelper; /** - * Build a search factory. + * Build a search factory following the builder pattern. * * @author Emmanuel Bernard * @author Hardy Ferentschik @@ -123,24 +121,7 @@ return this; } - //processing properties - ReflectionManager reflectionManager; - String indexingStrategy; - Map<Class<?>, DocumentBuilderIndexedEntity<?>> documentBuildersIndexedEntities; - Map<Class<?>, DocumentBuilderContainedEntity<?>> documentBuildersContainedEntities; - //keep track of the index modifiers per DirectoryProvider since multiple entity can use the same directory provider - Map<DirectoryProvider<?>, DirectoryProviderData> dirProviderData; - Worker worker; - ReaderProvider readerProvider; - BackendQueueProcessorFactory backendQueueProcessorFactory; - Map<String, FilterDef> filterDefinitions; - FilterCachingStrategy filterCachingStrategy; - Map<String, Analyzer> analyzers; - int cacheBitResultsSize; - Properties configurationProperties; - ErrorHandler errorHandler; - PolymorphicIndexHierarchy indexHierarchy; - Map<DirectoryProvider, LuceneIndexingParameters> dirProviderIndexingParams; + private final MutableSearchFactoryState factoryState = new MutableSearchFactoryState(); public SearchFactoryImplementor buildSearchFactory() { SearchFactoryImplementor searchFactoryImplementor; @@ -154,7 +135,7 @@ searchFactoryImplementor = buildIncrementalSearchFactory(); } - String enableJMX = configurationProperties.getProperty( Environment.JMX_ENABLED ); + String enableJMX = factoryState.getConfigurationProperties().getProperty( Environment.JMX_ENABLED ); if ( "true".equalsIgnoreCase( enableJMX ) ) { enableIndexControlBean( searchFactoryImplementor ); } @@ -165,6 +146,7 @@ if ( !searchFactoryImplementor.isJMXEnabled() ) { return; } + final Properties configurationProperties = factoryState.getConfigurationProperties(); // if we don't have a JNDI bound SessionFactory we cannot enable the index control bean if ( StringHelper.isEmpty( configurationProperties.getProperty( "hibernate.session_factory_name" ) ) ) { @@ -188,17 +170,17 @@ if ( classes.size() == 0 ) { return rootFactory; } - + final Properties configurationProperties = factoryState.getConfigurationProperties(); BuildContext buildContext = new BuildContext(); - copyStateFromOldFactory( rootFactory ); + factoryState.copyStateFromOldFactory( rootFactory ); //TODO we don't keep the reflectionManager. Is that an issue? IncrementalSearchConfiguration cfg = new IncrementalSearchConfiguration( classes, configurationProperties ); - reflectionManager = getReflectionManager( cfg ); - //TODO programmatic mapping support + final ReflectionManager reflectionManager = getReflectionManager( cfg ); + //TODO programmatic mapping support //FIXME The current initDocumentBuilders initDocumentBuilders( cfg, reflectionManager, buildContext ); - + final Map<Class<?>, DocumentBuilderIndexedEntity<?>> documentBuildersIndexedEntities = factoryState.getDocumentBuildersIndexedEntities(); Set<Class<?>> indexedClasses = documentBuildersIndexedEntities.keySet(); for ( DocumentBuilderIndexedEntity builder : documentBuildersIndexedEntities.values() ) { //FIXME improve this algorithm to deal with adding new classes to the class hierarchy. @@ -206,20 +188,21 @@ builder.postInitialize( indexedClasses ); } //not really necessary today + final Map<Class<?>, DocumentBuilderContainedEntity<?>> documentBuildersContainedEntities = factoryState.getDocumentBuildersContainedEntities(); for ( DocumentBuilderContainedEntity builder : documentBuildersContainedEntities.values() ) { builder.postInitialize( indexedClasses ); } fillSimilarityMapping(); //update backend - final BackendQueueProcessorFactory backend = this.backendQueueProcessorFactory; + final BackendQueueProcessorFactory backend = factoryState.getBackendQueueProcessorFactory(); if ( backend instanceof UpdatableBackendQueueProcessorFactory ) { final UpdatableBackendQueueProcessorFactory updatableBackend = ( UpdatableBackendQueueProcessorFactory ) backend; - updatableBackend.updateDirectoryProviders( this.dirProviderData.keySet(), buildContext ); + updatableBackend.updateDirectoryProviders( factoryState.getDirectoryProviderData().keySet(), buildContext ); } //safe for incremental init at least the ShredBufferReaderProvider //this.readerProvider = ReaderProviderFactory.createReaderProvider( cfg, this ); - StateSearchFactoryImplementor factory = new ImmutableSearchFactory( this ); + SearchFactoryImplementorWithShareableState factory = new ImmutableSearchFactory( factoryState ); rootFactory.setDelegate( factory ); return rootFactory; @@ -240,30 +223,12 @@ } } - private void copyStateFromOldFactory(StateSearchFactoryImplementor stateFactory) { - indexingStrategy = stateFactory.getIndexingStrategy(); - documentBuildersIndexedEntities = stateFactory.getDocumentBuildersIndexedEntities(); - documentBuildersContainedEntities = stateFactory.getDocumentBuildersContainedEntities(); - dirProviderData = stateFactory.getDirectoryProviderData(); - worker = stateFactory.getWorker(); - readerProvider = stateFactory.getReaderProvider(); - backendQueueProcessorFactory = stateFactory.getBackendQueueProcessorFactory(); - filterDefinitions = stateFactory.getFilterDefinitions(); - filterCachingStrategy = stateFactory.getFilterCachingStrategy(); - analyzers = stateFactory.getAnalyzers(); - cacheBitResultsSize = stateFactory.getCacheBitResultsSize(); - configurationProperties = stateFactory.getConfigurationProperties(); - errorHandler = stateFactory.getErrorHandler(); - indexHierarchy = stateFactory.getIndexHierarchy(); - dirProviderIndexingParams = stateFactory.getDirectoryProviderIndexingParams(); - } - private SearchFactoryImplementor buildNewSearchFactory() { createCleanFactoryState(); - configurationProperties = cfg.getProperties(); - errorHandler = createErrorHandler( configurationProperties ); - reflectionManager = getReflectionManager( cfg ); + factoryState.setConfigurationProperties( cfg.getProperties() ); + factoryState.setErrorHandler( createErrorHandler( factoryState.getConfigurationProperties() ) ); + final ReflectionManager reflectionManager = getReflectionManager( cfg ); BuildContext buildContext = new BuildContext(); final SearchMapping mapping = SearchMappingBuilder.getSearchMapping( cfg ); @@ -279,34 +244,39 @@ injector.setMetadataProvider( new MappingModelMetadataProvider( original, mapping ) ); } - indexingStrategy = defineIndexingStrategy( cfg );//need to be done before the document builds - dirProviderIndexingParams = new HashMap<DirectoryProvider, LuceneIndexingParameters>(); + factoryState.setIndexingStrategy( defineIndexingStrategy( cfg ) );//need to be done before the document builds + factoryState.setDirectoryProviderIndexingParams( new HashMap<DirectoryProvider, LuceneIndexingParameters>() ); initDocumentBuilders( cfg, reflectionManager, buildContext ); + final Map<Class<?>, DocumentBuilderIndexedEntity<?>> documentBuildersIndexedEntities = factoryState.getDocumentBuildersIndexedEntities(); Set<Class<?>> indexedClasses = documentBuildersIndexedEntities.keySet(); for ( DocumentBuilderIndexedEntity builder : documentBuildersIndexedEntities.values() ) { builder.postInitialize( indexedClasses ); } //not really necessary today + final Map<Class<?>, DocumentBuilderContainedEntity<?>> documentBuildersContainedEntities = factoryState.getDocumentBuildersContainedEntities(); for ( DocumentBuilderContainedEntity builder : documentBuildersContainedEntities.values() ) { builder.postInitialize( indexedClasses ); } fillSimilarityMapping(); //build back end - this.worker = WorkerFactory.createWorker( cfg, buildContext ); - this.readerProvider = ReaderProviderFactory.createReaderProvider( cfg, buildContext ); - this.filterCachingStrategy = buildFilterCachingStrategy( cfg.getProperties() ); - this.cacheBitResultsSize = ConfigurationParseHelper.getIntValue( - cfg.getProperties(), Environment.CACHE_DOCIDRESULTS_SIZE, CachingWrapperFilter.DEFAULT_SIZE + factoryState.setWorker( WorkerFactory.createWorker( cfg, buildContext ) ); + factoryState.setReaderProvider( ReaderProviderFactory.createReaderProvider( cfg, buildContext ) ); + factoryState.setFilterCachingStrategy( buildFilterCachingStrategy( cfg.getProperties() ) ); + factoryState.setCacheBitResultsSize( + ConfigurationParseHelper.getIntValue( + cfg.getProperties(), Environment.CACHE_DOCIDRESULTS_SIZE, CachingWrapperFilter.DEFAULT_SIZE + ) ); - StateSearchFactoryImplementor factory = new ImmutableSearchFactory( this ); + SearchFactoryImplementorWithShareableState factory = new ImmutableSearchFactory( factoryState ); rootFactory.setDelegate( factory ); return rootFactory; } private void fillSimilarityMapping() { - for ( DirectoryProviderData directoryConfiguration : dirProviderData.values() ) { + final Map<Class<?>, DocumentBuilderIndexedEntity<?>> documentBuildersIndexedEntities = factoryState.getDocumentBuildersIndexedEntities(); + for ( DirectoryProviderData directoryConfiguration : factoryState.getDirectoryProviderData().values() ) { for ( Class<?> indexedType : directoryConfiguration.getClasses() ) { DocumentBuilderIndexedEntity<?> documentBuilder = documentBuildersIndexedEntities.get( indexedType ); Similarity similarity = documentBuilder.getSimilarity(); @@ -343,12 +313,13 @@ private void createCleanFactoryState() { if ( rootFactory == null ) { + //set the mutable structure of factory state rootFactory = new MutableSearchFactory(); - documentBuildersIndexedEntities = new HashMap<Class<?>, DocumentBuilderIndexedEntity<?>>(); - documentBuildersContainedEntities = new HashMap<Class<?>, DocumentBuilderContainedEntity<?>>(); - dirProviderData = new HashMap<DirectoryProvider<?>, DirectoryProviderData>(); - filterDefinitions = new HashMap<String, FilterDef>(); - indexHierarchy = new PolymorphicIndexHierarchy(); + factoryState.setDocumentBuildersIndexedEntities( new HashMap<Class<?>, DocumentBuilderIndexedEntity<?>>() ); + factoryState.setDocumentBuildersContainedEntities( new HashMap<Class<?>, DocumentBuilderContainedEntity<?>>() ); + factoryState.setDirectoryProviderData( new HashMap<DirectoryProvider<?>, DirectoryProviderData>() ); + factoryState.setFilterDefinitions( new HashMap<String, FilterDef>() ); + factoryState.setIndexHierarchy( new PolymorphicIndexHierarchy() ); } } @@ -364,7 +335,9 @@ initProgrammaticAnalyzers( context, reflectionManager ); initProgrammaticallyDefinedFilterDef( reflectionManager ); - + final PolymorphicIndexHierarchy indexingHierarchy = factoryState.getIndexHierarchy(); + final Map<Class<?>, DocumentBuilderIndexedEntity<?>> documentBuildersIndexedEntities = factoryState.getDocumentBuildersIndexedEntities(); + final Map<Class<?>, DocumentBuilderContainedEntity<?>> documentBuildersContainedEntities = factoryState.getDocumentBuildersContainedEntities(); while ( iter.hasNext() ) { Class<?> mappedClass = iter.next(); if ( mappedClass == null ) { @@ -393,7 +366,7 @@ reflectionManager ); - indexHierarchy.addIndexedClass( mappedClass ); + indexingHierarchy.addIndexedClass( mappedClass ); documentBuildersIndexedEntities.put( mappedClass, documentBuilder ); } else { @@ -410,7 +383,7 @@ bindFilterDefs( mappedXClass ); //TODO should analyzer def for classes at tyher sqme level??? } - analyzers = context.initLazyAnalyzers(); + factoryState.setAnalyzers( context.initLazyAnalyzers() ); factory.startDirectoryProviders(); } @@ -428,7 +401,7 @@ } private void bindFilterDef(FullTextFilterDef defAnn, XClass mappedXClass) { - if ( filterDefinitions.containsKey( defAnn.name() ) ) { + if ( factoryState.getFilterDefinitions().containsKey( defAnn.name() ) ) { throw new SearchException( "Multiple definition of @FullTextFilterDef.name=" + defAnn.name() + ": " + mappedXClass.getName() @@ -440,9 +413,10 @@ private void bindFullTextFilterDef(FullTextFilterDef defAnn) { FilterDef filterDef = new FilterDef( defAnn ); + final Map<String, FilterDef> filterDefinition = factoryState.getFilterDefinitions(); if ( filterDef.getImpl().equals( ShardSensitiveOnlyFilter.class ) ) { //this is a placeholder don't process regularly - filterDefinitions.put( defAnn.name(), filterDef ); + filterDefinition.put( defAnn.name(), filterDef ); return; } try { @@ -481,7 +455,7 @@ filterDef.addSetter( Introspector.decapitalize( name.substring( 3 ) ), method ); } } - filterDefinitions.put( defAnn.name(), filterDef ); + filterDefinition.put( defAnn.name(), filterDef ); } private void initProgrammaticAnalyzers(ConfigContext context, ReflectionManager reflectionManager) { @@ -501,6 +475,7 @@ @SuppressWarnings("unchecked") Map defaults = reflectionManager.getDefaults(); FullTextFilterDef[] filterDefs = ( FullTextFilterDef[] ) defaults.get( FullTextFilterDefs.class ); if ( filterDefs != null && filterDefs.length != 0 ) { + final Map<String, FilterDef> filterDefinitions = factoryState.getFilterDefinitions(); for ( FullTextFilterDef defAnn : filterDefs ) { if ( filterDefinitions.containsKey( defAnn.name() ) ) { throw new SearchException( "Multiple definition of @FullTextFilterDef.name=" + defAnn.name() ); @@ -546,8 +521,15 @@ return indexingStrategy; } + /** + * Implementation of the Hibernate Search SPI WritableBuildContext and WorkerBuildContext + * The data is provided by the SearchFactoryState object associated to SearchFactoryBuilder. + */ private class BuildContext implements WritableBuildContext, WorkerBuildContext { + private final SearchFactoryState factoryState = SearchFactoryBuilder.this.factoryState; + public void addOptimizerStrategy(DirectoryProvider<?> provider, OptimizerStrategy optimizerStrategy) { + final Map<DirectoryProvider<?>, DirectoryProviderData> dirProviderData = factoryState.getDirectoryProviderData(); DirectoryProviderData data = dirProviderData.get( provider ); if ( data == null ) { data = new DirectoryProviderData(); @@ -557,10 +539,11 @@ } public void addIndexingParameters(DirectoryProvider<?> provider, LuceneIndexingParameters indexingParams) { - dirProviderIndexingParams.put( provider, indexingParams ); + factoryState.getDirectoryProviderIndexingParams().put( provider, indexingParams ); } public void addClassToDirectoryProvider(Class<?> entity, DirectoryProvider<?> directoryProvider, boolean exclusiveIndexUsage) { + final Map<DirectoryProvider<?>, DirectoryProviderData> dirProviderData = factoryState.getDirectoryProviderData(); DirectoryProviderData data = dirProviderData.get( directoryProvider ); if ( data == null ) { data = new DirectoryProviderData(); @@ -575,35 +558,35 @@ } public String getIndexingStrategy() { - return indexingStrategy; + return factoryState.getIndexingStrategy(); } public Set<DirectoryProvider<?>> getDirectoryProviders() { - return SearchFactoryBuilder.this.dirProviderData.keySet(); + return factoryState.getDirectoryProviderData().keySet(); } public void setBackendQueueProcessorFactory(BackendQueueProcessorFactory backendQueueProcessorFactory) { - SearchFactoryBuilder.this.backendQueueProcessorFactory = backendQueueProcessorFactory; + factoryState.setBackendQueueProcessorFactory( backendQueueProcessorFactory ); } public OptimizerStrategy getOptimizerStrategy(DirectoryProvider<?> provider) { - return dirProviderData.get( provider ).getOptimizerStrategy(); + return factoryState.getDirectoryProviderData().get( provider ).getOptimizerStrategy(); } public Set<Class<?>> getClassesInDirectoryProvider(DirectoryProvider<?> directoryProvider) { - return Collections.unmodifiableSet( dirProviderData.get( directoryProvider ).getClasses() ); + return Collections.unmodifiableSet( factoryState.getDirectoryProviderData().get( directoryProvider ).getClasses() ); } public LuceneIndexingParameters getIndexingParameters(DirectoryProvider<?> provider) { - return dirProviderIndexingParams.get( provider ); + return factoryState.getDirectoryProviderIndexingParams().get( provider ); } public ReentrantLock getDirectoryProviderLock(DirectoryProvider<?> dp) { - return SearchFactoryBuilder.this.dirProviderData.get( dp ).getDirLock(); + return factoryState.getDirectoryProviderData().get( dp ).getDirLock(); } public Similarity getSimilarity(DirectoryProvider<?> provider) { - Similarity similarity = dirProviderData.get( provider ).getSimilarity(); + Similarity similarity = factoryState.getDirectoryProviderData().get( provider ).getSimilarity(); if ( similarity == null ) { throw new SearchException( "Assertion error: a similarity should be defined for each provider" ); } @@ -611,16 +594,16 @@ } public boolean isExclusiveIndexUsageEnabled(DirectoryProvider<?> provider) { - return dirProviderData.get( provider ).isExclusiveIndexUsage(); + return factoryState.getDirectoryProviderData().get( provider ).isExclusiveIndexUsage(); } public ErrorHandler getErrorHandler() { - return errorHandler; + return factoryState.getErrorHandler(); } @SuppressWarnings("unchecked") public <T> DocumentBuilderIndexedEntity<T> getDocumentBuilderIndexedEntity(Class<T> entityType) { - return ( DocumentBuilderIndexedEntity<T> ) documentBuildersIndexedEntities.get( entityType ); + return ( DocumentBuilderIndexedEntity<T> ) factoryState.getDocumentBuildersIndexedEntities().get( entityType ); } } Added: search/trunk/hibernate-search/src/main/java/org/hibernate/search/spi/internals/SearchFactoryImplementorWithShareableState.java =================================================================== --- search/trunk/hibernate-search/src/main/java/org/hibernate/search/spi/internals/SearchFactoryImplementorWithShareableState.java (rev 0) +++ search/trunk/hibernate-search/src/main/java/org/hibernate/search/spi/internals/SearchFactoryImplementorWithShareableState.java 2010-10-14 17:30:18 UTC (rev 20833) @@ -0,0 +1,27 @@ +package org.hibernate.search.spi.internals; + +import java.util.Map; +import java.util.Properties; + +import org.apache.lucene.analysis.Analyzer; + +import org.hibernate.search.backend.BackendQueueProcessorFactory; +import org.hibernate.search.backend.LuceneIndexingParameters; +import org.hibernate.search.backend.Worker; +import org.hibernate.search.engine.DocumentBuilderContainedEntity; +import org.hibernate.search.engine.DocumentBuilderIndexedEntity; +import org.hibernate.search.engine.FilterDef; +import org.hibernate.search.engine.SearchFactoryImplementor; +import org.hibernate.search.exception.ErrorHandler; +import org.hibernate.search.filter.FilterCachingStrategy; +import org.hibernate.search.reader.ReaderProvider; +import org.hibernate.search.store.DirectoryProvider; + +/** + * Search Factory implementor exposing its sharable state. + * The state can then be extracted and used to mutate factories. + * + * @author Emmanuel Bernard + */ +public interface SearchFactoryImplementorWithShareableState extends SearchFactoryImplementor, SearchFactoryState { +} Copied: search/trunk/hibernate-search/src/main/java/org/hibernate/search/spi/internals/SearchFactoryState.java (from rev 20832, search/trunk/hibernate-search/src/main/java/org/hibernate/search/spi/internals/StateSearchFactoryImplementor.java) =================================================================== --- search/trunk/hibernate-search/src/main/java/org/hibernate/search/spi/internals/SearchFactoryState.java (rev 0) +++ search/trunk/hibernate-search/src/main/java/org/hibernate/search/spi/internals/SearchFactoryState.java 2010-10-14 17:30:18 UTC (rev 20833) @@ -0,0 +1,55 @@ +package org.hibernate.search.spi.internals; + +import org.apache.lucene.analysis.Analyzer; +import org.hibernate.search.backend.BackendQueueProcessorFactory; +import org.hibernate.search.backend.LuceneIndexingParameters; +import org.hibernate.search.backend.Worker; +import org.hibernate.search.engine.DocumentBuilderContainedEntity; +import org.hibernate.search.engine.DocumentBuilderIndexedEntity; +import org.hibernate.search.engine.FilterDef; +import org.hibernate.search.exception.ErrorHandler; +import org.hibernate.search.filter.FilterCachingStrategy; +import org.hibernate.search.reader.ReaderProvider; +import org.hibernate.search.store.DirectoryProvider; + +import java.util.Map; +import java.util.Properties; + +/** + * Represents the sharable state of a search factory + * + * @author Emmanuel Bernard + */ +public interface SearchFactoryState { + Map<Class<?>, DocumentBuilderContainedEntity<?>> getDocumentBuildersContainedEntities(); + + Map<DirectoryProvider<?>, DirectoryProviderData> getDirectoryProviderData(); + + Map<Class<?>, DocumentBuilderIndexedEntity<?>> getDocumentBuildersIndexedEntities(); + + String getIndexingStrategy(); + + Worker getWorker(); + + ReaderProvider getReaderProvider(); + + BackendQueueProcessorFactory getBackendQueueProcessorFactory(); + + void setBackendQueueProcessorFactory(BackendQueueProcessorFactory backendQueueProcessorFactory); + + Map<String, FilterDef> getFilterDefinitions(); + + FilterCachingStrategy getFilterCachingStrategy(); + + Map<String, Analyzer> getAnalyzers(); + + int getCacheBitResultsSize(); + + Properties getConfigurationProperties(); + + ErrorHandler getErrorHandler(); + + PolymorphicIndexHierarchy getIndexHierarchy(); + + Map<DirectoryProvider, LuceneIndexingParameters> getDirectoryProviderIndexingParams(); +} Deleted: search/trunk/hibernate-search/src/main/java/org/hibernate/search/spi/internals/StateSearchFactoryImplementor.java =================================================================== --- search/trunk/hibernate-search/src/main/java/org/hibernate/search/spi/internals/StateSearchFactoryImplementor.java 2010-10-14 12:58:00 UTC (rev 20832) +++ search/trunk/hibernate-search/src/main/java/org/hibernate/search/spi/internals/StateSearchFactoryImplementor.java 2010-10-14 17:30:18 UTC (rev 20833) @@ -1,55 +0,0 @@ -package org.hibernate.search.spi.internals; - -import java.util.Map; -import java.util.Properties; - -import org.apache.lucene.analysis.Analyzer; - -import org.hibernate.search.backend.BackendQueueProcessorFactory; -import org.hibernate.search.backend.LuceneIndexingParameters; -import org.hibernate.search.backend.Worker; -import org.hibernate.search.engine.DocumentBuilderContainedEntity; -import org.hibernate.search.engine.DocumentBuilderIndexedEntity; -import org.hibernate.search.engine.FilterDef; -import org.hibernate.search.engine.SearchFactoryImplementor; -import org.hibernate.search.exception.ErrorHandler; -import org.hibernate.search.filter.FilterCachingStrategy; -import org.hibernate.search.reader.ReaderProvider; -import org.hibernate.search.store.DirectoryProvider; - -/** - * State constituting a SearchFactory - * @author Emmanuel Bernard - */ -public interface StateSearchFactoryImplementor extends SearchFactoryImplementor { - - Map<Class<?>, DocumentBuilderContainedEntity<?>> getDocumentBuildersContainedEntities(); - - Map<DirectoryProvider<?>, DirectoryProviderData> getDirectoryProviderData(); - - Map<Class<?>, DocumentBuilderIndexedEntity<?>> getDocumentBuildersIndexedEntities(); - - String getIndexingStrategy(); - - Worker getWorker(); - - ReaderProvider getReaderProvider(); - - BackendQueueProcessorFactory getBackendQueueProcessorFactory(); - - Map<String, FilterDef> getFilterDefinitions(); - - FilterCachingStrategy getFilterCachingStrategy(); - - Map<String, Analyzer> getAnalyzers(); - - int getCacheBitResultsSize(); - - Properties getConfigurationProperties(); - - ErrorHandler getErrorHandler(); - - PolymorphicIndexHierarchy getIndexHierarchy(); - - Map<DirectoryProvider, LuceneIndexingParameters> getDirectoryProviderIndexingParams(); -}