Guide d'intégration du SDK de compression : appels multilangues Python/Java/C#

Conclusion d'abord : le SDK SmartSlim exporte une bibliothèque dynamique via l'ABI C standard, prenant en charge l'intégration en quatre langages (Python/Java/C#/Rust). Le flux d'appel principal se déroule en quatre étapes — initialisation du SDK, création de la configuration de compression, exécution de la compression, libération des ressources. La compression d'un PDF de 100 Mo prend environ 0,8 seconde, la latence de vérification de licence est inférieure à 5 ms. Cet article fournit des exemples de code d'intégration complets en trois langages, des tableaux de paramètres API et des solutions d'optimisation des performances, avec une démo de compression par lot. Commençons par l'architecture du SDK, puis détaillons les méthodes d'intégration pour chaque langage.

Si vous devez appeler le service de compression via une interface HTTP plutôt que par intégration SDK, nous vous recommandons de lire d'abord Guide pratique de l'API de compression : documentation détaillée de l'interface RESTful。

I. Architecture du SDK et principe d'intégration

Le SDK SmartSlim repose sur un moteur de compression en Rust, exporté sous forme de bibliothèque dynamique (.so/.dylib/.dll) via l'ABI C standard (Application Binary Interface). Tout langage prenant en charge FFI (Foreign Function Interface) peut charger et appeler cette bibliothèque. L'avantage de cette architecture est le suivant : le moteur principal est écrit une fois en Rust, puis la même bibliothèque binaire est réutilisée par plusieurs langages, sans réimplémenter la logique de compression dans chaque langage.

Composant	Technologie	Rôle	Sortie
Moteur de compression	Rust	Exécute l'algorithme de compression	Bibliothèque statique .a/.lib
Couche d'export ABI	Rust #[no_mangle]	Exporte des fonctions compatibles C	Bibliothèque dynamique .so/.dylib/.dll
Couche de liaison de langage	FFI de chaque langage	Encapsule les appels natifs	Paquet/bibliothèque de chaque langage
Module de licence	Rust + chiffrement	Vérifie la clé de licence	Intégré dans la bibliothèque dynamique
Gestion de configuration	Rust struct	Gestion des paramètres de compression	Configuration JSON/TOML

Le SDK fournit des bibliothèques précompilées pour 6 plateformes, couvrant les systèmes d'exploitation et architectures CPU les plus courants, prêtes à l'emploi sans avoir à compiler le code Rust soi-même.

Plateforme	Bibliothèque dynamique	Système d'exploitation	Architecture CPU	Cas d'usage
linux-x64	libsmartslim.so	Linux	x86_64	Serveur/bureau
linux-arm64	libsmartslim.so	Linux	aarch64	Serveur ARM/Raspberry Pi
macos-universal	libsmartslim.dylib	macOS	x86_64+arm64	Intel+Apple Silicon
windows-x64	smartslim.dll	Windows	x86_64	Windows bureau/serveur
linux-server-x64	libsmartslim.so	Linux	x86_64	Version optimisée serveur
linux-server-arm64	libsmartslim.so	Linux	aarch64	ARMVersion optimisée serveur

II. Détail des paramètres de l'API principale

L'API principale du SDK se divise en quatre catégories : initialisation, configuration, compression et libération. Le tableau ci-dessous liste les principales fonctions API et leurs paramètres.

Fonction API	Paramètres	Valeur de retour	Description
smartslim_init	license_key: String	handle: Handle	Initialise le SDK, vérifie la licence
smartslim_create_config	format, level, quality	config: ConfigHandle	Crée la configuration de compression
smartslim_compress	handle, input, output, config	result: ResultCode	Exécute la compression d'un seul fichier
smartslim_compress_batch	handle, files[], config, workers	results[]: ResultCode	Compression par lot (multi-concurrent)
smartslim_get_info	handle, filepath	FileInfo: struct	Obtient les informations de compression du fichier
smartslim_free_config	config: ConfigHandle	void	Libère les ressources de configuration
smartslim_free	handle: Handle	void	Libère l'instance du SDK

Les paramètres de configuration de compression prennent en charge 4 niveaux de compression (low/medium/high/ultra) x 15 scénarios x 5 profils de performance (ultrafast/fast/balanced/quality/optimal), soit 300 combinaisons au total, couvrant pratiquement tous les besoins de compression.

