Fichier de config

Author: Unknown

Date: 25/10/2024

Je veux traiter des fichiers de prise de notes diverses que j'ai sur mon disque. Dans certains cas, j'ai un fichier unique, avec plusieurs notes dedans. Par exemple:

❯ head NotesDiversesEnVrac.md
2020/06/01
#isolation #Travaux Isolation du toit par terre végétalisée: Deux paliers différents avec effet de seul, à 7cm et à 30cm (émission La terre au carré, S2 2020)

#nucléaire Tchernobyl et Fukushima: anomalies de croissance dans les végétaux, et baisse de la population d'oiseaux, non compensés par les effets du départ de l'homme des territoires irradiés. https://www.irsn.fr/FR/connaissances/Installations_nucleaires/Les-accidents-nucleaires/accident-fukushima-2011/fukushima-2016/Documents/IRSN_Fukushima-Tchernobyl_faune-flore_201603.pdf

#énergie #énergie-renouvelable Coût des énergies renouvelables en France:  121 milliards d’euros de dépenses publiques pour les énergies renouvelables, de 2018 à 2044  https://www.lemonde.fr/blog/huet/2018/04/19/la-cour-des-comptes-alerte-sur-le-cout-des-enr/

#changement-climatique Estimated Global Mortality from Present to 2100 from Climate Change, https://www.eenews.net/assets/2018/04/04/document_gw_09.pdf

Alain Grandjean, https://alaingrandjean.fr/wp-content/uploads/2020/01/developpement-enr-electrique.pdf

Dans d'autres cas, j'ai un fichier par note, dans un sous répertoire particulier. Par exemple:

❯ ls notes
'20240107-A simple method to resolve an argument.md'
'20240202-Afficher_les_M_dans vi.md'
 20240206-Convertir_un_document_Word_docx_en_texte_brut_txt_et_en_html.md
 20240206-Ouvrir_un_fichier_csv_multilignes_dans_Excel.md
 20240206-Ouvrir_un_fichier_csv_multilignes_dans_Excel_step_01.png
 20240206-Ouvrir_un_fichier_csv_multilignes_dans_Excel_step_02.png
 20240206-Ouvrir_un_fichier_csv_multilignes_dans_Excel_step_03.png
 20240206-Ouvrir_un_fichier_csv_multilignes_dans_Excel_step_04.png
 20240206-Ouvrir_un_fichier_csv_multilignes_dans_Excel_step_05.png
 20240206-Ouvrir_un_fichier_csv_multilignes_dans_Excel_step_06.png
 20240206-Ouvrir_un_fichier_csv_multilignes_dans_Excel_step_07.png
 20240206-Ouvrir_un_fichier_csv_multilignes_dans_Excel_step_08.png
 20240220-API.md
 20240223-Utiliser_l_authentification_windows_avec_Firefox.md
 20240223-Utiliser_l_authentification_windows_avec_Firefox.png
 20240227-Modifier_un_fichier_PDF_avec_Inkscape.md
 20240229-Bien_choisir_une_défonceuse.md
 NotesDiversesEnVrac.md
 NotesDiversesVélo.md
 RemorquesVelo.md

Pour arranger le tout, on peut voir que NotesDiversesEnVrac.md doit être traiter en tant que fichier regroupant plusieurs notes, et qu'en plus, il fait partie d'un dossier contenant plusieurs notes. Point à traiter plus tard. Pour l'instant, il me faut un fichier de configuration pour lister les dossiers de notes, les fichiers de notes, et les éventuelles étiquettes par défaut des uns et des autres. Et le code pour le lire.

Et comment j'appelle mon projet, à la base ?

J'appelle chatgpt, à l'aide, en mode "Parlons avec un quidam choisi au hasard dans la rue, donc en prenant du recul par rapport à ce qu'il me dit". Une espèce de miroir qui vous aide à avancer, quand on est seul chez soi. moi: Je suis en train d'écrire un nouveau projet intellij qui prendra en entrée des notes diverses et variées au format markdown, quelquefois un fichier par jour en mode diary, d'autres fois, un seul fichier contiendra plein de notes différentes. Tout cela fera in fine un blog. Comment pourrais je appeler mon projet intellij ? GPT-4o: Pour un projet Intellij qui gère des notes en markdown et les transforme en blog, voici quelques suggestions de noms :

  1. MarkBlog
  2. NoteToBlog
  3. DiaryPress
  4. MarkdownJourney
  5. DailyLog
  6. NoteBlogger
  7. MarkDiary
  8. BlogScribe
  9. NoteStream
  10. DailyDrafts Ces noms reflètent l'idée de transformer des notes en blog tout en mettant l'accent sur le format markdown et l'aspect journalier.

Banco pour NoteBlogger. Une petite vérification pour savoir si cela eixste déjà, une petite recherche sur le net .... Apparemment, non.

Comment faire ?

