diff --git a/src/main/java/org/springframework/data/gemfire/config/annotation/IndexConfiguration.java b/src/main/java/org/springframework/data/gemfire/config/annotation/IndexConfiguration.java index 5672931f..93835ffb 100644 --- a/src/main/java/org/springframework/data/gemfire/config/annotation/IndexConfiguration.java +++ b/src/main/java/org/springframework/data/gemfire/config/annotation/IndexConfiguration.java @@ -224,7 +224,6 @@ public class IndexConfiguration extends EntityDefinedRegionsConfiguration { }); } - /* (non-Javadoc) */ private String toRegionName(String from) { return Optional.ofNullable(from) @@ -233,13 +232,12 @@ public class IndexConfiguration extends EntityDefinedRegionsConfiguration { boolean isSubRegionPath = from.lastIndexOf(Region.SEPARATOR) > 0; - return (!isSubRegionPath && from.startsWith(Region.SEPARATOR) ? from.substring(1) : from); + return !isSubRegionPath && from.startsWith(Region.SEPARATOR) ? from.substring(1) : from; }) .orElseThrow(() -> newIllegalArgumentException("From clause [%s] is required", from)); } - /* (non-Javadoc) */ private String toRegionPath(String from) { return Optional.ofNullable(from) @@ -281,8 +279,11 @@ public class IndexConfiguration extends EntityDefinedRegionsConfiguration { String indexName = luceneIndexAttributes.getString("name"); - boolean destroy = (luceneIndexAttributes.containsKey("destroy") - && luceneIndexAttributes.getBoolean("destroy")); + boolean destroy = luceneIndexAttributes.containsKey("destroy") + && luceneIndexAttributes.getBoolean("destroy"); + + luceneIndexFactoryBeanBuilder.addPropertyReference("cache", + GemfireConstants.DEFAULT_GEMFIRE_CACHE_NAME); luceneIndexFactoryBeanBuilder.addPropertyValue("destroy", destroy); @@ -298,7 +299,6 @@ public class IndexConfiguration extends EntityDefinedRegionsConfiguration { }); } - /* (non-Javadoc) */ private List resolveIndexConfigurers() { return Optional.ofNullable(this.indexConfigurers) @@ -316,46 +316,45 @@ public class IndexConfiguration extends EntityDefinedRegionsConfiguration { ); } - /* (non-Javadoc) */ private boolean resolveDefine(AnnotationAttributes enableIndexingAttributes) { - return (enableIndexingAttributes.containsKey("define") - && enableIndexingAttributes.getBoolean("define")); + + return enableIndexingAttributes.containsKey("define") + && enableIndexingAttributes.getBoolean("define"); } - /* (non-Javadoc) */ @SuppressWarnings("unused") private String resolveExpression(GemfirePersistentEntity persistentEntity, GemfirePersistentProperty persistentProperty, AnnotationAttributes indexedAttributes) { - String expression = (indexedAttributes.containsKey("expression") - ? indexedAttributes.getString("expression") : null); + String expression = indexedAttributes.containsKey("expression") + ? indexedAttributes.getString("expression") + : null; return (StringUtils.hasText(expression) ? expression : persistentProperty.getName()); } - /* (non-Javadoc) */ @SuppressWarnings("unused") private String resolveFrom(GemfirePersistentEntity persistentEntity, GemfirePersistentProperty persistentProperty, AnnotationAttributes indexedAttributes) { - String from = (indexedAttributes.containsKey("from") - ? indexedAttributes.getString("from") : null); + String from = indexedAttributes.containsKey("from") + ? indexedAttributes.getString("from") + : null; return (StringUtils.hasText(from) ? from : persistentEntity.getRegionName()); } - /* (non-Javadoc) */ private String resolveName(GemfirePersistentEntity persistentEntity, GemfirePersistentProperty persistentProperty, AnnotationAttributes indexedAttributes, IndexType indexType) { - String indexName = (indexedAttributes.containsKey("name") - ? indexedAttributes.getString("name") : null); + String indexName = indexedAttributes.containsKey("name") + ? indexedAttributes.getString("name") + : null; return (StringUtils.hasText(indexName) ? indexName : generateIndexName(persistentEntity, persistentProperty, indexType)); } - /* (non-Javadoc) */ private String generateIndexName(GemfirePersistentEntity persistentEntity, GemfirePersistentProperty persistentProperty, IndexType indexType) { @@ -364,13 +363,13 @@ public class IndexConfiguration extends EntityDefinedRegionsConfiguration { StringUtils.capitalize(indexType.name().toLowerCase())); } - /* (non-Javadoc) */ @SuppressWarnings("unused") private IndexType resolveType(GemfirePersistentEntity persistentEntity, GemfirePersistentProperty persistentProperty, AnnotationAttributes indexedAttributes, IndexType indexType) { - IndexType resolvedIndexType = (indexedAttributes.containsKey("type") - ? indexedAttributes.getEnum("type") : null); + IndexType resolvedIndexType = indexedAttributes.containsKey("type") + ? indexedAttributes.getEnum("type") + : null; return Optional.ofNullable(resolvedIndexType).orElse(indexType); } diff --git a/src/test/java/org/springframework/data/gemfire/config/annotation/EnableLuceneIndexingConfigurationIntegrationTests.java b/src/test/java/org/springframework/data/gemfire/config/annotation/EnableLuceneIndexingConfigurationIntegrationTests.java new file mode 100644 index 00000000..3f1b1058 --- /dev/null +++ b/src/test/java/org/springframework/data/gemfire/config/annotation/EnableLuceneIndexingConfigurationIntegrationTests.java @@ -0,0 +1,102 @@ +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.data.gemfire.config.annotation; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.Collection; +import java.util.stream.Collectors; + +import javax.annotation.Resource; + +import org.apache.geode.cache.Region; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.DependsOn; +import org.springframework.data.gemfire.search.lucene.ProjectingLuceneOperations; +import org.springframework.data.gemfire.search.lucene.ProjectingLuceneTemplate; +import org.springframework.data.gemfire.test.model.Book; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringRunner; + +/** + * The EnableLuceneIndexingConfigurationIntegrationTests class... + * + * @author John Blum + * @since 1.0.0 + */ +@RunWith(SpringRunner.class) +@ContextConfiguration +@SuppressWarnings("unused") +public class EnableLuceneIndexingConfigurationIntegrationTests { + + @Autowired + private ProjectingLuceneOperations luceneTemplate; + + @Resource(name = "Books") + private Region books; + + @Before + public void setup() { + + long isbn = 1L; + + put(Book.newBook(++isbn, "Lord of the Rings - The Fellowship of the Ring")); + put(Book.newBook(++isbn, "Star Wars III - Revenge of the Sith")); + put(Book.newBook(++isbn, "Hitch Hikers Guide to the Galaxy")); + put(Book.newBook(++isbn, "Star Wars VI - Return of the Jedi")); + put(Book.newBook(++isbn, "Lord of the Rings - The Two Towers")); + put(Book.newBook(++isbn, "Star Wars VIII - The Last Jedi")); + put(Book.newBook(++isbn, "Lord of the Rings - The Return of the King")); + } + + private void put(Book book) { + this.books.put(book.getId(), book); + } + + @Test + public void searchForAllStarWarsBooksIsSuccessful() { + + Collection books = + this.luceneTemplate.query("title: Star Wars*", "title", BookTitleView.class); + + assertThat(books).isNotNull(); + assertThat(books).hasSize(3); + assertThat(books.stream().map(BookTitleView::getTitle).collect(Collectors.toList())) + .containsOnly("Star Wars III - Revenge of the Sith", "Star Wars VI - Return of the Jedi", + "Star Wars VIII - The Last Jedi"); + } + + @PeerCacheApplication(name = "EnableLuceneIndexingConfigurationIntegrationTests", logLevel = "error") + @EnableEntityDefinedRegions(basePackageClasses = Book.class) + @EnableIndexing + static class TestConfiguration { + + @Bean + @DependsOn("BookTitleIdx") + ProjectingLuceneOperations luceneTemplate() { + return new ProjectingLuceneTemplate("BookTitleIdx", "/Books"); + } + } + + interface BookTitleView { + String getTitle(); + } +} diff --git a/src/test/java/org/springframework/data/gemfire/test/model/Book.java b/src/test/java/org/springframework/data/gemfire/test/model/Book.java new file mode 100644 index 00000000..7ecb1abc --- /dev/null +++ b/src/test/java/org/springframework/data/gemfire/test/model/Book.java @@ -0,0 +1,60 @@ +/* + * Copyright 2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.data.gemfire.test.model; + +import java.io.Serializable; + +import org.springframework.data.annotation.Id; +import org.springframework.data.gemfire.mapping.annotation.LuceneIndexed; +import org.springframework.data.gemfire.mapping.annotation.Region; + +import lombok.Data; +import lombok.NonNull; +import lombok.RequiredArgsConstructor; + +/** + * Abstract Data Type (ADT) modeling a {@literal Book} application domain type. + * + * @author John Blum + * @see java.lang.Comparable + * @see java.io.Serializable + * @see org.springframework.data.gemfire.mapping.annotation.LuceneIndexed + * @see org.springframework.data.gemfire.mapping.annotation.Region + * @see lombok + * @since 2.2.0 + */ +@Data +@Region("Books") +@RequiredArgsConstructor(staticName = "newBook") +public class Book implements Comparable, Serializable { + + @NonNull @Id + private final Long id; + + @NonNull @LuceneIndexed(name = "BookTitleIdx") + private String title; + + @Override + public int compareTo(Book other) { + return this.getTitle().compareTo(other.getTitle()); + } + + @Override + public String toString() { + return this.getTitle(); + } +}