Paramètres	Valeurs possibles	Valeur par défaut	Description
format	pdf/image/video/office/ofd	Détection automatique	Type de fichier
level	low/medium/high/ultra	medium	Niveau de compression
quality	1-100	75	Facteur de qualité (image/PDF)
performance	ultrafast/fast/balanced/quality/optimal	balanced	Profil de performance
workers	1-16	4	Nombre de threads concurrents
security	DISABLED/LOW/MEDIUM/HIGH/MAXIMUM	MEDIUM	Niveau de sécurité

III. Exemples de code d'intégration en trois langages

Voici des exemples d'intégration complets en Python, Java et C#, tous basés sur la compression d'un seul fichier PDF.

1. Intégration Python (ctypes)

Python charge la bibliothèque dynamique via le module ctypes et appelle les fonctions exportées. Le code ci-dessous implémente le flux complet : initialisation du SDK, création de la configuration, compression du PDF et libération des ressources. La compression d'un PDF de 100 Mo prend environ 0,8 seconde.

Étape	Code Python	Description
1. Charger la bibliothèque	lib = ctypes.CDLL('./libsmartslim.so')	Charge la bibliothèque dynamique
2. Initialiser	handle = lib.smartslim_init(b"YOUR_LICENSE")	Transmet la clé de licence
3. Créer la configuration	config = lib.smartslim_create_config(b"pdf", b"medium", 75)	PDF/medium/q75
4. Exécuter la compression	lib.smartslim_compress(handle, b"in.pdf", b"out.pdf", config)	Compresse le fichier
5. Libérer les ressources	lib.smartslim_free_config(config); lib.smartslim_free(handle)	Libère la mémoire

2. Intégration Java (JNI)

Java appelle la bibliothèque dynamique via JNI (Java Native Interface). Il faut d'abord déclarer les méthodes native, puis charger le fichier de bibliothèque. Le code ci-dessous présente le flux d'appel principal, adapté à l'intégration dans des projets backend Java tels que Spring Boot.

Étape	Code Java	Description
1. Charger la bibliothèque	System.loadLibrary("smartslim")	Charge la DLL/SO
2. Déclarer la méthode	native long smartslim_init(String key)	Déclaration de méthode JNI
3. Initialiser	long handle = smartslim_init("YOUR_LICENSE")	Obtient le handle d'instance
4. Créer la configuration	long config = smartslim_create_config("pdf","medium",75)	Paramètres de configuration
5. Exécuter la compression	smartslim_compress(handle, "in.pdf", "out.pdf", config)	Compresse le fichier
6. Libérer les ressources	smartslim_free_config(config); smartslim_free(handle)	Libère la mémoire

3. Intégration C# (P-Invoke)

C# appelle la bibliothèque dynamique via P/Invoke (Platform Invocation Services). L'attribut DllImport est utilisé pour déclarer les fonctions externes, adapté aux projets .NET/.NET Core. Le code ci-dessous est compatible avec les plateformes Windows et Linux.

Étape	Code C#	Description
1. Déclarer la fonction	[DllImport("smartslim")] static extern IntPtr smartslim_init(string key)	Déclaration P-Invoke
2. Initialiser	IntPtr handle = smartslim_init("YOUR_LICENSE")	Obtient le handle
3. Créer la configuration	IntPtr config = smartslim_create_config("pdf","medium",75)	Paramètres de configuration
4. Exécuter la compression	smartslim_compress(handle, "in.pdf", "out.pdf", config)	Compresse le fichier
5. Libérer les ressources	smartslim_free_config(config); smartslim_free(handle)	Libère la mémoire

IV. Optimisation des performances et compression par lot

L'optimisation des performances de l'intégration du SDK s'articule autour de trois dimensions : concurrence, mémoire et traitement par lot. Le tableau ci-dessous compare les effets des différentes stratégies d'optimisation.

Stratégie d'optimisation	Temps par fichier	Temps total pour 100 fichiers	Occupation mémoire	Licence requise
Série mono-thread	0,8 s	80 s	50 Mo	Trial (1 concurrent)
4 threads concurrents	0,8 s	22 s	180 Mo	Standard (4 concurrents)
8 threads concurrents	0,8 s	12 s	320 Mo	Professional (8 concurrents)
16 threads concurrents	0,8 s	7 s	600 Mo	Enterprise (16+ concurrents)
Mode de compression en flux	1,2 s	95 s	15 Mo	Toutes les licences

Pour la compression par lot, il est recommandé d'utiliser l'interface intégrée smartslim_compress_batch du SDK, en transmettant la liste de fichiers et le nombre de concurrents. Le SDK utilise en interne l'ordonnancement de tâches asynchrones Rust, plus efficace que l'implémentation multithread dans chaque langage. Voici les données de performance d'une démo de compression par lot de 100 fichiers PDF.