Je ne veux pas dépendre pour le moment de gros frameworks. De mon jeune temps, on faisait cela via des fichiers .properties. Puis .xml. Sans doute qu'un .json serait plus dans l'air du temps.

Petite vérification avec mon nouveau copain: moi: bon, déjà, mon programme doit savoir plusieurs choses: quels sont les répertoires contenant mes fichiers markdown, les fichiers qui contiennent les notes en vrac, les catégories par défaut associés à ces fichiers et répertoires, le répertoire de sortie où je vais cracher mes fichiers HTML. donc, il me faut un fichier de config. de base, dans java, sans dépendre de framework extérieurs type Spring, c'est quoi la façon morderne de lire un fichier de config, et dans quel format celui-ci doit-il être ? GPT-4o: Pour lire un fichier de configuration sans dépendre de frameworks externes en Java, vous pouvez utiliser le format Java Properties ou JSON. Voici comment procéder pour chaque option :

Utiliser les Java Properties

  1. Format du fichier (config.properties par exemple) :
markdown.directories=path/to/markdown1,path/to/markdown2 note.files=path/to/notes1,path/to/notes2 default.categories=category1,category2 output.directory=path/to/output`
  1. Lecture en Java :
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class ConfigLoader {
    private Properties properties = new Properties();

    public ConfigLoader(String filePath) throws IOException {
        try (FileInputStream input = new FileInputStream(filePath)) {
            properties.load(input);
        }
    }

    public String[] getMarkdownDirectories() {
        return properties.getProperty("markdown.directories").split(",");
    }

    public String[] getNoteFiles() {
        return properties.getProperty("note.files").split(",");
    }

    public String[] getDefaultCategories() {
        return properties.getProperty("default.categories").split(",");
    }

    public String getOutputDirectory() {
        return properties.getProperty("output.directory");
    }
}

Utiliser JSON

  1. Format du fichier (config.json par exemple) :
{
  "markdownDirectories": ["path/to/markdown1", "path/to/markdown2"],
  "noteFiles": ["path/to/notes1", "path/to/notes2"],
  "defaultCategories": ["category1", "category2"],
  "outputDirectory": "path/to/output"
}
  1. Lecture en Java (vous pouvez utiliser la bibliothèque JSON-P fournie avec Java pour éviter des dépendances supplémentaires) :
import javax.json.*;
import java.io.FileInputStream;
import java.io.IOException;

public class ConfigLoader {
    private JsonObject config;

    public ConfigLoader(String filePath) throws IOException {
        try (FileInputStream fis = new FileInputStream(filePath);
             JsonReader reader = Json.createReader(fis)) {
            config = reader.readObject();
        }
    }

    public String[] getMarkdownDirectories() {
        JsonArray array = config.getJsonArray("markdownDirectories");
        return array.stream().map(JsonString::getString).toArray(String[]::new);
    }

    public String[] getNoteFiles() {
        JsonArray array = config.getJsonArray("noteFiles");
        return array.stream().map(JsonString::getString).toArray(String[]::new);
    }

    public String[] getDefaultCategories() {
        JsonArray array = config.getJsonArray("defaultCategories");
        return array.stream().map(JsonString::getString).toArray(String[]::new);
    }

    public String getOutputDirectory() {
        return config.getString("outputDirectory");
    }
}

Choisissez le format qui vous convient le mieux. Les fichiers .properties sont simples, tandis que JSON offre plus de flexibilité pour des configurations plus complexes.

Bon, OK, ca me confirme que je vais cela en json. Sympa de me filer déjà tout ce code, mais c'est bien plus que ce que je demandais. Un peu de bruit pour rien quand même. Mais puisqu'il est sympa, je vais lui demander de m'aider un peu plus en m'écrivant un code un peu plus aboutit.

moi: OK. Je vais cela en json. par contre, mes tags par défaut vont être différent répertoire par répertoire et fichier par fichier. Tu peux prendre cela en compte stp ? GPT-4o Bien sûr ! Pour gérer des catégories par défaut différentes pour chaque répertoire et fichier, vous pouvez structurer votre fichier JSON comme ceci :

Exemple de format JSON

{
  "markdownDirectories": ["path/to/markdown1", "path/to/markdown2"],
  "noteFiles": ["path/to/notes1", "path/to/notes2"],
  "defaultCategories": ["category1", "category2"],
  "outputDirectory": "path/to/output"
}

Lecture en Java

Voici comment vous pourriez lire cette configuration en Java :

import javax.json.*;
import java.io.FileInputStream;
import java.io.IOException;

public class ConfigLoader {
    private JsonObject config;

    public ConfigLoader(String filePath) throws IOException {
        try (FileInputStream fis = new FileInputStream(filePath);
             JsonReader reader = Json.createReader(fis)) {
            config = reader.readObject();
        }
    }

    public String[] getMarkdownDirectories() {
        JsonArray array = config.getJsonArray("markdownDirectories");
        return array.stream().map(JsonString::getString).toArray(String[]::new);
    }

    public String[] getNoteFiles() {
        JsonArray array = config.getJsonArray("noteFiles");
        return array.stream().map(JsonString::getString).toArray(String[]::new);
    }

    public String[] getDefaultCategories() {
        JsonArray array = config.getJsonArray("defaultCategories");
        return array.stream().map(JsonString::getString).toArray(String[]::new);
    }

    public String getOutputDirectory() {
        return config.getString("outputDirectory");
    }
}

Dans cet exemple, DirectoryConfig et FileConfig sont des classes internes à ConfigLoader pour représenter la configuration de chaque répertoire et fichier avec leurs catégories par défaut. Cette structure vous permet de gérer facilement les catégories spécifiques à chaque entité.

moi: javax.json, c'est un package standard ? GPT-4o: javax.json fait partie de Java EE et est fourni par l'API JSON-P (Java API for JSON Processing). Toutefois, dans une application Java SE, vous aurez besoin d'ajouter une dépendance externe, car elle n'est pas incluse dans le JDK standard. Une option courante est d'utiliser la bibliothèque javax.json en l'ajoutant via Maven ou Gradle. Voici comment faire :

Avec Maven

Ajoutez cette dépendance dans votre fichier pom.xml :

{
  "directories": [
    {
      "path": "path/to/markdown1",
      "defaultCategories": ["category1", "category2"]
    },
    {
      "path": "path/to/markdown2",
      "defaultCategories": ["category3", "category4"]
    }
  ],
  "files": [
    {
      "path": "path/to/notes1",
      "defaultCategories": ["category5"]
    },
    {
      "path": "path/to/notes2",
      "defaultCategories": ["category6", "category7"]
    }
  ],
  "outputDirectory": "path/to/output"
}

Avec Gradle

Ajoutez cette ligne dans votre fichier build.gradle : implementation 'org.glassfish:javax.json:1.1.4' avax.json:1.1.4'`

