java kontrola přípony souboru – detekce a ověření typů dokumentů

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

Už jste někdy nahráli soubor, jen aby se vaše aplikace zhroutila, protože nebyl ve očekávaném formátu? Nejste v tom sami. Detekce a ověřování formátů souborů v Javě je zásadní pro tvorbu robustních aplikací pro zpracování dokumentů—ale je obtížnější než kontrola přípon souborů (které lze snadno podvrhnout nebo jsou nesprávné).

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

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 ověřování 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í. Pojďme začít tím, že se ujistíme, že máte vše potřebné.

Rychlé odpovědi

  • Jaký je nejrychlejší způsob, jak java check file extension? 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 ověřovat nahrané soubory bez načtení celého souboru? 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é reflexní zatížení a zvyšuje propustnost pro služby s vysokým objemem.

Co je java check file extension?

java check file extension označuje proces potvrzení skutečného typu souboru kontrolou jeho hlavičky a metadat místo spoléhaní se pouze na příponu názvu souboru. To zajišťuje, že škodlivě přejmenované soubory jsou zachyceny včas, zabraňuje bezpečnostním incidentům způsobeným podvrženými příponami a garantuje, že aplikace zpracovává pouze podporované typy dokumentů.

Předpoklady

Před tím, než se ponoříte do detekce formátu souboru, ujistěte se, že máte připravené následující:

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šší (JDK 11+ se doporučuje pro lepší výkon)
  • Build tool: 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 zpracovávat soubory souběžně, přidělte JVM dostatek heap paměti (optimalizaci probereme později).

Nastavení GroupDocs.Signature pro Java

Získání GroupDocs.Signature do vašeho projektu je jednoduché — vyberte si 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 JAR stáhnout přímo z GroupDocs.Signature for Java releases a ručně jej přidat do classpathu. (I když Maven nebo Gradle vám ušetří spoustu starostí v budoucnu.)

Kroky pro získání licence

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

  • Free trial: Ideální pro testování — začněte okamžitě bez nutnosti zadání kreditní karty (no credit card required)
  • Temporary license: Potřebujete více času na vyhodnocení? Požádejte o 30‑denní dočasnou licenci s neomezeným přístupem
  • Purchase: Jakmile jste připraveni na produkci, pořiďte si trvalou licenci na GroupDocs Purchase Page

Pro tip: Začněte s bezplatnou zkušební verzí, abyste prozkoumali všechny funkce. Dočasná licence odstraňuje vodoznaky a omezení, pokud potřebujete prodloužené hodnocení.

Co je třída Signature?

Signature je hlavní vstupní bod pro všechny operace v GroupDocs.Signature. Zajišťuje načítání dokumentů, správu formátů a zpracování podpisů. Třída poskytuje metody pro otevírání dokumentů, získávání podporovaných formátů a aplikaci či ověřování podpisů napříč mnoha typy souborů.

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 zadaný 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 nepotřebujete (ukážeme to v další sekci).

Průvodce implementací

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 vaši pipeline zpracování dokumentů.

Proč je to důležité

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

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

Krok za krokem implementace

1. Import necessary classes

FileType je vstupní brána k detekci formátů — obsahuje veškerá metadata o podporovaných typech dokumentů. Metoda Signature.getSupportedFileTypes() vrací kolekci objektů FileType, které představují každý formát, který knihovna zvládne.

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

2. Create the retrieval class

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:

  • Signature.getSupportedFileTypes() 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 (prozkoumáme níže).

Nad rámec základních přípon

Objekt FileType vám poskytuje více než jen přípony. Zde je další informace, které 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
}

Jak java check file extension?

Načtěte název souboru, extrahujte jeho příponu a porovnejte ji s kešovaným seznamem vráceným metodou Signature.getSupportedFileTypes(). Tento dvoustupňový přístup zajišťuje, že kontrolujete aktuální katalog místo pevně zakódovaného pole. Navíc zabraňuje podvrženým příponám, protože GroupDocs.Signature validuje hlavičku souboru před dalším zpracováním, čímž zajišťuje, že obsah skutečně odpovídá deklarovanému typu.

Co je GroupDocs.Signature?

GroupDocs.Signature je Java knihovna, která umožňuje vývojářům přidávat, ověřovat a spravovat digitální podpisy napříč více než 50 formáty dokumentů. Poskytuje jednotné API pro PDF, Office, obrázky a mnoho dalších typů, zvládá složité scénáře validace, jako jsou šifrované soubory, dokumenty chráněné heslem a vícestránkové podpisy. Knihovna také nabízí detekci formátu založenou na obsahu, což pomáhá předcházet zpracování škodlivě přejmenovaných souborů.

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 vnitřní strukturu, čímž zajišťuje, že obsah 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, čímž poskytuje vyšší bezpečnostní záruku pro vaši aplikaci.

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

Kešujte seznam formátů při startu aplikace nebo při první potřebě 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 na každý požadavek. Uložením seznamu jednou snížíte zátěž CPU a zlepšíte celkovou odezvu.

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

Detekujte nepodporovaný formát co nejdříve, zaznamenejte pokus pro auditní účely a vraťte uživateli jasnou chybovou zprávu, která uvádí povolené přípony. Tento přístup zlepšuje uživatelskou zkušenost a snižuje zbytečné zatížení backendu, zatímco poskytuje bezpečnostním týmům přehled o možných pokusech o zneužití.

Kdy použít tento přístup

Ideální případy použití

