kontrollera filändelse java – Java filformatdetektering: validera och kontrollera dokumenttyper

En av de vanligaste uppgifterna är att check file extension java innan ett dokument bearbetas.

Har du någonsin laddat upp en fil bara för att din applikation kraschar eftersom den inte var i förväntat format? Du är inte ensam. Att upptäcka och validera filformat i Java är avgörande för att bygga robusta dokumentbehandlingsapplikationer—men det är svårare än att bara kontrollera filändelser (som lätt kan förfalskas eller vara felaktiga).

I den här guiden kommer du att lära dig hur du på ett pålitligt sätt upptäcker filformat i Java med hjälp av GroupDocs.Signature, ett kraftfullt bibliotek som går bortom enkel ändelsekontroll. Oavsett om du bygger ett dokumenthanteringssystem, validerar användaruppladdningar eller integrerar med molnlagringstjänster, kommer du att upptäcka praktiska tekniker för att säkert hantera olika dokumenttyper.

Vad du kommer att lära dig:

  • Hur man programatiskt hämtar stödjade filformat i Java
  • När man ska använda bibliotekbaserad detektering vs. inbyggda Java‑metoder
  • Vanliga fallgropar vid validering av filtyper (och hur man undviker dem)
  • Verkliga integrationsscenarier och tips för prestandaoptimering
  • Felsökningsstrategier för problem med formatdetektering

När du är klar har du en fungerande implementation som du kan klistra in i dina Java‑applikationer direkt. Låt oss börja med att säkerställa att du har allt du behöver.

Snabba svar

  • Vad är det snabbaste sättet att check file extension java? Använd Signature.getSupportedFileTypes() för att hämta hela listan och jämföra filens ändelse med den.
  • Behöver jag en licens för att använda GroupDocs.Signature? En gratis provperiod fungerar för utveckling; en permanent licens tar bort alla utvärderingsgränser.
  • Kan jag validera uppladdningar utan att läsa hela filen? Ja—GroupDocs.Signature inspekterar filhuvudet, vilket är mycket billigare än att ladda hela dokumentet.
  • Hur många format stöder GroupDocs.Signature? Över 50 in‑ och utdataformat, inklusive PDF, DOCX, XLSX, PPTX, JPG, PNG och många fler.
  • Är det nödvändigt att cacha formatlistan? Caching eliminerar upprepad reflektion och förbättrar genomströmning för tjänster med hög volym.

Förutsättningar

Innan du dyker ner i filformatdetektering, se till att du har dessa grundläggande saker klara:

Nödvändiga bibliotek och versioner

  • GroupDocs.Signature Library: Version 23.12 eller senare (vi använder den senaste stabila releasen)
  • Java Development Kit: JDK 1.8 eller högre (JDK 11+ rekommenderas för bättre prestanda)
  • Build Tool: Maven 3.x eller Gradle 6.x för beroendehantering

Krav för miljöinställning

  • Grundläggande Java‑programmeringskoncept (klasser, slingor, imports)
  • Använda Maven eller Gradle för att hantera beroenden
  • Köra Java‑applikationer från din IDE eller kommandorad

Snabbt tips: Om du arbetar med stora dokument eller planerar att bearbeta filer parallellt, allokera tillräckligt med heap‑minne till din JVM (vi går igenom optimering senare).

När din miljö är klar, låt oss gå vidare till att konfigurera GroupDocs.Signature i ditt projekt.

Konfigurera GroupDocs.Signature för Java

Att få in GroupDocs.Signature i ditt projekt är enkelt—välj ditt föredragna byggverktyg och följ med.

Använda Maven

Lägg till detta beroende i din pom.xml‑fil:

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

Efter att ha lagt till beroendet, kör mvn clean install för att ladda ner biblioteket.

Använda Gradle

Inkludera denna rad i din build.gradle‑fil:

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

Synkronisera sedan ditt Gradle‑projekt eller kör gradle build.