Alternatives

Si vous préférez éviter javax.json, vous pouvez aussi utiliser d'autres bibliothèques JSON populaires comme Gson ou Jackson, qui offrent des fonctionnalités similaires et sont aussi très faciles à utiliser.

Ok, c'est parti, je vais partir sur du maven, c'est du classique, j'en ai un vague souvenir. moi: peux tu me donner le fichier pom.xml complet ? GPT-4o: Bien sûr ! Voici un exemple de fichier pom.xml minimaliste incluant la dépendance pour javax.json :

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>com.example</groupId>
    <artifactId>markdown-blog</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.glassfish</groupId>
            <artifactId>javax.json</artifactId>
            <version>1.1.4</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>17</source>
                    <target>17</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    
</project>

Explications :

  • GroupId et ArtifactId : Identifiants de base pour votre projet.
  • Version : Version du projet que vous êtes en train de développer.
  • Packaging : Indique que le projet produira un fichier JAR.
  • maven.compiler.source/target : Définit la version de Java utilisée (ici, Java 17 comme exemple).
  • Dépendances : Contient la bibliothèque javax.json. Vous pouvez personnaliser le groupId, artifactId, et les versions de Java selon vos besoins.

moi: le nom de mon projet est NoteBlogger, peux tu me refaire le pom.xml qui convient ? GPT-4o: Bien sûr ! Voici le fichier pom.xml adapté pour le projet NoteBlogger :

Modifications :

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>com.example</groupId>
    <artifactId>noteblogger</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.glassfish</groupId>
            <artifactId>javax.json</artifactId>
            <version>1.1.4</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>17</source>
                    <target>17</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    
</project>
  • artifactId : Mis à jour en noteblogger pour correspondre au nom de votre projet. Assurez-vous de personnaliser le groupId si nécessaire pour refléter votre organisation ou votre projet spécifique.

Bah voilà qu'il oublie le contexte de ma demande. Je le lui précise donc: moi: avec l'import de la dépendance json stp GPT-4o: Bien sûr, le fichier pom.xml avec la dépendance JSON incluse :

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>com.example</groupId>
    <artifactId>noteblogger</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.glassfish</groupId>
            <artifactId>javax.json</artifactId>
            <version>1.1.4</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>17</source>
                    <target>17</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    
</project>

Détails :

  • Dépendance javax.json : Importée depuis le groupe org.glassfish avec la version 1.1.4. Ce fichier pom.xml est prêt pour être utilisé avec la bibliothèque JSON de javax.json.

