Discussion :

[Pecose]

Bonjour tout le monde,

Je me posai une petite question, pourquoi se prendre la tête avec Spring ou Google Guice ou autre quand on peux faire ça:

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
package dependences;
 
import java.io.File;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Scanner;
 
public class Injector {
 
	private Hashtable<String, Object> classList = new Hashtable<String, Object>();
 
	public Object get(String string){ return classList.get(string); }
 
	@SuppressWarnings("resource")
	public Injector(String configFileName){
		try {
			Scanner scanner = new Scanner(new File(configFileName));
			ArrayList<String> namesList = new ArrayList<String>();
			while(scanner.hasNext()){ namesList.add(scanner.next()); }
			for(String string : namesList){ 
				Object object = Class.forName(string).newInstance();
				String[] name = object.getClass().getInterfaces()[0].getName().split("\\.");
				classList.put(name[name.length-1], object);	
 
			}
		} catch(Exception e) { e.printStackTrace(); }
	}
 
}

Parce que ça fait plusieurs jours que je galère a essayer de comprendre comment utiliser ces saleté de frameworks inbittables, avec des tutos écrits par des gars qui ont pas l'air d'avoir eu-même pas bien compris de quoi ils parlaient, et là je me rend compte qu'on peut faire la même chose en 1000x plus simple en écrivant une classe de 20 lignes.

Alors il doit bien y avoir un truc que j'ai pas compris, ou que je ne connais pas parce que je ne peux pas avoir fait mieux que des millions d'ingénieurs qui ont travaillés sur le sujet pendant des années.

C'est pas possible.

Du coup merci de m'apporter vos lumières.

[PhilippeGibault]

Je pense qu'il serait souhaitable, effectivement, d'utiliser l'anti-pattern "Réinventer la roue (carrée)".

Je recommande Spring, c'est un très bon Framework, et il a fait ses preuves.

Surtout qu'aujourd'hui, la configuration est simplifié Grace à Spring-boot, et on peut lancer un Programme, aussi bien un client Lourd qu'un serveur Java Grâce à Spring Boot.

Le site:
https://spring.io/projects/spring-boot

Tutoriels:
https://www.baeldung.com/spring-boot-start

https://o7planning.org/fr/11267/le-t...-les-debutants

Cordialement.

[thelvin]

Par ailleurs, l'exemple donné au départ, montre que c'est pas compliqué de faire un fichier qui contient une liste de classes à instancier.

Certes.

Mais il reste à lier ces classes ensemble, être capable de déterminer quand il y a besoin de mettre une classe dans le fichier et quand il est évident qu'une autre classe a besoin de cette classe, configurer les valeurs des champs de toutes ces classes, et gérer les finitions de la construction d'une instance.

Sans compter que Spring n'a plus besoin d'un fichier qui liste les classes à instancier. Il suffit d'annoter la classe d'une annotation qui dit que c'est une classe à faire insérer par Spring (ou un autre).

Si tu trouves que c'est si facile à faire, je t'en prie, montre-nous.

Et c'est sans compter tout ce qui a été construit du fait que Spring existe avec son système, et donc qu'on peut ajouter au système. Jusqu'au point de Spring Boot qui autoconfigure énormément de choses pour qu'on puisse se concentrer sur la véritable valeur de la programmation : faire ce que le programme est censé faire.

Il se trouve qu'à titre personnel, bien que j'admette la valeur évidente de Spring, seul et en tant que standard industriel, je sais voir aussi que Spring n'est pas parfait et qu'on finit toujours par tomber dans un cas qu'il ne gère pas comme il le devrait, ou bien où il devrait laisser un choix et ne le laisse pas. Pas parfait, donc. Et du coup, je me suis fabriqué une alternative à Spring. "Réinventer la roue," oui, dans le seul but d'être maître à bord et que toute imperfection du système vienne de mon architecture et non pas du fait d'une des bibliothèques que j'utilise. C'est tout à fait faisable. Mais c'est une sacrée dévotion, juste à cause d'une insuffisance de détail détectée ça et là dans une bibliothèque mainstream.

