java verifica estensione file – rileva e valida i tipi di documento

Uno dei compiti più comuni è java verifica estensione file prima di elaborare un documento.

Hai mai caricato un file solo per vedere la tua applicazione andare in crash perché non era nel formato previsto? Non sei solo. Rilevare e validare i formati dei file in Java è fondamentale per costruire applicazioni di elaborazione documenti robuste, ma è più complicato del semplice controllo delle estensioni (che possono essere facilmente falsificate o errate).

In questa guida imparerai a rilevare in modo affidabile i formati dei file in Java usando GroupDocs.Signature, una libreria potente che va oltre il semplice controllo dell’estensione. Che tu stia costruendo un sistema di gestione documenti, validando upload degli utenti o integrandoti con servizi di storage cloud, scoprirai tecniche pratiche per gestire con sicurezza diversi tipi di documento.

Cosa imparerai:

  • Come recuperare programmaticamente i formati di file supportati in Java
  • Quando usare il rilevamento basato su libreria vs. gli approcci integrati di Java
  • Le insidie comuni nella validazione dei tipi di file (e come evitarle)
  • Scenari di integrazione reali e consigli per l’ottimizzazione delle prestazioni
  • Strategie di troubleshooting per problemi di rilevamento del formato

Alla fine avrai un’implementazione funzionante che potrai inserire subito nelle tue applicazioni Java. Iniziamo assicurandoci che tu abbia tutto il necessario.

Risposte rapide

  • Qual è il modo più veloce per java verifica estensione file? Usa Signature.getSupportedFileTypes() per recuperare l’intera lista e confrontare l’estensione del file con essa.
  • È necessaria una licenza per usare GroupDocs.Signature? Una prova gratuita è sufficiente per lo sviluppo; una licenza permanente rimuove tutti i limiti di valutazione.
  • Posso validare gli upload senza leggere l’intero file? Sì—GroupDocs.Signature ispeziona l’intestazione del file, molto più economico rispetto al caricamento dell’intero documento.
  • Quanti formati supporta GroupDocs.Signature? Oltre 50 formati di input e output, inclusi PDF, DOCX, XLSX, PPTX, JPG, PNG e molti altri.
  • È necessario memorizzare nella cache l’elenco dei formati? La cache elimina il sovraccarico di riflessione ripetuta e migliora il throughput per servizi ad alto volume.

Che cos’è java verifica estensione file?

java verifica estensione file indica il processo di conferma del vero tipo di un file esaminando la sua intestazione e i metadati anziché basarsi solo sul suffisso del nome. Questo garantisce che i file rinominati malevolmente vengano intercettati subito, previene violazioni di sicurezza causate da estensioni falsificate e assicura che solo i tipi di documento supportati vengano elaborati dalla tua applicazione.

Prerequisiti

Prima di immergerti nel rilevamento dei formati, assicurati di avere questi elementi pronti:

Librerie richieste e versioni

  • GroupDocs.Signature Library: Versione 23.12 o successiva (useremo l’ultima release stabile)
  • Java Development Kit: JDK 1.8 o superiore (JDK 11+ consigliato per migliori prestazioni)
  • Strumento di build: Maven 3.x o Gradle 6.x per la gestione delle dipendenze

Requisiti di configurazione dell’ambiente

Dovresti sentirti a tuo agio con:

  • Concetti base di programmazione Java (classi, loop, import)
  • Uso di Maven o Gradle per gestire le dipendenze
  • Esecuzione di applicazioni Java dal tuo IDE o da linea di comando

Suggerimento veloce: Se lavori con documenti di grandi dimensioni o prevedi di elaborare file in modo concorrente, assegna sufficiente memoria heap alla JVM (tratteremo l’ottimizzazione più avanti).

Configurare GroupDocs.Signature per Java

Integrare GroupDocs.Signature nel tuo progetto è semplice—scegli lo strumento di build preferito e segui le istruzioni.

