Java Scope类代码示例

import javax.inject.Scope; //导入依赖的package包/类
@Test
public void annotationWithoutValueMethod() {
	Annotation annotation = Singleton.class.getAnnotation(Scope.class);
	cache.getQualifier(annotation);

	InOrder inOrder = inOrder(lock, cache);

	// initial call
	inOrder.verify(cache).getQualifier(annotation);

	// internal thread safe method lookup
	inOrder.verify(cache).getValueMethodThreadSafe(Scope.class);
	inOrder.verify(lock).lock();
	inOrder.verify(cache).getValueMethod(Scope.class);
	inOrder.verify(lock).unlock();
	// no value Method found, so no invocation needed

	inOrder.verifyNoMoreInteractions();
	verifyZeroInteractions(cache);
	assertThat(bindActionMap.size(), is(1));
}
 

import javax.inject.Scope; //导入依赖的package包/类
/**
 * Lookup {@link javax.inject.Scope} annotated annotations to provide the name of the scope the {@code typeElement} belongs to.
 * The method logs an error if the {@code typeElement} has multiple scope annotations.
 *
 * @param typeElement the element for which a scope is to be found.
 * @return the scope of this {@code typeElement} or {@code null} if it has no scope annotations.
 */
private String getScopeName(TypeElement typeElement) {
  String scopeName = null;
  for (AnnotationMirror annotationMirror : typeElement.getAnnotationMirrors()) {
    TypeElement annotationTypeElement = (TypeElement) annotationMirror.getAnnotationType().asElement();
    if (annotationTypeElement.getAnnotation(Scope.class) != null) {
      checkScopeAnnotationValidity(annotationTypeElement);
      if (scopeName != null) {
        error(typeElement, "Only one @Scope qualified annotation is allowed : %s", scopeName);
      }
      scopeName = annotationTypeElement.getQualifiedName().toString();
    }
  }

  return scopeName;
}
 

import javax.inject.Scope; //导入依赖的package包/类
/**
 * Finds the scope for a bean producing declaration, either a method or
 * a type.
 */
private <T> InjectScope<T> findScope(AnnotatedElement annElement)
{
  for (Annotation ann : annElement.getAnnotations()) {
    Class<? extends Annotation> annType = ann.annotationType();

    if (annType.isAnnotationPresent(Scope.class)) {
      Supplier<InjectScope<T>> scopeGen = (Supplier) _scopeMap.get(annType);

      if (scopeGen != null) {
        return scopeGen.get();
      }
      else {
        log.fine(L.l("@{0} is an unknown scope", annType.getSimpleName()));
      }
    }
  }

  return new InjectScopeFactory<>();
}
 

import javax.inject.Scope; //导入依赖的package包/类
@Override
public BindingBuilderImpl<T> scope(Class<? extends Annotation> scopeType)
{
  Objects.requireNonNull(scopeType);

  if (! scopeType.isAnnotationPresent(Scope.class)) {
    throw error("'@{0}' is an invalid scope type because it is not annotated with @Scope",
                scopeType.getSimpleName());
  }

  if (_scopeMap.get(scopeType) == null) {
    throw error("'@{0}' is an unsupported scope. Only @Singleton and @Factory are supported.",
                scopeType.getSimpleName());

  }

  _scopeType = scopeType;

  return this;
}
 

import javax.inject.Scope; //导入依赖的package包/类
/**
 * Returns the scope of this module, null for unscoped modules. Dagger requires that each module
 * can only contain no more than one scope type of scoped binding. Unscoped bindings are not
 * limited.
 * TODO(freeman): supported included modules.
 */
@Nullable
public static TypeElement getModuleScope(DeclaredType moduleType) {
  TypeElement moduleElement = (TypeElement) moduleType.asElement();
  Preconditions.checkArgument(
      moduleElement.getAnnotation(Module.class) != null,
      String.format("not module: %s.", moduleType));
  for (Element element : moduleElement.getEnclosedElements()) {
    if (element.getKind().equals(ElementKind.METHOD)
        && (element.getAnnotation(Provides.class) != null)) {
      for (AnnotationMirror annotationMirror : element.getAnnotationMirrors()) {
        Annotation scope =
            annotationMirror.getAnnotationType().asElement().getAnnotation(Scope.class);
        if (scope != null) {
          return (TypeElement) annotationMirror.getAnnotationType().asElement();
        }
      }
    }
  }
  return null;
}
 

import javax.inject.Scope; //导入依赖的package包/类
/**
 * Find annotation that is itself annoted with @Scope
 * If there is one, it will be later applied on the generated component
 * Otherwise the component will be unscoped
 * Throw error if more than one scope annotation found
 */
