spring-data-jpa源码阅读笔记：Repository方法名查询推导(Query Derivation From Method Names)的实现原理 2

for (Method method : queryMethods) {

  // 使用lookupStrategy，针对Repository接口上的方法查询Query
  RepositoryQuery query = lookupStrategy.resolveQuery(method, repositoryInformation, factory, namedQueries);

  invokeListeners(query);
  queries.put(method, query);
}

// 使用外部类RepositoryFactorySupport#getQueryLookupStrategy(..., ...)（两个参）
// 或者RepositoryFactorySupport#getQueryLookupStrategy(...)（一个参）
// 来获取lookupStrategy
QueryLookupStrategy lookupStrategy = getQueryLookupStrategy(queryLookupStrategyKey,
    RepositoryFactorySupport.this.evaluationContextProvider);
lookupStrategy = lookupStrategy == null ? getQueryLookupStrategy(queryLookupStrategyKey) : lookupStrategy;

// 获取Repository接口上定义的方法
Iterable<Method> queryMethods = repositoryInformation.getQueryMethods();

// 如果没有找到lookupStrategy
if (lookupStrategy == null) {

  // 并且Repository接口上定义了方法，则抛出状态错误，注意IllegalStateException是RuntimeException。
  if (queryMethods.iterator().hasNext()) {
    throw new IllegalStateException("You have defined query method in the repository but "
        + "you don't have any query lookup strategy defined. The "
        + "infrastructure apparently does not support query methods!");
  }

  // 如果Repository接口上没有定义方法，则中断初始化。
  return;
}

public static QueryLookupStrategy create(EntityManager em, Key key, QueryExtractor extractor,
    EvaluationContextProvider evaluationContextProvider) {

  Assert.notNull(em, "EntityManager must not be null!");
  Assert.notNull(extractor, "QueryExtractor must not be null!");
  Assert.notNull(evaluationContextProvider, "EvaluationContextProvider must not be null!");

  switch (key != null ? key : Key.CREATE_IF_NOT_FOUND) {
    case CREATE:
      return new CreateQueryLookupStrategy(em, extractor);
    case USE_DECLARED_QUERY:
      return new DeclaredQueryLookupStrategy(em, extractor, evaluationContextProvider);
    case CREATE_IF_NOT_FOUND:
      return new CreateIfNotFoundQueryLookupStrategy(em, extractor, new CreateQueryLookupStrategy(em, extractor),
          new DeclaredQueryLookupStrategy(em, extractor, evaluationContextProvider));
    default:
      throw new IllegalArgumentException(String.format("Unsupported query lookup strategy %s!", key));
  }
}

@Override
protected RepositoryQuery resolveQuery(JpaQueryMethod method, EntityManager em, NamedQueries namedQueries) {

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

// 该段正则表达式在PartTree类中，主要作用是将一串方法名分解成主语(Subject对象)和谓语(Predicate对象)
/*
 * We look for a pattern of: keyword followed by
 *
 *  an upper-case letter that has a lower-case variant \p{Lu}
 * OR
 *  any other letter NOT in the BASIC_LATIN Uni-code Block \\P{InBASIC_LATIN} (like Chinese, Korean, Japanese, etc.).
 *
 * @see http://www.regular-expressions.info/unicode.html
 * @see http://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html#ubc
 */
private static final String KEYWORD_TEMPLATE = "(%s)(?=(\\p{Lu}|\\P{InBASIC_LATIN}))";
private static final String QUERY_PATTERN = "find|read|get|query|stream";
private static final String COUNT_PATTERN = "count";
private static final String DELETE_PATTERN = "delete|remove";
private static final Pattern PREFIX_TEMPLATE = Pattern.compile( //
    "^(" + QUERY_PATTERN + "|" + COUNT_PATTERN + "|" + DELETE_PATTERN + ")((\\p{Lu}.*?))??By");
    
  // ...省略...
  
  /**
	 * Creates a new {@link PartTree} by parsing the given {@link String}.
	 * 
	 * @param source the {@link String} to parse
	 * @param domainClass the domain class to check individual parts against to ensure they refer to a property of the
	 *          class
	 */
	public PartTree(String source, Class<?> domainClass) {

		Assert.notNull(source, "Source must not be null");
		Assert.notNull(domainClass, "Domain class must not be null");

    // 并且在其构造器中使用正则表达式分解方法名，将其分解为主、谓语两种对象。
		Matcher matcher = PREFIX_TEMPLATE.matcher(source);
		if (!matcher.find()) {
			this.subject = new Subject(null);
			this.predicate = new Predicate(source, domainClass);
		} else {
			this.subject = new Subject(matcher.group(0));
			this.predicate = new Predicate(source.substring(matcher.group().length()), domainClass);
		}
	}
  

/**
 * Represents the subject part of the query. E.g. {@code findDistinctUserByNameOrderByAge} would have the subject
 * {@code DistinctUser}.
 * 
 * @author Phil Webb
 * @author Oliver Gierke
 * @author Christoph Strobl
 * @author Thomas Darimont
 */
private static class Subject {

  private static final String DISTINCT = "Distinct";
  private static final Pattern COUNT_BY_TEMPLATE = Pattern.compile("^count(\\p{Lu}.*?)??By");
  private static final Pattern DELETE_BY_TEMPLATE = Pattern.compile("^(" + DELETE_PATTERN + ")(\\p{Lu}.*?)??By");
  private static final String LIMITING_QUERY_PATTERN = "(First|Top)(\\d*)?";
  private static final Pattern LIMITED_QUERY_TEMPLATE = Pattern.compile("^(" + QUERY_PATTERN + ")(" + DISTINCT + ")?"
      + LIMITING_QUERY_PATTERN + "(\\p{Lu}.*?)??By");

  // ...省略...

  public Subject(String subject) {

    // 继续通过正则表达式分析下列几种属性，为之后构建查询做准备。
    this.distinct = subject == null ? false : subject.contains(DISTINCT);
    this.count = matches(subject, COUNT_BY_TEMPLATE);
    this.delete = matches(subject, DELETE_BY_TEMPLATE);
    this.maxResults = returnMaxResultsIfFirstKSubjectOrNull(subject);
  }