import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
@Override
protected TarantoolRepositoryFactory createRepositoryFactory(
        KeyValueOperations operations,
        Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
        Class<? extends RepositoryQuery> repositoryQueryType
) {
    return new TarantoolRepositoryFactory(operations, queryCreator, repositoryQueryType);
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
public TarantoolRepositoryFactory(
        KeyValueOperations keyValueOperations,
        Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
        Class<? extends RepositoryQuery> repositoryQueryType
) {
    super(keyValueOperations, queryCreator, repositoryQueryType);
    this.keyValueOperations = keyValueOperations;
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
public ObjectifyRepositoryFactory(Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
                                  Class<? extends RepositoryQuery> repositoryQueryType,
                                  MappingContext<?, ?> mappingContext) {
    this.queryCreator = queryCreator;
    this.repositoryQueryType = repositoryQueryType;
    this.mappingContext = mappingContext;
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
/**
 * Creates a new {@link VaultPartTreeQuery} for the given {@link QueryMethod},
 * {@link EvaluationContextProvider}, {@link KeyValueOperations} and query creator
 * type.
 *
 * @param queryMethod must not be {@literal null}.
 * @param evaluationContextProvider must not be {@literal null}.
 * @param keyValueOperations must not be {@literal null}.
 * @param queryCreator must not be {@literal null}.
 */
@SuppressWarnings("unchecked")
public VaultPartTreeQuery(QueryMethod queryMethod,
		EvaluationContextProvider evaluationContextProvider,
		KeyValueOperations keyValueOperations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator) {

	super(queryMethod, evaluationContextProvider, keyValueOperations,
			new VaultQueryCreatorFactory(
					(MappingContext) keyValueOperations.getMappingContext()));
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
public VaultRepositoryFactory(KeyValueOperations keyValueOperations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
		Class<? extends RepositoryQuery> repositoryQueryType) {
	super(keyValueOperations, queryCreator, repositoryQueryType);

	this.operations = keyValueOperations;
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
@Override
protected VaultRepositoryFactory createRepositoryFactory(
		KeyValueOperations operations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
		Class<? extends RepositoryQuery> repositoryQueryType) {

	return new VaultRepositoryFactory(operations, queryCreator, repositoryQueryType);
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
public HazelcastRepositoryFactory(KeyValueOperations keyValueOperations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator) {

	super(keyValueOperations, queryCreator);

	this.keyValueOperations = keyValueOperations;
	this.queryCreator = queryCreator;
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
/**
 * Create a {@link KeyValueQuery} given {@link ParameterAccessor}.
 *
 * @param accessor must not be {@literal null}.
 * @return the {@link KeyValueQuery}.
 */
public KeyValueQuery<?> createQuery(ParameterAccessor accessor) {

	PartTree tree = new PartTree(getQueryMethod().getName(), getQueryMethod().getEntityInformation().getJavaType());

	AbstractQueryCreator<? extends KeyValueQuery<?>, ?> queryCreator = queryCreatorFactory.queryCreatorFor(tree,
			accessor);

	KeyValueQuery<?> query = queryCreator.createQuery();

	if (tree.isLimiting()) {
		query.setRows(tree.getMaxResults());
	}
	return query;
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
@Override
public AbstractQueryCreator<KeyValueQuery<?>, ?> queryCreatorFor(PartTree partTree, ParameterAccessor accessor) {

	Assert.state(constructor != null,
			() -> String.format("No constructor (PartTree, ParameterAccessor) could be found on type %s!", type));
	return (AbstractQueryCreator<KeyValueQuery<?>, ?>) BeanUtils.instantiateClass(constructor, partTree, accessor);
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
/**
 * Creates a new {@link KeyValueRepositoryFactory} for the given {@link KeyValueOperations} and
 * {@link AbstractQueryCreator}-type.
 *
 * @param keyValueOperations must not be {@literal null}.
 * @param queryCreator must not be {@literal null}.
 * @param repositoryQueryType must not be {@literal null}.
 * @since 1.1
 */
public KeyValueRepositoryFactory(KeyValueOperations keyValueOperations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator, Class<? extends RepositoryQuery> repositoryQueryType) {

	Assert.notNull(keyValueOperations, "KeyValueOperations must not be null!");
	Assert.notNull(queryCreator, "Query creator type must not be null!");
	Assert.notNull(repositoryQueryType, "RepositoryQueryType type must not be null!");

	this.queryCreator = queryCreator;
	this.keyValueOperations = keyValueOperations;
	this.context = keyValueOperations.getMappingContext();
	this.repositoryQueryType = repositoryQueryType;
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
/**
 * @param key
 * @param evaluationContextProvider
 * @param keyValueOperations
 * @param queryCreator
 * @since 1.1
 */
public KeyValueQueryLookupStrategy(@Nullable Key key, EvaluationContextProvider evaluationContextProvider,
		KeyValueOperations keyValueOperations, Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
		Class<? extends RepositoryQuery> repositoryQueryType) {

	Assert.notNull(evaluationContextProvider, "EvaluationContextProvider must not be null!");
	Assert.notNull(keyValueOperations, "KeyValueOperations must not be null!");
	Assert.notNull(queryCreator, "Query creator type must not be null!");
	Assert.notNull(repositoryQueryType, "RepositoryQueryType type must not be null!");

	this.evaluationContextProvider = evaluationContextProvider;
	this.keyValueOperations = keyValueOperations;
	this.queryCreator = queryCreator;
	this.repositoryQueryType = repositoryQueryType;
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test(expected = IllegalArgumentException.class) // DATAKV-123
public void rejectsInstanceWithoutKeyValueOperations() {

	Class<? extends AbstractQueryCreator<?, ?>> creatorType = (Class<? extends AbstractQueryCreator<?, ?>>) mock(
			AbstractQueryCreator.class).getClass();

	factoryBean.setQueryCreator(creatorType);
	factoryBean.afterPropertiesSet();
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
@Test // DATAKV-123
@SuppressWarnings("unchecked")
public void createsRepositoryFactory() {

	Class<? extends AbstractQueryCreator<?, ?>> creatorType = (Class<? extends AbstractQueryCreator<?, ?>>) mock(
			AbstractQueryCreator.class).getClass();
	Class<? extends RepositoryQuery> queryType = mock(KeyValuePartTreeQuery.class).getClass();

	factoryBean.setQueryCreator(creatorType);
	factoryBean.setKeyValueOperations(mock(KeyValueOperations.class));
	factoryBean.setQueryType(queryType);

	assertThat(factoryBean.createRepositoryFactory(), is(notNullValue()));
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
/**
 * Configures the {@link AbstractQueryCreator} to be used.
 * 
 * @param queryCreator must not be {@literal null}.
 */
public void setQueryCreator(Class<? extends AbstractQueryCreator<?, ?>> queryCreator) {
    Assert.notNull(queryCreator, "Query creator type must not be null!");

    this.queryCreator = queryCreator;
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
@Override
protected MyTitleRepositoryFactory createRepositoryFactory(KeyValueOperations operations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator, Class<? extends RepositoryQuery> repositoryQueryType) {

	return new MyTitleRepositoryFactory(operations, queryCreator);
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
public MyTitleRepositoryFactory(KeyValueOperations keyValueOperations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator) {
	super(keyValueOperations, queryCreator);
	this.keyValueOperations = keyValueOperations;
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
ConstructorCachingQueryCreatorFactory(Class<? extends AbstractQueryCreator<?, ?>> type) {

			this.type = type;
			this.constructor = ClassUtils.getConstructorIfAvailable(type, PartTree.class, ParameterAccessor.class);
		}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
public CachingKeyValuePartTreeQuery(QueryMethod queryMethod, EvaluationContextProvider evaluationContextProvider,
		KeyValueOperations keyValueOperations, Class<? extends AbstractQueryCreator<?, ?>> queryCreator) {
	super(queryMethod, evaluationContextProvider, keyValueOperations, queryCreator);
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
/**
 * <P>
 * Create a {@link RepositoryQuery} implementation for each query method defined in a {@link HazelcastRepository}.
 * </P>
 *
 * @param queryMethod Method defined in {@code HazelcastRepository}
 * @param evalulationContextProvider Not used
 * @param keyValueOperations Interface to Hazelcast
 * @param queryCreator Not used
 */
public HazelcastPartTreeQuery(QueryMethod queryMethod, EvaluationContextProvider evaluationContextProvider,
		KeyValueOperations keyValueOperations, Class<? extends AbstractQueryCreator<?, ?>> queryCreator) {
	super(queryMethod, evaluationContextProvider, keyValueOperations, queryCreator);
	this.queryMethod = queryMethod;
	this.keyValueOperations = keyValueOperations;

	this.isRearrangeKnown = false;
}
 

import org.springframework.data.repository.query.parser.AbstractQueryCreator; //导入依赖的package包/类
/**
 * <P>
 * Return a {@link HazelcastRepositoryFactory}.
 * </P>
 * <P>
 * {@code super} would return {@link KeyValueRepositoryFactory} which in turn builds {@link KeyValueRepository}
 * instances, and these have a private method that implement querying in a manner that does not fit with Hazelcast.
 * More details are in {@link HazelcastRepositoryFactory}.
 * </P>
 *
 * @param KeyValueOperations
 * @param Query Creator
 * @param RepositoryQueryType, not used
 * @return A {@link HazelcastRepositoryFactory} that creates {@link HazelcastRepository} instances.
 */
@Override
protected KeyValueRepositoryFactory createRepositoryFactory(KeyValueOperations operations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator, Class<? extends RepositoryQuery> repositoryQueryType) {

	return new HazelcastRepositoryFactory(operations, queryCreator);
}