[Pecose]

Alors, qu'on soit bien d'accord, je suis nul.
Je ne pose pas cette question pour critiquer mais parce que je n'ai rien compris.
Partant de là, Thelvin, tu dit:

Mais il reste à lier ces classes ensemble, être capable de déterminer quand il y a besoin de mettre une classe dans le fichier et quand il est évident qu'une autre classe a besoin de cette classe, configurer les valeurs des champs de toutes ces classes, et gérer les finitions de la construction d'une instance.

Et bien justement je ne comprend pas l’intérêt de le faire puisque selon moi ça ce fait tout seul.

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
public interface I {
	public void set(Y y);
	public int get();
}
 
public class A implements I{
 
	public int v = 321;
	@Override
	public void set(Y y) {
		v = y.get();	
	}
	@Override
	public int get() {
		return v;
	}
}

Code :

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

1
2
3
4
5
6
7
8
9
10
public interface Y {
	int get();
}
 
public class B implements Y{
	@Override
	public int get() {
		return 123;
	}
}

J'ai un peu changer Injector:

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
public class Injector {
 
	private Hashtable<String, Object> classList = new Hashtable<String, Object>();
	public Object get(String string){ return classList.get(string); }
 
	public Injector(String configFileName){
		try {
			Saver saver = new Saver("config.txt"); //créé le fichier s'il n'existe pas et permet d'y lire et d'y écrire
			Scanner scanner = saver.getScanner();
			ArrayList<String> namesList = new ArrayList<String>();
			while(scanner.hasNext()){ namesList.add(scanner.next()); }
			for(String string : namesList){ 
				Object object = Class.forName(string).newInstance();
				String[] name = object.getClass().getInterfaces()[0].getName().split("\\.");
				classList.put(name[name.length-1], object);	
 
			}
		} catch(Exception e) { e.printStackTrace(); }
	}
 
}

Ça c'est config.txt:

Code :

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

1
2
dependences.A
dependences.B

Tout ce passe ici:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public class Main{
 
	public static void main(String[] args){ 
		Injector injector = new Injector("config.txt");
		I i = (I) injector.get("I");
		Y y = (Y) injector.get("Y");
		i.set(y);
		System.out.println(i.get());
	}	
 
}

Bon là je suis obligé de faire un constructeur par défaut mais à par ça...

"Mais il reste à lier ces classes ensemble"
Pour quoi faire? J'ai pas compris, je suis nul...

"être capable de déterminer quand il y a besoin de mettre une classe dans le fichier"
Ça c'est la version de ton logiciel qui le détermine, donc soit tu le fait à la main soit par une classe qui le fait toute seul en fonction de la version. Et en plus c'est tout con à faire.

"quand il est évident qu'une autre classe a besoin de cette classe"
J'ai une classe qui dépend d'une autre et pourtant j'ai rien à lier, enfin je pense.

"configurer les valeurs des champs de toutes ces classes"
Je suis encore perdu, les valeurs les champs c'est toi qui les détermines par le biais du code. Dans ma classe A j'ai v qui vaut 321. Et je redéfinit cette valeur un peu plus tard avec la méthode get() de la classe B.C'est à moi de faire ça. Pourquoi demander à Spring de le faire? J'ai pas compris.

"et gérer les finitions de la construction d'une instance"
Ça se fait tout seul alors pourquoi s’embêter?

Merci infiniment pour vos réponses, vous m’êtes d'un aide inestimable.

[dotzero]

Bonjour,

Vu que les autres ont bien couvert la partie technique, je vais parler un peu de l'histoire.

Spring était une véritable évolution. Java EE 4 et 5 étaient très lourdes à utiliser et à maintenir. L'utilisation des fichiers XML pour la configuration, l'absence des CDI et l'absence des annotations étaient les principales motivations pour développer Spring.

Heureusement avec Java EE 7 et 8, plusieurs concepts de Spring ont été reprises, ainsi, si vous allez créer une application de base, vous pouvez utiliser Java EE tout court sans faire appel à des frameworks supplémentaires.

Bon Courage,