Let’s write.

Come personalizzare l’aspetto della firma con gradiente in Java

Ti sei mai accorto di come alcuni documenti firmati digitalmente appaiano, beh… noiosi? Solo testo semplice su sfondo bianco? Se stai costruendo un’applicazione che richiede firme di documento dall’aspetto professionale—pensa a contratti, fatture o certificati—vorrai qualcosa che risalti pur rimanendo funzionale. In questo tutorial imparerai a personalizzare l’aspetto della firma applicando un pennello a gradiente in Java. Creare una firma digitale a gradiente non solo aggiunge una rifinitura visiva, ma rafforza anche l’identità del brand e migliora l’autenticità percepita.

Risposte rapide

  • Che cos’è una firma digitale a gradiente? Un elemento visivo firmato digitalmente che utilizza un gradiente di colore per lo sfondo o il riempimento del testo.
  • Quale libreria supporta questa funzionalità in Java? GroupDocs.Signature per Java fornisce il supporto integrato ai pennelli a gradiente.
  • I gradienti influiscono sulla sicurezza crittografica? No. Il gradiente è puramente visivo; la firma digitale sottostante rimane invariata.
  • Quale versione di Java è necessaria? JDK 8 o superiore (consigliato JDK 11+).
  • È necessaria una licenza per la produzione? Sì—una licenza valida di GroupDocs.Signature è obbligatoria per l’uso non‑valutativo.

Come personalizzare l’aspetto della firma con un pennello a gradiente in Java

In questa sezione percorreremo l’intero processo—dalla configurazione della libreria all’applicazione di un pennello a gradiente lineare a una firma testuale. Alla fine sarai in grado di creare oggetti di firma digitale a gradiente dall’aspetto curato e in linea con i colori del tuo brand.

Perché utilizzare pennelli a gradiente per le firme digitali?

Prima di immergerci nel codice, parliamo del perché potresti volere effetti a gradiente in primo luogo.

Coerenza del brand: Se la tua azienda utilizza schemi di colore specifici, le firme a gradiente aiutano a mantenere la coerenza visiva in tutti i documenti. Un’azienda di servizi finanziari potrebbe usare gradienti dal blu al bianco per trasmettere fiducia, mentre un’agenzia creativa potrebbe optare per transizioni di colore vivaci.

Gerarchia del documento: Gli effetti a gradiente possono aiutare a distinguere i tipi di firma. Potresti usare gradienti sottili per approvazioni standard e gradienti più marcati per firme esecutive o autorizzazioni legali.

Appeal visivo senza compromessi: Ecco il bello—ottieni uno stile professionale senza sacrificare la sicurezza crittografica della tua firma digitale. Il gradiente è puramente visivo; la validità della firma rimane intatta.

Riduzione della percezione di falsificazione: I documenti con firme stilizzate appaiono spesso più autentici agli utenti finali. Sebbene ciò non aumenti la sicurezza reale, migliora la legittimità percepita (cosa importante per la fiducia dell’utente).

Cosa imparerai

Al termine di questa guida sarai in grado di:

  • Configurare GroupDocs.Signature per Java nel tuo progetto (Maven, Gradle o manuale)
  • Creare firme basate su testo con effetti di pennello a gradiente lineare
  • Personalizzare l’aspetto della firma, posizionamento e trasparenza
  • Risolvere i problemi comuni che possono bloccare gli sviluppatori
  • Ottimizzare le prestazioni per applicazioni in produzione
  • Applicare le migliori pratiche per un codice di firma manutenibile

Prerequisiti

Prima di iniziare, assicurati di avere:

  • Java Development Kit (JDK): Versione 8 o superiore (consiglio JDK 11+ per migliori prestazioni)
  • IDE: IntelliJ IDEA, Eclipse o VS Code con estensioni Java
  • Libreria GroupDocs.Signature per Java: La aggiungeremo tramite Maven o Gradle
  • Conoscenze di base di Java: Dovresti sentirti a tuo agio con oggetti, metodi e gestione delle eccezioni