À ce stade j'avoue que je n'aime pas trop de préciser à ce point les numéros de version liés à la compilation. Pour moi, je ne vais pas coder particulièrement dans une version. Ou, en effet, au moins à partir d'une version. Je verrai plus tard comment arranger cela #TODO. J'ai bien une petite idée d'où mettre le fichier pom.xml, mais je préfère vérifier: moi: ce fichier pom.xml, je le mets où dans mon arborescence de fichier de mon projet ? GPT-4o: Le fichier pom.xml doit être placé à la racine de votre projet Maven. Voici à quoi pourrait ressembler l'arborescence typique de votre projet :

noteblogger/
│
├── pom.xml
│
└── src/
    ├── main/
    │   ├── java/
    │   │   └── com/
    │   │       └── example/
    │   │           └── YourJavaFiles.java
    │   └── resources/
    │       └── config.json
    └── test/
        ├── java/
        └── resources/

Oui, en effet, j'avais oublié que même si mon code source n'est qu'en java, il faut mettre un sous répertoire par langage. Mais .... cela ne tombe pas en marche dans Intellij.

moi: apparemment intellij ne prends pas en compte le pom.xml GPT-4o: Si IntelliJ IDEA ne semble pas prendre en compte votre pom.xml, vous pouvez essayer ces étapes pour forcer la synchronisation de votre projet Maven :

  1. Ouvrir le projet comme un projet Maven : - Assurez-vous d'avoir ouvert le projet comme un projet Maven. Si vous avez juste déplacé le pom.xml dedans, vous devrez peut-être le recharger en tant que projet Maven.
  2. Synchroniser Maven : - Dans IntelliJ, allez dans la fenêtre "Maven" (généralement sur la droite).
    • Cliquez sur l'icône "Reload All Maven Projects" (un bouton avec deux flèches circulaires).
  3. Vérifier l'importation des dépendances : - Assurez-vous que votre connexion internet fonctionne (pour télécharger les dépendances).
    • Regardez dans External Libraries dans Project View pour voir si les dépendances ont été importées.
  4. Vérifier les paramètres Maven : - Allez dans File > Settings (ou IntelliJ IDEA > Preferences sur macOS).
    • Naviguez vers Build, Execution, Deployment > Build Tools > Maven.
    • Assurez-vous que le Home Directory de Maven est correctement configuré.
    • Vérifiez que le répertoire Java de votre JDK est bien configuré.
  5. Vérifier les onglets/outils actifs : - Assurez-vous que les outils "Maven" et "Project" sont bien affichés. Si ce n’est pas le cas, les activer depuis View > Tool Windows.
  6. Relancer IntelliJ : - Parfois, fermer et rouvrir le projet ou redémarrer IntelliJ peut résoudre le problème. Après avoir suivi ces étapes, votre pom.xml devrait être correctement pris en compte par IntelliJ IDEA.

Après avoir tout bien vérifié, c'est au final un redémarrage d'IntelliJ qui résoudra le problème. Solution que je devrai appliquer plusieurs fois dans la suite. Je continue avec mes questions de rebornnewbie: moi: où dois je mettre le fichier config json ? GPT-4o: Le fichier de configuration JSON doit être placé dans le répertoire src/main/resources. Cela garantit qu'il est accessible au code à l'exécution et inclus dans le classpath de votre application. Voici à quoi pourrait ressembler l'arborescence une fois que vous avez ajouté le fichier :

noteblogger/
│
├── pom.xml
│
└── src/
    ├── main/
    │   ├── java/
    │   │   └── com/
    │   │       └── example/
    │   │           └── YourJavaFiles.java
    │   └── resources/
    │       └── config.json
    └── test/
        ├── java/
        └── resources/

Comment y accéder dans le code Java :

Pour lire ce fichier depuis src/main/resources, vous pouvez utiliser le ClassLoader :

import java.io.InputStream;
import java.io.IOException;
import javax.json.*;

public class ConfigLoader {
    private JsonObject config;

    public ConfigLoader() throws IOException {
        try (InputStream is = getClass().getClassLoader().getResourceAsStream("config.json");
             JsonReader reader = Json.createReader(is)) {
            config = reader.readObject();
        }
    }

    // Méthodes pour accéder aux données de configuration...
}

En plaçant le fichier ici, il sera inclus dans le JAR lors de la construction et pourra être facilement lu par l'application.

moi: je m'aperçois que ma structure de répertoire n'est pas la bonne. comment faire dans intellij pour déplacer les sources de src/ vers src/main/java ? GPT-4o: Pour déplacer vos sources dans IntelliJ IDEA de src/ vers src/main/java, vous pouvez suivre ces étapes :

  1. Créer la nouvelle structure :
    • Dans le panneau de projet (Project), faites un clic droit sur le dossier src.
    • Sélectionnez New > Directory et créez les dossiers main/java à l'intérieur de src.
  2. Déplacer les fichiers :
    • Sélectionnez les fichiers Java et les répertoires existants dans src.
    • Faites-les glisser vers le nouveau dossier src/main/java.
  3. Marquer comme source :
    • Faites un clic droit sur le dossier src/main/java.
    • Sélectionnez Mark Directory as > Sources Root.
  4. Vérifier les ressources :
    • Si vous avez des ressources, assurez-vous qu'elles sont dans src/main/resources.
    • Marquez src/main/resources comme Resources Root de la même manière.
  5. Vérifier la configuration :
    • Allez dans File > Project Structure et assurez-vous que les chemins de source et de ressources sont correctement configurés.
  6. Synchroniser le projet :
    • Cliquez sur File > Synchronize pour vous assurer qu'IntelliJ reconnaît les modifications. Cela devrait aligner votre projet avec la structure standard de Maven.

