import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
protected Object getTargetRepository(RepositoryMetadata metadata) {

	SolrOperations operations = this.solrOperations;
	if (factory != null) {
		SolrTemplate template = new SolrTemplate(factory);
		template.setSolrCore(SolrServerUtils.resolveSolrCoreName(metadata.getDomainType()));
		addSchemaCreationFeaturesIfEnabled(template);
		template.afterPropertiesSet();
		operations = template;
	}

	SimpleSolrRepository repository = new SimpleSolrRepository(getEntityInformation(metadata.getDomainType()),
			operations);
	repository.setEntityClass(metadata.getDomainType());

	this.templateHolder.add(metadata.getDomainType(), operations);
	return repository;
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
@Override
public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, NamedQueries namedQueries) {

	SolrQueryMethod queryMethod = new SolrQueryMethod(method, metadata, entityInformationCreator);
	String namedQueryName = queryMethod.getNamedQueryName();

	SolrOperations solrOperations = selectSolrOperations(metadata);

	if (namedQueries.hasQuery(namedQueryName)) {
		String namedQuery = namedQueries.getQuery(namedQueryName);
		return new StringBasedSolrQuery(namedQuery, queryMethod, solrOperations);
	} else if (queryMethod.hasAnnotatedQuery()) {
		return new StringBasedSolrQuery(queryMethod, solrOperations);
	} else {
		return new PartTreeSolrQuery(queryMethod, solrOperations);
	}
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
/**
 * @param solrOperations must not be null
 * @param solrQueryMethod must not be null
 */
protected AbstractSolrQuery(SolrOperations solrOperations, SolrQueryMethod solrQueryMethod) {
	Assert.notNull(solrOperations);
	Assert.notNull(solrQueryMethod);
	this.solrOperations = solrOperations;
	this.solrQueryMethod = solrQueryMethod;
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
@Autowired
public SolrUI(SolrOperations solrOperations, PostDocService postDocService, SolrSettings solrSettings, PostService postService) {
    this.solrOperations = solrOperations;
    this.postDocService = postDocService;
    this.solrSettings = solrSettings;
    this.postService = postService;
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
public SolrRepositoryFactory(SolrOperations solrOperations) {
	Assert.notNull(solrOperations);

	if (solrOperations instanceof SolrTemplate) {
		addSchemaCreationFeaturesIfEnabled((SolrTemplate) solrOperations);
	}

	this.solrOperations = solrOperations;
	this.entityInformationCreator = new SolrEntityInformationCreatorImpl(solrOperations.getConverter()
			.getMappingContext());
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
private SolrOperations selectSolrOperations(RepositoryMetadata metadata) {
	SolrOperations ops = templateHolder.getSolrOperations(metadata.getDomainType());
	if (ops == null) {
		ops = solrOperations;
	}
	return ops;
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
/**
 * @param metadata must not be null
 * @param solrOperations must not be null
 */
public SimpleSolrRepository(SolrEntityInformation<T, ?> metadata, SolrOperations solrOperations) {
	this(solrOperations);
	Assert.notNull(metadata);

	this.entityInformation = metadata;
	setIdFieldName(this.entityInformation.getIdAttribute());
	setEntityClass(this.entityInformation.getJavaType());
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
public SolrRepositoryBean(Bean<SolrOperations> operations, Set<Annotation> qualifiers, Class<T> repositoryType,
		BeanManager beanManager) {
	super(qualifiers, repositoryType, beanManager);

	Assert.notNull(operations, "Cannot create repository with 'null' for SolrOperations.");
	this.solrOperationsBean = operations;
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
private <T> Bean<T> createRepositoryBean(Class<T> repositoryType, Set<Annotation> qualifiers, BeanManager beanManager) {
	Bean<SolrOperations> solrOperationBeans = this.solrOperationsMap.get(qualifiers.toString());

	if (solrOperationBeans == null) {
		throw new UnsatisfiedResolutionException(String.format("Unable to resolve a bean for '%s' with qualifiers %s.",
				SolrOperations.class.getName(), qualifiers));
	}

	return new SolrRepositoryBean<T>(solrOperationBeans, qualifiers, repositoryType, beanManager);
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
@Produces
public SolrOperations createSolrTemplate() throws IOException, ParserConfigurationException, SAXException {

	EmbeddedSolrServerFactory factory = new EmbeddedSolrServerFactory(ResourceUtils.getURL(
			"classpath:org/springframework/data/solr").getPath());

	SolrTemplate template = new SolrTemplate(factory);
	template.afterPropertiesSet();
	return template;
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
@Autowired
public PostDocServiceImpl(SolrOperations solrOperations, PostService postService, ApplicationSettings applicationSettings) {
    this.solrOperations = solrOperations;
    this.postService = postService;
    this.applicationSettings = applicationSettings;
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
@Bean
public SolrOperations solrTemplate(SolrClient server) throws Exception {
    return new SolrTemplate(server);
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
@Bean
public SolrOperations solrTemplate() {
	return new SolrTemplate(solrServer());
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
public PartTreeSolrQuery(SolrQueryMethod method, SolrOperations solrOperations) {
	super(solrOperations, method);
	this.tree = new PartTree(method.getName(), method.getEntityInformation().getJavaType());
	this.mappingContext = solrOperations.getConverter().getMappingContext();
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
public StringBasedSolrQuery(SolrQueryMethod method, SolrOperations solrOperations) {
	this(method.getAnnotatedQuery(), method, solrOperations);
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
void add(Class<?> domainType, SolrOperations repository) {
	operationsMap.put(domainType, repository);
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
SolrOperations getSolrOperations(Class<?> type) {
	return operationsMap.get(type);
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
/**
 * @return SolrOperations to be used for eg. custom implementation
 */
protected SolrOperations getSolrOperations() {
	return this.operations;
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
public final void setSolrOperations(SolrOperations solrOperations) {
	Assert.notNull(solrOperations, "SolrOperations must not be null.");

	this.solrOperations = solrOperations;
}
 

import org.springframework.data.solr.core.SolrOperations; //导入依赖的package包/类
public final SolrOperations getSolrOperations() {
	return solrOperations;
}