Librerie richieste

Aggiungi GroupDocs.Signature al tuo progetto usando lo strumento di build preferito.

Per Maven (aggiungi al tuo pom.xml):

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

Per Gradle (aggiungi al tuo build.gradle):

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

Installazione manuale: Se non utilizzi uno strumento di build (anche se lo consiglierei), puoi scaricare il file JAR direttamente da rilasci GroupDocs Signatures e aggiungerlo al classpath del tuo progetto.

Acquisizione della licenza

GroupDocs offre una prova gratuita ideale per test e sviluppo. Per l’uso in produzione, avrai bisogno di una licenza. Ecco come iniziare:

  1. Prova gratuita: Visita Versione di prova GroupDocs per scaricare senza impegni
  2. Licenza temporanea: Ottieni una licenza temporanea di 30 giorni da Licenza temporanea GroupDocs per test completi
  3. Licenza completa: Quando sei pronto per la produzione, consulta le loro opzioni di prezzo

La versione di prova aggiunge filigrane di valutazione, quindi prendi una licenza temporanea se stai costruendo qualcosa destinato ai clienti.

Configurare GroupDocs.Signature per Java

Prepariamo l’ambiente di sviluppo. Questa configurazione funziona sia per un nuovo progetto sia per l’integrazione in un’applicazione esistente.

Passi di installazione

1. Aggiungi la dipendenza (già descritta sopra—Maven o Gradle)

2. Verifica l’installazione creando una semplice classe di test:

import com.groupdocs.signature.Signature;

public class SignatureTest {
    public static void main(String[] args) {
        System.out.println("GroupDocs.Signature loaded successfully!");
    }
}

Se compila senza errori, sei a posto.

3. Configura la struttura delle cartelle dei documenti. Mi piace organizzare così:

project-root/
├── src/
├── resources/
│   ├── input/        // Source documents to sign
│   └── output/       // Signed documents
└── pom.xml (or build.gradle)

4. Inizializzazione di base (qui inizia la magia):

import com.groupdocs.signature.Signature;
import com.groupdocs.signature.exception.GroupDocsSignatureException;