En vrai, je fais tout comme il me dit. Ca ne marche pas. Je regarde sur le net, tout pareil. Reboot d'IntelliJ: ca fonctionne. Va comprendre... Bon, après tout, ce genre de refactoring, ca n'arrive qu'en début de projet, donc pas très souvent. Pas forcément étonnant que cela ne soit pas parfait.

moi: comment je fais pour instancier un objet ConfigLoader depuis un fichier config.json présent dans src/main/resources ? ** GPT-4o:** Pour instancier un objet ConfigLoader et lire le fichier config.json situé dans src/main/resources, vous pouvez procéder comme suit :

  1. Vérifiez la structure de votre projet : Assurez-vous que le fichier config.json est bien présent dans src/main/resources.
  2. Implémentez le code pour charger la configuration : Voici un exemple de classe ConfigLoader pour lire le fichier :
import javax.json.*;
import java.io.InputStream;
import java.io.IOException;

public class ConfigLoader {
    private JsonObject config;

    public ConfigLoader() throws IOException {
        try (InputStream is = getClass().getClassLoader().getResourceAsStream("config.json");
             JsonReader reader = Json.createReader(is)) {
            config = reader.readObject();
        }
    }

    public JsonObject getConfig() {
        return config;
    }

    // Méthodes pour accéder aux données de configuration...
}
  1. Instanciez ConfigLoader dans votre code principal :
    Voici comment créer une instance de ConfigLoader :
public class Main {
    public static void main(String[] args) {
        try {
            ConfigLoader configLoader = new ConfigLoader();
            JsonObject config = configLoader.getConfig();
            // Utilisez config ici...
        } catch (IOException e) {
            System.err.println("Erreur lors du chargement de la configuration : " + e.getMessage());
        }
    }
}

Explications :

  • getResourceAsStream("config.json") : Charge le fichier config.json depuis le classpath, ce qui inclut src/main/resources dans votre cas.
  • Gestion des exceptions : Gérez les exceptions avec un bloc try-catch pour capturer les erreurs de lecture du fichier. Avec cette approche, ConfigLoader lira correctement le fichier JSON à partir des ressources du projet.

Là, il y a quand même un truc qui m'étonne: on cherche le fichier de config dans le classpath. Dans l'absolu, j'aimerais que mon code java soit appelé en ligne de commanden avec le fichier de configuration en paramètre. Sans passer par un batch d'enrobage.

moi: mon configloader prend un file path dans son cosntructeur, c'est pas la meilleure pratique ? GPT-4o: Passer un chemin de fichier au constructeur peut être utile pour la flexibilité, surtout si vous voulez lire des fichiers de différents emplacements. Cependant, pour lire un fichier de configuration qui est dans src/main/resources, utiliser le classpath est généralement la meilleure pratique. Voici pourquoi :

Avantages d'utiliser le classpath :

  1. Portabilité : Vous n'avez pas besoin de spécifier le chemin absolu ou relatif lors du déploiement sur différents environnements.
  2. Gestion centralisée : Les ressources sont gérées par votre système de construction (comme Maven), ce qui simplifie l'organisation des fichiers.
  3. Facilité de packaging : Toutes les ressources sont automatiquement incluses dans votre JAR.

Adapter ConfigLoader pour utiliser le classpath :

Si vous préférez garder le constructeur avec un chemin de fichier pour la flexibilité, voici comment vous pourriez adapter votre code :

import javax.json.*;
import java.io.InputStream;
import java.io.IOException;

public class ConfigLoader {
    private JsonObject config;

    public ConfigLoader(String filePath) throws IOException {
        try (InputStream is = getClass().getClassLoader().getResourceAsStream(filePath);
             JsonReader reader = Json.createReader(is)) {
            config = reader.readObject();
        } catch (NullPointerException e) {
            throw new IOException("File not found in resources: " + filePath);
        }
    }

    public JsonObject getConfig() {
        return config;
    }
}

Utilisation :

public class Main {
    public static void main(String[] args) {
        try {
            ConfigLoader configLoader = new ConfigLoader("config.json");
            JsonObject config = configLoader.getConfig();
            // Utilisez config ici...
        } catch (IOException e) {
            System.err.println("Erreur lors du chargement de la configuration : " + e.getMessage());
        }
    }
}

Points à vérifier :

  • Si vous utilisez le chemin "config.json", assurez-vous que le fichier est bien présent dans src/main/resources.
  • Gérez les cas où le fichier pourrait être introuvable, avec une exception explicite. Cela vous permettra de lire le fichier directement depuis le classpath tout en conservant la flexibilité du chemin.

Bon, si on prend du recul, on voit qu'il déconne un peu quand même. Il me mets comme titre "Adapter ConfigLoader pour utiliser le classpath" suivi d'un "Si vous préférez garder le constructeur avec un chemin de fichier". Du coup, le code généré, je veux avoir confiance ou pas ?!?? Vu la tête de la méthode appelée, je pense que non. On va mettre cela de côté pour le moment. #TODO

moi: bon, j'ai mon configloader. quelle est la bonne pratique pour démarrer mon appli depuis intellij, appli qui poir le moment va juste lire le fichier de config et le charger en mémoire ? GPT-4o: Pour démarrer votre application depuis IntelliJ et lire le fichier de configuration, suivez ces étapes :

Étape 1 : Créer une Classe Main

Assurez-vous d'avoir une classe avec une méthode main comme point d'entrée de votre application.

public class Main {
    public static void main(String[] args) {
        try {
            ConfigLoader configLoader = new ConfigLoader("config.json");
            JsonObject config = configLoader.getConfig();
            System.out.println("Configuration chargée : " + config);
        } catch (IOException e) {
            System.err.println("Erreur lors du chargement de la configuration : " + e.getMessage());
        }
    }
}

Étape 2 : Configurer IntelliJ pour exécuter votre application

  1. Ouvrir IntelliJ et votre projet.
  2. Assurez-vous que la classe Main est sélectionnée.
    • Dans la fenêtre Project, localisez votre classe Main.
    • Faites un clic droit sur Main et sélectionnez Run 'Main.main()'.
  3. Configurer si nécessaire :
    • Allez dans Run > Edit Configurations....
    • Assurez-vous que l'entrée Main sous Application est sélectionnée.
    • Vérifiez que le Main class est défini sur com.example.Main ou selon le package que vous avez utilisé.
    • Configurez le Working directory si nécessaire (la plupart du temps, le répertoire du projet par défaut convient).
  4. Exécuter l'application :
    • Cliquez sur l'icône Run (triangle vert) pour exécuter l'application.
    • Vérifiez la console pour les sorties, par exemple, que votre configuration a été chargée avec succès.

Bonnes Pratiques

  • Gestion des exceptions : Continuez à gérer les exceptions pour éviter que l'application ne plante si le fichier de configuration est introuvable ou illisible.
  • Sortie appropriée : Utilisez les journaux pour des applications plus complexes. Pour le moment, System.out.println suffira.
  • Tests Unitaires : Même à ce stade, commencez à penser à écrire des tests unitaires pour garantir que le chargement de la config fonctionne correctement. En suivant ces étapes, vous devriez être en mesure de démarrer votre application depuis IntelliJ et lire la configuration avec succès.

Oui, c'est vrai, je devrais déjà commencer à faire des tests unitaires. #TODO Mais pour l'instant, je me pose des questions métaphysiques d'organisation du code: moi: mon Configloader est dans un package dédié, noteblogger. Dans quel package dois je mettre mon Main ? GPT-4o: Pour organiser votre projet de manière claire et maintenable, il est logique de placer votre classe Main dans le même package que vos autres classes essentielles, ou dans un package parent qui reflète la fonction principale de votre application. Voici quelques suggestions :

Structure suggérée

  1. Même package :
    • Si ConfigLoader est dans le package noteblogger, vous pouvez mettre Main dans ce même package.
noteblogger/
│
├── ConfigLoader.java
└── Main.java
  1. Package parent ou spécifique :
    • Si vous avez besoin de séparer clairement les responsabilités, vous pouvez créer un sous-package comme noteblogger.app ou juste utiliser noteblogger.
noteblogger/
├── app/
│   └── Main.java
└── ConfigLoader.java

Choix du package

  • Même package : Simplicité pour les petites applications.
  • Package spécifique : Pour une meilleure organisation si vous avez plusieurs points d'entrée ou fonctions principales distinctes.

OK, très bien, je fais le choix de mettre ma classe Main dans le package noteblogger. Et go, je clique sur le BoutonQuiVabien pour lancer ma classe Main. Mais.... ca marche pas 😭

moi: dans intellij, quand je "run" ma classe main, j'ai cette erreur: java.lang.ClassNotFoundException: noteblogger.Main GPT-4o: L'erreur ClassNotFoundException indique généralement qu'IntelliJ ne trouve pas votre classe Main. Voici quelques étapes pour résoudre ce problème :