Usare Maven

Aggiungi questa dipendenza al tuo file pom.xml:

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

Dopo aver aggiunto la dipendenza, esegui mvn clean install per scaricare la libreria.

Usare Gradle

Inserisci questa riga nel tuo file build.gradle:

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

Quindi sincronizza il progetto Gradle o esegui gradle build.

Alternativa di download diretto

Non usi uno strumento di build? Puoi scaricare il JAR direttamente da GroupDocs.Signature for Java releases e aggiungerlo manualmente al classpath. (Anche se Maven o Gradle ti risparmieranno mal di testa in futuro.)

Passaggi per l’acquisizione della licenza

GroupDocs.Signature offre opzioni di licenza flessibili:

  • Prova gratuita: Perfetta per i test—inizia subito senza carta di credito richiesta
  • Licenza temporanea: Hai bisogno di più tempo per valutare? Richiedi una licenza temporanea di 30 giorni per accesso illimitato
  • Acquisto: Quando sei pronto per la produzione, ottieni una licenza permanente dalla GroupDocs Purchase Page

Consiglio da esperto: Inizia con la prova gratuita per esplorare tutte le funzionalità. La licenza temporanea rimuove filigrane e limitazioni se ti serve più tempo per la valutazione.

Che cos’è la classe Signature?

Signature è il punto di ingresso principale per tutte le operazioni in GroupDocs.Signature. Incapsula il caricamento dei documenti, la gestione dei formati e l’elaborazione delle firme. La classe fornisce metodi per aprire documenti, recuperare i formati supportati e applicare o verificare firme su molti tipi di file.

Ecco come inizializzare GroupDocs.Signature nella tua applicazione Java:

import com.groupdocs.signature.Signature;

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

Questo crea un oggetto signature per il documento specificato. Userai questo schema quando lavori con documenti reali, ma per recuperare i formati supportati non ti servirà un file specifico (vedrai come nella sezione successiva).

Guida all’implementazione

Qui le cose diventano pratiche. Costruiremo una semplice utility che recupera tutti i formati di file supportati—una sorta di “controllo di compatibilità” per la tua pipeline di elaborazione documenti.

Perché è importante

Prima di spendere tempo nello sviluppo di funzionalità di elaborazione, devi sapere quali tipi di file la tua libreria supporta. Questa implementazione ti fornisce quell’informazione dinamicamente, il che significa:

  • Nessun hard‑coding di liste di estensioni che diventano obsolete
  • Validazione facile degli upload degli utenti rispetto ai formati supportati
  • Riferimento rapido per costruire filtri di tipo file nella tua UI

Implementazione passo‑passo

1. Importare le classi necessarie

FileType è il gateway al rilevamento dei formati—contiene tutti i metadati sui tipi di documento supportati. Il metodo Signature.getSupportedFileTypes() restituisce una collezione di oggetti FileType che rappresentano ogni formato gestito dalla libreria.

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

2. Creare la classe di recupero

Ecco l’implementazione completa:

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

Cosa succede:

  • Signature.getSupportedFileTypes() interroga il registro interno della libreria e restituisce una lista completa di formati supportati come oggetti FileType.
  • Il ciclo itera su ogni formato e ne stampa l’estensione (es. .pdf, .docx, .xlsx).
  • Ogni oggetto FileType contiene anche metadati aggiuntivi a cui puoi accedere (li esploreremo sotto).

Oltre le semplici estensioni

L’oggetto FileType fornisce più delle sole estensioni. Ecco cosa altro puoi recuperare:

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

Questo è utile quando devi mostrare nomi di formato leggibili dall’utente o raggruppare i formati per tipo (documenti vs. fogli di calcolo vs. immagini).

Come java verifica estensione file?

