Discussion :

[ToTo13]

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 java :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Merci par avance !

[bouye]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 console :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[ToTo13]

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

[joel.drigo]

Salut,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
 
	/* ... */
 
}

[ToTo13]

Ca marche parfaitement, merci !!!