kontrola přípony souboru java – Detekce formátu souboru Java: Ověření a kontrola typů dokumentů

Jedním z nejčastějších úkolů je kontrola přípony souboru java před zpracováním dokumentu.

Už jste někdy nahráli soubor a aplikace spadla, protože nebyl ve očekávaném formátu? Nejste v tom sami. Detekce a validace formátů souborů v Javě je klíčová pro tvorbu robustních aplikací pro zpracování dokumentů – ale je složitější než pouhá kontrola přípony (která může být snadno podvržena nebo nesprávná).

V tomto průvodci se naučíte spolehlivě detekovat formáty souborů v Javě pomocí GroupDocs.Signature, výkonné knihovny, která jde dál než jednoduchá kontrola přípony. Ať už budujete systém pro správu dokumentů, validujete nahrávání uživateli, nebo integrujete s cloudovými úložišti, objevíte praktické techniky, jak s různorodými typy dokumentů pracovat sebejistě.

Co se naučíte:

  • Jak programově získat podporované formáty souborů v Javě
  • Kdy použít detekci založenou na knihovně versus vestavěné přístupy Javy
  • Běžné úskalí při validaci typů souborů (a jak se jim vyhnout)
  • Reálné scénáře integrace a tipy na optimalizaci výkonu
  • Strategie řešení problémů s detekcí formátů

Na konci budete mít funkční implementaci, kterou můžete okamžitě vložit do svých Java aplikací. Začněme tím, že se ujistíme, že máte vše potřebné.

Rychlé odpovědi

  • Jaký je nejrychlejší způsob, jak zkontrolovat příponu souboru java? Použijte Signature.getSupportedFileTypes() k získání úplného seznamu a porovnejte příponu souboru s tímto seznamem.
  • Potřebuji licenci k použití GroupDocs.Signature? Bezplatná zkušební verze funguje pro vývoj; trvalá licence odstraňuje všechna omezení hodnocení.
  • Mohu validovat nahrané soubory, aniž bych načetl celý soubor? Ano – GroupDocs.Signature kontroluje hlavičku souboru, což je mnohem levnější než načítání celého dokumentu.
  • Kolik formátů GroupDocs.Signature podporuje? Více než 50 vstupních a výstupních formátů, včetně PDF, DOCX, XLSX, PPTX, JPG, PNG a mnoha dalších.
  • Je nutné kešovat seznam formátů? Kešování eliminuje opakované náklady na reflexi a zvyšuje propustnost pro služby s vysokým objemem.

Předpoklady

Než se ponoříte do detekce formátů souborů, ujistěte se, že máte připravené následující nezbytnosti:

Požadované knihovny a verze

  • GroupDocs.Signature Library: Verze 23.12 nebo novější (použijeme nejnovější stabilní vydání)
  • Java Development Kit: JDK 1.8 nebo vyšší (doporučeno JDK 11+ pro lepší výkon)
  • Nástroj pro sestavení: Maven 3.x nebo Gradle 6.x pro správu závislostí

Požadavky na nastavení prostředí

Měli byste být obeznámeni s:

  • Základními koncepty programování v Javě (třídy, smyčky, importy)
  • Používáním Maven nebo Gradle pro správu závislostí
  • Spouštěním Java aplikací z IDE nebo z příkazové řádky

Rychlá rada: Pokud pracujete s velkými dokumenty nebo plánujete souběžné zpracování souborů, přidělte JVM dostatečnou haldu (budeme se věnovat optimalizaci později).

S připraveným prostředím přejděme k nastavení GroupDocs.Signature ve vašem projektu.

Nastavení GroupDocs.Signature pro Java

Získání GroupDocs.Signature do projektu je jednoduché – vyberte svůj preferovaný nástroj pro sestavení a pokračujte podle návodu.

Použití Maven

Přidejte tuto závislost do souboru pom.xml:

<dependency>
    <groupId>com.groupdocs</groupId>
    <artifactId>groupdocs-signature</artifactId>
    <version>23.12</version>
</dependency>

Po přidání závislosti spusťte mvn clean install pro stažení knihovny.

Použití Gradle

Vložte tento řádek do souboru build.gradle:

implementation 'com.groupdocs:groupdocs-signature:23.12'

Poté synchronizujte projekt Gradle nebo spusťte gradle build.

Alternativa přímého stažení

Nevyužíváte nástroj pro sestavení? Můžete si stáhnout JAR přímo z GroupDocs.Signature for Java releases a ručně jej přidat do classpath. (Upřímně řečeno, Maven nebo Gradle vám ušetří spoustu starostí.)

Kroky k získání licence

GroupDocs.Signature nabízí flexibilní licenční možnosti:

  • Bezplatná zkušební verze: Ideální pro testování – začněte okamžitě bez nutnosti kreditní karty (odkaz)
  • Dočasná licence: Potřebujete více času na vyhodnocení? Požádejte o 30‑denní dočasnou licenci pro neomezený přístup
  • Koupě: Jakmile jste připraveni na produkci, pořiďte si trvalou licenci na GroupDocs Purchase Page

Tip od profesionála: Začněte s bezplatnou zkušební verzí a prozkoumejte všechny funkce. Dočasná licence odstraní vodoznaky a omezení, pokud potřebujete prodloužené testování.

Základní inicializace a nastavení

Signature je hlavní vstupní bod pro všechny operace v GroupDocs.Signature. Zahrnuje načítání dokumentu, správu formátů a zpracování podpisů.

Zde je ukázka, jak inicializovat GroupDocs.Signature ve vaší Java aplikaci:

import com.groupdocs.signature.Signature;

// Create an instance of Signature class
Signature signature = new Signature("sample.pdf");

Tím vytvoříte objekt signature pro konkrétní dokument. Tento vzor použijete při práci se skutečnými dokumenty, ale pro získání podporovaných formátů konkrétní soubor nebudete potřebovat (ukážeme to v další sekci).

Nyní, když je nastavení hotové, pojďme implementovat hlavní funkci pro detekci a získání podporovaných formátů souborů.

Praktický návod

Zde se dostáváme k praktické části. Vytvoříme jednoduchý nástroj, který získá všechny podporované formáty souborů – jakýsi „kontrolor kompatibility“ pro váš pipeline zpracování dokumentů.

Proč je to důležité

Než začnete implementovat funkce pro zpracování dokumentů, musíte vědět, jaké typy souborů vaše knihovna podporuje. Tento nástroj vám poskytne dynamické informace, což znamená:

  • Žádné pevně zakódované seznamy přípon, které se rychle zastarávají
  • Snadná validace nahrávaných souborů proti aktuálním podporovaným formátům
  • Rychlý odkaz pro tvorbu filtrů typů souborů ve vašem UI

Krok za krokem

1. Import potřebných tříd

FileType je vstupní brána k detekci formátů – obsahuje veškerá metadata o podporovaných typech dokumentů.

import com.groupdocs.signature.domain.documentpreview.FileType;
import java.util.List;

Třída FileType je popisovač GroupDocs.Signature pro každý podporovaný formát a poskytuje vlastnosti jako přípona, MIME typ a popis.

2. Vytvořte třídu pro získání seznamu

Zde je kompletní implementace:

public class GetSupportedFileFormats {
    public static void run() {
        // Retrieve a list of supported file types from the FileType utility.
        List<FileType> supportedFileTypes = FileType.getSupportedFileTypes();

        // Iterate over each FileType object and print its extension to the console.
        for (FileType fileType : supportedFileTypes) {
            System.out.print("\n" + fileType.getExtension());
        }
    }
}

Co se zde děje:

  • getSupportedFileTypes(): Statická metoda dotazuje interní registr knihovny a vrací úplný seznam podporovaných formátů jako objekty FileType
  • Smyčka prochází každý formát a vypisuje jeho příponu (např. .pdf, .docx, .xlsx)
  • Každý objekt FileType také obsahuje další metadata, ke kterým můžete přistupovat (ukážeme níže)

Více než jen základní přípony

Objekt FileType poskytuje více než jen přípony. Zde je, co dalšího můžete získat:

for (FileType fileType : supportedFileTypes) {
    System.out.println("Extension: " + fileType.getExtension());
    System.out.println("Format: " + fileType.getFileFormat());
    // Additional properties available depending on version
}

To je užitečné, když potřebujete zobrazit uživatelsky přívětivé názvy formátů nebo seskupit formáty podle typu (dokumenty vs. tabulky vs. obrázky).

Kdy použít tento přístup

Ne každá situace vyžaduje řešení založené na knihovně. Zde jsou případy, kdy detekce formátů GroupDocs.Signature vyniká:

Ideální scénáře

1. Validátory nahrávaných dokumentů
Když uživatelé nahrávají soubory, chcete validovat formáty na serveru (nikdy nespoléhejte jen na klientskou validaci). Tento přístup vám umožní zkontrolovat soubor proti kompletnímu seznamu podporovaných formátů před dalším zpracováním.

2. Dynamické filtry typů souborů
Budujete výběr souborů nebo komponentu pro nahrávání? Generujte seznam povolených formátů dynamicky místo statického pole, které může být neaktuální.

3. Pipeline pro zpracování více formátů
Pokud zpracováváte dokumenty z různých zdrojů (e‑mailové přílohy, cloudové úložiště, uživatelské nahrávání), potřebujete spolehlivou detekci formátu, aby se soubory nasměrovaly ke správným handlerům.

4. Integrace s cloudovými úložišti
Při synchronizaci s AWS S3, Google Drive nebo Azure Blob Storage validujte kompatibilitu dokumentů před stažením a zpracováním – šetříte šířku pásma i výpočetní čas.

Kdy může stačit vestavěná Java

Pro jednodušší scénáře mohou stačit vestavěné metody Javy:

  • Pouze kontrola přípony: file.getName().endsWith(".pdf")
  • Detekce MIME typu: Files.probeContentType(path)
  • Základní validace: Když máte plnou kontrolu nad zdrojem nahrávaných souborů a důvěřujete jejich příponám

Důležité upozornění: Vestavěné metody lze snadno oklamat. Soubor přejmenovaný z malicious.exe na document.pdf projde kontrolou přípony, ale selže při řádné validaci. GroupDocs.Signature provádí hlubší inspekci.

Časté problémy a řešení

Níže jsou typické problémy, na které můžete narazit, a rychlé způsoby, jak je vyřešit.

Problém 1: Vrací se prázdný nebo null seznam

Projev: getSupportedFileTypes() vrací prázdný seznam nebo null.

Příčiny a řešení:

  • Knihovna není správně inicializována: Ověřte, že je Maven/Gradle závislost správně přidána a synchronizována
  • Nekompatibilní verze: Používejte verzi 23.12 nebo novější (starší verze mohou mít odlišné API)
  • Problémy s classpath: Při ručním přidání JAR souborů se ujistěte, že jsou skutečně v classpath

Rychlá oprava:

List<FileType> formats = FileType.getSupportedFileTypes();
if (formats == null || formats.isEmpty()) {
    System.err.println("Error: No file types loaded. Check library initialization.");
    return;
}

Problém 2: Chybí očekávaný formát

Projev: Formát, který očekáváte, není v seznamu podporovaných.

Možné důvody:

  • Používáte specializovaný formát, který vyžaduje další pluginy (některé CAD nebo medicínské formáty potřebují samostatné moduly)
  • Formát byl přidán v novější verzi – zkontrolujte poznámky k vydání
  • Formát je podporován jen pro čtení, ne pro operace s podpisy (GroupDocs.Signature primárně slouží k přidávání podpisů)

Postup ladění:

// Check for specific format
boolean hasPDF = supportedFileTypes.stream()
    .anyMatch(ft -> ft.getExtension().equalsIgnoreCase(".pdf"));
System.out.println("PDF supported: " + hasPDF);

Problém 3: Pokles výkonu při velkém seznamu formátů

Projev: Opakované volání getSupportedFileTypes() zpomaluje aplikaci.

Řešení: Kešujte výsledek! Seznam se během běhu aplikace nemění:

public class FormatCache {
    private static List<FileType> cachedFormats = null;
    
    public static List<FileType> getSupportedFormats() {
        if (cachedFormats == null) {
            cachedFormats = FileType.getSupportedFileTypes();
        }
        return cachedFormats;
    }
}

Tento vzor zajistí, že dotaz na knihovnu provedete jen jednou během životního cyklu aplikace.

Problém 4: Omezení související s licencí

Projev: Zobrazují se varování o hodnocení nebo omezená podpora formátů.

Řešení:

  • Aplikujte licenci před voláním jakýchkoli metod GroupDocs
  • Ověřte, že cesta k souboru licence je správná
  • Zkontrolujte datum expirace, pokud používáte časově omezenou licenci
try {
    License license = new License();
    license.setLicense("path/to/GroupDocs.Signature.lic");
} catch (Exception e) {
    System.err.println("License error: " + e.getMessage());
}

Nejlepší postupy pro detekci formátů souborů

Dodržujte tato doporučení pro tvorbu robustní a udržovatelné detekce formátů.

