Java 类org.springframework.data.repository.query.RepositoryQuery 实例源码

@Override
protected RepositoryQuery resolveQuery(EbeanQueryMethod method, EbeanServer ebeanServer, NamedQueries namedQueries) {
  RepositoryQuery query = EbeanQueryFactory.INSTANCE.fromQueryAnnotation(method, ebeanServer, evaluationContextProvider);

  if (null != query) {
    return query;
  }

  String name = method.getNamedQueryName();
  if (namedQueries.hasQuery(name)) {
    return EbeanQueryFactory.INSTANCE.fromMethodWithQueryString(method, ebeanServer, namedQueries.getQuery(name),
        evaluationContextProvider);
  }

  query = NamedEbeanQuery.lookupFrom(method, ebeanServer);

  if (null != query) {
    return query;
  }

  throw new IllegalStateException(
      String.format("Did neither find a NamedQuery nor an annotated query for method %s!", method));
}

private void installAclProxy(RepositoryQuery query) {
  CriteriaQuery<?> criteriaQuery = criteriaQuery();
  if (criteriaQuery == null) {
    logger.warn("Unable to install ACL Jpa Specification for method '" + method
            + "' and query: " + query + " ; query methods with Pageable/Sort are not (yet) supported");
    return;
  }
  this.cachedCriteriaQuery = criteriaQuery;
  this.root = root(cachedCriteriaQuery);

  try {
    this.aclPredicateTargetSource = installAclPredicateTargetSource();
  } catch (Exception e) {
    logger.warn(
        "Unable to install ACL Jpa Specification for method '" + method + "' and query: " + query + " : " +
        getStackTrace(e));
  }
}

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

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

@Override
@SuppressWarnings("unchecked")
public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, ProjectionFactory factory,
        NamedQueries namedQueries) {

    QueryMethod queryMethod = new QueryMethod(method, metadata, factory);

    Constructor<? extends KeyValuePartTreeQuery> constructor = (Constructor<? extends KeyValuePartTreeQuery>) ClassUtils
            .getConstructorIfAvailable(this.repositoryQueryType, QueryMethod.class, EvaluationContextProvider.class,
                    KeyValueOperations.class, Class.class);

    Assert.state(constructor != null,
            String.format(
                    "Constructor %s(QueryMethod, EvaluationContextProvider, KeyValueOperations, Class) not available!",
                    ClassUtils.getShortName(this.repositoryQueryType)));

    return BeanUtils.instantiateClass(constructor, queryMethod, evaluationContextProvider, this.keyValueOperations,
            this.queryCreator);
}

@Override
protected RepositoryQuery resolveQuery(JdbcQueryMethod method, NamedQueries namedQueries) {
    PartTree tree = new PartTree(method.getName(), method.getEntityInformation().getJavaType());
    JdbcByNameRepositoryQueryCreator creator = new JdbcByNameRepositoryQueryCreator(method, tree, generator, template,
                                                                                    tableDescription, rowMapper);
    return creator.createQuery();
}

@Override
protected RepositoryQuery resolveQuery(JdbcQueryMethod method, NamedQueries namedQueries) {

    try {
        return lookupStrategy.resolveQuery(method, namedQueries);
    } catch (IllegalStateException e) {
        return createStrategy.resolveQuery(method, namedQueries);
    }
}

@Override
public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata,
                                    ProjectionFactory factory, NamedQueries namedQueries) {
    final DocumentDbQueryMethod queryMethod = new DocumentDbQueryMethod(method, metadata, factory);

    Assert.notNull(queryMethod, "queryMethod must not be null!");
    Assert.notNull(dbOperations, "dbOperations must not be null!");
    return new PartTreeDocumentDbQuery(queryMethod, dbOperations);

}

@Override
public RepositoryQuery resolveQuery(Method method, RepositoryMetadata repositoryMetadata, ProjectionFactory projectionFactory, NamedQueries namedQueries) {
    if (method.getAnnotation(MybatisQuery.class) != null) {
        log.info(repositoryMetadata.getRepositoryInterface().getName()+"."+method.getName()+" 为mybatis方法。 ");
        return new MybatisRepositoryQuery(sqlSessionTemplate , method , repositoryMetadata) ;
    } else {
        return jpaQueryLookupStrategy.resolveQuery(method, repositoryMetadata, projectionFactory,namedQueries);
    }
}

