Question

假设我们在同一个包中有一个单独的用户定义annoation的类，如

@One

class A
{


}

@Two

class B
{


}

@One

class C
{


}

如何找到哪个班级正在使用@one注释以及哪个@Two？

或

我们有一个类，其中方法被注释，我想检索哪个注释具有哪个注释

喜欢：

class A
{

  @two

  public method1()
  {

  }

  @one

  public method2()
  {

  }

  @two

  public method3()
  {

  }

 }

我正在使用核心java反射和注释。

任何其他想法做这样的事情将不胜感激。任何帮助将不胜感激

这是我的跟踪代码无效。如果你有一些新的方式而不是引导我。

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Arrays;

@GUI
public class Demo{


   public static void example() {
       Demo ob = new Demo();

      try {
         Class c = ob.getClass();

         // get the method example
         Method m = c.getMethod("example");

         // get the annotations
         Annotation[] annotation = m.getAnnotations();

         // print the annotation
         for (int i = 0; i < annotation.length; i++) {
            System.out.println(annotation[i]);
         }
      } catch (NoSuchMethodException exc) {
         exc.printStackTrace();
      }
   }


   public static void show()
   {
       java.lang.annotation.Annotation[] annotations = null;
    try {
        annotations = Class.forName("Demo").getAnnotations();
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
     //prints [@java.lang.Deprecated()]
     System.out.println(Arrays.toString(annotations));
   }

   public static void myMeth() {
       Demo ob = new Demo();

        try {
          Annotation annos[] = ob.getClass().getAnnotations();

          System.out.println("All annotations for Meta2:");
          for (Annotation a : annos)
            System.out.println(a);

          Method m = ob.getClass().getMethod("myMeth");
          annos = m.getAnnotations();

          System.out.println("All annotations for myMeth:");
          for (Annotation a : annos)
            System.out.println(a);

        } catch (NoSuchMethodException exc) {
          System.out.println("Method Not Found.");
        }
   }


   public static void main(String args[]) {
      example();
       show();
       myMeth();
   }
}

Answer 1

在类或方法上找到注释后，您可以检查注释的类型。

Annotation a = .....
if (a.annotationType().equals(GUI.class)) {
    System.out.println("Found");
}

编辑：完整的工人阶级

@Deprecated
public class Demo {
    public static void example() {
        try {
            Class c = Demo.class;
            // get the annotations
            Annotation[] classAnnotations = c.getAnnotations();
            // print Class annotation
            for (int i = 0; i < classAnnotations.length; i++) {
                if (classAnnotations[i].annotationType().equals(Deprecated.class)) {
                    System.out.println("Class Annotation: " + classAnnotations[i].annotationType());
                }
            }

            // get the method show
            Method m = c.getMethod("show");
            Annotation[] methodAnnotations = m.getDeclaredAnnotations();
            // print Methods annotation
            for (int i = 0; i < methodAnnotations.length; i++) {
                if (methodAnnotations[i].annotationType().equals(Deprecated.class)) {
                    System.out.println("Method Annotation: " + methodAnnotations[i].annotationType());
               }
            }

        } catch (NoSuchMethodException exc) {
            exc.printStackTrace();
        }
    }

    @Deprecated
    public static void show()
    {
    }


    public static void main(String args[]) {
        example();
    }
}

Answer 2

我通过一些不同的方式找到了这个问题的解决方案： -

创建用户定义注释

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation
{
    String testText();
}

创建一个使用此annoation的类

public class TestClass {
      @TestAnnotation(testText="arg")
        public void doSomething(){ 
          System.out.println("kaam banta arg 1111");
      }

      @TestAnnotation(testText="anu")
        public void doSomething1(){
          System.out.println("Calling ANU");


      }

      @TestAnnotation(testText="arg")
        public void doSomething2(){
          System.out.println("kaam banta arg 22222");
      }

使用此逻辑创建一个类

public class ClassesfromPackage {

    public static void main(String args[]) 
    {

        try {

            for (Method method : TestClass.class.getMethods())
            {
                if (method.isAnnotationPresent((Class<? extends Annotation>) TestAnnotation.class))
                {
                    TestAnnotation ta = method.getAnnotation(TestAnnotation.class);
                    if(ta.testText().contains("anu"))
                    {
                    String aMethod = method.getName();
                    System.out.println(aMethod);
                    Object iClass = TestClass.class.newInstance();
                    Class params[] = {};
                    Object paramsObj[] = {};
                    Method thisMethod = TestClass.class.getDeclaredMethod(aMethod, params);
                    // call the method
                    thisMethod.invoke(iClass, paramsObj);
                    }
                    /*else
                    {
                        String aMethod = method.getName();
                        Object iClass = TestClass.class.newInstance();
                        Class params[] = {};
                        System.out.println("Inside Else");
                        Object paramsObj[] = {};
                        Method thisMethod = TestClass.class.getDeclaredMethod(aMethod, params);
                        // call the method
                        thisMethod.invoke(iClass, paramsObj);
                    }*/
                }
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

}
}

这是调用相应的方法。

但是一个新问题出现了如何在TestClass中调用JUNIT @Test annoated方法，我们正在调用dosomething1之类的方法。

等待回答。

如何找到包含特定注释的类或方法？

2 个答案: