controllare l’estensione del file java – Rilevamento del formato file Java: convalida e verifica dei tipi di documento

Una delle attività più comuni è controllare l’estensione del file java prima di elaborare un documento.

Hai mai caricato un file solo per far crashare la tua applicazione perché non era nel formato previsto? Non sei solo. Rilevare e convalidare i formati dei file in Java è fondamentale per costruire applicazioni di elaborazione documenti robuste, ma è più complicato rispetto al 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 potente libreria che va oltre il semplice controllo delle estensioni. Che tu stia costruendo un sistema di gestione documenti, convalidando i caricamenti 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 utilizzare il rilevamento basato su libreria rispetto agli approcci Java integrati
  • Errori comuni nella convalida dei tipi di file (e come evitarli)
  • Scenari di integrazione reali e consigli per l’ottimizzazione delle prestazioni
  • Strategie di risoluzione dei problemi per i problemi di rilevamento del formato

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

Risposte rapide

  • Qual è il modo più veloce per controllare l’estensione del file java? Usa Signature.getSupportedFileTypes() per recuperare l’elenco completo e confrontare l’estensione del file con esso.
  • Ho bisogno di una licenza per usare GroupDocs.Signature? Una prova gratuita è sufficiente per lo sviluppo; una licenza permanente rimuove tutti i limiti di valutazione.
  • Posso convalidare i caricamenti senza leggere l’intero file? Sì—GroupDocs.Signature ispeziona l’intestazione del file, il che è molto meno costoso 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.

Prerequisiti

Prima di approfondire il rilevamento del formato file, assicurati di avere questi elementi essenziali pronti:

Librerie richieste e versioni

  • GroupDocs.Signature Library: Versione 23.12 o successiva (useremo l’ultima versione 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

  • Concetti di base della programmazione Java (classi, cicli, import)
  • Uso di Maven o Gradle per gestire le dipendenze
  • Esecuzione di applicazioni Java dal tuo IDE o dalla riga di comando

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

Con l’ambiente pronto, passiamo alla configurazione di GroupDocs.Signature nel tuo progetto.

Configurazione di GroupDocs.Signature per Java

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

Utilizzo di 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.

Utilizzo di Gradle

Inserisci questa riga nel tuo file build.gradle:

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

Quindi sincronizza il tuo progetto Gradle o esegui gradle build.

Alternativa di download diretto

Non stai usando uno strumento di build? Puoi scaricare il JAR direttamente da GroupDocs.Signature for Java releases e aggiungerlo manualmente al tuo classpath. (Anche se, onestamente, usare Maven o Gradle ti eviterà problemi in futuro.)

Passaggi per l’acquisizione della licenza

GroupDocs.Signature offre opzioni di licenza flessibili:

  • Free Trial: Perfetto per i test—inizia subito senza carta di credito no credit card required
  • Temporary License: Hai bisogno di più tempo per valutare? Richiedi una licenza temporanea di 30 giorni per accesso illimitato
  • Purchase: Quando sei pronto per la produzione, acquista una licenza permanente dalla GroupDocs Purchase Page

Consiglio professionale: Inizia con la prova gratuita per esplorare tutte le funzionalità. La licenza temporanea rimuove filigrane e limitazioni se hai bisogno di più tempo per la valutazione.

Inizializzazione e configurazione di base

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.

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 modello quando lavori con documenti reali, ma per recuperare i formati supportati non avrai bisogno di un file specifico (te lo mostreremo nella sezione successiva).

Ora che la configurazione è completa, implementiamo la funzionalità principale per rilevare e recuperare i formati di file supportati.

Guida all’implementazione

Qui entra in gioco la parte pratica. Costruiremo una semplice utility che recupera tutti i formati di file supportati—pensala come un “controllo di compatibilità” per il tuo flusso di elaborazione dei documenti.

Perché è importante

Prima di spendere tempo implementando funzionalità di elaborazione documenti, devi sapere quali tipi di file supporta la tua libreria. Questa implementazione ti fornisce quell’informazione in modo dinamico, il che significa:

  • Nessun elenco di estensioni hardcoded che diventa obsoleto
  • Facile convalida dei caricamenti degli utenti rispetto ai formati supportati
  • Riferimento rapido per costruire filtri di tipo file nella tua UI

Implementazione passo‑passo

1. Importa le classi necessarie

FileType è il gateway per il rilevamento dei formati—contiene tutti i metadati sui tipi di documento supportati.

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

La classe FileType è il descrittore di GroupDocs.Signature per ogni formato supportato, esponendo proprietà come estensione, tipo MIME e descrizione.

2. Crea 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 qui:

  • getSupportedFileTypes(): Questo metodo statico interroga il registro interno della libreria e restituisce un elenco completo dei formati supportati come oggetti FileType
  • Il ciclo itera su ogni formato e ne stampa l’estensione (come .pdf, .docx, .xlsx)
  • Ogni oggetto FileType contiene anche metadati aggiuntivi a cui puoi accedere (li esploreremo più avanti)

Oltre le estensioni di base

L’oggetto FileType ti fornisce più delle sole estensioni. Ecco cos’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).

