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>
 *   &#064;com.acme.util.Name(first=Alfred, middle=E., last=Neuman)
 * </pre>
 *
 * @return a string representation of this annotation
 */
String toString();

Solution

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();
    }
}