Direkt nedladdningsalternativ

Använder du inget byggverktyg? Du kan ladda ner JAR‑filen direkt från GroupDocs.Signature for Java releases och lägga till den i din classpath manuellt. (Ärligt talat, att använda Maven eller Gradle sparar dig huvudvärk längre fram.)

Steg för att skaffa licens

GroupDocs.Signature erbjuder flexibla licensalternativ:

  • Free Trial: Perfekt för testning—kom igång omedelbart utan kreditkort required
  • Temporary License: Behöver du mer tid för utvärdering? Begär en 30‑dagars tillfällig licens för obegränsad åtkomst
  • Purchase: När du är redo för produktion, skaffa en permanent licens från GroupDocs Purchase Page

Pro tip: Börja med gratis provperiod för att utforska alla funktioner. Den tillfälliga licensen tar bort vattenstämplar och begränsningar om du behöver förlängd utvärderingstid.

Grundläggande initiering och konfiguration

Signature är huvudinkörningspunkten för alla operationer i GroupDocs.Signature. Den kapslar in dokumentladdning, format‑hantering och signaturbehandling.

Så här initierar du GroupDocs.Signature i din Java‑applikation:

import com.groupdocs.signature.Signature;

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

Detta skapar ett signatur‑objekt för det angivna dokumentet. Du kommer att använda detta mönster när du arbetar med faktiska dokument, men för att hämta stödjade format behöver du inte en specifik fil (vi visar dig i nästa avsnitt).

Nu när konfigurationen är klar, låt oss implementera kärnfunktionaliteten för att upptäcka och hämta stödjade filformat.

Implementeringsguide

Här blir det praktiskt. Vi bygger ett enkelt verktyg som hämtar alla stödjade filformat—tänk på det som att skapa en ”kompatibilitetskontroll” för din dokumentbehandlingspipeline.

Varför detta är viktigt

Innan du lägger tid på att implementera dokumentbehandlingsfunktioner, måste du veta vilka filtyper ditt bibliotek stöder. Denna implementation ger dig den informationen dynamiskt, vilket betyder:

  • Ingen hårdkodning av filändelselistor som blir föråldrade
  • Enkel validering av användaruppladdningar mot stödjade format
  • Snabb referens för att bygga filtypfilter i ditt UI

Steg‑för‑steg‑implementation

1. Importera nödvändiga klasser

FileType är porten till formatdetektering—den innehåller all metadata om stödjade dokumenttyper.

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

FileType‑klassen är GroupDocs.Signature:s beskrivning för varje stödjat format, och exponerar egenskaper som ändelse, MIME‑typ och beskrivning.

2. Skapa hämtarklassen

Här är den kompletta implementationen:

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());
        }
    }
}

Vad som händer här:

  • getSupportedFileTypes(): Denna statiska metod frågar bibliotekets interna register och returnerar en komplett lista över stödjade format som FileType‑objekt
  • Loopen itererar genom varje format och skriver ut dess ändelse (t.ex. .pdf, .docx, .xlsx)
  • Varje FileType‑objekt innehåller också ytterligare metadata som du kan komma åt (vi utforskar det nedan)

Bortom grundläggande ändelser

FileType‑objektet ger dig mer än bara ändelser. Här är vad mer du kan hämta:

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

Detta är användbart när du behöver visa användarvänliga formatnamn eller gruppera format efter typ (dokument vs. kalkylblad vs. bilder).

När du ska använda detta tillvägagångssätt

Inte varje situation kräver en bibliotekslösning. Här är när GroupDocs.Signature:s formatdetektering lyser:

Perfekta användningsfall

1. Bygga dokumentuppladdningsvaliderare
När användare laddar upp filer till din applikation vill du validera format på serversidan (lita aldrig enbart på klientvalidering). Detta tillvägagångssätt låter dig kontrollera mot en omfattande lista över stödjade format innan bearbetning.