Quando utilizzare questo approccio

Non ogni situazione richiede una soluzione basata su libreria. Ecco quando il rilevamento del formato di GroupDocs.Signature brilla:

Casi d’uso perfetti

1. Costruire validatori di caricamento documenti
Quando gli utenti caricano file nella tua applicazione, vuoi convalidare i formati lato server (non fidarti mai solo della validazione lato client). Questo approccio ti consente di verificare rispetto a un elenco completo di formati supportati prima dell’elaborazione.

2. Creare filtri dinamici di tipo file
Stai costruendo un selettore di file o un’interfaccia di caricamento? Genera dinamicamente l’elenco dei formati consentiti invece di mantenere un array statico che può non essere più sincronizzato con le capacità della tua libreria.

3. Pipeline di elaborazione documenti multi‑formato
Se elabori documenti da varie fonti (allegati email, storage cloud, caricamenti utenti), hai bisogno di un rilevamento affidabile del formato per indirizzare 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à del documento prima di scaricare ed elaborare i file—risparmia larghezza di banda e tempo di elaborazione.

Quando le funzionalità integrate di Java possono bastare

Per scenari più semplici, gli approcci integrati di Java potrebbero bastare:

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

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

Problemi comuni e risoluzione

Ecco i problemi che potresti incontrare e come risolverli rapidamente.

Problema 1: Elenco vuoto o nullo restituito

Sintomo: getSupportedFileTypes() restituisce un elenco vuoto o null.

Cause e soluzioni:

  • Libreria non inizializzata correttamente: Verifica che la dipendenza Maven/Gradle sia aggiunta correttamente e sincronizzata
  • Compatibilità della versione: Assicurati di usare la versione 23.12 o successiva (le versioni precedenti potrebbero avere API diverse)
  • Problemi di classpath: Se usi file JAR manuali, conferma che siano aggiunti correttamente 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 previsto mancante

Sintomo: Un formato che ti aspetti di supportare non è presente nell’elenco supportato.

