Discussion :

[Orange57]

Bonjour, je vous explique mon problème.
Toujours sur mon projet de monnaie pour mon bot discord, je pensais créer un dossier TXT pour chaque personne et stocké leurs argent dedans, le problème est que je ne sais pas comment faire, entre temps un anglais a essayé de m'aider et ma parler de hashage de données ect.. j'ai pas très bien compris, je vous fournis mon code, celui de l'anglais et en espérant que quelqu'un pourrai m'aider.

Mon code: https://www.hastebin.com/vokakiyazi.scala
Celui de la personne qui a voulu m'aider : https://www.hastebin.com/setogukibe.java

Merci infiniment de votre aide.

[joel.drigo]

Salut,

Tout d'abord Eclipse est un outil d'aide au développement (ce qu'on appelle un environnement de développement intégré). C'est ton programme qui doit exécuter ce que tu veux, pas Eclipse.

Ensuite, il y a un truc qui n'est pas clair dans tes liens : c'est en Scala ou en Java, ton programme ?

Enfin, si je comprends bien tu voudrais sauvegarder des informations pour chaque personne, dans un fichier, lui même stocker dans un dossier. Un dossier par personne à priori. Tu parles de dossier TXT : un dossier c'est un dossier et n'a pas de format, donc n'est pas plus TXT que JPEG ou SCHMURF. Un fichier peut être en format texte lui en revanche.

Pour écrire dans un fichier texte en Java, pas besoin de ObjectOutputStream. Un ObjectOutputStream permet de sérialiser des objets qui ont des propriétés sérialisables, afin de pouvoir être échangés entre systèmes qui communiquent par un protocole de type texte (comme http par exemple).
On pourrait utiliser un DataOuputStream pour stocker les informations dans un fichier binaire non texte en revanche.
Pour un fichier texte, d'ailleurs, il serait pratique d'utiliser la classe Properties qui permet de gérer facilement un ensemble de propriétés qui ont des valeurs. Le seul souci, c'est que les valeurs seront toutes des String et donc il faudra les convertir si tu as des propriétés à stocker qui ne sont pas du texte. L'avantage d'utiliser un DataOutputStream (ou un ObjectOutputStream) est de pouvoir directement récupérer tes données typées (en int, en double, etc.).

Le programme qu'on ta donné en solution n'a rien à voir directement avec une notion de hashage, si ce n'est qu'il utilise des ConurrentHashMap qui utilisent un hashcode pour retrouver rapidement les valeurs dedans à partir d'une clef, mais on s'en fout un peu, c'est transparent pour le développeur. Le programme en revanche est assez alambiqué, et assez bancal (mélange de try/with/resource et de flush/close, erreur dans certains paramètre, code doublon étrange...).

Si on devait parler de hashage dans ton besoin, c'est si le nombre de personnes risque d'être élevé. En effet, si tu fais un dossier par personne et que tu as 10000 personnes, ça va faire 10000 dossiers. Et ça, certains OS, en particulier Windows, n'aiment pas trop. Cela risque de ralentir certains accès disque. Pour l'éviter on réduit le nombre de dossiers par fichier en créant des arborescences reposant une technique de hashage : au lieu d'avoir un seul dossier avec 10000 dossiers, on va faire un dossier qui contient un nombre maximal de dossier (256 par exemple, ce qui permet d'utiliser la valeur héxadécimale d'un octet), dont chacun contient lui aussi un maximum de 256 dossiers etc. La technique de hashage va permettre de créer un nombre limité de dossier en fonction des noms de personnes. On utilisera par exemple le hashcode du nom de la personne, écrit en héxadécimal, chaque octet donnant un sous-dossier.
Avec une tel technique, on aurait besoin d'une map effectivement comme cache, mais on pourrait retrouver le fichier d'une personne sans. A voir si un cache est vraiment indispensable (on va faire d'abord une solution sans, et si les performances ne sont pas satisfaisantes, on metteras en place un cache). En outre, l'important c'est de savoir quand on accèdera à ces propriétés, en lecture et en écriture. Si c'est une seule fois au démarrage, et sur certains actes de modification pour sauvegarder, cela me semble inutile d'avoir cette map.

[Orange57]

Salut,
merci énormément d'avoir pris le temps de me répondre.
Enfaite tu à mal compris, je voulais créer un fichier texte pour chaque personne donc en gros je voulais créer un fichier texte en particulier pour pouvoir me servir de inputstream afin de renvoyer cette valeur sur le salon textuelle, et je voulais faire en sorte que quand une personne tape une commande sa aie vérifier si cette personne possède un compte (dossier txt) et sinon sa en créer un du nom de la personne, sachant que le nom de la personne je le possède déjà, elle se stock dans une variable nommée name, et pour le hashage, est-ce simple à réaliser sachant que je le rappelle je suis débutant, et si oui avez-vous une piste pour commencer svp?
Merci encore de votre réponse qui ma apporter que du positif sur mon projet.

EDIT: C'est du java, comme je l'ai dit au dessus, je suis sous Eclipse et pour toute information de Discord j'utilise la librairie JDA, qui permet au bot de se connecter,récupérer les messages reçu ainsi que les informations sur les expéditeurs, c'est également grâce à sa que je sais qui envoie le message

[joel.drigo]

a me dit pas ce qu'il doit y avoir dans ce fichier. a me présise juste que c'est bien un fichier texte.

Pour le hash, on peut simplement déjà s'appuyer sur la méthode hashCode de String :

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
public class GestionFichierPersonnes {
 
	// un dossier pour stocker tous les dossier : là tu met ce que tu veux
	private static Path dossierDesPersonnes = Paths.get(System.getProperty("user.home")).resolve("myapp").resolve("personne");
 
	// une méthode pour pouvoir changer le dossier
	public static void setDossierDesPersonnes(Path chemin) {
		dossierDesPersonnes=Objects.requireNonNull(chemin);
	}
	public static Path getDossierDesPersonnes() {
		return dossierDesPersonnes;
	}
 
	public static Path getDossierPersonne(String nom) {
		String hex = Integer.toHexString(nom.hashCode()); // on utilse le hash de String
		if ( hex.length()%2==1 ) { // on formate le hash à un nombre pair de caractères
			hex = "0"+hex;
		}
		Path path=dossierDesPersonnes; 
		for(int i=0; i<hex.length(); i+=2 ) { // on parcourt les caractères 2 à 2
			Path subPath = Paths.get(hex.substring(i*2, (i*2)+2 )); // on convertit la sous-chaine en chemin
			path = path.resolve(subPath); // on concatène le chemin
		}
		return path;
	}
 
	// retourne le chemin d'un fichier texte pour une personne
	public static Path getCheminPersonne(String nom) {
		return getDossierPersonne(nom).resolve(nom+".txt");
	}
 
	// test si le fichier pour la personne existe
	public static boolean personneExiste(String nom) {
		return Files.exists(getCheminPersonne(nom));
	}
 
}

Si les fichiers contiennent bien des propriétés, en utilisant la classe Properties, on peut ajouter les méthodes suivantes :

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
 
	// lire les propriétés d'une personne
	public static Properties lireProprietesPersonne(String nom) throws IOException {
		Path path = getCheminPersonne(nom);
		Properties properties = new Properties();
		if ( Files.exists(path) ) {
			try(Reader reader=Files.newBufferedReader(path)) {
				properties.load(reader);
			}
		}
		return properties;
	}
 
	// sauver les propriétés d'une personne
	public static void sauverProprietesPersonne(String nom, Properties properties) throws IOException {
		Path path = getCheminPersonne(nom);
		Path dossier = path.getParent();
		if ( !Files.exists(dossier) ) {
			Files.createDirectories(dossier);
		}
		try(Writer writer=Files.newBufferedWriter(path)) {
			properties.store(writer, "Properties of " + nom);
		}
	}
 
        // pour modifier une propriété d'une personne, sans avoir le Properties, si valeurPropriété est null, la propriété est supprimée
	public static void setProprietePersonne(String nomPersonne, String nomPropriete, String valeurPropriete) throws IOException {
		Properties properties = lireProprietesPersonne(nomPersonne);
		if ( valeurPropriete==null ) {
                     properties.remove(nomPropriete);
                }
                else {
                     properties.setProperty(nomPropriete, valeurPropriete);
                }
		sauverProprietesPersonne(nomPersonne, properties);
	}
 
	public static String getProprietePersonne(String nomPersonne, String nomPropriete) throws IOException {
		Properties properties = lireProprietesPersonne(nomPersonne);
		return properties.getProperty(nomPropriete);
	}

On peut accèder à une propriété directement par getProprietePersonne(), ou en faisant exactement le même code que cette méthode en dehors de la classe.

Il y a une autre chose qui transparait dans le code qu'on t'a proposé en solution, par l'utilisation d'une ConcurrentHashMap : l'accès multi-thread. Les méthodes précédentes ne sont pas thread-safe : en cas d'accès multithread, on aura des exceptions d'accès concurrent.

Si c'est le cas, on pourrait faire comme ç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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
	// lire les propriétés d'une personne
	public static ConcurrentHashMap<String,String> lireProprietesPersonne(String nom) throws IOException {
		Path path = getCheminPersonne(nom);
		Properties properties = new Properties();
		if (Files.exists(path)) {
			try (Reader reader = Files.newBufferedReader(path)) {
				properties.load(reader);
			}
		}
		ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
		for(Map.Entry<Object, Object> entry : properties.entrySet()) {
			map.put(String.valueOf(entry.getKey()),  String.valueOf(entry.getValue()));
		}
		return map;
	}
 
        // verrous pour éviter qu'on écrive les propriétés d'une même personne plusieurs fois en même temps
	private final static ConcurrentHashMap<String,Object> LOCKS = new ConcurrentHashMap<String,Object>();
	// sauver les propriétés d'une personne
	public static void sauverProprietesPersonne(String nom, ConcurrentHashMap<String, String> properties) throws IOException {
		synchronized(LOCKS.computeIfAbsent(nom, k->new Object())) {
			Path path = getCheminPersonne(nom);
			Path dossier = path.getParent();
			if (!Files.exists(dossier)) {
				Files.createDirectories(dossier);
			}
			Properties prop = new Properties();
			prop.putAll(properties);
			try (Writer writer = Files.newBufferedWriter(path)) {
				prop.store(writer, "Properties of " + nom);
			}
		}
	}
 
	public static void setProprietePersonne(String nomPersonne, String nomPropriete, String valeurPropriete)
			throws IOException {
		ConcurrentHashMap<String,String> properties = lireProprietesPersonne(nomPersonne);
		if (valeurPropriete == null) {
			properties.remove(nomPropriete);
		} else {
			properties.put(nomPropriete, valeurPropriete);
		}
		sauverProprietesPersonne(nomPersonne, properties);
	}
 
	public static String getProprietePersonne(String nomPersonne, String nomPropriete) throws IOException {
		ConcurrentHashMap<String, String> properties = lireProprietesPersonne(nomPersonne);
		return properties.get(nomPropriete);
	}

Et avec cache par exemple :

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
        // une map pour stocker les propriétés des personnes en mémoire, qui évitera qu'on relise les fichiers à chaque fois qu'on en a besoin
	private static final ConcurrentHashMap<String, ConcurrentHashMap<String,String>> CACHE = new ConcurrentHashMap<>();
 
	// lire les propriétés d'une personne
	private static ConcurrentHashMap<String,String> lireProprietesPersonne(String nom) {
		return CACHE.computeIfAbsent(nom, k-> lireFichierProprietesPersonne(nom));
	}
	private static ConcurrentHashMap<String,String> lireFichierProprietesPersonne(String nom) {
		Path path = getCheminPersonne(nom);
		Properties properties = new Properties();
		if (Files.exists(path)) {
			try (Reader reader = Files.newBufferedReader(path)) {
				properties.load(reader);
			} catch (IOException e) {
				throw new UncheckedIOException(e);
			}
		}
		ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
		for(Map.Entry<Object, Object> entry : properties.entrySet()) {
			map.put(String.valueOf(entry.getKey()),  String.valueOf(entry.getValue()));
		}
		return map;
	}
 
	private final static ConcurrentHashMap<String,Object> LOCKS = new ConcurrentHashMap<String,Object>();
	// sauver les propriétés d'une personne
	public static void sauverProprietesPersonne(String nom) {
		ConcurrentHashMap<String, String> properties = CACHE.get(nom);
		if(  properties!=null ) {
			sauverFichierProprietesPersonne(nom, properties);
		}
	}
	public static void sauverProprietesPersonne(String nom, ConcurrentHashMap<String, String> properties) throws IOException {
		CACHE.put(nom, Objects.requireNonNull(properties));
		sauverFichierProprietesPersonne(nom, properties);
	}
	private static void sauverFichierProprietesPersonne(String nom, ConcurrentHashMap<String, String> properties) {
		synchronized(LOCKS.computeIfAbsent(nom, k->new Object())) {
			Path path = getCheminPersonne(nom);
			Path dossier = path.getParent();
			try {
				if (!Files.exists(dossier)) {
					Files.createDirectories(dossier);
				}
				Properties prop = new Properties();
				prop.putAll(properties);
				try (Writer writer = Files.newBufferedWriter(path)) {
					prop.store(writer, "Properties of " + nom);
				}
			}
			catch(IOException e) {
				throw new UncheckedIOException(e);
			}
		}
	}
 
	public static void setProprietePersonne(String nomPersonne, String nomPropriete, String valeurPropriete)
			throws IOException {
		ConcurrentHashMap<String,String> properties = lireProprietesPersonne(nomPersonne);
		if (valeurPropriete == null) {
			properties.remove(nomPropriete);
		} else {
			properties.put(nomPropriete, valeurPropriete);
		}
		sauverProprietesPersonne(nomPersonne, properties);
	}
 
	public static String getProprietePersonne(String nomPersonne, String nomPropriete) throws IOException {
		ConcurrentHashMap<String, String> properties = lireProprietesPersonne(nomPersonne);
		return properties.get(nomPropriete);
	}

Toutes les explications supplémentaires peuvent être obtenues par la doc, puisqu'il s'agit d'utilisation de méthodes standard sans algorithme particulier

[Orange57]

Bonjour,
C'est génial de m'avoir aider à se point et franchement je doit t'avouer que je m'attendais pas à se que vous arriviez jusqu’à me fournir du code directement, il me reste plus qu'a le comprendre dès a présent, si tu pourrai m'envoyez la doc que tu m'a parler et mon problème sera résolut.
Merci infiniment.

[joel.drigo]

La documentation tu peux l'obtenir en cherchant sur Internet "javadoc api" par exemple. Mais comme tu es sur Eclipse, c'est encore plus simple : il suffit d'afficher la vue "JavaDoc" et en cliquant sur une classe ou une méthode, la javadoc correspondante s'affichera dans cette vue

Par exemple, là, j'ai cliqué sur ConcurrentHashMap :

[Orange57]

Bon, et bien j'ai plus qu'a décrypter tout sa et c'est régler merci énormément de ton aide.
Bonne soirée.