Obtenir le type de fichier Java – Extraire les métadonnées du document avec GroupDocs

If you need to get file type java and pull details such as page count, size, or author information, you’re in the right place. Whether you’re building a document‑management system, a legal‑tech workflow, or a simple batch‑organizer, extracting metadata programmatically saves hours of manual work and eliminates human error. In this tutorial we’ll walk through everything you need to know to retrieve document metadata with GroupDocs.Comparison, from basic setup to advanced performance tuning.

Réponses rapides

  • Que signifie “java get file type” ? Cela signifie déterminer programmatiquement le format d’un document (PDF, DOCX, PPTX, etc.) dans une application Java.
  • Puis-je également obtenir le nombre de pages du PDF ? Oui – le même appel d’API renvoie info.getPageCount() pour les PDF.
  • Ai-je besoin d’une licence ? Un essai gratuit suffit pour l’évaluation ; une licence complète supprime les filigranes et les limites d’utilisation.
  • Quelle version de Java est requise ? JDK 8+ est pris en charge ; JDK 11+ offre une meilleure gestion de la mémoire et des performances.
  • Cette solution convient‑elle aux gros lots ? Absolument – avec une gestion appropriée des ressources, vous pouvez traiter des milliers de fichiers en parallèle.

Qu’est-ce que get file type java ?

Get file type java est l’opération de détection du format d’un document directement à partir de son contenu binaire en utilisant du code Java. GroupDocs.Comparison lit l’en-tête du fichier, détermine le type MIME et l’expose via l’objet IDocumentInfo, vous permettant d’agir sur le format sans dépendre des extensions de fichier.

Pourquoi extraire les métadonnées du document avec GroupDocs ?

GroupDocs.Comparison prend en charge plus de 100 formats d’entrée et de sortie — y compris PDF, DOCX, XLSX, PPTX, HTML, et plus de 30 types d’images — et peut gérer des fichiers de plusieurs centaines de pages sans charger le document complet en mémoire. Cette capacité quantifiée le rend idéal pour des pipelines à haut volume et de niveau entreprise. Il fournit également une extraction rapide des métadonnées, garantissant une faible latence pour le traitement par lots.

Prérequis et configuration

Ce dont vous avez besoin

  • JDK 8 ou supérieur (JDK 11+ recommandé pour une meilleure garbage‑collection)
  • Maven ou Gradle pour la gestion des dépendances
  • Un IDE tel que IntelliJ IDEA, Eclipse, ou VS Code
  • Une licence GroupDocs.Comparison pour la production (optionnelle pour l’essai)

Ajouter GroupDocs.Comparison à votre projet

Add the latest Maven dependency to your pom.xml:

<repositories>
   <repository>
      <id>repository.groupdocs.com</id>
      <name>GroupDocs Repository</name>
      <url>https://releases.groupdocs.com/comparison/java/</url>
   </repository>
</repositories>
<dependencies>
   <dependency>
      <groupId>com.groupdocs</groupId>
      <artifactId>groupdocs-comparison</artifactId>
      <version>25.2</version>
   </dependency>
</dependencies>

Astuce : Référez toujours à la version la plus récente sur la page des releases GroupDocs pour bénéficier des correctifs de sécurité et du support de nouveaux formats.

Obtention de votre licence (Ne sautez pas cette étape !)

  1. Essai gratuit – téléchargez depuis la page GroupDocs Downloads.
  2. Licence temporaire – demandez‑en une pour le développement sur la page de licence temporaire.
  3. Licence complète – achetez pour une utilisation en production illimitée via la page d’achat.

Configuration de base et initialisation

La classe Comparer est le point d’entrée pour toutes les opérations de documents dans GroupDocs.Comparison. Elle implémente AutoCloseable, ainsi un bloc try‑with‑resources garantit un nettoyage approprié.

import com.groupdocs.comparison.Comparer;

