Java SolrCrudRepository类代码示例

import org.springframework.data.solr.repository.SolrCrudRepository; //导入依赖的package包/类
/**
 * Insure that a non-null document decorator is provided by the abstract impl\
 */
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
public void testDefaultDocumentDecorator() {
    Function documentMapper = mock(Function.class);
    SolrCrudRepository repository = mock(SolrCrudRepository.class);
    SolrTemplate template = mock(SolrTemplate.class);

    AbstractEventTupleIndexer underTest = new AbstractEventTupleIndexer(documentMapper, repository, template) {
        @Override
        public void preIndex(EventDiscoTuple tuple) {

        }

        @Override
        public void postIndex(Object solrDocument) {

        }
    };

    assertNotNull(underTest.documentDecorator);
}
 

import org.springframework.data.solr.repository.SolrCrudRepository; //导入依赖的package包/类
/**
 * {@inheritDoc}
 *
 * @param documentMapper {@inheritDoc}
 * @param repository {@inheritDoc}
 * @param template {@inheritDoc}
 */
public DiscosIndexer(Function<EventDiscoTuple, DiscoSolrDocument> documentMapper,
                     SolrCrudRepository<DiscoSolrDocument, Long> repository, SolrTemplate template) {
    super(documentMapper, repository, template);

    // There *is* a Spring Bean definition for DiscoSolrOperations that *ought* to be injected by this constructor.
    // However, DiscoSolrOperations test coverage is nill.  Testing of DiscoSolrOperations is indirectly
    // accomplished by the DiscosIndexerTest, whereby expectations on the SolrTemplate are verified.
    // If DiscoSolrOperations is injected into this constructor, then the DiscoIndexerTest would need to be
    // re-written with expectations against DiscoSolrOperations, not the SolrTemplate.  And DiscoSolrOperations
    // would need its own test.  All good things, but due to lack of time, leaving this as a TODO.
    this.discoOperations = new DiscosSolrOperations(template, CORE_NAME);
}
 

import org.springframework.data.solr.repository.SolrCrudRepository; //导入依赖的package包/类
/**
 * @see DATASOLR-184
 */
@Test
public void shoudReturnStoreSpecificRepositoryInterfacesAsIdentifyingTypes() {

	assertThat(extension.getIdentifyingTypes(), hasSize(2));
	assertThat(extension.getIdentifyingTypes(),
			IsCollectionContaining.<Class<?>> hasItems(SolrRepository.class, SolrCrudRepository.class));
}
 

import org.springframework.data.solr.repository.SolrCrudRepository; //导入依赖的package包/类
@Before
@SuppressWarnings("unchecked")
public void setUpMocks() throws Exception {
    this.mockTemplate = mock(SolrTemplate.class);
    underTest = new DiscosIndexer(mock(EventDiscoTupleMapper.class), mock(SolrCrudRepository.class), mockTemplate);
}
 

import org.springframework.data.solr.repository.SolrCrudRepository; //导入依赖的package包/类
@Override
protected Collection<Class<?>> getIdentifyingTypes() {
	return Arrays.<Class<?>> asList(SolrRepository.class, SolrCrudRepository.class);
}
 

import org.springframework.data.solr.repository.SolrCrudRepository; //导入依赖的package包/类
/**
 * Constructs a repository implementation that:
 * <ul>
 *     <li>Produces Solr documents from {@link EventDiscoTuple}s using the supplied {@code documentMapper}</li>
 *     <li>Deposits Solr documents in the supplied {@link SolrCrudRepository}</li>
 *     <li>Provides the supplied {@link SolrTemplate} to implementations, allowing custom processing of the
 *         index</li>
 * </ul>
 * @param documentMapper maps tuples to Solr documents
 * @param repository stores Solr documents
 * @param template perform custom operations on indexes
 */
public AbstractEventTupleIndexer(Function<EventDiscoTuple, T> documentMapper, SolrCrudRepository<T, ID> repository,
                                 SolrTemplate template) {
    this.documentMapper = assertNotNull(documentMapper,
            "EventDiscoTuple document mapper must not be null.");
    this.repository = assertNotNull(repository, "Solr repository must not be null.");
    this.template = assertNotNull(template, "Solr template must not be null");
}