1. Building document upload validators
Když uživatelé nahrávají soubory do vaší aplikace, chcete validovat formáty na serveru (nikdy nespoléhejte jen na klientskou validaci). Tento přístup vám umožní zkontrolovat soubor vůči kompletnímu seznamu podporovaných formátů před dalším zpracováním.

2. Creating dynamic file‑type filters
Budujete výběr souborů nebo komponentu pro nahrávání? Generujte seznam povolených formátů dynamicky místo udržování statického pole, které může být neaktuální vůči schopnostem knihovny.

3. Multi‑format document processing pipelines
Pokud zpracováváte dokumenty z různých zdrojů (e‑mailové přílohy, cloudové úložiště, uživatelské nahrávky), potřebujete spolehlivou detekci formátu, aby soubory byly směrovány ke správným zpracovatelům.

4. Integration with cloud storage services
Při synchronizaci s AWS S3, Google Drive nebo Azure Blob Storage validujte kompatibilitu dokumentu před stažením a zpracováním — šetříte šířku pásma i výpočetní čas.

Kdy může být vestavěná Java dostatečná

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

  • File extension checking only: file.getName().endsWith(".pdf")
  • MIME type detection: Files.probeContentType(path)
  • Basic validation: Když máte kontrolu nad zdrojem nahrávání a důvěřujete příponám souborů

Důležitá poznámka: Vestavěné metody lze 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.

Běžné problémy a řešení

Problém 1: Vrácený seznam je prázdný nebo null

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

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

  • Library not properly initialised – ověřte, že je Maven/Gradle závislost správně přidána a synchronizována.
  • Version compatibility – ujistěte se, že používáte verzi 23.12 nebo novější (starší verze mohou mít odlišné API).
  • Classpath issues – pokud používáte ručně stažené JAR soubory, potvrďte, že jsou správně zahrnuty do classpathu.

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

Symptom: 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é obrazové 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 pro čtení, ale ne pro operace podpisu (GroupDocs.Signature primárně přidává podpisy; ne všechny operace podporují všechny formáty stejně).

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ých seznamech formátů

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

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

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

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

Symptom: 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átu souboru

1. Ověřujte brzy, selhání rychle

Zkontrolujte formáty co nejdříve ve vaší 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;
}

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

Při odmítnutí souboru informujte uživatele 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ů

Soubor přejmenovaný z .exe na .pdf bude mít příponu .pdf, ale nebude validní PDF. GroupDocs.Signature ověřuje skutečný obsah, ne jen přípony — ale i tak kombinujte přístupy:

// 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. Zpracovávejte výjimky elegantně

Validace souborů 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 chování při detekci formátů

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átu souboru může vypadat jako drobnost, ale má význam při zpracování tisíců dokumentů nebo při souběžných nahrávkách.

Správa paměti

Kešovací strategie: 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č je to důležité: Načtení seznamu formátů zahrnuje reflexi a interní inicializaci knihovny. Provedení jednou šetří cykly CPU a alokace paměti.

Pokyny pro využití zdrojů

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

  • Používejte thread‑safe keš pro seznamy formátů (příklad výše je thread‑safe, protože je neměnný).
  • Zvažte lazy inicializaci, pokud vaše aplikace nevyžaduje detekci formátů ve všech částech.
  • Při zpracování dokumentů uzavírejte objekty Signature okamžitě po dokončení, aby se uvolnily zdroje.
try (Signature signature = new Signature(filePath)) {
    // Process document
} // Automatically closed, resources freed

Optimalizace dávkového zpracování

Pokud validujete více souborů najednou, zvažte 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 I/O‑bound (čtení z disku), nadměrný počet vláken nepomůže. Otestujte a najděte optimální počet vláken.

Tipy pro ladění JVM

Pro aplikace s velkým objemem dokumentů:

  • Zvyšte velikost heapu: -Xmx2g (upravit podle potřeb).
  • Sledujte garbage collection: použijte -XX:+PrintGCDetails k 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 souboru nezbytná.

1. Systémy pro správu dokumentů

Scénář: Uživatelé nahrávají dokumenty, které je potř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 cloudového úložiště

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 pracovních toků

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

Příklad: PDF jde do workflow pro podpis, tabulky do extrakce dat, obrázky do 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. Vytváření výběrů typů souborů

Scénář: Tvorba UI komponent s dynamickou podporou formátů.

Frontend integrace:

@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í souborů:

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

Často kladené otázky

Q: Jak aktualizovat verzi knihovny GroupDocs.Signature v Maven?
A: Změňte tag <version> ve vašem 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áty souborů i když je přípona špatná?
A: Ano. Knihovna provádí validaci založenou na obsahu, takže soubor přejmenovaný z .exe na .pdf bude odmítnut jako neplatný PDF během zpracování. getSupportedFileTypes() pouze vypisuje formáty, které knihovna zvládne; skutečná validace vyžaduje pokus 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 vodotisky a některá omezení funkcí. Dočasná licence poskytuje plnou funkčnost po 30 dnů bez vodotisků, ideální pro důkladné testování v prostředí podobném produkci.

Q: Jak by měl aplikace 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 případně uživateli zobrazte tooltip s povolenými typy.

Q: Pracuje 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. Detekce formátu samotná heslo nevyžaduje, ale následné operace (např. přidání podpisu) jej potřebují.

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

Zdroje

Dokumentace:

Stažení a licence:

Podpora a komunita:

Poslední aktualizace: 2026-08-19
Testováno s: GroupDocs.Signature 23.12 for 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