Java Annotation.toString方法代码示例

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
private Bundle prepareBundle(Object[] args) {
  Bundle bundle = new Bundle();
  int paramCount = parameterTypes.length;
  if (parameterTypes != null && paramCount > 0){
    for (int i = 0; i < paramCount; i++) {
      String key;
      Annotation[] paramAnnotations = parameterAnnotationsArray[i];
      for (Annotation anno: paramAnnotations) {
        if (anno instanceof Key){
          key = ((Key) anno).value();
          handleParams(bundle, key, parameterTypes[i], args[i]);
        }else if(anno instanceof FieldMap){

        }else{
          throw new IllegalStateException("不支持的参数注解: " + anno.toString() );
        }
      }
    }
  }
  return bundle;
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
private void parseMethodAnnotation(Annotation annotation) {
  if (annotation instanceof Scheme){

    scheme = ((Scheme) annotation).value();
  }else if (annotation instanceof TargetName){

    className = ((TargetName) annotation).value();
  }else if(annotation instanceof TargetClass){

    className = ((TargetClass) annotation).value().getName();
  }else if(annotation instanceof RequestCode){

    requestCode = ((RequestCode) annotation).value();
  }else if(annotation instanceof Flags){

    flags |= ((Flags) annotation).value();
  }else{

    throw new IllegalStateException("不支持的方法注解: " + annotation.toString() );
  }
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
String getAnnotationName() {
    Annotation annotation = annotationStrategy.getAnnotation();
    if (annotation != null) {
        return annotation.toString();
    }

    // not test-covered
    return annotationStrategy.getAnnotationType().toString();
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
/**
 * Returns a new multibinder that collects instances of {@code type} in a {@link Set} that is
 * itself bound with {@code annotation}.
 */
public static <T> Multibinder<T> newSetBinder(
        Binder binder, TypeLiteral<T> type, Annotation annotation) {
    binder = binder.skipSources(RealMultibinder.class, Multibinder.class);
    RealMultibinder<T> result = new RealMultibinder<>(binder, type, annotation.toString(),
            Key.get(Multibinder.<T>setOf(type), annotation));
    binder.install(result);
    return result;
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
String getAnnotationName() {
  Annotation annotation = annotationStrategy.getAnnotation();
  if (annotation != null) {
    return annotation.toString();
  }

  // not test-covered
  return annotationStrategy.getAnnotationType().toString();
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
private boolean compareArrVals(Annotation[] actualAnnos, String[] expectedAnnos) {
    // Look if test case was run.
    if (actualAnnos == specialAnnoArray) {
        return false; // no testcase matches
    }
    if (actualAnnos.length != expectedAnnos.length) {
        System.out.println("Length not same. "
                + " actualAnnos length = " + actualAnnos.length
                + " expectedAnnos length = " + expectedAnnos.length);
        printArrContents(actualAnnos);
        printArrContents(expectedAnnos);
        return false;
    } else {
        int i = 0;
        String[] actualArr = new String[actualAnnos.length];
        for (Annotation a : actualAnnos) {
            actualArr[i++] = a.toString();
        }
        List<String> actualList = Arrays.asList(actualArr);
        List<String> expectedList = Arrays.asList(expectedAnnos);

        if (!actualList.containsAll(expectedList)) {
            System.out.println("Array values are not same");
            printArrContents(actualAnnos);
            printArrContents(expectedAnnos);
            return false;
        }
    }
    return true;
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
private static boolean compareAnnotations(Annotation[] actualAnnos,
        String[] expectedAnnos) {
    boolean compOrder = false;

    // Length is different
    if (actualAnnos.length != expectedAnnos.length) {
        error("Length not same, Actual length = " + actualAnnos.length
                + " Expected length = " + expectedAnnos.length);
        printArrContents(actualAnnos);
        printArrContents(expectedAnnos);
        return false;
    } else {
        int i = 0;
        // Length is same and 0
        if (actualAnnos.length == 0) {
            // Expected/actual lengths already checked for
            // equality; no more checks do to
            return true;
        }
        // Expected annotation should be NULL
        if (actualAnnos[0] == null) {
            if (expectedAnnos[0].equals("NULL")) {
                debugPrint("Arr values are NULL as expected");
                return true;
            } else {
                error("Array values are not NULL");
                printArrContents(actualAnnos);
                printArrContents(expectedAnnos);
                return false;
            }
        }
        // Lengths are same, compare array contents
        String[] actualArr = new String[actualAnnos.length];
        for (Annotation a : actualAnnos) {
            if (a.annotationType().getSimpleName().contains("Expected"))
            actualArr[i++] = a.annotationType().getSimpleName();
             else if (a.annotationType().getName().contains(TESTPKG)) {
                String replaced = a.toString().replaceAll(Pattern.quote("testpkg."),"");
                actualArr[i++] = replaced;
            } else
                actualArr[i++] = a.toString();
        }
        List<String> actualList = new ArrayList<String>(Arrays.asList(actualArr));
        List<String> expectedList = new ArrayList<String>(Arrays.asList(expectedAnnos));
        if (!actualList.containsAll(expectedList)) {
            error("Array values are not same");
            printArrContents(actualAnnos);
            printArrContents(expectedAnnos);
            return false;
        } else {
            debugPrint("Arr values are same as expected");
            if (CHECKORDERING) {
                debugPrint("Checking if annotation ordering is as expected..");
                compOrder = compareOrdering(actualList, expectedList);
                if (compOrder)
                    debugPrint("Arr values ordering is as expected");
                else
                    error("Arr values ordering is not as expected! actual values: "
                        + actualList + " expected values: " + expectedList);
            } else
                compOrder = true;
        }
    }
    return compOrder;
}