2. Skapa dynamiska filtypfilter
Bygger du en filväljare eller uppladdningsgränssnitt? Generera din lista över tillåtna format dynamiskt istället för att underhålla en statisk array som kan bli osynkroniserad med ditt biblioteks funktioner.

3. Flermålsdokumentbehandlingspipeline
Om du bearbetar dokument från olika källor (e‑postbilagor, molnlagring, användaruppladdningar) behöver du pålitlig formatdetektering för att dirigera filer till rätt hanterare.

4. Integration med molnlagringstjänster
När du synkroniserar med AWS S3, Google Drive eller Azure Blob Storage, validera dokumentkompatibilitet innan du laddar ner och bearbetar filer—sparar bandbredd och bearbetningstid.

När inbyggd Java kan räcka

För enklare scenarier kan Javas inbyggda metoder räcka:

  • Endast filändelsekontroll: file.getName().endsWith(".pdf")
  • MIME‑typdetektering: Files.probeContentType(path)
  • Grundläggande validering: När du kontrollerar uppladdningskällan och litar på filändelserna

Viktig anmärkning: Inbyggda metoder kan luras. En fil som bytt namn från malicious.exe till document.pdf klarar ändelsekontrollen men misslyckas med korrekt validering. GroupDocs.Signature utför djupare inspektion.

Vanliga problem och felsökning

Här är de problem du sannolikt kommer att stöta på och hur du snabbt löser dem.

Problem 1: Tom eller null‑lista returnerad

Symptom: getSupportedFileTypes() returnerar en tom lista eller null.

Orsaker & lösningar:

  • Biblioteket är inte korrekt initierat: Verifiera att ditt Maven/Gradle‑beroende är korrekt tillagt och synkat
  • Versionkompatibilitet: Säkerställ att du använder version 23.12 eller senare (tidigare versioner kan ha andra API:er)
  • Classpath‑problem: Om du använder manuella JAR‑filer, bekräfta att de är korrekt tillagda i din classpath

Snabb fix:

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

Problem 2: Förväntat format saknas

Symptom: Ett format du förväntar dig att fungera finns inte i den stödjade listan.

Möjliga orsaker:

  • Du använder ett specialiserat format som kräver extra plugins (vissa CAD‑ eller medicinska bildformat kräver separata moduler)
  • Formatet lades till i en nyare version—kontrollera release‑noterna
  • Formatet stöds för läsning men inte för signaturoperationer (GroupDocs.Signature är främst för att lägga till signaturer, inte alla operationer stödjer alla format lika)

Felsökningsmetod:

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

Problem 3: Prestandaförsämring med stora formatlistor

Symptom: Att anropa getSupportedFileTypes() upprepade gånger saktar ner din applikation.

Lösning: Cacha resultaten! Denna lista förändras inte under körning:

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

Detta mönster säkerställer att du bara frågar biblioteket en gång per applikationslivscykel.

Problem 4: Licensrelaterade begränsningar

Symptom: Får du utvärderingsvarningar eller begränsat formatstöd.

Lösning:

  • Applicera din licens innan du anropar några GroupDocs‑metoder
  • Verifiera att sökvägen till licensfilen är korrekt
  • Kontrollera licensens utgångsdatum om du använder en tidsbegränsad licens
try {
    License license = new License();
    license.setLicense("path/to/GroupDocs.Signature.lic");
} catch (Exception e) {
    System.err.println("License error: " + e.getMessage());
}

Bästa praxis för filformatdetektering

Följ dessa riktlinjer för att bygga robust och underhållbar formatdetektering i dina applikationer.

1. Validera tidigt, misslyckas snabbt

Kontrollera filformat så tidigt som möjligt i din bearbetningspipeline:

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;
}

Det förhindrar slöseri med bearbetningstid på stödjade format.

2. Ge tydlig återkoppling till användaren