Carica il nome del file, estrai il suo suffisso e confrontalo con la lista memorizzata nella cache restituita da Signature.getSupportedFileTypes(). Questo approccio a due step garantisce che tu stia verificando rispetto a un catalogo aggiornato anziché a un array hard‑coded. Previene anche le estensioni falsificate perché GroupDocs.Signature valida l’intestazione del file prima di qualsiasi ulteriore elaborazione, assicurando che il contenuto corrisponda davvero al tipo dichiarato.

Che cos’è GroupDocs.Signature?

GroupDocs.Signature è una libreria Java che consente agli sviluppatori di aggiungere, verificare e gestire firme digitali su più di 50 formati di documento. Fornisce un’API unificata per PDF, Office, immagini e molti altri tipi, gestendo scenari di validazione complessi come file criptati, documenti protetti da password e firme su più pagine. La libreria offre anche il rilevamento di formato basato sul contenuto, che aiuta a prevenire l’elaborazione di file rinominati malevolmente.

Perché usare il rilevamento basato su libreria invece dei metodi integrati di Java?

Il rilevamento basato su libreria ispeziona l’intestazione reale del file e la sua struttura interna, garantendo che il contenuto corrisponda davvero al formato dichiarato. I metodi integrati come Files.probeContentType o i semplici controlli di suffisso possono essere ingannati rinominando eseguibili maligni in .pdf. GroupDocs.Signature elimina questo rischio eseguendo un’analisi approfondita del contenuto prima di qualsiasi altra operazione, fornendo una garanzia di sicurezza superiore per la tua applicazione.

Quando dovrei memorizzare nella cache i formati di file supportati?

Cachea la lista dei formati all’avvio dell’applicazione o al primo utilizzo, e riutilizza la collezione immutabile per tutta la vita della JVM. La cache è particolarmente vantaggiosa in servizi web ad alto throughput dove ogni richiesta potrebbe altrimenti attivare l’inizializzazione pesante della libreria, aggiungendo millisecondi di latenza per chiamata. Memorizzando la lista una sola volta, riduci l’overhead CPU e migliori i tempi di risposta complessivi.

Come gestire formati di file non supportati in Java?

Rileva il formato non supportato subito, registra il tentativo per scopi di audit e restituisci un messaggio d’errore chiaro all’utente che elenchi le estensioni consentite. Questo approccio migliora l’esperienza utente e riduce il carico di elaborazione inutile sul backend, fornendo al contempo al team di sicurezza visibilità su eventuali tentativi di abuso.

Quando usare questo approccio

Casi d’uso perfetti

1. Costruire validator per upload di documenti
Quando gli utenti caricano file nella tua applicazione, vuoi validare i formati lato server (mai fidarsi solo della validazione client). Questo approccio ti consente di verificare contro una lista completa di formati supportati prima dell’elaborazione.

2. Creare filtri dinamici per tipi di file
Stai costruendo un selettore di file o un’interfaccia di upload? Genera la lista dei formati consentiti dinamicamente invece di mantenere un array statico che può andare fuori sync con le capacità della libreria.

3. Pipeline di elaborazione documenti multi‑formato
Se elabori documenti provenienti da varie fonti (allegati email, storage cloud, upload utenti), hai bisogno di un rilevamento affidabile per instradare i file ai gestori appropriati.

4. Integrazione con servizi di storage cloud
Quando sincronizzi con AWS S3, Google Drive o Azure Blob Storage, valida la compatibilità dei documenti prima di scaricarli e processarli—risparmia banda e tempo di elaborazione.

Quando i metodi integrati di Java possono bastare

Per scenari più semplici, gli approcci nativi di Java potrebbero essere sufficienti:

  • Controllo solo dell’estensione: file.getName().endsWith(".pdf")
  • Rilevamento MIME: Files.probeContentType(path)
  • Validazione base: Quando controlli la fonte di upload e ti fidi delle estensioni

Nota importante: I metodi integrati possono essere ingannati. Un file rinominato da malicious.exe a document.pdf supererà il controllo dell’estensione ma fallirà la validazione corretta. GroupDocs.Signature esegue un’ispezione più profonda.