Possibili ragioni:

  • Stai usando un formato specializzato che richiede plugin aggiuntivi (alcuni formati CAD o di imaging medico necessitano di 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 elenchi di formati grandi

Sintomo: Chiamare ripetutamente getSupportedFileTypes() rallenta la tua applicazione.

Soluzione: Metti nella cache i risultati! Questo elenco non cambia durante l’esecuzione:

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: Ricevere avvisi di valutazione o supporto limitato ai formati.

Soluzione:

  • Applica la tua licenza prima di chiamare qualsiasi metodo GroupDocs
  • Verifica che il percorso del file di licenza sia corretto
  • Controlla la data di scadenza della licenza 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

Segui queste linee guida per costruire un rilevamento del formato robusto e manutenibile nelle tue applicazioni.

1. Convalida presto, fallisci velocemente

Verifica i formati dei file il più presto possibile nella tua 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 file, informa gli utenti 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 dei file

Un file rinominato da .exe a .pdf avrà un’estensione .pdf ma non sarà un PDF valido. GroupDocs.Signature convalida il contenuto reale, non solo le estensioni—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 convalida dei file 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 del supporto ai formati

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

  • Nuovi formati supportati
  • Supporto a formati deprecati
  • Comportamento modificato nel rilevamento dei formati

Considera di aggiungere test unitari che verificano 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 è importante quando si elaborano migliaia di documenti o si gestiscono caricamenti concorrenti.

Gestione della memoria

Strategia di caching: Come accennato prima, metti nella cache l’elenco 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 l’elenco dei formati richiede 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 gli elenchi di formati (l’esempio sopra è thread‑safe poiché è immutabile)
  • Considera l’inizializzazione lazy se la tua applicazione non ha sempre bisogno del rilevamento dei formati
  • Durante l’elaborazione dei documenti, chiudi prontamente gli oggetti Signature per liberare risorse
try (Signature signature = new Signature(filePath)) {
    // Process document
} // Automatically closed, resources freed

Ottimizzazione dell’elaborazione batch

Se convalidi più file, considera 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 sovraparallelizzare. Se sei limitato da I/O (lettura da disco), troppi thread non aiuteranno. Testa per trovare il numero ottimale di thread.

Suggerimenti per il tuning della JVM

Per applicazioni con molti documenti:

  • Aumenta la dimensione dell’heap: -Xmx2g (adatta in base alle tue esigenze)
  • Monitora la garbage collection: Usa -XX:+PrintGCDetails per identificare problemi
  • Considera G1GC per tempi di pausa migliori: -XX:+UseG1GC

Applicazioni pratiche e integrazione

Esaminiamo scenari reali in cui il rilevamento del formato file diventa essenziale.

1. Sistemi di gestione documenti

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

Modello 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 elaborare file non supportati, risparmiando larghezza di 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 flussi di lavoro aziendali

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

Esempio: I PDF vanno al flusso di lavoro di firma, i fogli di calcolo all’estrazione dati, le immagini all’elaborazione 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. Creazione di selettori 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 questo per configurare i componenti di caricamento file:

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

Come controllare l’estensione del file java?

Carica il nome del file, estrai il suo suffisso e confrontalo con l’elenco memorizzato nella cache restituito da Signature.getSupportedFileTypes(). Questo approccio a due passaggi garantisce che tu stia verificando rispetto a un catalogo aggiornato anziché a un array hard‑coded. Previene anche le estensioni falsificate perché GroupDocs.Signature convalida l’intestazione del file prima di qualsiasi ulteriore elaborazione.

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 convalida complessi come file crittografati, documenti protetti da password e firme multi‑pagina.

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, assicurando che il contenuto corrisponda davvero al formato dichiarato. Metodi integrati come Files.probeContentType o semplici controlli di suffisso di stringa possono essere ingannati rinominando eseguibili dannosi in .pdf. GroupDocs.Signature elimina questo rischio eseguendo un’analisi approfondita del contenuto prima di qualsiasi ulteriore elaborazione.

Quando dovrei memorizzare nella cache i formati di file supportati?

Metti nella cache l’elenco dei formati all’avvio dell’applicazione o al primo utilizzo, e riutilizza la collezione immutabile per tutta la durata della JVM. Il caching è particolarmente vantaggioso nei servizi web ad alto throughput dove ogni richiesta altrimenti attiverebbe un’inizializzazione della libreria pesante di riflessione, aggiungendo millisecondi di latenza per chiamata.

Come gestire i formati di file non supportati in Java?

Rileva il formato non supportato in anticipo, registra il tentativo per scopi di audit e restituisci un messaggio di errore chiaro all’utente che elenca le estensioni consentite. Questo approccio migliora l’esperienza dell’utente e riduce il carico di elaborazione non necessario sul tuo backend.

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 release notes per le modifiche incompatibili.

D: GroupDocs.Signature può rilevare i formati dei file anche se l’estensione è errata?
R: Sì. La libreria esegue una convalida 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 che la libreria può gestire; devi comunque provare ad aprire il file per verificare il suo 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 alcuni limiti di funzionalità. Una licenza temporanea offre accesso completo a tutte le funzionalità per 30 giorni senza filigrane, ideale per test approfonditi in un ambiente simile alla produzione.

D: Come dovrei gestire i formati di file non supportati nella mia applicazione?
R: Restituisci un errore conciso come “Formato non supportato. Le estensioni supportate sono: .pdf, .docx, .xlsx, .png, .jpg.” Registra l’incidente per il monitoraggio della sicurezza e considera di avvisare l’utente con un tooltip UI che elenca i tipi consentiti.

D: GroupDocs.Signature funziona con file crittografati 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 (ad esempio aggiungere una firma) lo richiederà.

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

Risorse

Documentazione:

Download e licenze:

Supporto e community:

Ultimo aggiornamento: 2026-05-11
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