Vérifier la Structure du Projet

  1. Assurez-vous de la bonne structure :
    • Vos fichiers sources devraient être dans src/main/java/noteblogger.
  2. Vérifiez que Main.java contient la bonne déclaration de package :
    • Assurez que le haut de votre fichier Main.java contient package noteblogger;.

Configurer IntelliJ

  1. Vérifiez que le bon répertoire est marqué comme source :
    • Faites un clic droit sur src/main/java dans le panneau de projet.
    • Sélectionnez Mark Directory as > Sources Root.
  2. Vérifiez la configuration de lancement :
    • Allez dans Run > Edit Configurations....
    • Vérifiez que dans Application, votre classe principale est bien noteblogger.Main
  3. Synchroniser le projet :
    • Cliquez sur File > Synchronize ou appuyez sur Ctrl + Alt + Y (Windows/Linux) ou Cmd + Option + Y (Mac).

Redémarrer IntelliJ

  1. Parfois, fermer et rouvrir IntelliJ peut résoudre ces problèmes.
  2. Après avoir redémarré, ressayez de lancer la classe Main.

Nettoyer et Rebuild

  1. Clean et Rebuild le projet :
    • Allez dans Build > Clean Project, puis Build > Rebuild Project. Cela devrait aider à résoudre l'erreur et permettre à IntelliJ de localiser et d'exécuter votre classe Main.

Je fais tout comme il dit, et cela fonctionne. Quand même, c'est pas mal. C'est quand même le genre de truc où tu sens que tu as l'air con quand tu demandes de l'aide, et là tu t'en sors tout seul avec chatgpt. Mais retiens-t-on autant ? Bah, je verrai bien si je retiens.... Pour autant, le code se lance, mais cela ne fonctionne pas: il trouve pas le fichier de configuration.

moi:: j'ai le message suivant: Erreur lors du chargement de la configuration : config.json (Le fichier spécifié est introuvable) GPT-4o: L'erreur indiquant que le fichier config.json est introuvable peut être résolue en vérifiant plusieurs points :

Vérification de l'emplacement du fichier

  1. Assurez-vous que config.json est dans src/main/resources:
    • Vérifiez l'arborescence de votre projet pour s'assurer que config.json est bien placé directement sous src/main/resources.
  2. Vérifiez l'orthographe du nom du fichier:
    • Assurez-vous qu'il n'y ait pas d'erreur dans le nom du fichier (majuscule, minuscule, extension).

Vérification du classpath

  1. Assurez-vous que src/main/resources est bien marqué comme Resources Root:
    • Faites un clic droit sur src/main/resources.
    • Sélectionnez Mark Directory as > Resources Root.

Vérification du chargement du fichier

  1. Corrigez le chemin dans le code si nécessaire: Assurez-vous que votre ConfigLoader utilise le classloader correctement pour lire le fichier du classpath : InputStream is = getClass().getClassLoader().getResourceAsStream("config.json");
  2. Vérifiez que l'InputStream n'est pas null: Avant de lire le fichier, assurez-vous que l'InputStream n'est pas null, ce qui signifie que le fichier n'a pas été trouvé.
  3. Gestion de l'exception: Si is est null, gérer l'erreur avec un message explicite : if (is == null) { throw new IOException("Fichier config.json introuvable dans les ressources."); }

Réexécutez et Vérifiez

  1. Rebuild le projet :
    • Allez dans Build > Rebuild Project.
  2. Relancer l’application :
    • Essayez à nouveau de lancer votre application depuis IntelliJ. Ces étapes devraient vous aider à résoudre l'erreur de fichier introuvable.

Bon, il dit des trucs qui n'ont aucun sens, genre, vérifier que l' InputStream n'est pas nul. Mais dans cas, j'aurais un NullPointerException, pas un ClassNotFoundException. Bon, néanmoins, si j'applique tout le reste, cela fini par tomber en marche. Très bien. Maintenant, je veux vérifier que tout est bien lu, et donc recracher sur la sortie standard la structure de données montée en mémoire.

moi: voici une classe de config:

package noteblogger;

import javax.json.*;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

public class ConfigLoader {
	private JsonObject config;
	public ConfigLoader(String filePath) throws IOException {
	    try (InputStream is =getClass().getClassLoader().getResourceAsStream(filePath);
	         JsonReader reader = Json.createReader(is)) {
	        config = reader.readObject();
	    }
	}
	
	public List<DirectoryConfig> getDirectories() {
	    JsonArray array = config.getJsonArray("directories");
	    List<DirectoryConfig> directories = new ArrayList<>();
	    for (JsonObject obj : array.getValuesAs(JsonObject.class)) {
	        directories.add(new DirectoryConfig(
	                obj.getString("path"),
	                obj.getJsonArray("defaultCategories").getValuesAs(JsonString.class)
	                        .stream().map(JsonString::getString).toList()
	        ));
	    }
	    return directories;
	}
	