Nombre de fichiers	Moyenne par fichier	Volume total	Volume après compression	Temps (8 concurrents)	Taux de compression
100 PDF	15 Mo	1,5 Go	320 Mo	12 s	78,7 %
100 PNG	8 Mo	800 Mo	180 Mo	8 s	77,5 %
100 DOCX	5 Mo	500 Mo	120 Mo	6 s	76,0 %
100 MP4	50 Mo	5 Go	1,8 Go	45 s	64,0 %

Si vous souhaitez comparer les algorithmes sous-jacents des bibliothèques de compression Rust, vous pouvez consulter Comparaison des bibliothèques de compression Rust : pourquoi choisir Rust pour écrire un moteur de compression. Si vous avez besoin de déployer le service de compression en conteneur via Docker, vous pouvez consulter Déploiement Docker du service de compression。

V. FAQ

Q1：Quels langages de programmation le SDK de compression prend-il en charge ?

Le SDK SmartSlim exporte une bibliothèque dynamique via l'ABI C standard, prenant en charge l'intégration en quatre langages : Python (ctypes), Java (JNI), C# (P-Invoke) et Rust (FFI). Le SDK fournit des bibliothèques précompilées pour 6 plateformes (linux-x64/arm64, macos-universal, windows-x64, etc.), prêtes à l'emploi sans compilation. D'autres langages prenant en charge les appels ABI C (comme Go, Node.js, PHP) peuvent également être intégrés via leurs propres mécanismes FFI.

Q2：Quel est le flux d'appel de l'API du SDK de compression ?

Le flux d'appel standard se déroule en quatre étapes : 1. appeler smartslim_init pour initialiser le SDK et transmettre la clé de licence ; 2. appeler smartslim_create_config pour créer la configuration de compression (format, niveau, profil de performance) ; 3. appeler smartslim_compress pour exécuter la compression (chemin d'entrée et chemin de sortie) ; 4. appeler smartslim_free pour libérer les ressources. La compression d'un PDF de 100 Mo prend environ 0,8 seconde, la latence de vérification de licence est inférieure à 5 ms.

Q3：Comment implémenter la compression par lot avec le SDK de compression ?

La compression par lot propose deux méthodes : premièrement, appeler en boucle l'interface de compression monofichier avec concurrence multithread (Python utilise concurrent.futures, Java utilise ThreadPoolExecutor) ; deuxièmement, utiliser l'interface de compression par lot intégrée au SDK smartslim_compress_batch, en transmettant la liste de fichiers et le nombre de concurrents, le SDK utilisant en interne l'ordonnancement de tâches asynchrones Rust. La deuxième méthode est recommandée : la licence Standard prend en charge 4 concurrents, Professional 8 concurrents, Enterprise 16 concurrents et plus.

Q4：Que faire en cas d'erreur d'intégration du SDK de compression ?

Erreurs courantes et solutions : 1. UnsatisfiedLinkError (Java) ou échec de chargement DLL — vérifier que le chemin de la bibliothèque dynamique correspond à l'architecture système ; 2. échec de vérification de licence — vérifier si la clé de licence est correcte et non expirée ; 3. débordement mémoire — réduire le nombre de concurrents ou activer le mode de compression en flux ; 4. format non pris en charge — vérifier si la version du SDK prend en charge le format cible. Il est recommandé d'activer les journaux DEBUG pour localiser le problème ou de contacter le support technique SmartSlim.

Conclusion

Le SDK SmartSlim implémente, via l'ABI C standard, le principe « écrire une fois, appeler depuis plusieurs langages », prenant en charge l'intégration en quatre langages : Python/Java/C#/Rust. Le flux d'appel principal se déroule en quatre étapes : initialisation, création de la configuration, exécution de la compression, libération des ressources. La compression d'un PDF de 100 Mo prend 0,8 seconde, la compression par lot de 100 fichiers avec 8 concurrents ne prend que 12 secondes. L'optimisation des performances s'articule autour de trois dimensions : concurrence (4 à 16 threads), mémoire (le mode flux réduit l'occupation de 75 %), traitement par lot (interface batch intégrée).

Retenez trois points : premièrement, choisissez la bibliothèque précompilée correspondant à l'architecture de votre système (6 plateformes couvertes) ; deuxièmement, pour la compression par lot, utilisez prioritairement l'interface batch intégrée plutôt que d'implémenter votre propre multithreading ; troisièmement, en production, une licence Professional ou supérieure (8 concurrents) est recommandée pour équilibrer performance et coût. Si vous préférez les appels via interface HTTP plutôt que l'intégration SDK, consultez le guide pratique de l'API de compression.