1. Validujte co nejdříve, selhání okamžitě

Zkontrolujte formát souboru co nejdříve v pipeline:

public boolean validateFileFormat(String filePath) {
    String extension = getFileExtension(filePath);
    List<FileType> supported = FormatCache.getSupportedFormats();
    
    boolean isSupported = supported.stream()
        .anyMatch(ft -> ft.getExtension().equalsIgnoreCase(extension));
    
    if (!isSupported) {
        throw new UnsupportedFormatException(
            "File format " + extension + " is not supported"
        );
    }
    return true;
}

Tím zabráníte zbytečnému zpracování nepodporovaných souborů.

2. Poskytněte uživateli jasnou zpětnou vazbu

Při odmítnutí souboru uveďte přesně, které formáty jsou podporovány:

public String getSupportedFormatsMessage() {
    List<FileType> formats = FormatCache.getSupportedFormats();
    String extensions = formats.stream()
        .map(FileType::getExtension)
        .collect(Collectors.joining(", "));
    
    return "Supported formats: " + extensions;
}

3. Nespoléhejte se jen na přípony

Soubor přejmenovaný z .exe na .pdf bude mít příponu .pdf, ale nebude validní PDF. GroupDocs.Signature ověřuje skutečný obsah, ale kombinace přístupů je stále vhodná:

// First check extension (fast)
if (!hasValidExtension(file)) {
    return false;
}

// Then validate with library (more thorough)
try (Signature signature = new Signature(file)) {
    // If initialization succeeds, format is valid
    return true;
} catch (Exception e) {
    return false;
}

4. Ošetřujte výjimky elegantně

Validace může selhat z mnoha důvodů mimo nepodporované formáty:

public ValidationResult validateDocument(String path) {
    try {
        // Your validation logic
        return ValidationResult.success();
    } catch (UnsupportedFormatException e) {
        return ValidationResult.failure("Unsupported format: " + e.getMessage());
    } catch (IOException e) {
        return ValidationResult.failure("File access error: " + e.getMessage());
    } catch (Exception e) {
        return ValidationResult.failure("Unexpected error: " + e.getMessage());
    }
}

5. Sledujte změny podpory formátů

Při aktualizaci knihovny GroupDocs.Signature kontrolujte poznámky k vydání ohledně:

  • Nových podporovaných formátů
  • Ukončené podpory některých formátů
  • Změn v chování detekce

Zvažte přidání unit testů, které ověří, že očekávané formáty jsou podporovány:

@Test
public void testEssentialFormatsSupported() {
    List<String> required = Arrays.asList(".pdf", ".docx", ".xlsx");
    List<FileType> supported = FileType.getSupportedFileTypes();
    
    for (String format : required) {
        assertTrue(
            supported.stream().anyMatch(ft -> ft.getExtension().equals(format)),
            format + " should be supported"
        );
    }
}

Úvahy o výkonu

Optimalizace detekce formátů může vypadat jako drobnost, ale při zpracování tisíců dokumentů nebo při souběžném nahrávání je zásadní.

Správa paměti

Strategie kešování: Jak již bylo zmíněno, kešujte seznam podporovaných formátů:

// Good: Load once, reuse many times
private static final List<FileType> SUPPORTED_FORMATS = 
    FileType.getSupportedFileTypes();

// Bad: Loads list every time method is called
public boolean isSupported(String ext) {
    return FileType.getSupportedFileTypes().stream()
        .anyMatch(ft -> ft.getExtension().equals(ext));
}

Proč to funguje: Načtení seznamu zahrnuje reflexi a interní inicializaci knihovny. Jednorázové načtení šetří CPU cykly i alokace paměti.

Pokyny pro využití zdrojů

Pro scénáře s vysokým objemem:

  • Používejte thread‑safe keš pro seznam formátů (ukázka výše je neproměnná, takže je bezpečná)
  • Zvažte lazy inicializaci, pokud aplikace nemusí vždy detekci formátů používat
  • Při zpracování dokumentů uzavírejte objekty Signature okamžitě, aby se uvolnily zdroje
try (Signature signature = new Signature(filePath)) {
    // Process document
} // Automatically closed, resources freed

Optimalizace dávkového zpracování

Při validaci více souborů najednou můžete využít paralelizaci:

List<String> files = Arrays.asList("doc1.pdf", "doc2.docx", "doc3.xlsx");