private AnnotationMirror findScope() {
    AnnotationMirror annotationTypeMirror = null;

    for (AnnotationMirror annotationMirror : element.getAnnotationMirrors()) {
        Element annotationElement = annotationMirror.getAnnotationType().asElement();
        if (MoreElements.isAnnotationPresent(annotationElement, Scope.class)) {
            // already found one scope
            if (annotationTypeMirror != null) {
                errors.addInvalid("Several dagger scopes on same element are not allowed");
                continue;
            }

            annotationTypeMirror = annotationMirror;
        }
    }

    return annotationTypeMirror;
}
 

import javax.inject.Scope; //导入依赖的package包/类
public DocumentedAnnotations(Element element) {
    List<AnnotationMirror> allAnnotations = new ArrayList<AnnotationMirror>();
    allAnnotations.addAll(annotationsOf(element, Qualifier.class));
    allAnnotations.addAll(annotationsOf(element, Scope.class));

    if (allAnnotations.isEmpty()) {
        this.description = Optional.absent();
        return;
    }

    StringBuilder result = new StringBuilder();
    for (AnnotationMirror annotation : allAnnotations) {
        if (result.length() > 0) {
            result.append(" ");
        }
        result.append(annotation.toString());
    }

    this.description = Optional.of(result.toString());
}
 

import javax.inject.Scope; //导入依赖的package包/类
@Test
public void methodCaching() {
	Annotation annotation = Singleton.class.getAnnotation(Scope.class);
	// call twice - should cache once
	cache.getQualifier(annotation);
	cache.getQualifier(annotation);

	assertThat(bindActionMap.size(), is(1));
}
 

import javax.inject.Scope; //导入依赖的package包/类
@Test
public void fieldScopeTest() throws NoSuchFieldException {
	Field field = Testable.class.getDeclaredField("scopedField");
	Annotation namedAnnotation = Annotations.findAnnotationAnnotatedWith(Scope.class, field);

	assertThat(namedAnnotation, allOf(notNullValue(), annotationOfType(Singleton.class)));
}
 

import javax.inject.Scope; //导入依赖的package包/类
@Test
public void methodScopeTest() throws NoSuchMethodException {
	Method method = Testable.class.getDeclaredMethod("scopedMethod");
	Annotation namedAnnotation = Annotations.findAnnotationAnnotatedWith(Scope.class, method);

	assertThat(namedAnnotation, allOf(notNullValue(), annotationOfType(Singleton.class)));
}
 

import javax.inject.Scope; //导入依赖的package包/类
@Test
public void methodArgumentScopeTest() throws NoSuchMethodException {
	Method method = Testable.class.getDeclaredMethod("scopedMethodArguments", Object.class);
	Annotation[] annotations = method.getParameterAnnotations()[0];
	Annotation namedAnnotation = Annotations.findAnnotationAnnotatedWith(Scope.class, annotations);

	assertThat(namedAnnotation, allOf(notNullValue(), annotationOfType(Singleton.class)));
}
 

import javax.inject.Scope; //导入依赖的package包/类
@Test
public void methodArgumentScopeMissingTest() throws NoSuchMethodException {
	Method method = Testable.class.getDeclaredMethod("scopedMethodArgumentsMissing", Object.class);
	Annotation[] annotations = method.getParameterAnnotations()[0];
	Annotation namedAnnotation = Annotations.findAnnotationAnnotatedWith(Scope.class, annotations);

	assertThat(namedAnnotation, is(nullValue()));
}
 

import javax.inject.Scope; //导入依赖的package包/类
private void createFactoriesForClassesAnnotatedWithScopeAnnotations(RoundEnvironment roundEnv, Set<? extends TypeElement> annotations) {
  for (TypeElement annotation : annotations) {
    if (annotation.getAnnotation(Scope.class) != null) {
      checkScopeAnnotationValidity(annotation);
      createFactoriesForClassesAnnotatedWith(roundEnv, annotation);
    }
  }
}
 

import javax.inject.Scope; //导入依赖的package包/类
private void checkScopeAnnotationValidity(TypeElement annotation) {
  if (annotation.getAnnotation(Scope.class) == null) {
    error(annotation, "Scope Annotation %s does not contain Scope annotation.", annotation.getQualifiedName());
    return;
  }

  Retention retention = annotation.getAnnotation(Retention.class);
  if (retention == null || retention.value() != RetentionPolicy.RUNTIME) {
    error(annotation, "Scope Annotation %s does not have RUNTIME retention policy.", annotation.getQualifiedName());
  }
}
 

import javax.inject.Scope; //导入依赖的package包/类
@Override
public Class<? extends Annotation> getScope() {
	Class<? extends Annotation> scope = Arrays.stream(javaType.getAnnotations())
		.map(a -> a.getClass())
			.filter(a -> a.getAnnotation(Scope.class) != null)
				.findFirst().orElse(null);

	return scope == null ? Dependent.class : scope;
}