Problemi comuni e troubleshooting

Problema 1: Lista vuota o null restituita

Sintomo: Signature.getSupportedFileTypes() restituisce una lista vuota o null.

Cause e soluzioni:

  • Libreria non inizializzata correttamente – verifica che la dipendenza Maven/Gradle sia aggiunta e sincronizzata.
  • Compatibilità di versione – assicurati di usare la versione 23.12 o successiva (le versioni precedenti possono avere API diverse).
  • Problemi di classpath – se usi JAR manuali, conferma che siano correttamente aggiunti al classpath.

Correzione rapida:

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

Problema 2: Formato atteso mancante

Sintomo: Un formato che ti aspetti non compare nella lista supportata.

Possibili ragioni:

  • Stai usando un formato specializzato che richiede plugin aggiuntivi (alcuni formati CAD o di imaging medico necessitano moduli separati).
  • Il formato è stato aggiunto in una versione più recente—controlla le note di rilascio.
  • Il formato è supportato per la lettura ma non per le operazioni di firma (GroupDocs.Signature è principalmente per aggiungere firme; non tutte le operazioni supportano tutti i formati allo stesso modo).

Approccio di debug:

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

Problema 3: Degrado delle prestazioni con liste di formati grandi

Sintomo: Chiamare ripetutamente Signature.getSupportedFileTypes() rallenta l’applicazione.

Soluzione: Cachea i risultati! Questa lista non cambia durante il runtime:

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

Problema 4: Limitazioni legate alla licenza

Sintomo: Ricevi avvisi di valutazione o supporto limitato a certi formati.

Soluzione:

  • Applica la licenza prima di chiamare qualsiasi metodo GroupDocs.
  • Verifica che il percorso del file di licenza sia corretto.
  • Controlla la data di scadenza se usi una licenza a tempo limitato.
try {
    License license = new License();
    license.setLicense("path/to/GroupDocs.Signature.lic");
} catch (Exception e) {
    System.err.println("License error: " + e.getMessage());
}

Best practice per il rilevamento del formato file

1. Valida subito, fallisci velocemente

Controlla i formati dei file il più presto possibile nella pipeline di elaborazione:

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. Fornisci feedback chiaro all’utente

Quando rifiuti un file, indica all’utente esattamente quali formati SONO supportati:

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

3. Non fidarti solo delle estensioni

Un file rinominato da .exe a .pdf avrà l’estensione .pdf ma non sarà un PDF valido. GroupDocs.Signature valida il contenuto reale, non solo l’estensione—ma dovresti comunque combinare gli approcci:

// 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. Gestisci le eccezioni in modo elegante

La validazione può fallire per molte ragioni oltre ai formati non supportati:

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. Monitora i cambiamenti di supporto ai formati

Quando aggiorni la libreria GroupDocs.Signature, controlla le note di rilascio per:

  • Nuovi formati supportati
  • Formati deprecati
  • Cambiamenti nel comportamento del rilevamento

Considera di aggiungere test unitari che verifichino che i formati attesi siano supportati:

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

Considerazioni sulle prestazioni

Ottimizzare il rilevamento del formato file può sembrare un dettaglio, ma conta quando si elaborano migliaia di documenti o upload concorrenti.

Gestione della memoria

Strategia di cache: Come già accennato, cachea la lista dei formati supportati:

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

Perché è importante: Caricare la lista comporta riflessione e inizializzazione interna della libreria. Farlo una sola volta salva cicli CPU e allocazioni di memoria.

Linee guida sull’uso delle risorse

Per scenari ad alto volume:

  • Usa una cache thread‑safe per le liste di formati (l’esempio sopra è thread‑safe poiché immutabile).
  • Considera l’inizializzazione lazy se la tua applicazione non ha sempre bisogno del rilevamento.
  • Quando elabori documenti, chiudi prontamente gli oggetti Signature per liberare risorse.