// Process in parallel
files.parallelStream()
    .forEach(file -> {
        if (validateFileFormat(file)) {
            processDocument(file);
        }
    });

Upozornění: Nepřehánějte paralelizaci. Pokud jste omezeni I/O (čtení z disku), nadměrný počet vláken nepřinese zisk. Otestujte optimální počet vláken pro vaše prostředí.

Tipy pro ladění JVM

Pro aplikace s těžkým zpracováním dokumentů:

  • Zvyšte velikost haldy: -Xmx2g (upravit podle potřeb)
  • Sledujte garbage collection: -XX:+PrintGCDetails pro identifikaci problémů
  • Zvažte G1GC pro kratší pauzy: -XX:+UseG1GC

Praktické aplikace a integrace

Podívejme se na reálné scénáře, kde je detekce formátu nezbytná.

1. Systémy pro správu dokumentů

Scénář: Uživatelé nahrávají dokumenty, které je třeba indexovat, zpracovat a uložit.

Implementační vzor:

public class DocumentUploadHandler {
    public void handleUpload(MultipartFile file) {
        // Validate format first
        if (!isFormatSupported(file.getOriginalFilename())) {
            throw new InvalidFormatException(
                "Please upload: " + getSupportedFormatsString()
            );
        }
        
        // Process valid document
        processAndStore(file);
    }
    
    private boolean isFormatSupported(String filename) {
        String ext = getExtension(filename);
        return FormatCache.getSupportedFormats().stream()
            .anyMatch(ft -> ft.getExtension().equalsIgnoreCase(ext));
    }
}

2. Integrace s cloudovým úložištěm

Scénář: Synchronizace dokumentů z AWS S3 nebo Google Drive a zpracování jen podporovaných formátů.

Proč je to užitečné: Vyhnete se stahování a pokusu o zpracování nepodporovaných souborů, čímž šetříte šířku pásma i výpočetní čas.

public void syncFromS3(String bucketName) {
    S3Client s3 = S3Client.create();
    ListObjectsV2Request listReq = ListObjectsV2Request.builder()
        .bucket(bucketName)
        .build();
    
    ListObjectsV2Response listing = s3.listObjectsV2(listReq);
    
    for (S3Object object : listing.contents()) {
        if (isFormatSupported(object.key())) {
            // Download and process only supported formats
            downloadAndProcess(bucketName, object.key());
        } else {
            logger.info("Skipping unsupported format: " + object.key());
        }
    }
}

3. Automatizace podnikových workflow

Scénář: Směrování dokumentů do různých pipeline podle typu.

Příklad: PDF → workflow pro podpis, tabulky → extrakci dat, obrázky → OCR.

public void routeDocument(String filePath) {
    try (Signature signature = new Signature(filePath)) {
        FileType type = signature.getDocumentInfo().getFileType();
        
        switch (type.getExtension()) {
            case ".pdf":
            case ".docx":
                sendToSignatureWorkflow(filePath);
                break;
            case ".xlsx":
            case ".csv":
                sendToDataExtractionWorkflow(filePath);
                break;
            case ".jpg":
            case ".png":
                sendToOCRWorkflow(filePath);
                break;
            default:
                logger.warn("No workflow defined for: " + type.getExtension());
        }
    }
}

4. Tvorba výběrů typů souborů v UI

Scénář: Dynamické komponenty pro výběr souborů s aktuální podporou formátů.

Ukázka integrace na frontendu:

@RestController
public class FormatController {
    @GetMapping("/api/supported-formats")
    public ResponseEntity<List<String>> getSupportedFormats() {
        List<String> extensions = FileType.getSupportedFileTypes().stream()
            .map(FileType::getExtension)
            .sorted()
            .collect(Collectors.toList());
        
        return ResponseEntity.ok(extensions);
    }
}

Frontend pak může použít tento seznam k nastavení komponenty pro nahrávání:

// Frontend code (for context, not part of Java implementation)
fetch('/api/supported-formats')
    .then(res => res.json())
    .then(formats => {
        fileInput.accept = formats.join(',');
    });

Jak zkontrolovat příponu souboru java?

Načtěte název souboru, extrahujte jeho příponu a porovnejte ji s kešovaným seznamem vráceným Signature.getSupportedFileTypes(). Tento dvoukrokový přístup zaručuje, že kontrolujete aktuální katalog místo pevně zakódovaného pole a zároveň zabraňuje podvrženým příponám, protože GroupDocs.Signature ověřuje hlavičku souboru před dalším zpracováním.