public class BasicSignatureSetup {
    public static void main(String[] args) {
        try {
            // Initialize with your source document path
            Signature signature = new Signature("resources/input/sample.pdf");
            
            // Your signing code will go here
            
            signature.dispose(); // Always clean up resources
        } catch (GroupDocsSignatureException e) {
            System.err.println("Signature error: " + e.getMessage());
            e.printStackTrace();
        } catch (Exception e) {
            System.err.println("General error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Consiglio professionale: Avvolgi sempre l’oggetto Signature in un blocco try‑with‑resources o chiama manualmente dispose(). GroupDocs mantiene handle di file, e dimenticare di rilasciarli provoca errori “file in use” (chiedimi come lo so).

Guida all’implementazione: Creare firme a gradiente

Ora la parte divertente—costruiamo una firma con effetto pennello a gradiente. Partiremo da un esempio semplice e aggiungeremo complessità man mano.

Passo 1: Inizializzare le opzioni della firma

Prima definiamo cosa dirà la nostra firma e come si comporterà. La classe TextSignOptions gestisce le firme basate su testo:

import com.groupdocs.signature.domain.enums.HorizontalAlignment;
import com.groupdocs.signature.domain.enums.VerticalAlignment;
import com.groupdocs.signature.domain.signatures.TextSignOptions;

TextSignOptions options = new TextSignOptions("John Smith");

Questo crea una firma di base con il testo “John Smith”. Semplice, vero? Ma così com’è, sarebbe solo testo nero su sfondo trasparente—noioso. È qui che entrano in gioco i gradienti.

Perché separare le opzioni dall’oggetto firma? Questo pattern consente di riutilizzare la stessa configurazione di firma su più documenti. Configurala una volta, applicala ovunque.

Passo 2: Personalizzare lo sfondo con pennello a gradiente

Qui la tua firma inizia a sembrare professionale. Creeremo un gradiente lineare che passa dal verde al bianco:

import com.groupdocs.signature.domain.Background;
import com.groupdocs.signature.domain.extensions.brushes.LinearGradientBrush;
import java.awt.Color;

// Create the background container
Background background = new Background();
background.setColor(Color.GREEN);        // Fallback color (rarely seen)
background.setTransparency(0.5f);         // 50% transparency (0.0 = opaque, 1.0 = invisible)

// Define the gradient: start color, end color, and angle
LinearGradientBrush brush = new LinearGradientBrush(
    Color.GREEN,    // Start color (left/top)
    Color.WHITE,    // End color (right/bottom)
    45              // Angle in degrees (45 = diagonal)
);

// Apply the brush to the background
background.setBrush(brush);
options.setBackground(background);

Analizziamo cosa succede:

  • Colore di base: setColor(Color.GREEN) imposta un fallback solido. Se i gradienti falliscono (raro, ma possibile), questo colore verrà mostrato.
  • Trasparenza: setTransparency(0.5f) rende la firma semi‑trasparente. È cruciale per i documenti in cui non vuoi coprire il testo sottostante. Valori più vicini a 0 sono più opachi; più vicini a 1 più trasparenti.
  • Angolo del gradiente: Il valore 45 indica che il gradiente scorre diagonalmente dall’angolo in alto a sinistra a quello in basso a destra. Usa 0 per orizzontale (sinistra → destra), 90 per verticale (alto → basso) o qualsiasi angolo intermedio.

Le scelte di colore contano: Verde‑bianco suggerisce approvazione o conferma (pensate ai segnali “go”). Blu‑bianco trasmette fiducia e professionalità. Rosso‑bianco può indicare urgenza o importanza. Scegli colori in linea con lo scopo del documento e l’identità del tuo brand.

Passo 3: Impostare il posizionamento della firma

Ora dobbiamo indicare dove la firma deve apparire nel documento. Il posizionamento è più complesso di quanto sembri perché occorre bilanciare visibilità e non coprire contenuti importanti:

import com.groupdocs.signature.domain.Padding;

// Set signature dimensions (in pixels or points, depending on document)
options.setWidth(100);
options.setHeight(80);

// Center the signature both horizontally and vertically
options.setVerticalAlignment(VerticalAlignment.Center);
options.setHorizontalAlignment(HorizontalAlignment.Center);

// Add margins to fine‑tune positioning
Padding padding = new Padding();
padding.setTop(20);      // 20 units from the alignment point
padding.setRight(20);    // 20 units from the right edge
options.setMargin(padding);

Comprendere allineamento vs. margine: Pensa all’allineamento come punto di ancoraggio e al margine come offset. Se imposti HorizontalAlignment.Center, la firma si centra nella pagina, poi il margine la sposta rispetto a quel punto centrale. Questo approccio a due step offre un controllo preciso.

Pattern di posizionamento comuni:

  • Angolo in basso a destra: HorizontalAlignment.Right, VerticalAlignment.Bottom, con margine superiore negativo
  • Area intestazione: VerticalAlignment.Top, HorizontalAlignment.Right, con padding
  • Centro pagina: Entrambi gli allineamenti impostati su Center, regola i margini a piacere

Considerazioni sulle dimensioni: I valori setWidth(100) e setHeight(80) funzionano per la maggior parte dei documenti standard, ma potresti doverli adeguare in base alle dimensioni del documento e alla lunghezza del testo della firma. Se il testo viene troncato, aumenta la larghezza. Se appare troppo compresso, aumenta l’altezza o riduci la dimensione del carattere.

Passo 4: Applicare la firma e salvare

Infine, firmiamo il documento e salviamo il risultato. Qui tutte le configurazioni si uniscono:

import com.groupdocs.signature.Signature;
import com.groupdocs.signature.domain.SignResult;

try {
    // Initialize signature with source document
    Signature signature = new Signature("resources/input/sample.pdf");
    
    // Apply the signature options we configured above
    SignResult result = signature.sign("resources/output/SignedWithGradient.pdf", options);
    
    // Check the result
    if (result.getSucceeded().size() > 0) {
        System.out.println("Document signed successfully!");
        System.out.println("Signed with " + result.getSucceeded().size() + " signature(s)");
    } else {
        System.out.println("No signatures were applied.");
    }
    
    // Clean up
    signature.dispose();
    
} catch (Exception e) {
    System.err.println("Error signing document: " + e.getMessage());
    e.printStackTrace();
}

Cosa fa il metodo sign()? Prende il documento di origine, applica le opzioni di firma configurate e scrive un nuovo file con la firma incorporata. Il file originale rimane intatto (buona pratica: non modificare mai direttamente i documenti sorgente).

L’oggetto SignResult ti informa su cosa è accaduto. Controlla getSucceeded() per vedere quali firme sono state applicate con successo e getFailed() per individuare eventuali errori.

Esempio completo funzionante

Ecco tutto messo insieme in una singola classe eseguibile che puoi copiare e testare subito:

import com.groupdocs.signature.Signature;
import com.groupdocs.signature.domain.Background;
import com.groupdocs.signature.domain.Padding;
import com.groupdocs.signature.domain.SignResult;
import com.groupdocs.signature.domain.enums.HorizontalAlignment;
import com.groupdocs.signature.domain.enums.VerticalAlignment;
import com.groupdocs.signature.domain.extensions.brushes.LinearGradientBrush;
import com.groupdocs.signature.domain.signatures.TextSignOptions;
import java.awt.Color;

public class GradientSignatureExample {
    public static void main(String[] args) {
        try {
            // Initialize signature object with source document
            Signature signature = new Signature("resources/input/sample.pdf");
            
            // Configure text signature options
            TextSignOptions options = new TextSignOptions("John Smith");
            
            // Create gradient background
            Background background = new Background();
            background.setColor(Color.GREEN);
            background.setTransparency(0.5f);
            
            LinearGradientBrush brush = new LinearGradientBrush(
                Color.GREEN,  // Start color
                Color.WHITE,  // End color
                45            // Angle
            );
            
            background.setBrush(brush);
            options.setBackground(background);
            
            // Set positioning
            options.setWidth(100);
            options.setHeight(80);
            options.setVerticalAlignment(VerticalAlignment.Center);
            options.setHorizontalAlignment(HorizontalAlignment.Center);
            
            Padding padding = new Padding();
            padding.setTop(20);
            padding.setRight(20);
            options.setMargin(padding);
            
            // Sign and save
            SignResult result = signature.sign(
                "resources/output/SignedWithGradient.pdf", 
                options
            );
            
            System.out.println("Success! Signatures applied: " + 
                result.getSucceeded().size());
            
            signature.dispose();
            
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Esegui questo codice con un file PDF nella cartella resources/input/ e otterrai una versione firmata con un bellissimo effetto gradiente.

Casi d’uso comuni

Vediamo quando e dove le firme a gradiente hanno più senso nelle applicazioni reali.

1. Sistemi aziendali di gestione contratti

Scenario: Stai costruendo un flusso di lavoro di approvazione contratti dove più stakeholder firmano documenti in fasi diverse.
Applicazione: Usa colori di gradiente diversi per rappresentare i livelli di approvazione—i responsabili di dipartimento ottengono un gradiente blu‑bianco, i revisori legali un gradiente oro‑bianco, gli esecutivi un gradiente blu scuro‑azzurro. Questa gerarchia visiva aiuta gli utenti a vedere subito chi ha firmato e a che livello.

2. Elaborazione automatica delle fatture

Scenario: Il tuo sistema contabile firma automaticamente le fatture generate prima di inviarle ai clienti.
Applicazione: Un gradiente sottile nei colori del brand rende le fatture più professionali e più difficili da falsificare. Mantieni il gradiente discreto così la fattura resta leggibile.

3. Generazione di certificati

Scenario: Generi certificati di completamento per corsi online o programmi di formazione.
Applicazione: Gradienti vivaci e celebrativi (oro‑giallo o blu‑viola) rendono i certificati ufficiali e degni di condivisione. L’appeal visivo aumenta il valore percepito e incentiva la condivisione sui social.

4. Filigrane dei documenti

Scenario: Devi contrassegnare i documenti come “Bozza”, “Confidenziale” o “Approvato”.
Applicazione: Pur non essendo una firma, puoi riutilizzare la tecnica del gradiente con testo trasparente per creare filigrane accattivanti che non oscurano il contenuto sottostante. Imposta la trasparenza tra 0.7‑0.8 per un effetto sottile.

Risoluzione dei problemi più comuni

Ecco i problemi che ho incontrato (e risolto) lavorando con firme a gradiente. Risparmia tempo di debug.

Problema 1: “File is being used by another process”

Sintomi: L’applicazione lancia un’eccezione che impedisce l’accesso al file, anche se nessun altro programma lo ha aperto.
Causa: Hai dimenticato di chiamare signature.dispose() o di chiudere correttamente l’oggetto Signature. Java mantiene l’handle del file finché l’oggetto non viene garbage‑collected.
Soluzione:

// Always use try‑with‑resources (Java 7+)
try (Signature signature = new Signature("path/to/document.pdf")) {
    // Your signing code here
} catch (Exception e) {
    // Handle errors
}
// File handle automatically released when try block exits

Oppure manualmente:

Signature signature = null;
try {
    signature = new Signature("path/to/document.pdf");
    // Your signing code
} finally {
    if (signature != null) {
        signature.dispose();
    }
}

Problema 2: La firma appare ma il gradiente non è visibile

Sintomi: Vedi il testo della firma, ma è di un colore solido.
Possibili cause:

  1. Il visualizzatore PDF non supporta i gradienti – prova con Adobe Acrobat, Foxit Reader o un browser moderno.
  2. Trasparenza impostata troppo alta – setTransparency(1.0f) rende il gradiente invisibile. Prova 0.3‑0.7.
  3. Pennello non applicato – assicurati di aver chiamato background.setBrush(brush) e options.setBackground(background).

Suggerimento di debug: Usa colori ad alto contrasto (es. Color.RED a Color.BLUE) prima. Se il gradiente non appare comunque, la configurazione è errata, non i colori.

Problema 3: La firma sovrappone contenuti importanti del documento

Sintomi: La firma a gradiente è bella ma copre testo o campi critici.
Soluzione: Regola dinamicamente il posizionamento in base al contenuto del documento. Ecco un pattern che utilizzo:

// For documents with content primarily at the top
options.setVerticalAlignment(VerticalAlignment.Bottom);
Padding padding = new Padding();
padding.setBottom(30);  // Leave space from bottom edge
options.setMargin(padding);

// For documents that need signatures in specific locations
options.setVerticalAlignment(VerticalAlignment.Top);
options.setHorizontalAlignment(HorizontalAlignment.Left);
padding.setTop(600);     // Absolute Y position
padding.setLeft(400);    // Absolute X position
options.setMargin(padding);

Approccio migliore: Analizza prima il documento per trovare spazi vuoti, poi posiziona le firme programmaticamente in quelle aree.

Problema 4: Problemi di prestazioni con documenti di grandi dimensioni

Sintomi: La firma richiede molto tempo per PDF con molte pagine o immagini ad alta risoluzione.
Causa: GroupDocs elabora l’intero documento, e i gradienti complessi aggiungono overhead di rendering.
Soluzioni:

  1. Firma solo pagine specifiche anziché l’intero file.
  2. Usa gradienti più semplici—i gradienti lineari a due colori sono più veloci di quelli radiali o con più stop.
  3. Riduci le dimensioni della firma—larghezza/altezza minori comportano meno lavoro di rendering.
  4. Elabora in modo asincrono—non bloccare il thread principale durante la firma.

Esempio di prestazioni:

// Faster configuration
TextSignOptions options = new TextSignOptions("Approved");
options.setWidth(80);   // Smaller than default 100
options.setHeight(60);  // Smaller than default 80

// Simple horizontal gradient (fastest)
LinearGradientBrush brush = new LinearGradientBrush(
    Color.BLUE, 
    Color.WHITE, 
    0  // Horizontal gradient
);

Problema 5: Il colore non corrisponde alle aspettative

Sintomi: Il gradiente appare diverso da quanto specificato nel codice.
Cause:

  1. Differenze nello spazio colore RGB—Color di Java usa sRGB, ma i PDF possono renderizzare in uno spazio diverso.
  2. Interazioni di trasparenza—I gradienti semi‑trasparenti si mescolano con lo sfondo del documento, alterando il colore percepito.
  3. Calibrazione del monitor—Ciò che vedi sul tuo schermo può differire da quello di altri utenti.

Soluzione: Testa i documenti firmati su più dispositivi e visualizzatori PDF. Se la coerenza del brand è critica, usa valori RGB esatti e verifica su più piattaforme. Mantieni l’opacità intorno a 0.3‑0.5 per ridurre le variazioni di colore.

Best practice per applicazioni in produzione

Ecco ciò che ho imparato usando firme a gradiente in sistemi reali.

1. Centralizzare la configurazione della firma

Non spargere lo styling nel codice. Crea una classe helper:

public class SignatureStyles {
    public static TextSignOptions getApprovalSignature(String signerName) {
        TextSignOptions options = new TextSignOptions(signerName);
        
        Background background = new Background();
        background.setTransparency(0.4f);
        
        LinearGradientBrush brush = new LinearGradientBrush(
            new Color(0, 102, 204),  // Brand blue
            Color.WHITE,
            45
        );
        
        background.setBrush(brush);
        options.setBackground(background);
        
        // Standard positioning
        options.setWidth(100);
        options.setHeight(70);
        
        return options;
    }
    
    // Add more style methods as needed
}

Ora puoi riutilizzare gli stili in modo coerente: SignatureStyles.getApprovalSignature("Jane Doe").

2. Validare i documenti prima di firmare

Controlla sempre che il documento sorgente sia valido:

try {
    Signature signature = new Signature("path/to/document.pdf");
    
    // Validate format
    if (!"PDF".equalsIgnoreCase(signature.getDocumentInfo().getFileType())) {
        throw new IllegalArgumentException("Only PDF files supported");
    }
    
    // Ensure at least one page
    if (signature.getDocumentInfo().getPageCount() < 1) {
        throw new IllegalArgumentException("Document has no pages");
    }
    
    // Proceed with signing...
    
} catch (Exception e) {
    // Handle validation errors
}

3. Registrare le operazioni di firma

Mantieni un audit trail:

SignResult result = signature.sign(outputPath, options);
logger.info("Document signed: " + outputPath);
logger.info("Signatures applied: " + result.getSucceeded().size());
logger.info("Signer: " + signerName);
logger.info("Timestamp: " + LocalDateTime.now());

if (!result.getFailed().isEmpty()) {
    logger.warn("Failed signatures: " + result.getFailed().size());
}

4. Gestire le eccezioni in modo elegante

Non lasciare che un fallimento di firma blocchi il servizio:

try {
    SignResult result = signature.sign(outputPath, options);
    return result.getSucceeded().size() > 0;
} catch (GroupDocsSignatureException e) {
    logger.error("Signature error: " + e.getMessage());
    return false;
} catch (IOException e) {
    logger.error("File I/O error: " + e.getMessage());
    return false;
} catch (Exception e) {
    logger.error("Unexpected error during signing: " + e.getMessage());
    return false;
}

5. Testare con documenti reali

Non limitarti ai PDF di esempio. Usa file reali del tuo flusso di lavoro:

  • Moduli con campi esistenti
  • Contratti multi‑pagina
  • Immagini scansionate (PDF basati su immagini)
  • Documenti che già contengono firme

Ogni tipologia può comportarsi diversamente con il rendering dei gradienti.

Pro tip per utenti avanzati

Pronto a fare il salto di qualità? Ecco alcune tecniche avanzate.

Tip 1: Creare schemi di colore personalizzati

Definisci palette di brand una sola volta e riutilizzale:

public class BrandColors {
    public static final Color PRIMARY   = new Color(0, 102, 204);
    public static final Color SECONDARY = new Color(102, 178, 255);
    public static final Color ACCENT    = new Color(255, 193, 7);
    
    public static LinearGradientBrush getPrimaryGradient(int angle) {
        return new LinearGradientBrush(PRIMARY, Color.WHITE, angle);
    }
}

Tip 2: Trasparenza dinamica in base al tipo di documento

public static float getOptimalTransparency(Signature signature) {
    if (hasComplexBackground(signature)) {
        return 0.6f; // More transparent for image‑heavy docs
    }
    return 0.4f;
}

Tip 3: Elaborazione batch con thread pool

ExecutorService executor = Executors.newFixedThreadPool(4);
List<String> files = getDocumentsToSign();

for (String file : files) {
    executor.submit(() -> {
        try {
            signDocument(file);
        } catch (Exception e) {
            logger.error("Failed to sign: " + file, e);
        }
    });
}
executor.shutdown();
executor.awaitTermination(5, TimeUnit.MINUTES);

Tip 4: Styling condizionale in base al tipo di firma

public static TextSignOptions getStyledSignature(String name, SignatureType type) {
    TextSignOptions options = new TextSignOptions(name);
    LinearGradientBrush brush;
    switch (type) {
        case APPROVAL:   brush = new LinearGradientBrush(Color.GREEN, Color.WHITE, 45); break;
        case REJECTION:  brush = new LinearGradientBrush(Color.RED,   Color.WHITE, 45); break;
        case REVIEW:     brush = new LinearGradientBrush(Color.ORANGE,Color.WHITE,45); break;
        default:         brush = new LinearGradientBrush(Color.BLUE,  Color.WHITE,45);
    }
    Background bg = new Background();
    bg.setBrush(brush);
    bg.setTransparency(0.5f);
    options.setBackground(bg);
    return options;
}

Domande frequenti

D: Posso usare questo in un servizio Java basato sul web?
R: Sì. GroupDocs.Signature è puro Java e funziona in qualsiasi backend Java, inclusi Spring Boot o Jakarta EE.

D: Il gradiente influisce sulla dimensione del PDF firmato?
R: Solo marginalmente. Il gradiente è memorizzato nello stream di aspetto visivo, aggiungendo tipicamente qualche kilobyte.

D: Come firmo PDF protetti da password?
R: Passa la password quando crei l’oggetto Signature: new Signature("file.pdf", "password").

D: È possibile applicare il gradiente a una firma basata su immagine anziché su testo?
R: Assolutamente. Usa ImageSignOptions e imposta il suo Background con un LinearGradientBrush proprio come nell’esempio testuale.

D: E se mi serve un gradiente radiale invece di lineare?
R: Attualmente GroupDocs supporta solo LinearGradientBrush. Per effetti radiali, puoi pre‑creare un’immagine con gradiente radiale e usarla come sfondo.

Ultimo aggiornamento: 2026-03-14
Testato con: GroupDocs.Signature 23.12 per Java
Autore: GroupDocs