När du avvisar filer, informera användarna exakt vilka format SOM stöds:

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

3. Lita inte bara på filändelser

En fil som bytt namn från .exe till .pdf får en .pdf‑ändelse men är inte en giltig PDF. GroupDocs.Signature validerar faktiskt innehåll, inte bara ändelser—men du bör ändå kombinera metoder:

// 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. Hantera undantag på ett smidigt sätt

Filvalidering kan misslyckas av många anledningar utöver stödjade format:

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. Övervaka förändringar i formatstöd

När du uppdaterar GroupDocs.Signature‑biblioteket, kontrollera release‑noterna för:

  • Nya stödjade format
  • Utfasat formatstöd
  • Ändrat beteende i formatdetektering

Överväg att lägga till enhetstester som verifierar att förväntade format stöds:

@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"
        );
    }
}

Prestandaöverväganden

Att optimera filformatdetektering kan verka obetydligt, men det spelar roll när du bearbetar tusentals dokument eller hanterar samtidiga uppladdningar.

Minneshantering

Cachningsstrategi: Som nämnt tidigare, cacha listan över stödjade format:

// 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));
}

Varför det är viktigt: Att ladda formatlistan innebär reflektion och intern bibliotekinitiering. Att göra detta en gång sparar CPU‑cykler och minnesallokeringar.

Riktlinjer för resursanvändning

För högvolymscenarier:

  • Använd en trådsäker cache för formatlistor (exemplet ovan är trådsäkert eftersom det är oföränderligt)
  • Överväg lazy‑initiering om din applikation inte alltid behöver formatdetektering
  • När du bearbetar dokument, stäng Signature‑objekt snabbt för att frigöra resurser
try (Signature signature = new Signature(filePath)) {
    // Process document
} // Automatically closed, resources freed

Optimering av batch‑bearbetning

Om du validerar flera filer, överväg parallellisering:

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

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

Varning: Överparallellisera inte. Om du är I/O‑begränsad (läser från disk) hjälper för många trådar inte. Testa för att hitta optimal trådräknare.

JVM‑optimeringstips

För dokumenttunga applikationer:

  • Öka heap‑storlek: -Xmx2g (justera efter dina behov)
  • Övervaka skräpsamling: Använd -XX:+PrintGCDetails för att identifiera problem
  • Överväg G1GC för bättre paus‑tider: -XX:+UseG1GC

Praktiska tillämpningar och integration

Låt oss titta på verkliga scenarier där filformatdetektering blir avgörande.

1. Dokumenthanteringssystem

Scenario: Användare laddar upp dokument som måste indexeras, bearbetas och lagras.

Implementeringsmönster:

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. Integration med molnlagring

Scenario: Synkronisera dokument från AWS S3 eller Google Drive och bearbeta endast stödjade format.

Varför det är användbart: Undvik att ladda ner och försöka bearbeta stödjade filer, vilket sparar bandbredd och bearbetningstid.

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. Företagsarbetsflödesautomatisering

Scenario: Ruttning av dokument genom olika bearbetningspipeline baserat på typ.

Exempel: PDF‑filer går till signatur‑arbetsflöde, kalkylblad till dataextraktion, bilder till OCR‑bearbetning.

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. Bygga filtyp‑väljare

Scenario: Skapa UI‑komponenter med dynamiskt formatstöd.

Frontend‑integrationsexempel:

@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);
    }
}

Din frontend kan sedan använda detta för att konfigurera filuppladdningskomponenter:

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

Hur man check file extension java?

Läs in filnamnet, extrahera dess suffix och jämför det med den cachade listan som returneras av Signature.getSupportedFileTypes(). Detta tvåstegs‑tillvägagångssätt garanterar att du kontrollerar mot en uppdaterad katalog istället för en hårdkodad array. Det förhindrar också förfalskade ändelser eftersom GroupDocs.Signature validerar filhuvudet innan någon vidare bearbetning.