	public List<FileConfig> getFiles() {
	    JsonArray array = config.getJsonArray("files");
	    List<FileConfig> files = new ArrayList<>();
	    for (JsonObject obj : array.getValuesAs(JsonObject.class)) {
	        files.add(new FileConfig(
	                obj.getString("path"),
	                obj.getJsonArray("defaultCategories").getValuesAs(JsonString.class)
	                        .stream().map(JsonString::getString).toList()
	        ));
	    }
	    return files;
	}
	
	public String getOutputDirectory() {
	    return config.getString("outputDirectory");
	}
	
	public static class DirectoryConfig {
	    private String path;
	    private List<String> defaultCategories;
	
	    public DirectoryConfig(String path, List<String> defaultCategories) {
	        this.path = path;
	        this.defaultCategories = defaultCategories;
	    }
	
	    public String getPath() {
	        return path;
	    }
	
	    public List<String> getDefaultCategories() {
	        return defaultCategories;
	    }
	}
	
	public static class FileConfig {
	    private String path;
	    private List<String> defaultCategories;
	
	    public FileConfig(String path, List<String> defaultCategories) {
	        this.path = path;
	        this.defaultCategories = defaultCategories;
	    }
	
	    public String getPath() {
	        return path;
	    }
	
	    public List<String> getDefaultCategories() {
	        return defaultCategories;
	    }
	}
}

peux-tu me donner une méthode sui me liste tous les éléments lus par le fichier de config ? GPT-4o: Bien sûr, vous pouvez ajouter une méthode à votre ConfigLoader qui affiche tous les éléments lus depuis le fichier de configuration. Voici comment le faire :

public void printConfigDetails() {
    System.out.println("Directories:");
    for (DirectoryConfig dir : getDirectories()) {
        System.out.println("Path: " + dir.getPath());
        System.out.println("Default Categories: " + String.join(", ", dir.getDefaultCategories()));
    }
    
    System.out.println("\nFiles:");
    for (FileConfig file : getFiles()) {
        System.out.println("Path: " + file.getPath());
        System.out.println("Default Categories: " + String.join(", ", file.getDefaultCategories()));
    }
    
    System.out.println("\nOutput Directory: " + getOutputDirectory());
}

moi: peux tu plutôt me mettre les détails dans une chaine de caractère plutôt que les imprimer à l'écran ? GPT-4o: Bien sûr ! Vous pouvez construire une chaîne de caractères avec les détails de la configuration au lieu de les imprimer directement. Voici comment vous pourriez le faire :

public String getConfigDetails() {
    StringBuilder details = new StringBuilder();

    details.append("Directories:\n");
    for (DirectoryConfig dir : getDirectories()) {
        details.append("Path: ").append(dir.getPath()).append("\n");
        details.append("Default Categories: ").append(String.join(", ", dir.getDefaultCategories())).append("\n");
    }

    details.append("\nFiles:\n");
    for (FileConfig file : getFiles()) {
        details.append("Path: ").append(file.getPath()).append("\n");
        details.append("Default Categories: ").append(String.join(", ", file.getDefaultCategories())).append("\n");
    }

    details.append("\nOutput Directory: ").append(getOutputDirectory()).append("\n");

    return details.toString();
}

Alors, c'est pas mal. Mais, les méthodes getDirectrories(), getFiles() reparcourent systématiquement le fichier de config. Même si ce n'est pas super super grave, ca me titille et je trouve que c'est dommage. Je préfère que cela soit parcouru dans le constructeur, monté en mémoire en tant que propriété de la classe ConfigLoader. Cela, je le modifie moi-même dans le code. Et dans l'absolu, la classe que j'interroge pour obtenir mes données de configuration se nomme ConfigLoader alors que ce serait plutôt un Config, je trouve, non ? Je demande son avis à chatgpt: moi: Et dans l'absolu, la classe que j'interroge pour obtenir mes données de configuration se nomme ConfigLoader alors que ce serait plutôt un Config, je trouve, non ? Qu'en penses-tu ? GPT-4o: C'est une bonne idée de distinguer clairement les responsabilités des classes par leur nom. L'utilisation du nom ConfigLoader suggère effectivement que la classe est principalement responsable du chargement de la configuration, tandis qu'un nom comme Config indiquerait plus clairement qu'il s'agit d'un objet contenant la configuration elle-même.

Proposition d'organisation

  1. ConfigLoader (ou ConfigReader) :
    • Cette classe devrait se concentrer sur l'aspect du chargement de la configuration à partir d'un fichier. Elle pourrait retourner un objet Config.
  2. Config :
    • Représente la configuration elle-même, et contient les données configurées sous forme de membres de classe. Elle offre des méthodes pour accéder à ces données.

Exemple de refactoring

....

Mouais, c'est quand même un peu lourdingue. je vais juste renommer ConfigLoader en Config, et compacter un peu la sortie de la méthode `getConfigDetails()'.

Tags: computing back2code