/**
   * Goes through the class hierarchy and find the authorization annotations attached to a certain
   * method.
   *
   * @param clazz class to be scanned
   * @param authorizationActionMap the map to be populated
   */
  private void findAuthorizationActions(
      Class<?> clazz, Map<String, String> authorizationActionMap) {
    if (clazz == null || clazz == Object.class) {
      return;
    }
    String classAuthorizationActionsAllowed =
        getAuthorizationActions(clazz.getAnnotations(), AUTHORIZATION_ANNOTATION_CLASS_NAME);
    for (Method m : clazz.getMethods()) {
      if (SKIP_METHODS.contains(m.getName())) {
        continue;
      }
      String methodAuthorizationActionsAllowed =
          getAuthorizationActions(m.getAnnotations(), AUTHORIZATION_ANNOTATION_CLASS_NAME);
      String authorizationActions =
          methodAuthorizationActionsAllowed != null
              ? methodAuthorizationActionsAllowed
              : classAuthorizationActionsAllowed;
      if (authorizationActions != null) {
        authorizationActionMap.put(m.getName(), authorizationActions);
      }
    }
    if (!authorizationActionMap.isEmpty()) {
      return;
    }

    findAuthorizationActions(clazz.getSuperclass(), authorizationActionMap);

    if (!authorizationActionMap.isEmpty()) {
      return;
    }

    for (Class<?> interfaceCls : clazz.getInterfaces()) {
      findAuthorizationActions(interfaceCls, authorizationActionMap);
    }
  }
 private void assertAnnotations(Class<?> type) {
   assertThat(
       describe(type).getDeclaredAnnotations(),
       hasItems(
           new AnnotationList.ForLoadedAnnotations(type.getDeclaredAnnotations())
               .toArray(new AnnotationDescription[type.getDeclaredAnnotations().length])));
   assertThat(
       describe(type).getDeclaredAnnotations().size(), is(type.getDeclaredAnnotations().length));
   assertThat(
       describe(type).getInheritedAnnotations(),
       hasItems(
           new AnnotationList.ForLoadedAnnotations(type.getAnnotations())
               .toArray(new AnnotationDescription[type.getAnnotations().length])));
   assertThat(describe(type).getInheritedAnnotations().size(), is(type.getAnnotations().length));
 }
예제 #3
0
 private static boolean isTest(Class c) {
   for( Annotation a : c.getAnnotations() )
     if( a instanceof Ignore )
       return false;
   for( Method m : c.getMethods() )
     for( Annotation a : m.getAnnotations() )
       if( a instanceof Test )
         return true;
   return false;
 }
예제 #4
0
  /**
   * Gets all the annotation info for a particular class and puts it in our annotation info cache.
   *
   * @param c
   * @return
   */
  public AnnotationInfo putAnnotationInfo(Class c) {
    {
      Entity entity = (Entity) c.getAnnotation(Entity.class);
      if (entity == null) {
        throw new PersistenceException("Class not marked as an @Entity: " + c.getName());
      }
    }
    AnnotationInfo ai = new AnnotationInfo();
    ai.setClassAnnotations(c.getAnnotations());
    ai.setMainClass(c);
    Class superClass = c;
    Class rootClass = null;
    while ((superClass = superClass.getSuperclass()) != null) {
      MappedSuperclass mappedSuperclass =
          (MappedSuperclass) superClass.getAnnotation(MappedSuperclass.class);
      Entity entity = (Entity) superClass.getAnnotation(Entity.class);
      Inheritance inheritance = (Inheritance) superClass.getAnnotation(Inheritance.class);
      if (mappedSuperclass != null || entity != null) {
        putProperties(ai, superClass);
        putMethods(ai, superClass);
        if (entity != null) {
          rootClass = superClass;
        }
        putEntityListeners(ai, superClass);
      }
    }
    if (rootClass != null) {
      ai.setRootClass(rootClass);
      DiscriminatorValue dv = (DiscriminatorValue) c.getAnnotation(DiscriminatorValue.class);
      String discriminatorValue;
      if (dv != null) {
        discriminatorValue = dv.value();
        if (discriminatorValue == null) {
          throw new PersistenceException(
              "You must specify a value= for @DiscriminatorValue on " + c.getName());
        }
      } else {
        discriminatorValue = c.getSimpleName();
      }
      ai.setDiscriminatorValue(discriminatorValue);
      discriminatorMap.put(discriminatorValue, ai);
    } else {
      ai.setRootClass(c);
    }
    putTableDeclaration(ai, c);
    putProperties(ai, c);
    putMethods(ai, c);
    if (ai.getIdMethod() == null) {
      throw new PersistenceException("No ID method specified for: " + c.getName());
    }
    putEntityListeners(ai, c);

    getAnnotationMap().put(c.getName(), ai);
    return ai;
  }
예제 #5
0
파일: Dom.java 프로젝트: hk2-project/hk2
 public static <T extends Annotation> T digAnnotation(
     Class<?> target, Class<T> annotationType, List<Class<? extends Annotation>> visited) {
   T result = target.getAnnotation(annotationType);
   if (result == null) {
     for (Annotation a : target.getAnnotations()) {
       if (!visited.contains(a.annotationType())) {
         visited.add(a.annotationType());
         result = digAnnotation(a.annotationType(), annotationType, visited);
         if (result != null) {
           return result;
         }
       }
     }
   }
   return result;
 }
예제 #6
0
  public static void printAnnos(Class clazz) {
    try {
      Annotation[] annos = clazz.getAnnotations();
      System.out.println(
          "Annotations on " + clazz.getName() + "? " + (annos != null && annos.length != 0));
      if (annos != null && annos.length > 0) {
        List<Annotation> la = new ArrayList<Annotation>();
        for (Annotation anno : annos) {
          la.add(anno);
        }
        Collections.<Annotation>sort(la, new AnnoComparator());

        System.out.println("Annotation count is " + annos.length);
        for (Annotation anno : la) {
          System.out.println(anno);
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
예제 #7
0
  public static boolean isAnnotatedWith(
      @Nonnull Class<?> clazz, @Nonnull Class<? extends Annotation> annotationType) {
    requireNonNull(clazz, "Argument 'class' must not be null");
    requireNonNull(annotationType, "Argument 'annotationType' must not be null");

    //noinspection ConstantConditions
    while (clazz != null) {
      for (Annotation annotation : clazz.getAnnotations()) {
        if (annotationType.equals(annotation.annotationType())) {
          return true;
        }
      }
      for (Class<?> iface : clazz.getInterfaces()) {
        if (isAnnotatedWith(iface, annotationType)) {
          return true;
        }
      }

      clazz = clazz.getSuperclass();
    }
    return false;
  }
예제 #8
0
 @Nonnull
 public static List<Annotation> harvestQualifiers(@Nonnull Class<?> klass) {
   requireNonNull(klass, "Argument 'class' must not be null");
   List<Annotation> list = new ArrayList<>();
   Annotation[] annotations = klass.getAnnotations();
   for (Annotation annotation : annotations) {
     if (AnnotationUtils.isAnnotatedWith(annotation, Qualifier.class)) {
       // special case @BindTo is only used during tests
       if (BindTo.class.isAssignableFrom(annotation.getClass())) {
         continue;
       }
       // special case for @Named
       if (Named.class.isAssignableFrom(annotation.getClass())) {
         Named named = (Named) annotation;
         if (isBlank(named.value())) {
           list.add(named(getPropertyName(klass)));
           continue;
         }
       }
       list.add(annotation);
     }
   }
   return list;
 }