Hur man signerar Java-filer med streckkoder och QR-koder
Introduktion
Har du någonsin undrat hur du kan bevisa att dina filer inte har manipulerats med hjälp av how to sign java‑tekniker? Eller behövt ett sätt att autentisera dokument programatiskt utan komplexa kryptografiska uppsättningar? Traditionella digitala signaturer kan vara överdrivna för vissa användningsfall. Ibland behöver du bara en lättviktig, skanningsbar metod för att verifiera filintegritet—särskilt när du hanterar arkiv, säkerhetskopior eller automatiserade arbetsflöden. Det är där streckkod- och QR‑kodsignaturer kommer in.
I den här handledningen kommer du att lära dig hur du implementerar how to sign java med hjälp av GroupDocs.Signature. Vi kommer att fokusera på att signera TAR‑arkiv (perfekt för backup‑system och programvarudistribution), men dessa tekniker fungerar med olika dokumentformat. Oavsett om du bygger ett dokumenthanteringssystem eller bara vill lägga till ett extra säkerhetslager till dina filer, är du på rätt plats.
Vad du kommer att få med dig:
- En fungerande implementation av streckkod- och QR‑kodsignaturer i Java
- Förståelse för när du ska använda varje signaturtyp (och varför det är viktigt)
- Praktiska lösningar på vanliga signeringsutmaningar
- Verkliga integrationsmönster som du kan använda idag
- Prestandaoptimeringstips för produktionssystem
Låt oss dyka ner—ingen kryptografiexamen krävs.
Snabba svar
- Vilket bibliotek hanterar streckkodssignaturer i Java? GroupDocs.Signature for Java.
- Vilken signaturtyp lagrar mer data? QR‑koder (upp till 4 296 alfanumeriska tecken).
- Kan jag signera stora TAR‑filer (>100 MB)? Ja—använd bakgrundstrådar och öka JVM‑heapen.
- Behöver jag en internetanslutning? Nej, biblioteket fungerar helt offline.
- Krävs en licens för produktion? Ja, en giltig GroupDocs.Signature‑licens är obligatorisk.
Vad är digital signatur java?
Digital signatur java är processen att bädda in en verifierbar visuell token—såsom en streckkod eller QR‑kod—direkt i en Java‑genererad fil för att bevisa dess äkthet och integritet, vilket ger ett snabbt, mänskligt läsbart bevis på att filen inte har ändrats sedan den signerades samtidigt som programmatisk verifiering möjliggörs via GroupDocs.Signature‑API.
Varför använda streckkod- eller QR‑kodsignaturer?
GroupDocs.Signature stöder 50+ in- och utdataformat (inklusive PDF, DOCX, XLSX, HTML, PNG och TAR) och kan bearbeta dokument med hundratals sidor utan att ladda hela filen i minnet. Streckkoder och QR‑koder ger dig ett skanningsbart, självständigt bevis på äkthet, vilket eliminerar behovet av externa certifikatutfärdare i många interna arbetsflöden.
| Faktor | Barcode (Code128) | QR Code |
|---|---|---|
| Datakapacitet | ~80 tecken | Upp till 4 296 alfanumeriska tecken |
| Läsbarhet | Kräver streckkodsläsare | Fungerar med smartphone‑kameror |
| Platsutnyttjande | Mer kompakt horisontellt | Kräver fyrkantigt område |
| Bäst för | Enkla ID:n, tidsstämplar, korta koder | URL:er, JSON‑data, detaljerad metadata |
| Felförbättring | Minimal | Inbyggd (kan återhämta sig från skador) |
Allmän regel:
- Använd streckkoder för snabba, skanningsbara ID:n eller tidsstämplar.
- Använd QR‑koder när du behöver bädda in rikare data eller vill ha smartphone‑kompatibilitet.
- Kombinera båda för maximal redundans och spårbarhet.
Förutsättningar
- GroupDocs.Signature för Java‑bibliotek – version 23.12 eller senare
- Java Development Kit (JDK) – version 8 eller högre
- IDE – IntelliJ IDEA, Eclipse eller någon Java‑kompatibel editor
- Grundläggande Java‑kunskaper – du bör vara bekväm med klasser och imports
Miljöinställning
Att få in GroupDocs.Signature i ditt projekt är enkelt. Välj ditt byggverktyg:
Maven (add this to your pom.xml):
<dependency>
<groupId>com.groupdocs</groupId>
<artifactId>groupdocs-signature</artifactId>
<version>23.12</version>
</dependency>
Gradle (add to your build.gradle):
implementation 'com.groupdocs:groupdocs-signature:23.12'
Manuell nedladdning: Använder du inte Maven eller Gradle? Hämta JAR-filen direkt från GroupDocs.Signature releases och lägg till den i din classpath.
Licensanskaffning
GroupDocs erbjuder flexibel licensiering:
- Gratis provperiod: Perfekt för testning—inget kreditkort krävs. Starta här
- Tillfällig licens: Behöver du mer tid för att utvärdera? Begär en tillfällig licens för full funktionalitet under utveckling
- Produktionslicens: När du är redo att distribuera, köp en licens baserat på dina behov
Ytterligare användbara länkar
- GroupDocs.Signature för Java‑dokumentation
- API‑referensguide
- Community‑supportforum
- Senaste biblioteksversionerna
- Gratis provnedladdning
- Begär tillfällig licens
- Köp full licens
Proffstips: Börja med gratis provperiod för att prototypa din lösning, och skaffa sedan en tillfällig licens om du behöver mer tid innan du binder dig.
Konfigurering av GroupDocs.Signature för Java
Signature‑klassen är ingångspunkten för alla signeringsoperationer i GroupDocs.Signature. Den representerar en enskild fil som laddas in i minnet och tillhandahåller metoder för att lägga till, söka eller ta bort visuella signaturer.
Skapa en Signature‑instans som pekar på din TAR‑fil. Detta laddar filen i minnet för bearbetning:
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...
}
}
Viktigt: Stäng alltid Signature‑objektet när du är klar (eller använd try‑with‑resources) för att undvika minnesläckor med stora filer.
Välja mellan streckkod- och QR‑kodsignaturer
Oroar du dig för vilken signaturtyp du ska använda? Här är en snabb beslutsguide:
| Faktor | Barcode (Code128) | QR Code |
|---|---|---|
| Datakapacitet | ~80 tecken | Upp till 4 296 alfanumeriska tecken |
| Läsbarhet | Kräver streckkodsläsare | Fungerar med smartphone‑kameror |
| Platsutnyttjande | Mer kompakt horisontellt | Kräver fyrkantigt område |
| Bäst för | Enkla ID:n, tidsstämplar, korta koder | URL:er, JSON‑data, detaljerad metadata |
| Felförbättring | Minimal | Inbyggd (kan återhämta sig från skador) |
Allmän regel:
- Använd streckkoder för snabba, skanningsbara ID:n eller tidsstämplar.
- Använd QR‑koder när du behöver bädda in rikare data eller vill ha smartphone‑kompatibilitet.
- Kombinera båda för maximal redundans och spårbarhet.
Implementeringsguide
Signera TAR‑arkiv med streckkod
Varför signera med streckkoder?
Streckkoder är perfekta för TAR‑arkiv eftersom de är kompakta och skanningsbara. Du kan bädda in tidsstämplar, versionsnummer, användar‑ID:n eller kontrollsummor för snabb verifiering.
Steg
1. Initiera signatur
Först, skapa en Signature‑instans för TAR‑filen:
import com.groupdocs.signature.Signature;
final Signature signature = new Signature("path/to/your/archive.tar");
Proffstips: För stora TAR‑filer (över 100 MB), kör signeringsoperationen i en bakgrundstråd för att hålla UI‑responsen.
2. Konfigurera streckkodsalternativBarcodeSignature‑klassen definierar streckkodens innehåll, typ och placering. BarcodeOptions‑objektet innehåller dessa inställningar:
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 låter dig specificera den visuella utformningen och positionen för streckkoden.BarcodeTypes är en enum som listar stödda streckkodssymboler såsom Code128, Code39 osv.
Vad händer här?
"12345678"är data som kodas i streckkoden—ersätt den med ditt faktiska ID, tidsstämpel eller verifieringskod.BarcodeTypes.Code128balanserar datakapacitet med skanningspålitlighet.- Positionsvärdena (100, 100) placerar streckkoden 100 px från övre vänstra hörnet.
Anpassningsalternativ du kanske vill ha:
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. Signera och spara dokumentet
Kör signeringsoperationen och lagra det signerade arkivet:
import com.groupdocs.signature.domain.SignResult;
String outputFilePath = "output/path/SignWithBarcode/archive_signed.tar";
SignResult signResult = signature.sign(outputFilePath, bcOptions);
Det returnerade SignResult‑objektet berättar om operationen lyckades och var signaturen placerades.
Vanligt fallgropp: Säkerställ att mål katalogen finns innan du anropar sign(). Biblioteket skapar inte automatiskt överordnade kataloger.
Signera TAR‑arkiv med QR‑kod
När du ska använda QR‑koder
QR‑koder glänser när du behöver lagra strukturerad data (JSON, XML), bädda in verifierings‑URL:er eller möjliggöra smartphone‑skanning.
Steg
1. Initiera signatur
Samma som tidigare—skapa din Signature‑instans:
final Signature signature = new Signature("path/to/your/archive.tar");
2. Konfigurera QR‑kodalternativ
Ställ in din QR‑kod med den data du vill bädda in:
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 är en enum som specificerar vilken typ av QR‑kod som ska genereras (standard‑QR, DataMatrix, Aztec, osv).
Verkligt exempel – embed a JSON payload with verification data:
String verificationData = "{\"version\":\"1.0\",\"timestamp\":\"2025-01-02T10:30:00Z\",\"user\":\"john.doe\"}";
QrCodeSignOptions qrOptions = new QrCodeSignOptions(verificationData, QrCodeTypes.QR);
QR‑kodtypsalternativ:
QrCodeTypes.QR– standard QR‑kod (vanligast)QrCodeTypes.DataMatrix– mer kompakt för liten dataQrCodeTypes.Aztec– bra för böjda ytor
3. Signera och spara dokumentet
Slutför signeringsprocessen precis som med streckkoder:
String outputFilePath = "output/path/SignWithQRCode/archive_signed.tar";
SignResult signResult = signature.sign(outputFilePath, qrOptions);
Prestandaanteckning: QR‑kodgenerering är något långsammare än streckkoder på grund av felkorrigeringsberäkningar, men skillnaden är försumbar för de flesta användningsfall (vanligtvis några millisekunder).
Signera TAR‑arkiv med flera signaturer
Varför använda flera signaturer?
- Redundans – om en signatur är skadad kan den andra fortfarande verifieras.
- Olika målgrupper – streckkoder för skannrar, QR‑koder för smartphones.
- Lagerad data – snabb ID i streckkod, detaljerad metadata i QR‑kod.
- Efterlevnad – vissa regler kräver flera verifieringsmetoder.
Steg
1. Initiera signatur
Samma initiering som tidigare:
final Signature signature = new Signature("path/to/your/archive.tar");
2. Konfigurera flera alternativ
Skapa båda signaturtyperna och kombinera dem i en lista:
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);
Proffstips: Positionera signaturerna strategiskt—hörn eller områden som inte stör fungerar bäst för TAR‑arkiv.
3. Signera och spara dokumentet
Skicka listan med alternativ till sign()‑metoden:
String outputFilePath = "output/path/SignWithMultipleSignatures/archive_signed.tar";
SignResult signResult = signature.sign(outputFilePath, listOptions);
GroupDocs bearbetar varje signatur sekventiellt och bäddar in dem i dokumentets metadata. Ordningen i din lista påverkar inte verifieringen.
Verkliga användningsfall
1. Programvarudistributionspipeline
Scenario: Distribuera programvarupaket som TAR‑arkiv och bevisa att de inte har ändrats.
Lösning: Signera varje release med en QR‑kod som innehåller en JSON‑payload:
String releaseData = String.format(
"{\"version\":\"%s\",\"buildDate\":\"%s\",\"sha256\":\"%s\"}",
version, buildDate, checksum
);
Varför det fungerar: Användare kan skanna QR‑koden för att verifiera paketets integritet innan installation—ingen GPG‑nyckelhantering behövs.
2. Automatiserade backup‑system
Scenario: Dagliga backup‑TAR‑arkiv behöver revisionsspår.
Lösning: Lägg till en streckkod med backup‑tidsstämpeln och server‑ID:n:
String backupId = String.format("SRV01-%s", LocalDateTime.now().format(formatter));
BarcodeSignOptions bcOptions = new BarcodeSignOptions(backupId, BarcodeTypes.Code128);
Varför det fungerar: Snabb visuell verifiering av backup‑äkthet utan att öppna arkivet.
3. Dokumenthanteringssystem
Scenario: Juridiska dokument lagrade som arkiv kräver manipulering‑säker verifiering.
Lösning: Använd både streckkod (snabb skanning) och QR‑kod (detaljerad metadata) på samma arkiv.
4. Spårning av leveranskedjan
Scenario: Spåra filpaket genom flera organisationer.
Lösning: Bädda in QR‑koder med spårnings‑URL:er som länkar till ett verifierings‑API:
String trackingUrl = "https://verify.yourcompany.com/track/" + uniqueId;
QrCodeSignOptions qrOptions = new QrCodeSignOptions(trackingUrl, QrCodeTypes.QR);
Vanliga problem och lösningar
Problem 1: “Signature not found” efter signering
Symptom: sign() lyckas, men signaturen är inte synlig.
Orsaker: Fel placering, överskrivning av originalfil, begränsningar i TAR‑visare.
Lösning:
// 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();
Problem 2: OutOfMemoryError med stora TAR‑filer
Symptom: JVM kraschar för arkiv > 500 MB.
Lösning: Öka heap‑storleken (-Xmx) och frigör Signature‑objekt omedelbart:
java -Xmx2G -jar your-application.jar
Eller implementera segmenterad bearbetning:
// For very large files, consider signing metadata separately
// rather than embedding in the TAR itself
Problem 3: Signaturdata trunkeras
Symptom: Långa strängar kapas av.
Orsak: Överskriden kapacitet för Code128 (≈ 80 tecken).
Lösning: Byt till QR‑koder för längre 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);
Problem 4: Licensvalideringsfel
Symptom: LicenseException eller varningar om “Trial version” i produktion.
Lösning: Läs in licensen innan du skapar några Signature‑instanser:
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");
Proffstips: Läs in licensen en gång vid applikationsstart, inte före varje signeringsoperation.
Problem 5: Positionsvärden fungerar inte som förväntat
Symptom: Signaturer visas på oväntade platser.
Orsak: Förvirring mellan pixlar och punkter.
Lösning: GroupDocs använder pixlar som standard. För exakt placering:
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);
Integrationsmönster
Mönster 1: REST‑API‑tjänst
Exponera signering som en mikrotjänst:
@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);
}
}
}
Mönster 2: Batch‑bearbetningspipeline
Signera flera arkiv i en 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
}
}
Mönster 3: Händelsedriven arkitektur
Utlösa signering när arkiv skapas:
@Component
public class ArchiveCreatedListener {
@EventListener
public void onArchiveCreated(ArchiveCreatedEvent event) {
CompletableFuture.runAsync(() -> {
signArchive(event.getFilePath());
});
}
private void signArchive(String filePath) {
// ... signing logic
}
}
Prestandaöverväganden
Minneshantering
Problemet: Varje Signature‑instans laddar hela filen i minnet.
Bästa praxis:
// 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
}
Filstorleksoptimering
- Små filer (< 10 MB) – signera synkront.
- Mellanstora filer (10‑100 MB) – använd bakgrundstrådar.
- Stora filer (> 100 MB) – överväg att signera metadata separat eller använda streaming‑API:er.
Signaturkomplexitet (ungefärliga tider på en standardserver)
| Signaturtyp | Tid per dokument |
|---|---|
| Enstaka streckkod | 50‑100 ms |
| Enstaka QR‑kod | 100‑200 ms |
| Flera signaturer | 150‑300 ms |
Optimeringstips: För tusentals filer, batcha dem och använd en trådpool (se batch‑bearbetningsmönstret ovan).
Biblioteksuppdateringar
GroupDocs släpper regelbundna prestandaförbättringar. Kontrollera alltid changelog före större utrullningar.
Uppdateringsstrategi:
- Testa nya versioner i staging.
- Granska brytande förändringar.
- Benchmarka med riktiga filer.
- Rulla ut stegvis.
Bästa praxis för produktion
1. Validera licensstatus
License license = new License();
if (!license.isLicensed()) {
logger.warn("Running in trial mode - features may be limited");
}
2. Implementera robust felhantering
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. Använd beskrivande signaturdata
// 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. Versionshantera ditt signaturformat Inkludera ett versionsnummer i den inbäddade JSON‑payloaden för att framtidssäkra din verifieringslogik:
String qrData = String.format(
"{\"v\":\"1.0\",\"type\":\"archive\",\"timestamp\":\"%s\"}",
timestamp
);
5. Testa med verkliga filer – validera alltid med produktionsstora arkiv för att tidigt fånga minnes- och prestandaproblem.
Slutsats
Du har nu en solid grund för att implementera how to sign java med streckkoder och QR‑koder. Här är vad du har lärt dig:
- Hur man signerar TAR‑arkiv (och andra dokument) med både streckkod‑ och QR‑kodsignaturer
- När man väljer varje signaturtyp baserat på specifika behov
- Hur man felsöker vanliga problem innan de når produktion
- Verkliga integrationsmönster för REST‑API:er, batch‑bearbetning och händelsedrivna system
- Prestandaoptimeringstekniker för att hantera filer av alla storlekar
Nästa steg:
- Utforska signaturverifiering med
search()‑metoden. - Prova andra dokumentformat—GroupDocs.Signature stöder PDF, DOCX, XLSX, PNG och mer.
- Anpassa signaturens utseende (färger, storlekar, ramar).
- Bygg ett verifierings‑API för att programatiskt validera signaturer.
Kraften i GroupDocs.Signature sträcker sig långt bortom den här guiden. Kolla in GroupDocs.Signature för Java‑dokumentation för att upptäcka avancerade funktioner som textsignaturer, bildsignaturer och metadataextraktion.
Har du frågor eller vill dela din implementation? Gå med i GroupDocs community‑forum för hjälp från andra utvecklare.
Vanliga frågor
Q: Kan jag signera andra dokument än TAR‑arkiv?
A: Absolut! GroupDocs.Signature stöder över 50 filformat, inklusive PDF, DOCX, XLSX, PNG och mer. Ändra bara filändelsen i Signature‑konstruktorn för att arbeta med någon stödd typ.
Q: Hur verifierar jag signaturer efter signering?
A: Använd search()‑metoden för att lokalisera och validera signaturer:
Signature signature = new Signature("signed-document.tar");
BarcodeSearchOptions searchOptions = new BarcodeSearchOptions();
List<BarcodeSignature> signatures = signature.search(BarcodeSignature.class, searchOptions);
Q: Är signaturerna säkra mot manipulation?
A: Streckkod- och QR‑kodsignaturer ger visuell verifiering men är inte kryptografiskt starka som digitala certifikat. För maximal säkerhet, kombinera dem med traditionell PKI eller lagra signaturhashar i en extern databas.
Q: Vad är den maximala mängden data jag kan lagra i en signatur?
- Code128‑streckkod: ~80 alfanumeriska tecken
- QR‑kod (Version 40): upp till 4 296 alfanumeriska tecken eller 7 089 numeriska tecken
Q: Kan jag anpassa signaturens utseende?
A: Ja! Styr färger, storlekar, ramar och mer:
bcOptions.setForeColor(Color.BLUE);
bcOptions.setBackgroundColor(Color.YELLOW);
bcOptions.setBorder(new Border());
bcOptions.getBorder().setColor(Color.RED);
bcOptions.getBorder().setWeight(2);
Q: Vad händer om jag signerar en fil två gånger?
A: Varje sign()‑anrop lägger till en ny signatur. För att ersätta en befintlig, ta först bort den med delete()‑metoden.
Q: Hur hanterar jag stora filer utan att få minnet fullt?
A: Öka JVM‑heapen (-Xmx), frigör Signature‑objekt omedelbart, och överväg att signera metadata separat för multi‑gigabyte‑arkiv.
Q: Behöver jag en internetanslutning för att signera dokument?
A: Nej. GroupDocs.Signature fungerar helt offline när biblioteket är installerat.
Senast uppdaterad: 2026-10-06
Testad med: GroupDocs.Signature 23.12 för Java
Författare: GroupDocs