org.springframework.data.repository.query.parser.AbstractQueryCreator Java Examples

/**
 * @param key
 * @param evaluationContextProvider
 * @param keyValueOperations
 * @param queryCreator
 * @since 1.1
 */
public KeyValueQueryLookupStrategy(@Nullable Key key,
		QueryMethodEvaluationContextProvider 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;
}
 

/**
 * <p>
 * Required constructor, capturing arguments for use in {@link #resolveQuery}.
 * </P>
 * <p>
 * Assertions copied from {@link KayValueRepositoryFactory.KeyValueQUeryLookupStrategy} which this class essentially
 * duplicates.
 * </P>
 *
 * @param key                       Not used
 * @param evaluationContextProvider For evaluation of query expressions
 * @param keyValueOperations        Bean to use for Key/Value operations on Hazelcast repos
 * @param queryCreator              Likely to be {@link HazelcastQueryCreator}
 * @param hazelcastInstance         Instance of Hazelcast
 */
public HazelcastQueryLookupStrategy(QueryLookupStrategy.Key key,
                                    QueryMethodEvaluationContextProvider evaluationContextProvider,
                                    KeyValueOperations keyValueOperations,
                                    Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
                                    HazelcastInstance hazelcastInstance) {

    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(hazelcastInstance, "HazelcastInstance must not be null!");

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

/**
 * 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;
}
 

@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()).isNotNull();
}
 

@SuppressWarnings("unchecked")
@Test // DATAKV-123
public void rejectsInstanceWithoutKeyValueOperations() {

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

	factoryBean.setQueryCreator(creatorType);

	assertThatIllegalArgumentException().isThrownBy(() -> factoryBean.afterPropertiesSet());
}
 

/**
 * 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;
}
 

@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);
}
 

@Override
protected MyTitleRepositoryFactory createRepositoryFactory(KeyValueOperations operations,
                                                           Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
                                                           Class<? extends RepositoryQuery> repositoryQueryType) {

    return new MyTitleRepositoryFactory(operations, queryCreator, hazelcastInstance);
}
 

public HazelcastRepositoryFactory(KeyValueOperations keyValueOperations,
                                  Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
                                  HazelcastInstance hazelcastInstance) {

    super(keyValueOperations, queryCreator);

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

@Override
protected VaultRepositoryFactory createRepositoryFactory(KeyValueOperations operations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
		Class<? extends RepositoryQuery> repositoryQueryType) {

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

public VaultRepositoryFactory(KeyValueOperations keyValueOperations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
		Class<? extends RepositoryQuery> repositoryQueryType) {
	super(keyValueOperations, queryCreator, repositoryQueryType);

	this.operations = keyValueOperations;
}
 

public MyTitleRepositoryFactory(KeyValueOperations keyValueOperations,
                                Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
                                HazelcastInstance hazelcastInstance) {
    super(keyValueOperations, queryCreator, hazelcastInstance);
    this.keyValueOperations = keyValueOperations;
}
 

ConstructorCachingQueryCreatorFactory(Class<? extends AbstractQueryCreator<?, ?>> type) {

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

public CachingKeyValuePartTreeQuery(QueryMethod queryMethod,
		QueryMethodEvaluationContextProvider evaluationContextProvider, KeyValueOperations keyValueOperations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator) {
	super(queryMethod, evaluationContextProvider, keyValueOperations, queryCreator);
}
 

public VaultRepositoryFactory(KeyValueOperations keyValueOperations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator) {
	this(keyValueOperations, queryCreator, KeyValuePartTreeQuery.class);
}
 

/**
 * Creates a new {@link KeyValuePartTreeQuery} 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}.
 */
public KeyValuePartTreeQuery(QueryMethod queryMethod, QueryMethodEvaluationContextProvider evaluationContextProvider,
		KeyValueOperations keyValueOperations, Class<? extends AbstractQueryCreator<?, ?>> queryCreator) {

	this(queryMethod, evaluationContextProvider, keyValueOperations,
			new ConstructorCachingQueryCreatorFactory(queryCreator));
}
 

/**
 * 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, QueryMethodEvaluationContextProvider evaluationContextProvider,
		KeyValueOperations keyValueOperations, Class<? extends AbstractQueryCreator<?, ?>> queryCreator) {

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

/**
 * <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) {
    Assert.state(hazelcastInstance != null, "HazelcastInstance must be set");

    return new HazelcastRepositoryFactory(operations, queryCreator, hazelcastInstance);
}
 

/**
 * <p>
 * Create a {@link RepositoryQuery} implementation for each query method defined in a {@link HazelcastRepository}.
 * </P>
 *
 * @param queryMethod                Method defined in {@code HazelcastRepository}
 * @param evaluationContextProvider  Not used
 * @param keyValueOperations         Interface to Hazelcast
 * @param queryCreator               Not used
 */
public HazelcastPartTreeQuery(QueryMethod queryMethod, QueryMethodEvaluationContextProvider evaluationContextProvider,
                              KeyValueOperations keyValueOperations,
                              Class<? extends AbstractQueryCreator<?, ?>> queryCreator) {
    super(queryMethod, evaluationContextProvider, keyValueOperations, queryCreator);
    this.queryMethod = queryMethod;
    this.keyValueOperations = keyValueOperations;

    this.isRearrangeKnown = false;
}
 

/**
 * Configures the {@link QueryCreatorType} 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;
}
 

/**
 * 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}.
 */
public KeyValueRepositoryFactory(KeyValueOperations keyValueOperations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator) {

	this(keyValueOperations, queryCreator, KeyValuePartTreeQuery.class);
}
 

/**
 * Create the repository factory to be used to create repositories.
 *
 * @param operations will never be {@literal null}.
 * @param queryCreator will never be {@literal null}.
 * @param repositoryQueryType will never be {@literal null}.
 * @return must not be {@literal null}.
 * @since 1.1
 */
protected KeyValueRepositoryFactory createRepositoryFactory(KeyValueOperations operations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator, Class<? extends RepositoryQuery> repositoryQueryType) {

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