Hoe Java-bestanden te ondertekenen met barcodes en QR-codes
Introductie
Heb je je ooit afgevraagd hoe je kunt bewijzen dat je bestanden niet zijn gemanipuleerd met how to sign java‑technieken? Of had je een manier nodig om documenten programmatisch te authenticeren zonder complexe cryptografische instellingen? Traditionele digitale handtekeningen kunnen overkill zijn voor bepaalde use‑cases. Soms heb je gewoon een lichte, scanbare methode nodig om de bestandsintegriteit te verifiëren—vooral bij archieven, back‑ups of geautomatiseerde workflows. Daar komen barcode‑ en QR‑codehandtekeningen om de hoek kijken.
In deze tutorial leer je hoe je how to sign java implementeert met GroupDocs.Signature. We richten ons op het ondertekenen van TAR‑archieven (perfect voor back‑upsystemen en software‑distributie), maar deze technieken werken met verschillende documentformaten. Of je nu een documentbeheersysteem bouwt of gewoon een extra beveiligingslaag aan je bestanden wilt toevoegen, je bent op de juiste plek.
Wat je mee krijgt:
- Een werkende implementatie van barcode‑ en QR‑codehandtekeningen in Java
- Begrip van wanneer elk handtekeningtype te gebruiken (en waarom het belangrijk is)
- Praktische oplossingen voor veelvoorkomende ondertekeningsuitdagingen
- Realtime integratiepatronen die je vandaag kunt gebruiken
- Prestatie‑optimalisatietips voor productiesystemen
Laten we beginnen—geen cryptografie‑diploma vereist.
Snelle antwoorden
- Welke bibliotheek verwerkt barcode‑handtekeningen in Java? GroupDocs.Signature for Java.
- Welk handtekeningtype slaat meer data op? QR‑codes (tot 4.296 alfanumerieke tekens).
- Kan ik grote TAR‑bestanden (>100 MB) ondertekenen? Ja—gebruik achtergrondthreads en vergroot de JVM‑heap.
- Heb ik een internetverbinding nodig? Nee, de bibliotheek werkt volledig offline.
- Is een licentie vereist voor productie? Ja, een geldige GroupDocs.Signature‑licentie is verplicht.
Wat is digitale handtekening java?
Digitale handtekening java is het proces waarbij een verifieerbaar visueel token—zoals een barcode of QR‑code—direct in een door Java gegenereerd bestand wordt ingebed om de authenticiteit en integriteit te bewijzen, waardoor een snelle, door mensen leesbare bevestiging ontstaat dat het bestand niet is gewijzigd sinds het ondertekend werd, terwijl programmatische verificatie via de GroupDocs.Signature‑API mogelijk blijft.
Waarom barcodes of QR‑codehandtekeningen gebruiken?
GroupDocs.Signature ondersteunt meer dan 50 invoer‑ en uitvoerformaten (inclusief PDF, DOCX, XLSX, HTML, PNG en TAR) en kan documenten van honderden pagina’s verwerken zonder het volledige bestand in het geheugen te laden. Barcodes en QR‑codes bieden een scanbare, zelf‑behorende bewijs van authenticiteit, waardoor de noodzaak voor externe certificaatautoriteiten in veel interne workflows wordt geëlimineerd.
| Factor | Barcode (Code128) | QR‑code |
|---|---|---|
| Gegevenscapaciteit | ~80 tekens | Tot 4.296 alfanumerieke tekens |
| Leesbaarheid | Vereist barcode‑scanner | Werkt met smartphone‑camera’s |
| Ruimte‑efficiëntie | Meer compact horizontaal | Vereist vierkante ruimte |
| Beste voor | Eenvoudige ID’s, tijdstempels, korte codes | URL’s, JSON‑data, gedetailleerde metadata |
| Foutcorrectie | Minimaal | Ingebouwd (kan herstellen van schade) |
Rule of thumb:
- Gebruik barcodes voor snelle, scanbare ID’s of tijdstempels.
- Gebruik QR‑codes wanneer je rijkere data wilt embedden of smartphone‑compatibiliteit nodig hebt.
- Combineer beide voor maximale redundantie en auditbaarheid.
Voorvereisten
- GroupDocs.Signature for Java Library – versie 23.12 of hoger
- Java Development Kit (JDK) – versie 8 of hoger
- IDE – IntelliJ IDEA, Eclipse, of een Java‑compatibele editor
- Basis Java‑kennis – je moet vertrouwd zijn met klassen en imports
Omgevingsconfiguratie
GroupDocs.Signature in je project krijgen is eenvoudig. Kies je build‑tool:
Maven (voeg dit toe aan je pom.xml):
<dependency>
<groupId>com.groupdocs</groupId>
<artifactId>groupdocs-signature</artifactId>
<version>23.12</version>
</dependency>
Gradle (voeg toe aan je build.gradle):
implementation 'com.groupdocs:groupdocs-signature:23.12'
Handmatige download: Gebruik je geen Maven of Gradle? Haal de JAR direct van GroupDocs.Signature releases en voeg deze toe aan je classpath.
Licentie‑acquisitie
GroupDocs biedt flexibele licenties:
- Gratis proefversie: Perfect voor testen—geen creditcard vereist. Start hier
- Tijdelijke licentie: Meer tijd nodig om te evalueren? Vraag een tijdelijke licentie aan voor volledige functionaliteit tijdens ontwikkeling
- Productielicentie: Wanneer je klaar bent om te implementeren, koop een licentie op basis van je behoeften
Additional useful links
- GroupDocs.Signature voor Java Documentatie
- API‑referentiegids
- Community‑ondersteuningsforum
- Laatste bibliotheekreleases
- Gratis proefversie download
- Vraag tijdelijke licentie aan
- Koop volledige licentie
Pro tip: Begin met de gratis proefversie om je oplossing te prototypen, en haal vervolgens een tijdelijke licentie als je meer tijd nodig hebt voordat je committeert.
GroupDocs.Signature voor Java instellen
De Signature‑klasse is het toegangspunt voor alle ondertekeningsbewerkingen in GroupDocs.Signature. Het vertegenwoordigt één bestand dat in het geheugen is geladen en biedt methoden om visuele handtekeningen toe te voegen, te zoeken of te verwijderen.
Maak een Signature‑instantie die naar je TAR‑bestand wijst. Dit laadt het bestand in het geheugen voor verwerking:
import com.groupdocs.signature.Signature;
public class InitializeSignature {
public static void main(String[] args) {
Signature signature = new Signature("your-document-path");
// Additional setup and usage here...
}
}
Belangrijk: Sluit altijd het Signature‑object wanneer je klaar bent (of gebruik try‑with‑resources) om geheugenlekken bij grote bestanden te voorkomen.
Kiezen tussen barcode‑ en QR‑codehandtekeningen
Niet zeker welk handtekeningtype te gebruiken? Hier is een snelle beslissingsgids:
| Factor | Barcode (Code128) | QR‑code |
|---|---|---|
| Gegevenscapaciteit | ~80 tekens | Tot 4.296 alfanumerieke tekens |
| Leesbaarheid | Vereist barcode‑scanner | Werkt met smartphone‑camera’s |
| Ruimte‑efficiëntie | Meer compact horizontaal | Vereist vierkante ruimte |
| Beste voor | Eenvoudige ID’s, tijdstempels, korte codes | URL’s, JSON‑data, gedetailleerde metadata |
| Foutcorrectie | Minimaal | Ingebouwd (kan herstellen van schade) |
Rule of thumb:
- Gebruik barcodes voor snelle, scanbare ID’s of tijdstempels.
- Gebruik QR‑codes wanneer je rijkere data wilt embedden of smartphone‑compatibiliteit nodig hebt.
- Combineer beide voor maximale redundantie en auditbaarheid.
Implementatie‑gids
TAR‑archief ondertekenen met barcode
Waarom ondertekenen met barcodes?
Barcodes zijn perfect voor TAR‑archieven omdat ze compact en scanbaar zijn. Je kunt tijdstempels, versienummers, gebruikers‑ID’s of checksum‑waarden embedden voor snelle verificatie.
Stappen
1. Initialiseer handtekening
Eerst maak je een Signature‑instantie voor het TAR‑bestand:
import com.groupdocs.signature.Signature;
final Signature signature = new Signature("path/to/your/archive.tar");
Pro tip: Voor grote TAR‑bestanden (meer dan 100 MB), voer de ondertekeningsbewerking uit in een achtergrondthread om de UI responsief te houden.
2. Configureer barcode‑opties
De BarcodeSignature‑klasse definieert de barcode‑inhoud, het type en de plaatsing. Het BarcodeOptions‑object bevat deze instellingen:
import com.groupdocs.signature.options.sign.BarcodeSignOptions;
import com.groupdocs.signature.domain.barcodes.BarcodeTypes;
BarcodeSignOptions bcOptions = new BarcodeSignOptions("12345678", BarcodeTypes.Code128);
bcOptions.setLeft(100); // X position in pixels
bcOptions.setTop(100); // Y position in pixels
BarcodeOptions laat je het visuele uiterlijk en de positie van de barcode specificeren.BarcodeTypes is een enum die ondersteunde barcode‑symbologieën opsomt, zoals Code128, Code39, enz.
Wat gebeurt hier?
"12345678"is de data die in de barcode wordt gecodeerd—vervang dit door je eigen ID, tijdstempel of verificatiecode.BarcodeTypes.Code128biedt een balans tussen gegevenscapaciteit en scanbetrouwbaarheid.- Positiewaarden (100, 100) plaatsen de barcode 100 px vanaf de linkerbovenhoek.
Aanpassingsopties die je misschien wilt:
bcOptions.setWidth(200); // Barcode width in pixels
bcOptions.setHeight(50); // Barcode height in pixels
bcOptions.setForeColor(Color.BLACK); // Barcode color
bcOptions.setBackgroundColor(Color.WHITE); // Background color
3. Onderteken en sla het document op
Voer de ondertekeningsbewerking uit en sla het ondertekende archief op:
import com.groupdocs.signature.domain.SignResult;
String outputFilePath = "output/path/SignWithBarcode/archive_signed.tar";
SignResult signResult = signature.sign(outputFilePath, bcOptions);
Het geretourneerde SignResult‑object vertelt je of de bewerking geslaagd is en waar de handtekening geplaatst is.
Veelvoorkomend probleem: Zorg ervoor dat de uitvoermap bestaat voordat je sign() aanroept. De bibliotheek maakt geen bovenliggende mappen automatisch aan.
TAR‑archief ondertekenen met QR‑code
Wanneer QR‑codes gebruiken
QR‑codes blinken wanneer je gestructureerde data (JSON, XML) moet opslaan, verificatie‑URL’s wilt embedden of smartphone‑scanning wilt mogelijk maken.
Stappen
1. Initialiseer handtekening
Zelfde als eerder—maak je Signature‑instantie:
final Signature signature = new Signature("path/to/your/archive.tar");
2. Configureer QR‑code‑opties
Stel je QR‑code in met de data die je wilt embedden:
import com.groupdocs.signature.options.sign.QrCodeSignOptions;
import com.groupdocs.signature.domain.qrcodes.QrCodeTypes;
QrCodeSignOptions qrOptions = new QrCodeSignOptions("12345678", QrCodeTypes.QR);
qrOptions.setLeft(400); // X position
qrOptions.setTop(400); // Y position
QrCodeTypes is een enum die het type QR‑code specificeert dat gegenereerd moet worden (standaard QR, DataMatrix, Aztec, enz.).
Real‑world example – embed een JSON‑payload met verificatiedata:
String verificationData = "{\"version\":\"1.0\",\"timestamp\":\"2025-01-02T10:30:00Z\",\"user\":\"john.doe\"}";
QrCodeSignOptions qrOptions = new QrCodeSignOptions(verificationData, QrCodeTypes.QR);
QR‑code type‑opties:
QrCodeTypes.QR– standaard QR‑code (meest gebruikelijk)QrCodeTypes.DataMatrix– compacter voor kleine dataQrCodeTypes.Aztec– geschikt voor gebogen oppervlakken
3. Onderteken en sla het document op
Voltooi het ondertekeningsproces net als bij barcodes:
String outputFilePath = "output/path/SignWithQRCode/archive_signed.tar";
SignResult signResult = signature.sign(outputFilePath, qrOptions);
Prestatie‑opmerking: QR‑codegeneratie is iets trager dan barcodes vanwege fout‑correctieberekeningen, maar het verschil is verwaarloosbaar voor de meeste use‑cases (meestal enkele milliseconden).
TAR‑archief ondertekenen met meerdere handtekeningen
Waarom meerdere handtekeningen gebruiken?
- Redundantie – als één handtekening beschadigd is, kan de andere nog steeds verifiëren.
- Verschillende doelgroepen – barcodes voor scanners, QR‑codes voor smartphones.
- Gelaagde data – snelle ID in barcode, gedetailleerde metadata in QR‑code.
- Compliance – sommige regelgeving vereist meerdere verificatiemethoden.
Stappen
1. Initialiseer handtekening
final Signature signature = new Signature("path/to/your/archive.tar");
2. Configureer meerdere opties
Maak beide handtekeningtypes en combineer ze in een lijst:
import java.util.ArrayList;
import java.util.List;
// Set up barcode (reusing from earlier example)
BarcodeSignOptions bcOptions = new BarcodeSignOptions("12345678", BarcodeTypes.Code128);
bcOptions.setLeft(100);
bcOptions.setTop(100);
// Set up QR code (different position to avoid overlap)
QrCodeSignOptions qrOptions = new QrCodeSignOptions("12345678", QrCodeTypes.QR);
qrOptions.setLeft(400);
qrOptions.setTop(400);
// Combine them
List<com.groupdocs.signature.options.sign.SignOptions> listOptions = new ArrayList<>();
listOptions.add(bcOptions);
listOptions.add(qrOptions);
Pro tip: Positioneer handtekeningen strategisch—hoeken of niet‑interfererende gebieden werken het beste voor TAR‑archieven.
3. Onderteken en sla het document op
String outputFilePath = "output/path/SignWithMultipleSignatures/archive_signed.tar";
SignResult signResult = signature.sign(outputFilePath, listOptions);
GroupDocs verwerkt elke handtekening opeenvolgend, en embedt ze in de documentmetadata. De volgorde in je lijst heeft geen invloed op de verificatie.
Praktijkvoorbeelden
1. Software‑distributiepijplijnen
Scenario: Softwarepakketten distribueren als TAR‑archieven en bewijzen dat ze niet zijn gewijzigd.
Solution: Sign each release with a QR code containing a JSON payload:
String releaseData = String.format(
"{\"version\":\"%s\",\"buildDate\":\"%s\",\"sha256\":\"%s\"}",
version, buildDate, checksum
);
Waarom het werkt: Gebruikers kunnen de QR‑code scannen om de integriteit van het pakket te verifiëren vóór installatie—geen GPG‑sleutelbeheer nodig.
2. Geautomatiseerde back‑upsystemen
Scenario: Dagelijkse back‑up TAR‑archieven hebben audit‑trails nodig.
Solution: Add a barcode with the backup timestamp and server ID:
String backupId = String.format("SRV01-%s", LocalDateTime.now().format(formatter));
BarcodeSignOptions bcOptions = new BarcodeSignOptions(backupId, BarcodeTypes.Code128);
Waarom het werkt: Snelle visuele verificatie van de authenticiteit van de back‑up zonder het archief te openen.
3. Documentbeheersystemen
Scenario: Juridische documenten opgeslagen als archieven vereisen manipulatie‑bestendige verificatie.
Solution: Use both barcode (quick scan) and QR code (detailed metadata) on the same archive.
4. Leveringsketen‑tracking
Scenario: Bestandenpakketten volgen door meerdere organisaties.
Solution: Embed QR codes with tracking URLs that link to a verification API:
String trackingUrl = "https://verify.yourcompany.com/track/" + uniqueId;
QrCodeSignOptions qrOptions = new QrCodeSignOptions(trackingUrl, QrCodeTypes.QR);
Veelvoorkomende problemen en oplossingen
Probleem 1: “Handtekening niet gevonden” na ondertekenen
Symptoom: sign() slaagt, maar de handtekening is niet zichtbaar.
Oorzaken: Verkeerde plaatsing, overschrijven van het originele bestand, beperkingen van de TAR‑viewer.
Solution:
// Always verify the signing succeeded
SignResult result = signature.sign(outputFilePath, bcOptions);
if (result.getSucceeded().size() > 0) {
System.out.println("Signature added successfully at: " + outputFilePath);
} else {
System.err.println("Signing failed: " + result.getFailed());
}
// Use absolute paths to avoid confusion
String absolutePath = new File(outputFilePath).getAbsolutePath();
Probleem 2: OutOfMemoryError bij grote TAR‑bestanden
Symptoom: JVM crasht bij archieven > 500 MB.
Solution: Increase heap size (-Xmx) and dispose of Signature objects promptly:
java -Xmx2G -jar your-application.jar
Or implement chunked processing:
// For very large files, consider signing metadata separately
// rather than embedding in the TAR itself
Probleem 3: Handtekeninggegevens worden afgekapt
Symptoom: Lange strings worden afgekapt.
Oorzaak: Capaciteit van Code128 overschreden (≈ 80 tekens).
Solution: Switch to QR codes for longer payloads:
// Bad: Too much data for Code128
BarcodeSignOptions bcOptions = new BarcodeSignOptions(veryLongString, BarcodeTypes.Code128);
// Good: Use QR code instead
QrCodeSignOptions qrOptions = new QrCodeSignOptions(veryLongString, QrCodeTypes.QR);
Probleem 4: Licentie‑validatiefouten
Symptoom: LicenseException of “Trial version” waarschuwingen in productie.
Solution: Load the license before creating any Signature instances:
import com.groupdocs.signature.License;
License license = new License();
license.setLicense("path/to/GroupDocs.Signature.lic");
// Now create signatures
Signature signature = new Signature("document.tar");
Pro tip: Laad de licentie één keer bij het opstarten van de applicatie, niet vóór elke ondertekeningsbewerking.
Probleem 5: Positiewaarden werken niet zoals verwacht
Symptoom: Handtekeningen verschijnen op onverwachte locaties.
Oorzaak: Verwarring tussen pixels en punten.
Solution: GroupDocs uses pixels by default. For precise placement:
bcOptions.setLeft(100); // 100 pixels from left edge
bcOptions.setTop(100); // 100 pixels from top edge
// If you need percentage-based positioning:
bcOptions.setHorizontalAlignment(HorizontalAlignment.Center);
bcOptions.setVerticalAlignment(VerticalAlignment.Center);
Integratiepatronen
Patroon 1: REST‑API‑service
Expose signing as a microservice:
@RestController
@RequestMapping("/api/signature")
public class SignatureController {
@PostMapping("/sign")
public ResponseEntity<SignatureResponse> signFile(
@RequestParam("file") MultipartFile file,
@RequestParam("signatureType") String type) {
try {
// Save uploaded file temporarily
File tempFile = File.createTempFile("upload-", ".tar");
file.transferTo(tempFile);
// Sign based on type
Signature signature = new Signature(tempFile.getAbsolutePath());
SignOptions options = type.equals("barcode")
? createBarcodeOptions()
: createQROptions();
String outputPath = generateOutputPath();
SignResult result = signature.sign(outputPath, options);
// Return signed file
return ResponseEntity.ok(new SignatureResponse(outputPath, result));
} catch (Exception e) {
return ResponseEntity.status(500).body(null);
}
}
}
Patroon 2: Batch‑verwerkingspijplijn
Sign multiple archives in a pipeline:
public class BatchSigner {
public void signArchiveBatch(List<File> archives) {
ExecutorService executor = Executors.newFixedThreadPool(4);
archives.forEach(archive -> {
executor.submit(() -> {
try {
signSingleArchive(archive);
} catch (Exception e) {
logger.error("Failed to sign: " + archive.getName(), e);
}
});
});
executor.shutdown();
executor.awaitTermination(1, TimeUnit.HOURS);
}
private void signSingleArchive(File archive) throws Exception {
Signature signature = new Signature(archive.getAbsolutePath());
// ... signing logic
}
}
Patroon 3: Event‑gedreven architectuur
Trigger signing when archives are created:
@Component
public class ArchiveCreatedListener {
@EventListener
public void onArchiveCreated(ArchiveCreatedEvent event) {
CompletableFuture.runAsync(() -> {
signArchive(event.getFilePath());
});
}
private void signArchive(String filePath) {
// ... signing logic
}
}
Prestatie‑overwegingen
Geheugenbeheer
Het probleem: Elke Signature‑instantie laadt het volledige bestand in het geheugen.
Best practices:
// Bad: Creating multiple instances for same file
Signature sig1 = new Signature("file.tar");
Signature sig2 = new Signature("file.tar"); // Loads again!
// Good: Reuse the instance
try (Signature signature = new Signature("file.tar")) {
signature.sign(output1, options1);
signature.sign(output2, options2); // Same instance, different outputs
}
Bestandsgrootte‑optimalisatie
- Kleine bestanden (< 10 MB) – onderteken synchroon.
- Middelgrote bestanden (10‑100 MB) – gebruik achtergrondthreads.
- Grote bestanden (> 100 MB) – overweeg metadata apart te ondertekenen of streaming‑API’s te gebruiken.
Handtekeningcomplexiteit (bij benadering timings op een standaard server)
| Handtekeningtype | Tijd per document |
|---|---|
| Single barcode | 50‑100 ms |
| Single QR code | 100‑200 ms |
| Multiple signatures | 150‑300 ms |
Optimalisatietip: Voor duizenden bestanden, batch ze en gebruik een thread‑pool (zie het batch‑verwerkingspatroon hierboven).
Library updates
GroupDocs brengt regelmatig prestatieverbeteringen uit. Controleer altijd de changelog vóór grote implementaties.
Update‑strategie:
- Test nieuwe versies in staging.
- Review breaking changes.
- Benchmark met echte bestanden.
- Rol geleidelijk uit.
Best practices voor productie
1. Valideer licentiestatus
License license = new License();
if (!license.isLicensed()) {
logger.warn("Running in trial mode - features may be limited");
}
2. Implementeer robuuste foutafhandeling
try {
signature.sign(outputPath, options);
} catch (Exception e) {
logger.error("Signature failed", e);
// Don't just swallow exceptions - log or re-throw
throw new SignatureException("Failed to sign document", e);
}
3. Gebruik beschrijvende handtekeningdata
// Bad: Meaningless ID
new BarcodeSignOptions("12345678", BarcodeTypes.Code128);
// Good: Self-documenting data
String signatureData = String.format("DOC-%s-%s",
docType,
LocalDateTime.now().format(DateTimeFormatter.ISO_DATE_TIME)
);
new BarcodeSignOptions(signatureData, BarcodeTypes.Code128);
4. Versieer je handtekeningformaat Include a version number in embedded JSON to future‑proof your verification logic:
String qrData = String.format(
"{\"v\":\"1.0\",\"type\":\"archive\",\"timestamp\":\"%s\"}",
timestamp
);
5. Test met real‑world bestanden – valideer altijd met productie‑grootte archieven om geheugen‑ en prestatieproblemen vroegtijdig te ontdekken.
Conclusie
Je hebt nu een solide basis om how to sign java te implementeren met barcodes en QR‑codes. Dit heb je geleerd:
- Hoe TAR‑archieven (en andere documenten) te ondertekenen met zowel barcode‑ als QR‑codehandtekeningen
- Wanneer elk handtekeningtype te kiezen op basis van specifieke behoeften
- Hoe veelvoorkomende problemen op te lossen voordat ze productie bereiken
- Realtime integratiepatronen voor REST‑API’s, batch‑verwerking en event‑gedreven systemen
- Prestatie‑optimalisatietechnieken voor het verwerken van bestanden van elke grootte
Volgende stappen:
- Verken handtekeningverificatie met de
search()‑methode. - Probeer andere documentformaten—GroupDocs.Signature ondersteunt PDF, DOCX, XLSX, PNG en meer.
- Pas het uiterlijk van de handtekening aan (kleuren, groottes, randen).
- Bouw een verificatie‑API om handtekeningen programmatisch te valideren.
De kracht van GroupDocs.Signature gaat veel verder dan deze gids. Bekijk de GroupDocs.Signature voor Java Documentatie om geavanceerde functies te ontdekken zoals tekst‑handtekeningen, afbeelding‑handtekeningen en metadata‑extractie.
Heb je vragen of wil je je implementatie delen? Word lid van de GroupDocs community‑forums voor hulp van andere ontwikkelaars.
Veelgestelde vragen
V: Kan ik documenten ondertekenen anders dan TAR‑archieven?
A: Absoluut! GroupDocs.Signature ondersteunt meer dan 50 bestandsformaten, inclusief PDF, DOCX, XLSX, PNG en meer. Verander alleen de bestandsextensie in de Signature‑constructor om met elk ondersteund type te werken.
V: Hoe verifieer ik handtekeningen na het ondertekenen?
A: Use the search() method to locate and validate signatures:
Signature signature = new Signature("signed-document.tar");
BarcodeSearchOptions searchOptions = new BarcodeSearchOptions();
List<BarcodeSignature> signatures = signature.search(BarcodeSignature.class, searchOptions);
V: Zijn de handtekeningen veilig tegen manipulatie?
A: Barcode and QR code signatures provide visual verification but are not cryptographically strong like digital certificates. For maximum security, combine them with traditional PKI or store signature hashes in an external database.
V: Wat is de maximale hoeveelheid data die ik in een handtekening kan opslaan?
- Code128 barcode: ~80 alfanumerieke tekens
- QR‑code (Versie 40): tot 4.296 alfanumerieke tekens of 7.089 numerieke tekens
V: Kan ik het uiterlijk van de handtekening aanpassen?
A: Yes! Control colours, sizes, borders, and more:
bcOptions.setForeColor(Color.BLUE);
bcOptions.setBackgroundColor(Color.YELLOW);
bcOptions.setBorder(new Border());
bcOptions.getBorder().setColor(Color.RED);
bcOptions.getBorder().setWeight(2);
V: Wat gebeurt er als ik een bestand twee keer onderteken?
A: Each sign() call adds a new signature. To replace an existing one, delete it first with the delete() method.
V: Hoe ga ik om met grote bestanden zonder geheugen op te raken?
A: Increase JVM heap (-Xmx), dispose of Signature objects promptly, and consider signing metadata separately for multi‑gigabyte archives.
V: Heb ik een internetverbinding nodig om documenten te ondertekenen?
A: No. GroupDocs.Signature works entirely offline once the library is installed.
Laatst bijgewerkt: 2026-10-06
Getest met: GroupDocs.Signature 23.12 for Java
Auteur: GroupDocs