Récupérer @version dans un String

Bonjour,

dans la javadoc, il est possible de définir la version d'un classe en utilisant @version.
Est ce que l'on peut récupérer cette information dans la classe ?
Par exemple quelque chose du type :
Code:

1 2 3 4 5 6 7 8 /** ma javadoc. * @version 1.1 */ class maclass { String version = @version ; }
Merci par avance !

Peut-être en utilisant l'API de la javadoc mais il faut passer le code source ou voir s'il est possible de compiler en conservant les commentaires dans le bytecode.

Sinon, j'ignore si c'est la manière correcte de faire (vu que j’expérimente un peu dans le domaine), mais tu peux utiliser les annotations :

L'annotation:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package anotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.TYPE})
public @interface Version {
 
    String value() default "1.0";
}

Le code qui l'utilise:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package anotation;
 
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
 
@Version("2.0")
public class Test {
 
    public final String version1;
 
    @Version("0.1")
    protected Test() {
        final Version classVersion = getClass().getAnnotation(Version.class);
        version1 = classVersion.value();
        System.out.println(version1);
        final Constructor[] constructors = getClass().getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            final Version constructorVersion = constructor.getDeclaredAnnotation(Version.class);
            final String version = (constructorVersion == null) ? null : constructorVersion.value();
            System.out.printf("%s - %s", constructor.getName(), version).println();
        }
        final Method[] methods = getClass().getDeclaredMethods();
        for (Method method : methods) {
            final Version methodVersion = method.getAnnotation(Version.class);
            final String version = (methodVersion == null) ? null : methodVersion.value();
            System.out.printf("%s - %s", method.getName(), version).println();
        }
    }
 
    @Version
    private void toto() {
    }
 
    @Version("3.5")
    public static void main(String... args) {
        new Test();
    }
}

Ça devrait sortir un truc du genre:

Code:

1
2
3
4
2.0
anotation.Test - 0.1
main - 3.5
toto - 1.0

Merci pour la réponse.
Je m'attendais à quelque chose de simple... :-(

Salut,

Tu peux procéder dans le sens inverse, éventuellement :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * A class to...
 * 
 * @version {@value #VERSION}
 * @author Joël
 *
 */
public class MyClass {
 
	public final static double VERSION = 1.0;
 
	/* ... */
 
}

Ca marche parfaitement, merci !!!