Discussion :

[jerem721]

Bonjour,
j'ai cree une application qui demande une certaine versions du JRE.
pour cela je voudrais prévenir l'utilisateur que sa version nets trop veille si c'est le cas mais comment faire ?


jerem721

[Invité]

Salut,
Tu veux faire ce test dans ton programme Java ou avant dans un script ? En java tu récupères la version du JRE avec :

Code :

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

1
2
 
System.getProperty("java.version");

Tschau

[jerem721]

ok merci beaucoup c'est ce que je cherchais

mais peut on le récupéré sous forme de int?

[tchize_]

non, puisque la version n'est pas un int. (exemple: 1.4.2, c'est pas un int ça)

[jerem721]

donc comment faire pour savoir si l'utilisateur posséde une version supérieur ou inférieur à celle requis?

[tchize_]

tu lit "java.version"

[jerem721]

ouia sa je suis d'accord avec toi, mais pour la comparer a celle demander quelle code je doit utiliser pour dire
SI version < 1.6._12 ALORS sa envoie un message

comment je peu traduire sa ? en java

a moins qu'il existe une autre méthode

[tchize_]

tu va devoir dépatouiller toi même la string de version pour savoir si c'est bon. La version a toujours la forme majeur.moyen[.mineur]

[jerem721]

j'ai fait comme sa cela c'est correct ?

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
 
NumberFormat formatNombres = NumberFormat.getInstance();
 
		String ver = System.getProperty("java.version");
		System.out.println(ver);
 
		//recupere la version sous dorme de int 
		version = formatNombres.parse(ver,
					new ParsePosition(2) /*ne sert pas */).
					//puis donne sa valeur en tant que double
					intValue();
 
		//recupere la version sous dorme de int 
		version2 = formatNombres.parse(ver,
					new ParsePosition(6) /*ne sert pas */).
					//puis donne sa valeur en tant que double
					intValue();
 
		System.out.println(version2);
 
		if(version < 6 || version2 < 12)
		{
			 JOptionPane.showMessageDialog(null, "Version de java trop veille " + version+"."+version2); 
 
		}

[tchize_]

ton code va refuser 7.8, par exemple, parce que 8 < 12

[Djobird]

Heu question conne, mais ton test, tu vas le faire dans ton appli ?
Parce que si ton appli est compilé dans la version dont tu as besoin, bah de tout façon l'utilisateur pourra pas la lancer.

[tchize_]

tout dépend si c'est une version pour le format de classes qu'il vise ou une version des librairies. Dans le deuxième cas, son code marchera jusqu'à ce qu'il essaie d'utiliser une classe non présente. Il peux aussi compiler son main en visant java 1.4 pour être sur :p

[jerem721]

j'ai peu être trouver une solution qui permet de de savoir si la version de l'utilisateur est une version supérieur ou inférieur à celle demander

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
 
public class VersionJRE {
 
	int majeur, moyen, mineur1, mineur2, version;
 
 
	VersionJRE()
	{
		NumberFormat formatNombres = NumberFormat.getInstance();
 
		String ver = System.getProperty("java.version");
		System.out.println(ver);
 
		//recupere la version sous dorme de int 
		majeur = formatNombres.parse(ver,
					new ParsePosition(0) ).
					//puis donne sa valeur en tant que double
					intValue();
 
		//recupere la version sous dorme de int 
		moyen = formatNombres.parse(ver,
					new ParsePosition(2) ).
					//puis donne sa valeur en tant que double
					intValue();
 
		//recupere la version sous dorme de int 
		mineur1 = formatNombres.parse(ver,
					new ParsePosition(4) ).
					//puis donne sa valeur en tant que double
					intValue();
 
		//recupere la version sous dorme de int 
		mineur2 = formatNombres.parse(ver,
					new ParsePosition(6)).
					//puis donne sa valeur en tant que double
					intValue();
 
 
		//tranforme tous les int pour former un seul int sous la forme de 
		//ex. 1.6.0_13  -->  16013
 
		version = (majeur * 10000) + (moyen * 1000) + (mineur1 * 100) + mineur2;
		System.out.println(version);
 
		//compare la version apres transformation à celle demandé
		//la version demandé est : 1.6.0_12 apres transformation on obtient  16012
		if(version < 16012)
		{
			System.out.println("votre version est trop veille");
		}
 
 
	}
 
}

vous en pensez quoi ?
sa à l'air de fonctionner comme sa ? non?

[_-Sky-_]

Ton code fonctionne chez moi, sur plusieurs de mes VM Sun (1.4.2_10, 1.5.0_06 et 1.6.0_05)

Juste une petite remarque : j'ai déjà eu à faire cela sur des environnements et avec d'autres VM que les Sun. Et, sur l'une de ces platteformes au moins, "mineur2" n'existait pas. (J'ai eu du "1.5.0" par exemple)

Avec ton code tel qu'il est, cela aurait pour effet de provoquer une exception de type java.lang.NullPointerException.
Je pense qu'il faut s'assurer de la forme exacte de la partie mineure.

EDIT : J'ai essayé de trouver la description de cette propriété, mais je n'ai rien trouvé de probant. Mais, sur cette page, on peut trouver des exemples de résultats, dont certains qui ne fonctionneraient pas avec ton code (ex : "1.3.1" sous MacOS X ou "1.1.4" sur d'anciens Windows livrés avec des VM Microsoft). Ce ne sont peut-être pas des environnements que ton logiciel considère, mais il peut être intéressant de le savoir !!

Au passage, voici une variante, avec l'utilisation d'un objet StringTokenizer pour l'analyse de la chaine de caractères (la partie test est inchangée) :

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
public static void testJreVersion() {
	int majeur, moyen, mineur1, mineur2, version;
 
	String ver = System.getProperty("java.version");
	System.out.println(ver);
 
	StringTokenizer tokens = new StringTokenizer(ver, "._");
	majeur  = Integer.parseInt(tokens.nextToken());
	moyen   = Integer.parseInt(tokens.nextToken());
	mineur1 = Integer.parseInt(tokens.nextToken());
	if(tokens.hasMoreTokens()) {
		mineur2 = Integer.parseInt(tokens.nextToken());
	}
	else {
		mineur2 = 0;
	}
 
	version = (majeur * 10000) + (moyen * 1000) + (mineur1 * 100) + mineur2;
	System.out.println(version);
 
	if(version < 16012)
	{
		System.out.println("votre version est trop vieille");
	}
}