java kontrollera filändelse – upptäck och validera dokumenttyper

En av de vanligaste uppgifterna är att java kontrollera filändelse 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 dokumentbearbetningsapplikationer—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 kontra 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 kommer du att ha en fungerande implementation som du kan lägga in i dina Java‑applikationer omedelbart. 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 java kontrollera filändelse? 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 provversion fungerar för utveckling; en permanent licens tar bort alla utvärderingsbegränsningar.
  • 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ödjer 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 högvolymtjänster.

Vad är java kontrollera filändelse?

java check file extension avser processen att bekräfta en fils verkliga typ genom att undersöka dess header och metadata snarare än att enbart förlita sig på filnamnets suffix. Detta säkerställer att skadligt omdöpta filer fångas tidigt, förhindrar säkerhetsintrång orsakade av förfalskade ändelser och garanterar att endast stödjade dokumenttyper bearbetas av din applikation.

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 kommer att använda den senaste stabila versionen)
  • Java Development Kit: JDK 1.8 eller högre (JDK 11+ rekommenderas för bättre prestanda)
  • Byggverktyg: Maven 3.x eller Gradle 6.x för beroendehantering

Krav för miljöinställning

Du bör vara bekväm med:

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

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

Installera 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 för Java‑utgåvor och lägga till den i din classpath manuellt. (Även om Maven eller Gradle sparar dig huvudvärk längre fram.)

Steg för att skaffa licens

GroupDocs.Signature erbjuder flexibla licensalternativ:

  • Gratis provversion: Perfekt för testning—kom igång omedelbart utan kreditkort krävs
  • Tillfällig licens: Behöver du mer tid för att utvärdera? Begär en 30‑dagars tillfällig licens för obegränsad åtkomst
  • Köp: När du är redo för produktion, skaffa en permanent licens från GroupDocs köpsida

Proffstips: Börja med gratis provversion 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.

Vad är Signature‑klassen?

Signature är huvudingångspunkten för alla operationer i GroupDocs.Signature. Den kapslar in dokumentladdning, format‑hantering och signaturbearbetning. Klassen erbjuder metoder för att öppna dokument, hämta stödjade format och applicera eller verifiera signaturer över många filtyper.

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 ingen specifik fil (vi visar dig detta i nästa avsnitt).

Implementeringsguide

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

Varför detta är viktigt

Innan du lägger tid på att implementera dokumentbearbetningsfunktioner, måste du veta vilka filtyper ditt bibliotek stödjer. 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 filtyp‑filter 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. Metoden Signature.getSupportedFileTypes() returnerar en samling av FileType‑objekt som representerar varje format som biblioteket kan hantera.

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

2. Skapa hämtningsklassen

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:

  • Signature.getSupportedFileTypes() 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).

Utöver 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
}

Hur man java kontrollerar filändelse?

Läs in filnamnet, extrahera dess suffix och jämför det med den cachade listan som returneras av Signature.getSupportedFileTypes(). Detta tvåstegs‑förfarande 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, vilket säkerställer att innehållet verkligen matchar den påstådda typen.

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. Biblioteket erbjuder också innehållsbaserad formatdetektering, vilket hjälper till att förhindra bearbetning av skadligt omdöpta filer.

Varför använda bibliotekbaserad detektering istället för inbyggda Java‑metoder?

Bibliotekbaserad 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, vilket ger en högre säkerhetsgaranti för din applikation.

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ömningstjänster där varje begäran annars kan trigga reflektionstung bibliotekinitialisering, vilket lägger till millisekunder av latens per anrop. Genom att lagra listan en gång minskar du CPU‑belastning och förbättrar den totala svarstiden.

Hur hanterar man 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, samtidigt som det ger säkerhetsteamet insyn i potentiella missbruksförsök.

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

Perfekta användningsfall

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

2. Skapa dynamiska filtyp‑filter
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åls‑dokumentbearbetningspipeline
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 inbyggda Java‑metoder kan räcka

För enklare scenarier kan Java:s 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

Viktigt förbehåll: Inbyggda metoder kan luras. En fil som bytt namn från malicious.exe till document.pdf passerar ändelsekontroller men misslyckas med korrekt validering. GroupDocs.Signature utför djupare inspektion.

Vanliga problem och felsökning

Problem 1: Tom eller null‑lista returnerad

Symptom: Signature.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.
  • Versionskompatibilitet – 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 behö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 Signature.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;
    }
}

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

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

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 enbart 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 ej 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

Optimering av filformatdetektering kan verka obetydligt, men det är viktigt 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 bibliotekinitialisering. Att göra detta en gång sparar CPU‑cykler och minnesallokeringar.

Riktlinjer för resursanvändning

För högvolyms‑scenarier:

  • 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‑initialisering om din applikation inte alltid behöver formatdetektering.
  • När du bearbetar dokument, stäng Signature‑objekt omedelbart 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‑bunden (läser från disk) hjälper inte för många trådar. 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 ej 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ödesautomation

Scenario: Rutta 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.

Exempel på frontend‑integration:

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

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

Vanliga frågor

Q: Hur uppdaterar jag min GroupDocs.Signature‑biblioteksversion i Maven?
A: Ändra <version>‑taggen i din pom.xml till önskad version, kör sedan mvn clean install. Granska alltid release‑noterna 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 ogiltig 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 verkliga typ.

Q: Vad är skillnaden mellan en gratis provversion och en tillfällig licens?
A: Gratis provversion 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‑forumet för community‑diskussioner, kodexempel och direkta svar från GroupDocs‑teamet.

Resurser

Dokumentation:

Nedladdningar och licensiering:

Support och community:

Senast uppdaterad: 2026-08-19
Testad 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