设置 groupdocs 许可证

<repositories>
   <repository>
      <id>repository.groupdocs.com</id>
      <name>GroupDocs Repository</name>
      <url>https://releases.groupdocs.com/annotation/java/</url>
   </repository>
</repositories>
<dependencies>
   <dependency>
      <groupId>com.groupdocs</groupId>
      <artifactId>groupdocs-annotation</artifactId>
      <version>25.2</version>
   </dependency>
</dependencies>

repositories {
    maven {
        url 'https://releases.groupdocs.com/annotation/java/'
    }
}

dependencies {
    implementation 'com.groupdocs:groupdocs-annotation:25.2'
}

String licensePath = YOUR_DOCUMENT_DIRECTORY + "/your-license-file.lic";

if (new File(licensePath).isFile()) {
    // Proceed with setting the license
} else {
    System.err.println("License file not found at: " + licensePath);
    // Handle the missing file scenario appropriately
}

try (InputStream stream = new FileInputStream(licensePath)) {
    // Continue with setting the license using this stream
} catch (FileNotFoundException e) {
    System.err.println("License file could not be opened: " + e.getMessage());
    // Handle appropriately - maybe fall back to trial mode
} catch (IOException e) {
    System.err.println("Error reading license file: " + e.getMessage());
    // Log and handle the error
}

License license = new License();
try {
    license.setLicense(stream);
    System.out.println("License applied successfully");
} catch (Exception e) {
    System.err.println("Failed to apply license: " + e.getMessage());
    // Handle license application failure
}

if (!License.isValidLicense()) {
    System.out.println("License validation failed - running in trial mode");
    // Implement fallback behavior for trial mode
} else {
    System.out.println("License is valid and active");
}

// Example for server deployment
String licensePath = System.getProperty("app.config.dir", "/etc/myapp/") + "license.lic";

// Docker-friendly approach
String licensePath = System.getenv("LICENSE_PATH");
if (licensePath == null) {
    licensePath = "/app/config/license.lic"; // default fallback
}

// Example: Loading from cloud storage (pseudo-code)
// You'd implement the actual cloud storage client
InputStream licenseStream = cloudStorageClient.getObject("bucket", "license.lic");

// Add detailed license validation
try {
    license.setLicense(stream);
    if (License.isValidLicense()) {
        System.out.println("License valid until: " + license.getExpirationDate());
    } else {
        System.out.println("License validation failed - check license file and expiration");
    }
} catch (Exception e) {
    System.err.println("License error details: " + e.getMessage());
}

String[] possiblePaths = {
    System.getProperty("license.path"),
    "./license.lic",
    "/etc/myapp/license.lic",
    System.getProperty("user.home") + "/myapp/license.lic"
};

InputStream stream = null;
for (String path : possiblePaths) {
    if (path != null && new File(path).exists()) {
        stream = new FileInputStream(path);
        break;
    }
}

// Set appropriate JVM flags
// -Xmx4g -XX:+UseG1GC -XX:MaxGCPauseMillis=200

// Always close resources properly
try (Annotator annotator = new Annotator("document.pdf")) {
    // Process annotations
    annotator.save("output.pdf");
} // Automatically closes and frees resources

// Process documents in batches to manage memory
List<String> documents = getDocumentList();
int batchSize = 10;

for (int i = 0; i < documents.size(); i += batchSize) {
    List<String> batch = documents.subList(i, Math.min(i + batchSize, documents.size()));
    processBatch(batch);
    // Force garbage collection between batches if needed
    System.gc();
}

private static Boolean licenseValid = null;

public static boolean isLicenseValid() {
    if (licenseValid == null) {
        licenseValid = License.isValidLicense();
    }
    return licenseValid;
}

// Example: Reading encrypted license file
byte[] encryptedLicense = Files.readAllBytes(Paths.get(licensePath));
byte[] decryptedLicense = decrypt(encryptedLicense);
InputStream stream = new ByteArrayInputStream(decryptedLicense);

String licensePath = System.getenv("GROUPDOCS_LICENSE_PATH");

@Component
public class GroupDocsLicenseManager {
    
    @Value("${groupdocs.license.path:license.lic}")
    private String licensePath;
    
    @PostConstruct
    public void initializeLicense() {
        try (InputStream stream = new FileInputStream(licensePath)) {
            License license = new License();
            license.setLicense(stream);
            
            if (License.isValidLicense()) {
                log.info("GroupDocs license applied successfully");
            } else {
                log.warn("GroupDocs license validation failed");
            }
        } catch (Exception e) {
            log.error("Failed to initialize GroupDocs license", e);
        }
    }
}

@Service
public class LicenseService {
    private static final AtomicBoolean licenseInitialized = new AtomicBoolean(false);
    
    public void ensureLicense() {
        if (licenseInitialized.compareAndSet(false, true)) {
            // Initialize license once per service instance
            initializeLicense();
        }
    }
}

byte[] licenseData = loadLicenseFromDatabase();
InputStream stream = new ByteArrayInputStream(licenseData);