问题
How to read value of java annotation with JDK8 and JDK11?
import io.cucumber.java.en.When;
public class Sof {
private static final Logger log = LoggerFactory.getLogger(Sof.class);
@When(value = "I update text {string} with {string}(\\?)")
public static void main(String[] args) {
Class c = Sof.class;
Method[] methods = c.getMethods();
Method method = null;
for (Method m : methods) {
if (m.getName().equals("main")) {
method = m;
}
}
Annotation stepAnnotation = method.getAnnotation(When.class);
Object as[] = { "a", "b" };
Matcher matcher = Pattern.compile("value=(.*)\\)").matcher(stepAnnotation.toString());
if (matcher.find()) {
log.info("---> " + stepAnnotation.annotationType().getSimpleName() + " " + String.format(matcher.group(1).replaceAll("\\{\\S+\\}", "{%s}").replace("(\\?)", ""), as));
} else {
System.err.println("error");
}
}
}
/!\ in reality, I do not know the type of annotation @When
. this can be any of the interfaces in the io.cucumber.java package
result JDK8:
---> When I update text {a} with {b}
result JDK11 (extra quote): (stepAnnotation.toString()
is different!)
---> When "I update text {a} with {b}"
EDIT openjdk11
and oraclejdk11
do not respect javadoc:
/**
* Returns a string representation of this annotation. The details
* of the representation are implementation-dependent, but the following
* may be regarded as typical:
* <pre>
* @com.acme.util.Name(first=Alfred, middle=E., last=Neuman)
* </pre>
*
* @return a string representation of this annotation
*/
String toString();
回答1:
You should not depend on the toString()
implementation which is normally for debugging/logging only.
See Is it possible to read the value of a annotation in java? for more details on how to read the value of an annotation.
UPDATE:
To do everything via reflection, you can so something like this:
import org.springframework.transaction.annotation.Transactional;
import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
public class AnnotationTest {
public static void main(String[] args) throws IllegalAccessException, InvocationTargetException {
Method[] methods = AnnotationTest.class.getMethods();
System.out.println("methods = " + Arrays.toString(methods));
for (Method method : methods) {
System.out.println("method = " + method);
Annotation[] annotations = method.getAnnotations();
System.out.println("annotations = " + Arrays.toString(annotations));
for (Annotation annotation : annotations) {
System.out.println("annotation = " + annotation);
Class<? extends Annotation> annotationClass = annotation.annotationType();
System.out.println("annotationClass = " + annotationClass);
Method[] annotationMethods = annotationClass.getMethods();
System.out.println("annotation methods = " + Arrays.toString(annotationMethods));
for (Method annotationMethod : annotationMethods) {
if (Modifier.isPublic(annotationMethod.getModifiers())) {
String name = annotationMethod.getName();
Object o = annotationMethod.invoke(annotation);
System.out.println(name + ": " + o);
}
}
}
}
}
@Transactional("bla")
public void test() {
}
}
(I used one of Spring's annotations here since that is what I happen to have on my classpath)
UPDATE (with end of solution):
@When(value = "I update text {string} with {string}(\\?)")
public static void main(String[] args) {
Object as[] = { "a", "b" };
Class c = Sof.class;
Method[] methods = c.getMethods();
Method method = null;
for (Method m : methods) {
if (m.getName().equals("main")) {
method = m;
}
}
Annotation stepAnnotation = method.getAnnotation(When.class);
Class<? extends Annotation> annotationClass = stepAnnotation.annotationType();
try {
Method valueMethods = annotationClass.getDeclaredMethod("value");
if (Modifier.isPublic(valueMethods.getModifiers())) {
log.info("---> {} " + String.format(valueMethods.invoke(stepAnnotation).toString().replaceAll("\\{\\S+\\}", "{%s}").replace("(\\?)", ""), as),
stepAnnotation.annotationType().getSimpleName());
}
} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e1) {
e1.printStackTrace();
}
}
来源:https://stackoverflow.com/questions/60651653/how-to-read-value-of-java-annotation-with-jdk8-and-jdk11