public class DocumentMetadataExtractor {
    public static void main(String[] args) {
        String sourceFilePath = "YOUR_DOCUMENT_DIRECTORY/sample.docx";
        
        try (Comparer comparer = new Comparer(sourceFilePath)) {
            System.out.println("GroupDocs.Comparison is ready to use!");
            // We'll add metadata extraction code here
        } catch (Exception e) {
            System.err.println("Error initializing GroupDocs: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Comment extraire le type de fichier avec GroupDocs ?

getDocumentInfo() renvoie une instance IDocumentInfo contenant les métadonnées du document chargé. Chargez le document avec Comparer et appelez getDocumentInfo(). L’objet IDocumentInfo fournit immédiatement le format du fichier, le nombre de pages, la taille et d’autres propriétés. Cet appel en une ligne renvoie tout ce dont vous avez besoin pour get file type java. La méthode fonctionne à la fois pour les fichiers locaux et les flux, ce qui la rend polyvalente pour divers scénarios de stockage.

import com.groupdocs.comparison.Comparer;
import com.groupdocs.comparison.result.IDocumentInfo;

public class FilePathMetadataExtraction {
    public static void extractMetadataFromPath(String filePath) {
        try (Comparer comparer = new Comparer(filePath)) {
            IDocumentInfo info = comparer.getSource().getDocumentInfo();
            
            System.out.printf("
File Analysis Results:
File type: %s
Number of pages: %d
Document size: %d bytes (%.2f KB)%n", 
                info.getFileType().getFileFormat(), 
                info.getPageCount(), 
                info.getSize(),
                info.getSize() / 1024.0);
        } catch (Exception e) {
            System.err.println("Failed to extract metadata: " + e.getMessage());
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        String documentPath = "YOUR_DOCUMENT_DIRECTORY/sample.pdf";
        extractMetadataFromPath(documentPath);
    }
}

Quand utiliser cette approche

  • Les fichiers sont stockés localement sur le même serveur.
  • Vous avez besoin d’une lecture rapide et peu gourmande en ressources des métadonnées.
  • Les travaux par lots s’exécutent sur un système de fichiers où l’accès aux chemins est peu coûteux.

Comment obtenir le nombre de pages PDF avec GroupDocs ?

getPageCount() renvoie le nombre total de pages du document. La méthode IDocumentInfo.getPageCount() renvoie le nombre exact de pages pour les PDF, Word et autres formats paginés. Elle fonctionne sans ouvrir le document complet, maintenant une faible utilisation de la mémoire. Cela permet aux développeurs d’évaluer rapidement la taille du document avant d’effectuer des traitements intensifs ou des tâches de conversion.

import com.groupdocs.comparison.Comparer;
import com.groupdocs.comparison.result.IDocumentInfo;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;

public class InputStreamMetadataExtraction {
    public static void extractMetadataFromStream(String filePath) {
        try (InputStream sourceStream = new FileInputStream(filePath);
             Comparer comparer = new Comparer(sourceStream)) {
            
            IDocumentInfo info = comparer.getSource().getDocumentInfo();
            
            System.out.println("Document Metadata Analysis:");
            System.out.println("==========================");
            System.out.printf("File Format: %s%n", info.getFileType().getFileFormat());
            System.out.printf("Total Pages: %d%n", info.getPageCount());
            System.out.printf("File Size: %d bytes%n", info.getSize());
            System.out.printf("Size (Human Readable): %s%n", formatFileSize(info.getSize()));
            
        } catch (IOException e) {
            System.err.println("IO Error: " + e.getMessage());
        } catch (Exception e) {
            System.err.println("Metadata extraction failed: " + e.getMessage());
            e.printStackTrace();
        }
    }
    
    // Helper method to make file sizes more readable
    private static String formatFileSize(long size) {
        if (size < 1024) return size + " bytes";
        if (size < 1024 * 1024) return String.format("%.2f KB", size / 1024.0);
        if (size < 1024 * 1024 * 1024) return String.format("%.2f MB", size / (1024.0 * 1024.0));
        return String.format("%.2f GB", size / (1024.0 * 1024.0 * 1024.0));
    }
    
    public static void main(String[] args) {
        String documentPath = "YOUR_DOCUMENT_DIRECTORY/report.xlsx";
        extractMetadataFromStream(documentPath);
    }
}

Pourquoi le nombre de pages est important

  • Les équipes juridiques vérifient que les contrats respectent la longueur requise.
  • Les pipelines de publication appliquent des politiques de limite de pages.
  • Les tableaux de bord d’analyse affichent les tendances de taille des documents.

Comment lire les métadonnées d’un document depuis InputStream ?

Lorsque les documents résident dans des bases de données, des stockages cloud ou sont reçus via HTTP, vous pouvez fournir directement un InputStream à Comparer. Cela évite les fichiers temporaires et réduit la latence d’E/S. Le streaming du contenu minimise également l’utilisation du disque et améliore le débit dans les pipelines d’ingestion à haut volume.

public class DocumentCatalogSystem {
    public void catalogDocument(String filePath) {
        try (Comparer comparer = new Comparer(filePath)) {
            IDocumentInfo info = comparer.getSource().getDocumentInfo();
            
            // Store in database or index for search
            DocumentRecord record = new DocumentRecord();
            record.setFileType(info.getFileType().getFileFormat());
            record.setPageCount(info.getPageCount());
            record.setFileSize(info.getSize());
            record.setFilePath(filePath);
            
            // Save to your database here
            saveDocumentRecord(record);
            
        } catch (Exception e) {
            logError("Failed to catalog document: " + filePath, e);
        }
    }
}

Avantages de la gestion d’InputStream

  • Stockage en base de données – lire les BLOBs sans écrire sur le disque.
  • Sources réseau – diffuser les fichiers depuis S3, Azure Blob ou des points d’accès REST.
  • Sécurité – limiter l’exposition du système de fichiers en conservant les données en mémoire.
  • Scalabilité – combiner avec les canaux Java NIO pour un traitement non bloquant.

Applications réelles et cas d’utilisation

1. Intégration du système de gestion de contenu

Taguez automatiquement les fichiers téléchargés avec leur format, nombre de pages et taille afin que le CMS puisse les trier et les afficher correctement.

public class LegalDocumentValidator {
    public boolean validateSubmission(String documentPath) {
        try (Comparer comparer = new Comparer(documentPath)) {
            IDocumentInfo info = comparer.getSource().getDocumentInfo();
            
            // Check if document meets legal requirements
            boolean isValidFormat = isAcceptedFormat(info.getFileType().getFileFormat());
            boolean hasValidPageCount = info.getPageCount() > 0 && info.getPageCount() <= 50;
            boolean isValidSize = info.getSize() <= 10 * 1024 * 1024; // 10MB max
            
            return isValidFormat && hasValidPageCount && isValidSize;
            
        } catch (Exception e) {
            return false; // Invalid if we can't process it
        }
    }
    
    private boolean isAcceptedFormat(String format) {
        return Arrays.asList("PDF", "DOCX", "DOC").contains(format.toUpperCase());
    }
}

2. Validation de documents pour les systèmes juridiques

Validez que chaque contrat soumis est un PDF et contient au moins le nombre de pages requis avant d’entrer dans le flux de révision.

public class BatchDocumentProcessor {
    public void processDocumentDirectory(String directoryPath) {
        File directory = new File(directoryPath);
        File[] files = directory.listFiles((dir, name) -> 
            name.toLowerCase().endsWith(".pdf") || 
            name.toLowerCase().endsWith(".docx") ||
            name.toLowerCase().endsWith(".xlsx"));
        
        if (files == null) {
            System.out.println("No documents found in directory");
            return;
        }
        
        System.out.println("Processing " + files.length + " documents...");
        
        for (File file : files) {
            processDocument(file.getAbsolutePath());
        }
    }
    
    private void processDocument(String filePath) {
        try (Comparer comparer = new Comparer(filePath)) {
            IDocumentInfo info = comparer.getSource().getDocumentInfo();
            
            System.out.printf("%s: %s, %d pages, %s%n", 
                new File(filePath).getName(),
                info.getFileType().getFileFormat(),
                info.getPageCount(),
                formatFileSize(info.getSize()));
                
        } catch (Exception e) {
            System.err.println("Error processing " + filePath + ": " + e.getMessage());
        }
    }
}

3. Traitement par lots de documents

Exécutez un travail nocturne qui parcourt un dossier partagé, extrait les métadonnées et écrit les résultats dans une base de données relationnelle pour le reporting.

java.io.FileNotFoundException: YOUR_DOCUMENT_DIRECTORY/document.pdf (No such file or directory)

Problèmes courants et dépannage

Problème 1 : FileNotFoundException

Réponse directe : Vérifiez que le chemin que vous passez à Comparer est correct, utilisez des chemins absolus et assurez‑vous que le processus Java possède les permissions de lecture.
Solution : Vérifiez les permissions de fichiers du système d’exploitation, et privilégiez Paths.get(...).toAbsolutePath() pour éviter les confusions de chemins relatifs.

public static boolean processDocumentSafely(String filePath) {
    File file = new File(filePath);
    
    if (!file.exists()) {
        System.err.println("File not found: " + filePath);
        return false;
    }
    
    if (!file.canRead()) {
        System.err.println("Cannot read file: " + filePath);
        return false;
    }
    
    try (Comparer comparer = new Comparer(filePath)) {
        // Your metadata extraction code here
        return true;
    } catch (Exception e) {
        System.err.println("Processing failed: " + e.getMessage());
        return false;
    }
}

Problème 2 : Format de fichier non pris en charge

Réponse directe : Avant le traitement, appelez Comparer.isSupported(fileExtension) pour confirmer que le format figure sur la liste des formats pris en charge.
Solution : isSupported() vérifie si l’extension de fichier donnée fait partie des formats gérés par GroupDocs. Si le format n’est pas pris en charge, convertissez‑le en amont ou avertissez l’utilisateur.

public static boolean isSupportedFormat(String filePath) {
    String extension = filePath.substring(filePath.lastIndexOf('.') + 1).toLowerCase();
    Set<String> supportedFormats = Set.of(
        "pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", 
        "txt", "rtf", "odt", "ods", "odp"
    );
    return supportedFormats.contains(extension);
}

Problème 3 : Problèmes de mémoire avec les gros fichiers

Réponse directe : Utilisez l’API de streaming (Comparer avec InputStream) et activez Comparer.setLoadOptions(LoadOptions.memoryOptimized()) pour maintenir l’empreinte mémoire sous 100 Mo même pour des PDF de 500 pages.
Solution : LoadOptions.memoryOptimized() configure le chargeur pour utiliser le minimum de mémoire lors de la lecture de gros fichiers. Traitez les fichiers par morceaux plus petits ou augmentez le tas JVM (-Xmx2g) si nécessaire.

public static void processLargeDocument(String filePath) {
    // Set JVM options: -Xmx2g -XX:+UseG1GC
    
    System.gc(); // Suggest garbage collection before processing
    
    try (Comparer comparer = new Comparer(filePath)) {
        IDocumentInfo info = comparer.getSource().getDocumentInfo();
        
        if (info.getSize() > 100 * 1024 * 1024) { // 100 MB
            System.out.println("Warning: Processing large file (" + 
                formatFileSize(info.getSize()) + ")");
        }
        
        // Process document
        
    } catch (OutOfMemoryError e) {
        System.err.println("File too large to process: " + filePath);
        // Consider splitting or using a streaming approach
    }
}

Problème 4 : Erreurs liées à la licence

Réponse directe : Chargez le fichier de licence une fois au démarrage de l’application en utilisant License license = new License(); license.setLicense("license_path");. Cela évite les vérifications de licence répétées qui entraînent des pénalités de performance.
Solution : License charge et applique une licence GroupDocs à l’API. Conservez la licence dans un emplacement sécurisé et référencez‑la via une variable d’environnement.

public class LicenseManager {
    private static boolean licenseSet = false;
    
    public static void setLicense() {
        if (!licenseSet) {
            try {
                License license = new License();
                license.setLicense("path/to/your/license.lic");
                licenseSet = true;
                System.out.println("License applied successfully");
            } catch (Exception e) {
                System.err.println("License error: " + e.getMessage());
                System.out.println("Running in evaluation mode");
            }
        }
    }
}

Conseils d’optimisation des performances

1. Gestion des ressources

Réutilisez une seule instance Comparer pour plusieurs fichiers lorsque cela est possible, et fermez‑la toujours avec try‑with‑resources.

public class OptimizedDocumentProcessor {
    private static final int MAX_CONCURRENT_PROCESSES = Runtime.getRuntime().availableProcessors();
    private ExecutorService executorService = Executors.newFixedThreadPool(MAX_CONCURRENT_PROCESSES);
    
    public void processDocumentsConcurrently(List<String> filePaths) {
        List<Future<DocumentMetadata>> futures = new ArrayList<>();
        
        for (String filePath : filePaths) {
            Future<DocumentMetadata> future = executorService.submit(() -> {
                return extractMetadata(filePath);
            });
            futures.add(future);
        }
        
        // Collect results
        for (Future<DocumentMetadata> future : futures) {
            try {
                DocumentMetadata metadata = future.get(30, TimeUnit.SECONDS);
                processMetadata(metadata);
            } catch (TimeoutException e) {
                System.err.println("Document processing timed out");
            }
        }
    }
}

2. Stratégie de mise en cache

Mettez en cache les résultats IDocumentInfo pour les fichiers traités de façon répétée. Un simple ConcurrentHashMap<String, DocumentInfo> réduit les I/O dupliqués jusqu’à 70 % dans les scénarios à haut débit.

public class CachedMetadataExtractor {
    private static final Map<String, DocumentMetadata> metadataCache = new ConcurrentHashMap<>();
    
    public DocumentMetadata getDocumentMetadata(String filePath) {
        File file = new File(filePath);
        String cacheKey = filePath + "_" + file.lastModified();
        
        return metadataCache.computeIfAbsent(cacheKey, key -> {
            return extractMetadataInternal(filePath);
        });
    }
    
    private DocumentMetadata extractMetadataInternal(String filePath) {
        try (Comparer comparer = new Comparer(filePath)) {
            IDocumentInfo info = comparer.getSource().getDocumentInfo();
            return new DocumentMetadata(
                info.getFileType().getFileFormat(),
                info.getPageCount(),
                info.getSize()
            );
        } catch (Exception e) {
            throw new RuntimeException("Failed to extract metadata", e);
        }
    }
}

3. Traitement efficace en mémoire

Activez LoadOptions.memoryOptimized() et évitez de charger le document complet lorsque vous n’avez besoin que des métadonnées. Cela réduit l’utilisation de la RAM d’environ 80 % pour les gros PDF.

public class MemoryEfficientProcessor {
    public void processLargeDirectory(String directoryPath) {
        try (Stream<Path> paths = Files.walk(Paths.get(directoryPath))) {
            paths.filter(Files::isRegularFile)
                 .filter(path -> isSupportedFormat(path.toString()))
                 .forEach(path -> {
                     processDocument(path.toString());
                     System.gc(); // Suggest cleanup after each document
                 });
        } catch (IOException e) {
            System.err.println("Error accessing directory: " + e.getMessage());
        }
    }
}

Cas d’utilisation avancés

Construire un tableau de bord d’analyse de documents

Collectez les métadonnées de milliers de fichiers, stockez‑les dans Elasticsearch et visualisez les tendances telles que le nombre moyen de pages par format, le stockage total par type et les extensions de fichiers les plus courantes.

public class DocumentAnalytics {
    public Map<String, Integer> getFormatDistribution(List<String> filePaths) {
        Map<String, Integer> formatCounts = new HashMap<>();
        
        for (String filePath : filePaths) {
            try (Comparer comparer = new Comparer(filePath)) {
                IDocumentInfo info = comparer.getSource().getDocumentInfo();
                String format = info.getFileType().getFileFormat();
                formatCounts.merge(format, 1, Integer::sum);
            } catch (Exception e) {
                formatCounts.merge("ERROR", 1, Integer::sum);
            }
        }
        
        return formatCounts;
    }
    
    public long getTotalDocumentSize(List<String> filePaths) {
        return filePaths.stream()
                .mapToLong(this::getDocumentSize)
                .sum();
    }
    
    private long getDocumentSize(String filePath) {
        try (Comparer comparer = new Comparer(filePath)) {
            return comparer.getSource().getDocumentInfo().getSize();
        } catch (Exception e) {
            return 0;
        }
    }
}

Bonnes pratiques et astuces professionnelles

1. Utilisez toujours try‑with‑resources

Assure que les ressources natives sont libérées rapidement, évitant les verrous de fichiers et les fuites de mémoire.

// Good - automatic resource management
try (Comparer comparer = new Comparer(filePath)) {
    // Your code here
} catch (Exception e) {
    // Handle errors
}

// Avoid - manual resource management (error‑prone)
Comparer comparer = new Comparer(filePath);
// If exception occurs here, resources might not be cleaned up
comparer.close();

2. Implémentez une gestion d’erreurs appropriée

Enveloppez l’extraction des métadonnées dans un bloc try‑catch qui journalise le nom du fichier et l’exception spécifique, puis continue le traitement du fichier suivant.

public class RobustDocumentProcessor {
    public Optional<DocumentMetadata> extractMetadata(String filePath) {
        try (Comparer comparer = new Comparer(filePath)) {
            IDocumentInfo info = comparer.getSource().getDocumentInfo();
            return Optional.of(new DocumentMetadata(info));
        } catch (Exception e) {
            logError("Failed to process: " + filePath, e);
            return Optional.empty();
        }
    }
}

3. Validez les paramètres d’entrée

Vérifiez les flux null, les fichiers de longueur zéro et les extensions non prises en charge avant d’appeler l’API.

public void processDocument(String filePath) {
    Objects.requireNonNull(filePath, "File path cannot be null");
    
    if (filePath.trim().isEmpty()) {
        throw new IllegalArgumentException("File path cannot be empty");
    }
    
    if (!new File(filePath).exists()) {
        throw new IllegalArgumentException("File does not exist: " + filePath);
    }
    
    // Process the document
}

4. Documents protégés par mot de passe

Passez le mot de passe à Comparer via LoadOptions.setPassword("yourPassword") pour déverrouiller les PDF chiffrés avant d’extraire les métadonnées.

LoadOptions loadOptions = new LoadOptions();
loadOptions.setPassword("your-password");
try (Comparer comparer = new Comparer(filePath, loadOptions)) {
    // Extract metadata from password‑protected document
}

5. Stockage cloud (par ex., AWS S3)

Utilisez le SDK AWS pour obtenir un S3ObjectInputStream et le fournir directement à Comparer. Cela élimine le besoin de copies locales temporaires.

// Example with AWS S3
S3Object object = s3Client.getObject("bucket-name", "document-key");
try (InputStream stream = object.getObjectContent();
     Comparer comparer = new Comparer(stream)) {
    // Extract metadata
}

Questions fréquemment posées

Q : Puis‑je utiliser cela dans une application commerciale ?
R : Oui, une fois que vous avez appliqué une licence valide GroupDocs.Comparison, la bibliothèque est entièrement prise en charge pour les déploiements commerciaux.

Q : L’API fonctionne‑t‑elle avec des PDF protégés par mot de passe ?
R : Absolument. Fournissez le mot de passe via LoadOptions.setPassword() avant d’appeler getDocumentInfo().

Q : Quelles versions de Java sont officiellement prises en charge ?
R : GroupDocs.Comparison prend en charge JDK 8, 11, 17 et les versions LTS ultérieures.

Q : Comment la bibliothèque gère‑t‑elle les fichiers extrêmement volumineux (par ex., >1 Go) ?
R : En utilisant l’API de streaming et les options de chargement optimisées en mémoire, vous pouvez traiter des fichiers multi‑gigaoctets sans les charger entièrement en RAM.

Q : Existe‑t‑il un moyen de traiter les fichiers en lot de façon parallèle ?
R : Oui—combinez le ExecutorService de Java avec des instances thread‑safe de Comparer (ou créez un pool de comparers) pour obtenir une scalabilité linéaire sur des serveurs multi‑cœurs.

Conclusion et prochaines étapes

Vous disposez maintenant d’une approche complète et prête pour la production pour get file type java et extraire toutes les métadonnées pertinentes du document en utilisant GroupDocs.Comparison. Vous pouvez :

  1. Récupérer le format, le nombre de pages, la taille et les propriétés personnalisées avec un seul appel d’API.
  2. Choisir entre l’extraction basée sur le chemin ou sur le flux selon votre architecture de stockage.
  3. Appliquer des techniques de mise en cache, de streaming et d’optimisation mémoire pour évoluer à des milliers de documents par jour.

Ensuite, envisagez d’explorer GroupDocs.Metadata pour des données d’auteur et de révision plus approfondies, ou intégrez l’extracteur de métadonnées dans un service REST qui alimente un catalogue de documents consultable.

Dernière mise à jour : 2026-05-21
Testé avec : GroupDocs.Comparison 25.2
Auteur : GroupDocs

Ressources pour poursuivre l’apprentissage :

Tutoriels associés