Co je GroupDocs.Signature?

GroupDocs.Signature je Java knihovna, která vývojářům umožňuje přidávat, ověřovat a spravovat digitální podpisy ve více než 50 formátech dokumentů. Poskytuje jednotné API pro PDF, Office, obrázky a mnoho dalších typů, přičemž řeší složité scénáře jako šifrované soubory, dokumenty chráněné heslem a vícestránkové podpisy.

Proč použít detekci založenou na knihovně místo vestavěných metod Javy?

Detekce založená na knihovně kontroluje skutečnou hlavičku souboru a jeho interní strukturu, čímž zajišťuje, že obsah skutečně odpovídá deklarovanému formátu. Vestavěné metody jako Files.probeContentType nebo jednoduché kontroly přípony lze snadno oklamat přejmenováním škodlivých spustitelných souborů na .pdf. GroupDocs.Signature eliminuje toto riziko prováděním hluboké analýzy obsahu před jakýmkoli dalším zpracováním.

Kdy bych měl kešovat podporované formáty souborů?

Kešujte seznam formátů při startu aplikace nebo při prvním požadavku a používejte tuto neměnnou kolekci po celou dobu běhu JVM. Kešování je zvláště výhodné v webových službách s vysokým provozem, kde by každé volání jinak spouštělo reflexní inicializaci knihovny, což přidává milisekundy latence.

Jak zacházet s nepodporovanými formáty souborů v Javě?

Detekujte nepodporovaný formát co nejdříve, zaznamenejte pokus pro audit a vraťte uživateli jasnou chybovou zprávu s výčtem povolených přípon. Tento přístup zlepšuje uživatelskou zkušenost a snižuje zbytečnou zátěž backendu.

Často kladené otázky

Q: Jak aktualizuji verzi knihovny GroupDocs.Signature v Maven?
A: Změňte hodnotu <version> v souboru pom.xml na požadovanou verzi a spusťte mvn clean install. Vždy si přečtěte poznámky k vydání pro případné breaking changes.

Q: Dokáže GroupDocs.Signature detekovat formát souboru i při špatné příponě?
A: Ano. Knihovna provádí validaci založenou na obsahu, takže soubor přejmenovaný z .exe na .pdf bude během zpracování odmítnut jako neplatný PDF. getSupportedFileTypes() pouze uvádí, které formáty knihovna dokáže zpracovat; skutečná validace proběhne při pokusu o otevření souboru.

Q: Jaký je rozdíl mezi bezplatnou zkušební verzí a dočasnou licencí?
A: Bezplatná zkušební verze poskytuje okamžitý přístup, ale obsahuje vodoznaky a některá omezení funkcí. Dočasná licence odstraňuje vodoznaky a omezení po dobu 30 dnů, což je ideální pro důkladné testování v prostředí podobném produkci.

Q: Jak mám v aplikaci zacházet s nepodporovanými formáty souborů?
A: Vraťte stručnou chybu typu „Unsupported format. Supported extensions are: .pdf, .docx, .xlsx, .png, .jpg.“ Zaznamenejte incident pro bezpečnostní monitoring a zvažte UI tooltip, který uživateli zobrazí povolené typy.

Q: Funguje GroupDocs.Signature s šifrovanými nebo heslem chráněnými soubory?
A: Ano, ale musíte při vytváření instance Signature předat heslo. Samotná detekce formátu nevyžaduje heslo, ale jakékoli následné operace (např. přidání podpisu) jej budou potřebovat.

Q: Existuje komunita nebo fórum podpory pro GroupDocs.Signature?
A: Určitě! Navštivte GroupDocs Forum pro diskuze, ukázky kódu a přímé odpovědi od týmu GroupDocs.

Zdroje

Dokumentace:

Stahování a licence:

Podpora a komunita:

Poslední aktualizace: 2026-05-11
Testováno s: GroupDocs.Signature 23.12 pro Java
Autor: GroupDocs

<version>24.1</version>  <!-- Update to newer version -->

try {
    validateAndProcess(file);
} catch (UnsupportedFormatException e) {
    return ResponseEntity
        .badRequest()
        .body("Unsupported format. Please upload: " + getSupportedFormatsString());
}

LoadOptions loadOptions = new LoadOptions();
loadOptions.setPassword("your-password");
Signature signature = new Signature("protected.pdf", loadOptions);

Související tutoriály