try (Signature signature = new Signature(filePath)) {
    // Process document
} // Automatically closed, resources freed

Ottimizzazione per elaborazione batch

Se devi validare più file, valuta la parallelizzazione:

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

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

Attenzione: Non esagerare con il parallelismo. Se il collo di bottiglia è I/O (lettura da disco), troppe thread non aiuteranno. Testa per trovare il numero ottimale di thread.

Suggerimenti per il tuning della JVM

Per applicazioni con molti documenti:

  • Aumenta la heap size: -Xmx2g (adatta in base alle tue esigenze).
  • Monitora il garbage collection: usa -XX:+PrintGCDetails per identificare problemi.
  • Considera G1GC per pause più brevi: -XX:+UseG1GC.

Applicazioni pratiche e integrazioni

Esaminiamo scenari reali in cui il rilevamento del formato file è fondamentale.

1. Sistemi di gestione documenti

Scenario: Gli utenti caricano documenti che devono essere indicizzati, elaborati e archiviati.

Pattern di implementazione:

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. Integrazione con storage cloud

Scenario: Sincronizzare documenti da AWS S3 o Google Drive ed elaborare solo i formati supportati.

Perché è utile: Evita di scaricare e tentare di processare file non supportati, risparmiando banda e tempo di elaborazione.

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. Automazione dei workflow aziendali

Scenario: Instradare i documenti attraverso pipeline diverse in base al tipo.

Esempio: PDF verso workflow di firma, fogli di calcolo verso estrazione dati, immagini verso 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. Costruire picker di tipo file

Scenario: Creare componenti UI con supporto dinamico ai formati.

Esempio di integrazione frontend:

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

Il tuo frontend può quindi usare queste informazioni per configurare i componenti di upload:

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

Domande frequenti

D: Come aggiorno la versione della libreria GroupDocs.Signature in Maven?
R: Modifica il tag <version> nel tuo pom.xml con la versione desiderata, poi esegui mvn clean install. Controlla sempre le note di rilascio per eventuali breaking change.

D: GroupDocs.Signature può rilevare il formato anche se l’estensione è sbagliata?
R: Sì. La libreria esegue una validazione basata sul contenuto, quindi un file rinominato da .exe a .pdf verrà rifiutato come non valido PDF durante l’elaborazione. getSupportedFileTypes() elenca solo i formati gestibili; devi comunque provare ad aprire il file per verificare il vero tipo.

D: Qual è la differenza tra prova gratuita e licenza temporanea?
R: La prova gratuita fornisce accesso immediato ma include filigrane di valutazione e alcune limitazioni di funzionalità. Una licenza temporanea offre accesso completo per 30 giorni senza filigrane, ideale per test approfonditi in un ambiente quasi di produzione.

D: Come devo gestire i formati non supportati nella mia applicazione?
R: Restituisci un errore conciso tipo “Formato non supportato. Le estensioni consentite sono: .pdf, .docx, .xlsx, .png, .jpg.” Registra l’incidente per il monitoraggio di sicurezza e considera di mostrare all’utente un tooltip con i tipi consentiti.

D: GroupDocs.Signature funziona con file criptati o protetti da password?
R: Sì, ma devi fornire la password quando crei l’istanza Signature. Il rilevamento del formato stesso non richiede la password, ma qualsiasi elaborazione successiva (es. aggiunta di firma) ne avrà bisogno.

D: Esiste una community o un forum di supporto per GroupDocs.Signature?
R: Certamente! Visita il GroupDocs Forum per discussioni, esempi di codice e risposte dirette dal team di GroupDocs.

Risorse

Documentazione:

Download e licenze:

Supporto e community:

Ultimo aggiornamento: 2026-08-19
Testato con: GroupDocs.Signature 23.12 per Java
Autore: 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);

Tutorial correlati