@Override
protected TarantoolRepositoryFactory createRepositoryFactory(
        KeyValueOperations operations,
        Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
        Class<? extends RepositoryQuery> repositoryQueryType
) {
    return new TarantoolRepositoryFactory(operations, queryCreator, repositoryQueryType);
}

public TarantoolRepositoryFactory(
        KeyValueOperations keyValueOperations,
        Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
        Class<? extends RepositoryQuery> repositoryQueryType
) {
    super(keyValueOperations, queryCreator, repositoryQueryType);
    this.keyValueOperations = keyValueOperations;
}

@Override
public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, ProjectionFactory factory, NamedQueries namedQueries) {

    SnowdropQueryMethod queryMethod = new SnowdropQueryMethod(method, metadata, factory);
    String namedQueryName = queryMethod.getNamedQueryName();

    if (namedQueries.hasQuery(namedQueryName)) {
        String namedQuery = namedQueries.getQuery(namedQueryName);
        return new SnowdropStringQuery(queryMethod, snowdropOperations, namedQuery);
    } else if (queryMethod.hasAnnotatedQuery()) {
        return new SnowdropStringQuery(queryMethod, snowdropOperations, queryMethod.getAnnotatedQuery());
    }
    return new SnowdropPartQuery(queryMethod, snowdropOperations);
}

public ObjectifyRepositoryFactory(Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
                                  Class<? extends RepositoryQuery> repositoryQueryType,
                                  MappingContext<?, ?> mappingContext) {
    this.queryCreator = queryCreator;
    this.repositoryQueryType = repositoryQueryType;
    this.mappingContext = mappingContext;
}

@Override
public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, ProjectionFactory factory,
                                    NamedQueries namedQueries) {
    QueryMethod queryMethod = new QueryMethod(method, metadata, factory);

    return new ObjectifyRepositoryQuery(queryMethod);
}

/**
 * Looks up a named query for the given {@link org.springframework.data.repository.query.QueryMethod}.
 *
 * @param method
 * @return
 */
public static RepositoryQuery lookupFrom(EbeanQueryMethod method, EbeanServer ebeanServer) {
  final String queryName = method.getNamedQueryName();

  LOG.debug("Looking up named query {}", queryName);

  try {
    io.ebean.Query query = ebeanServer.createNamedQuery(method.getEntityInformation().getJavaType(), queryName);
    return new NamedEbeanQuery(method, ebeanServer, query);
  } catch (PersistenceException e) {
    LOG.debug("Did not find named query {}", queryName);
    return null;
  }
}

@Override
protected RepositoryQuery resolveQuery(EbeanQueryMethod method, EbeanServer ebeanServer, NamedQueries namedQueries) {

  try {
    return new PartTreeEbeanQuery(method, ebeanServer);
  } catch (IllegalArgumentException e) {
    throw new IllegalArgumentException(
        String.format("Could not create query metamodel for method %s!", method.toString()), e);
  }
}

@Override
protected RepositoryQuery resolveQuery(EbeanQueryMethod method, EbeanServer ebeanServer, NamedQueries namedQueries) {
  try {
    return lookupStrategy.resolveQuery(method, ebeanServer, namedQueries);
  } catch (IllegalStateException e) {
    return createStrategy.resolveQuery(method, ebeanServer, namedQueries);
  }
}

@Override
protected RepositoryQuery resolveQuery(MybatisQueryMethod method, NamedQueries namedQueries) {
    try {
        return new PartTreeMybatisQuery(context, sqlSessionTemplate, dialect, method);
    } catch (IllegalArgumentException e) {
        throw new IllegalArgumentException(
                String.format("Could not create query metamodel for method %s!", method.toString()), e);
    }
}

@Override
        protected RepositoryQuery resolveQuery(MybatisQueryMethod method, NamedQueries namedQueries) {

            RepositoryQuery query = MybatisQueryFactory.INSTANCE.fromQueryAnnotation(sqlSessionTemplate, method, evaluationContextProvider);
            if (null != query) {
                return query;
            }
//            String name = method.getNamedQueryName();
//            if (namedQueries.hasQuery(name)) {
//                return MybatisQueryFactory.INSTANCE.fromMethodWithQueryString(sqlSessionTemplate, method, namedQueries.getQuery(name), evaluationContextProvider);
//            }
            throw new IllegalStateException(
                    String.format("Did neither find a NamedQuery nor an annotated query for method %s!", method));
        }