Vad är GroupDocs.Signature?

GroupDocs.Signature är ett Java‑bibliotek som låter utvecklare lägga till, verifiera och hantera digitala signaturer över mer än 50 dokumentformat. Det erbjuder ett enhetligt API för PDF, Office, bilder och många andra typer, och hanterar komplexa valideringsscenarier såsom krypterade filer, lösenordsskyddade dokument och flersidiga signaturer.

Varför använda bibliotek‑baserad detektering istället för Javas inbyggda metoder?

Bibliotek‑baserad detektering inspekterar det faktiska filhuvudet och den interna strukturen, vilket säkerställer att innehållet verkligen matchar det påstådda formatet. Inbyggda metoder som Files.probeContentType eller enkla sträng‑suffixkontroller kan luras genom att byta namn på skadliga körbara filer till .pdf. GroupDocs.Signature eliminerar denna risk genom att utföra djup innehållsanalys innan någon vidare bearbetning.

När bör jag cacha stödjade filformat?

Cacha formatlistan vid applikationsstart eller första gången du behöver den, och återanvänd den oföränderliga samlingen under JVM‑livstiden. Caching är särskilt fördelaktigt i hög‑genomströmning webbtjänster där varje begäran annars kan trigga reflektionstung bibliotekinitiering, vilket lägger till millisekunder av latens per anrop.

Hur man hanterar ej stödjade filformat i Java?

Upptäck det ej stödjade formatet tidigt, logga försöket för revisionsändamål, och returnera ett tydligt felmeddelande till användaren som listar de tillåtna ändelserna. Detta tillvägagångssätt förbättrar användarupplevelsen och minskar onödig bearbetningsbelastning på din backend.

Vanliga frågor

Q: Hur uppdaterar jag min GroupDocs.Signature‑biblioteks version i Maven?
A: Ändra <version>‑taggen i din pom.xml till önskad version, kör sedan mvn clean install. Granska alltid release notes för brytande förändringar.

Q: Kan GroupDocs.Signature upptäcka filformat även om ändelsen är fel?
A: Ja. Biblioteket utför innehållsbaserad validering, så en fil som bytt namn från .exe till .pdf kommer att avvisas som inte en giltig PDF under bearbetning. getSupportedFileTypes() listar bara format som biblioteket kan hantera; du måste fortfarande försöka öppna filen för att verifiera dess faktiska typ.

Q: Vad är skillnaden mellan en gratis provperiod och en tillfällig licens?
A: Gratis provperiod ger omedelbar åtkomst men inkluderar utvärderingsvattenstämplar och vissa funktionsbegränsningar. En tillfällig licens ger full funktionstillgång i 30 dagar utan vattenstämplar, idealisk för grundlig testning i en produktionsliknande miljö.

Q: Hur bör jag hantera ej stödjade filformat i min applikation?
A: Returnera ett kort felmeddelande som “Unsupported format. Supported extensions are: .pdf, .docx, .xlsx, .png, .jpg.” Logga händelsen för säkerhetsövervakning och överväg att informera användaren med ett UI‑tooltip som listar tillåtna typer.

Q: Fungerar GroupDocs.Signature med krypterade eller lösenordsskyddade filer?
A: Ja, men du måste ange lösenordet när du skapar Signature‑instansen. Formatdetektionen i sig kräver inte lösenordet, men efterföljande bearbetning (t.ex. lägga till en signatur) gör det.

Q: Finns det ett community eller supportforum för GroupDocs.Signature?
A: Absolut! Besök GroupDocs Forum för community‑diskussioner, kodexempel och direkta svar från GroupDocs‑teamet.

Resurser

Dokumentation:

Nedladdningar och licensiering:

Support och community:

Senast uppdaterad: 2026-05-11
Testat med: GroupDocs.Signature 23.12 för Java
Författare: 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);

Relaterade handledningar