@Override
protected RepositoryQuery resolveQuery(MybatisQueryMethod method, NamedQueries namedQueries) {
    try {
        return lookupStrategy.resolveQuery(method, namedQueries);
    } catch (IllegalStateException e) {
        return createStrategy.resolveQuery(method, namedQueries);
    }

}

@Override
public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, ProjectionFactory factory,
        NamedQueries namedQueries) {
    if (method.getAnnotation(TemplateQuery.class) == null) {
        return jpaQueryLookupStrategy.resolveQuery(method, metadata, factory, namedQueries);
    }
    else {
        return new FreemarkerTemplateQuery(new JpaQueryMethod(method, metadata, factory, extractor), entityManager);
    }
}

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

    this.operations = keyValueOperations;
}

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

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

@Override
public RepositoryQuery resolveQuery(Method method, RepositoryMetadata repositoryMetadata,
                                    ProjectionFactory projectionFactory, NamedQueries namedQueries) {
  if (!isAggregateQueryAnnotated(method)) {
    return parentQueryLookupStrategy.resolveQuery(method, repositoryMetadata, projectionFactory, namedQueries);
  }
  else {
    return new AggregateMongoQuery(method, repositoryMetadata, mongoOperations, projectionFactory, queryExecutor);
  }
}

@Test(dataProvider = "queryMethods", expectedExceptions = {NullPointerException.class, IllegalArgumentException.class})
public void testCreateAggregateQuery(String methodName) throws Exception {
  AggregateQuerySupportingRepositoryFactory factory = new AggregateQuerySupportingRepositoryFactory(mongoOperations,
                                                                                                    queryExecutor);
  QueryLookupStrategy lookupStrategy = factory.getQueryLookupStrategy(CREATE_IF_NOT_FOUND, evaluationContextProvider);

  Method method = TestAggregateRepository22.class.getMethod(methodName);
  RepositoryMetadata repositoryMetadata = new DefaultRepositoryMetadata(TestAggregateRepository22.class);
  ProjectionFactory projectionFactory = new SpelAwareProxyProjectionFactory();
  RepositoryQuery query = lookupStrategy.resolveQuery(method, repositoryMetadata, projectionFactory, null);
  assertNotNull(query);
  Object object = query.execute(new Object[0]);
  assertNull(object);
}

public AclJpaQuery(Method method, RepositoryQuery query, Class<?> domainType, EntityManager em,
    JpaSpecProvider<Object> jpaSpecProvider) {
  this.method = method;
  this.query = query;
  this.domainType = domainType;
  this.em = em;
  this.jpaSpecProvider = jpaSpecProvider;
  installAclProxy(query);
}

/**
 * @since Spring data JPA 1.10.0
 */
public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata,
      ProjectionFactory factory, NamedQueries namedQueries) {
  QueryLookupStrategy queryLookupStrategy =
      Factory.super.getQueryLookupStrategy(key, evaluationContextProvider);

  RepositoryQuery query = queryLookupStrategy.resolveQuery(method, metadata, factory, namedQueries);
  return wrapQuery(method, metadata, query);
}

private RepositoryQuery wrapQuery(Method method, RepositoryMetadata metadata,
      RepositoryQuery query) {
  if (method.getDeclaredAnnotation(NoAcl.class) != null) {
    // no acl applied here
    return query;
  }
  if (query instanceof PartTreeJpaQuery) {
    query = new AclJpaQuery(method, query, metadata.getDomainType(), em, jpaSpecProvider);
  } else {
    logger.warn(
        "Unsupported query type for method '{}' > ACL Jpa Specification not installed: {}",
        method, query.getClass());
  }
  return query;
}

@Override
public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, NamedQueries namedQueries) {
    if (method.getAnnotation(MybatisQuery.class) != null) {
        log.info(metadata.getRepositoryInterface().getName()+"."+method.getName()+" 为mybatis方法。 ");
        return new MybatisRepositoryQuery(sqlSessionTemplate , method , metadata) ;
    } else {
        return jpaQueryLookupStrategy.resolveQuery(method, metadata, namedQueries);
    }
}

/** {@inheritDoc} */
@Override protected QueryLookupStrategy getQueryLookupStrategy(final QueryLookupStrategy.Key key,
    EvaluationContextProvider evaluationCtxProvider) {

    return new QueryLookupStrategy() {
        @Override public RepositoryQuery resolveQuery(final Method mtd, final RepositoryMetadata metadata,
            final ProjectionFactory factory, NamedQueries namedQueries) {

            final Query annotation = mtd.getAnnotation(Query.class);

            if (annotation != null) {
                String qryStr = annotation.value();

                if (key != Key.CREATE && StringUtils.hasText(qryStr))
                    return new IgniteRepositoryQuery(metadata,
                        new IgniteQuery(qryStr, isFieldQuery(qryStr), IgniteQueryGenerator.getOptions(mtd)),
                        mtd, factory, ignite.getOrCreateCache(repoToCache.get(metadata.getRepositoryInterface())));
            }

            if (key == QueryLookupStrategy.Key.USE_DECLARED_QUERY)
                throw new IllegalStateException("To use QueryLookupStrategy.Key.USE_DECLARED_QUERY, pass " +
                    "a query string via org.apache.ignite.springdata.repository.config.Query annotation.");

            return new IgniteRepositoryQuery(metadata, IgniteQueryGenerator.generateSql(mtd, metadata), mtd,
                factory, ignite.getOrCreateCache(repoToCache.get(metadata.getRepositoryInterface())));
        }
    };
}

/**
 * <P>
 * Use {@link HazelcastPartTreeQuery} for resolving queries against Hazelcast repositories.
 * </P>
 *
 * @param Method, the query method
 * @param RepositoryMetadata, not used
 * @param ProjectionFactory, not used
 * @param NamedQueries, not used
 * @return A mechanism for querying Hazelcast repositories
 */
public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, 
        ProjectionFactory projectionFactory, NamedQueries namedQueries) {

    HazelcastQueryMethod queryMethod = new HazelcastQueryMethod(method, metadata, projectionFactory);

    if (queryMethod.hasAnnotatedQuery()) {
        return new StringBasedHazelcastRepositoryQuery(queryMethod);

    }

    return new HazelcastPartTreeQuery(queryMethod, evaluationContextProvider, this.keyValueOperations,
            this.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}.
 * @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;
}

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

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

@Override
protected <T, ID extends Serializable> RepositoryQuery createDynamoDBQuery(Method method, RepositoryMetadata metadata,
        Class<T> entityClass, Class<ID> idClass, NamedQueries namedQueries) {
    try {
        return new PartTreeDynamoDBQuery<T, ID>(dynamoDBOperations, new DynamoDBQueryMethod<T, ID>(method, metadata));
    } catch (IllegalArgumentException e) {
        throw new IllegalArgumentException(String.format("Could not create query metamodel for method %s!",
                method.toString()), e);
    }
}

@Override
public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, NamedQueries namedQueries) {
    SimpleDbQueryMethod queryMethod;

    if(SimpleDbQueryMethod.isAnnotatedQuery(method)) {
        queryMethod = new SimpleDbQueryMethod(method, metadata, simpleDbOperations.getSimpleDb()
                .getSimpleDbDomain());
    } else {
        queryMethod = new SimpleDbPartTreeQueryMethod(method, metadata, simpleDbOperations.getSimpleDb()
                .getSimpleDbDomain());
    }

    return SimpleDbRepositoryQuery.fromQueryAnnotation(queryMethod, simpleDbOperations);
}

@Override
public RepositoryQuery resolveQuery(final Method method, final RepositoryMetadata metadata, final ProjectionFactory factory, final NamedQueries namedQueries) {
    return resolveQuery(new JdbcQueryMethod(method, metadata, factory), namedQueries);
}

@Override
protected RepositoryQuery resolveQuery(JdbcQueryMethod method, NamedQueries namedQueries) {
    JdbcAnnotatedRepositoryQueryCreator creator = new JdbcAnnotatedRepositoryQueryCreator(method, generator, template,
                                                                                          tableDescription, rowMapper);
    return creator.createQuery();
}

public RepositoryQuery createQuery() {
    return new JdbcAnnotatedRepositoryQuery(method, template, query, rowMapper, strategy, parameterKeys);
}

@Override
public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, ProjectionFactory factory, NamedQueries namedQueries) {

    return null;
}