> ## Documentation Index > Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt > Use this file to discover all available pages before exploring further. # Utiliser Java avec FRE for Windows > Utilisez ABBYY FineReader Engine avec Java sous Windows : ajoutez le fichier .jar com.abbyy.FREngine du dossier Inc/Java à votre classpath, puis chargez et déchargez Engine. Cette rubrique s’applique à FRE for Windows.
## Ajout de la bibliothèque FineReader Engine à un projet Java
ABBYY FineReader Engine comprend un fichier com.abbyy.FREngine-%BUILD\_ID%.jar, qui contient la bibliothèque de classes Java pour FineReader Engine. Vous pouvez le trouver dans le dossier [Inc](/fr/fine-reader/engine/distribution/distribution-windows/distribution-kit#incsamples)**Java**. Le chemin d’accès à ce fichier peut être indiqué dans le paramètre classpath sur la ligne de commande ainsi que dans les paramètres du projet de différents environnements de développement Java. Exemple : ```csharp theme={null} %JDK%\bin\Javac -classpath /com.abbyy.FREngine-%BUILD_ID%.jar Hello.java ``` %JDK% correspond au chemin d’accès du kit de développement Java. Consultez la liste des kits de développement Java pris en charge dans [Configuration système requise](/fr/fine-reader/engine/specifications/system-requirements#jdk_requirements).
## Chargement et déchargement de FineReader Engine
Vous pouvez utiliser la classe statique Engine pour charger l’objet [Engine](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface). La classe Engine fournit des méthodes qui correspondent aux [fonctions](/fr/fine-reader/engine/api-reference/functions) d’ABBYY FineReader Engine pour charger et décharger Engine : | Fonction | Méthode de la classe Engine | Signature de la méthode de la classe Engine | | ------------------------------------------------------------------------------------------------ | --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [InitializeEngine](/fr/fine-reader/engine/api-reference/functions/initializeengine-function) | InitializeEngine | `csharp static public IEngine InitializeEngine( String dllFolder, String customerProjectId, String licensePath, String licensePassword, String dataFolder, String tempFolder, boolean isSharedCPUCoresMode ) throws Exception; ` | | [DeinitializeEngine](/fr/fine-reader/engine/api-reference/functions/deinitializeengine-function) | DeinitializeEngine | `static public void DeinitializeEngine() throws Exception;` | ```csharp theme={null} import com.abbyy.FREngine.*; public class Hello { public static void main( String[] args ) { try { // Charger Engine avec une licence en ligne engine = Engine.InitializeEngine( dllPath, customerProjectId, LicensePath, LicensePassword, "", "", false ); try { // Charger un profil prédéfini engine.LoadPredefinedProfile( "DocumentConversion_Accuracy" ); // Traiter les images IFRDocument document = engine.CreateFRDocument(); ... } finally { engine = null; System.runFinalization(); Engine.DeinitializeEngine(); } } catch( Exception ex ) { trace( ex.getMessage() ); } } private IEngine engine = null; ... } ``` Pour charger Engine au moyen de COM, utilisez les méthodes GetEngineInprocLoader ou GetEngineOutprocLoader. Consultez la description de l’interface [IEngineLoader](/fr/fine-reader/engine/api-reference/engine-loaders/iengineloader) pour plus de détails. Si vous utilisez la méthode GetEngineOutprocLoader pour le chargement, vous n’avez pas besoin d’appeler la méthode [IHostProcessControl::SetClientProcessId](/fr/fine-reader/engine/api-reference/engine-loaders/ihostprocesscontrol/setclientprocessid-method), car le processus parent sera défini automatiquement. Si vous développez votre application sous Windows mais prévoyez de l’exécuter sous Linux, n’utilisez pas ces méthodes pour charger Engine. Utilisez uniquement la méthode InitializeEngine décrite ci-dessus. Cette limitation est due au fait que les objets implémentant IEngineLoader ne sont pas disponibles sous Linux. ```csharp theme={null} import com.abbyy.FREngine.*; // Chargement d’Engine avec une licence en ligne engineLoader = Engine.GetEngineInprocLoader(); engine = engineLoader.InitializeEngine( customerProjectId, LicensePath, LicensePassword, "", "", false ); ... // Déchargement d’Engine engine = null; System.runFinalization(); engineLoader.ExplicitlyUnload(); engineLoader = null; System.runFinalization(); ``` ```csharp theme={null} import com.abbyy.FREngine.*; // Chargement d’Engine avec une licence en ligne engineLoader = Engine.GetEngineOutprocLoader(); engine = engineLoader.InitializeEngine( customerProjectId, LicensePath, LicensePassword, "", "", false ); ... // Déchargement d’Engine engine = null; System.runFinalization(); engineLoader.ExplicitlyUnload(); engineLoader = null; System.runFinalization(); ``` Pour travailler avec l’objet Engine créé via un chargeur Engine, la classe Engine fournit des méthodes qui appellent les fonctions COM correspondantes afin de marshaller le pointeur d’interface entre les threads : | Méthode | Signature | Commentaire | | ------------------ | ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | MarshalInterface | `long MarshalInterface();` | Appelle la fonction COM CoMarshalInterface pour marshaller l’interface [IEngine](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface). Cette méthode doit être appelée sur le thread où Engine a été créé, afin de garantir que les données nécessaires à la création d’un objet proxy sur un autre thread seront disponibles. Retourne le handle des données de marshaling. | | UnmarshalInterface | `csharp IEngine UnmarshalInterface( long handle ); ` | Appelle la fonction COM CoUnmarshalInterface pour démarshaller l’interface [IEngine](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface), c’est-à-dire créer un objet proxy avec lequel le processus client pourra interagir de la même manière qu’avec Engine lui-même. Prend en paramètre d’entrée le handle des données de marshaling (retourné par la méthode MarshalInterface) et retourne un pointeur vers l’interface IEngine. | Le fichier com.abbyy.FREngine-%BUILD\_ID%.jar est une archive auto-extractible qui est extraite sur votre machine lors de la première utilisation de l’API Java FineReader Engine. Le dossier dans lequel les fichiers sont extraits par défaut est [Inc](/fr/fine-reader/engine/distribution/distribution-windows/distribution-kit#incsamples)\Java pour Windows. Si vous devez utiliser un autre dossier, appelez la méthode Engine.SetJNIDllFolder avant de charger Engine à l’aide de l’une des méthodes décrites ci-dessus. Pour connaître le dossier actuellement défini pour l’extraction de l’archive, appelez Engine.GetJNIDllFolder.
## Utiliser Engine dans des applications Java multithread
Pour les applications Java multithread, vous pouvez utiliser la classe EnginesPool, qui offre une solution complète pour créer et gérer un pool d’objets FineReader Engine. Cette classe implémente l’interface java.lang.Runnable. ```java theme={null} public class EnginesPool implements Runnable; ``` Les méthodes de la classe EnginesPool sont répertoriées ci-dessous. | Method | Signature | Comment | | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | constructor | `public EnginesPool( int enginesCount, int waitingEngineTimeout, String customerProjectId, String licensePath, String licensePassword, String dataFolder, String tempFolder, boolean isSharedCPUCoresMode ) throws Exception;` | Crée un nouveau pool de `enginesCount` Engines. `waitingEngineTimeout` définit le délai d’attente pour `EnginesPool.GetEngine`. Les autres paramètres sont identiques à ceux de [InitializeEngine](/fr/fine-reader/engine/api-reference/functions/initializeengine-function) | | GetEngine | `csharp public IEngine GetEngine() throws Exception; ` | Obtient une instance d’Engine du pool. Déclenche une exception si le délai `waitingEngineTimeout` est dépassé. | | ReleaseEngine | `csharp public void ReleaseEngine( IEngine engine, boolean isRecycleRequired ) throws Exception; ` | Replace une instance d’Engine dans le pool. Si `isRecycleRequired` vaut true, cette instance est supprimée et remplacée par une nouvelle (même si la limite d’utilisation n’est pas atteinte ou si le recyclage automatique est désactivé). | | SetAutoRecycleUsageCount | `public void SetAutoRecycleUsageCount( int value );` | Définit combien de fois une même instance d’Engine de ce pool peut être réutilisée avant d’être recyclée, c’est-à-dire supprimée puis remplacée automatiquement par une nouvelle. Cette valeur peut être définie sur 0 pour désactiver tout recyclage automatique (seul le recyclage manuel via `ReleaseEngine` sera alors possible). La valeur par défaut est 0 (aucun recyclage automatique). | | GetAutoRecycleUsageCount | `public int GetAutoRecycleUsageCount();` | Obtient la limite de réutilisation d’une instance d’Engine pour ce pool. | | UnloadEngines | `public void UnloadEngines() throws Exception;` | Décharge tous les Engines et désinitialise le pool. | Consultez l’[exemple de code EnginesPool](/fr/fine-reader/engine/guided-tour/samples#enginespool) pour voir un exemple d’utilisation de la classe EnginesPool.
## Gestion des erreurs
ABBYY FineReader Engine peut lever des exceptions des types suivants : * java.lang.OutOfMemoryError * com.abbyy.FREngine.EngineException L’exception com.abbyy.FREngine.EngineException hérite de java.lang.Exception et contient une méthode supplémentaire, int getHResult, qui renvoie le code HRESULT de l’erreur qui s’est produite. Pour une exception de ce type, vous pouvez non seulement récupérer le message d’erreur à l’aide de la méthode getMessage(), mais aussi le code d’erreur. ``` try { ... } catch( Exception ex ) { displayMessage( "Message = " + ex.getMessage() ); if( ex instanceof EngineException ) { displayMessage( "HResult = " + Integer.toString( ( ( EngineException )ex ).getHResult() ) ); } } ```
## Appel de méthodes avec des paramètres out
Plusieurs méthodes de l’API ABBYY FineReader Engine comportent des paramètres out, qui reçoivent une nouvelle valeur après l’appel de la méthode et doivent être passés par référence. Ces paramètres sont indiqués dans la bibliothèque de types et dans la description des méthodes de cette documentation développeur comme \[out] ou \[in, out]. Lorsque vous travaillez avec ABBYY FineReader Engine en Java, vous devez utiliser une classe Ref spéciale pour passer un paramètre par référence. Voir les exemples ci-dessous. Exemple dans lequel les paramètres out sont passés par référence à la méthode [IFRPage::FindPageSplitPosition](/fr/fine-reader/engine/api-reference/document-related-objects/frpage/findpagesplitposition-method) : ``` Ref _ps = new Ref(); Ref _start = new Ref(); Ref _end = new Ref(); page.FindPageSplitPosition( null, null, _ps, _start, _end ); PageSplitDirectionEnum ps = _ps.get(); Integer start = _start.get(); Integer end = _end.get(); ``` Exemple dans lequel les paramètres in/out sont passés par référence à la méthode [ICoordinatesConverter::ConvertCoordinates](/fr/fine-reader/engine/api-reference/image-related-objects/coordinatesconverter/convertcoordinates-method) : ``` Ref _x = new Ref( 100 ); Ref _y = new Ref( 200 ); cnv.ConvertCoordinates( ImageTypeEnum.IT_Modified, ImageTypeEnum.IT_Base, _x, _y ); Integer x = _x.get(); Integer y = _y.get(); ``` L’exemple suivant montre les paramètres out de type tableau passés par référence à la méthode [IPlainText::GetCharacterData](/fr/fine-reader/engine/api-reference/text-related-objects/plaintext/getcharacterdata-method) : ``` Ref _leftBorders = new Ref(); Ref _topBorders = new Ref(); Ref _rightBorders = new Ref(); Ref _bottomBorders = new Ref(); Ref _confidences = new Ref(); Ref _isSuspicious = new Ref(); plainText.GetCharacterData( _pageNumbers, _leftBorders, _topBorders, _rightBorders, _bottomBorders, _confidences, _isSuspicious ); int[] pageNumbers = _pageNumbers.get(); int[] leftBorders = _leftBorders.get(); int[] topBorders = _topBorders.get(); int[] rightBorders = _rightBorders.get(); int[] bottomBorders = _bottomBorders.get(); int[] confidences = _confidences.get(); boolean[]isSuspicious = _isSuspicious.get(); Ref _pageNumbers = new Ref(); ```
## Gestion des ressources
FineReader Engine prend en charge l’interface AutoCloseable, ce qui vous permet d’utiliser l’instruction try pour gérer les ressources allouées aux objets. Cela signifie qu’une fois le bloc try terminé, toutes les ressources allouées sont fermées automatiquement, sans qu’il soit nécessaire d’appeler explicitement des méthodes de fermeture. Nous vous recommandons d’utiliser l’instruction try pour tous les objets de votre code (voir l’exemple ci-dessous) : ```csharp theme={null} try( IFRDocument document = engine.CreateDocument() ) { // Ajouter une image à un document document.AddImageFile( imagePath, null, null ); ... // Enregistrer les résultats au format PDF document.Export( pdfExportPath, FileExportFormatEnum.FEF_PDF, pdfParams ); } ``` Utilisation de HGLOBAL Certaines méthodes de l’API ABBYY FineReader Engine prennent comme paramètre d’entrée un handle HGLOBAL vers un bloc de mémoire (passé en tant que [\_\_int64](/fr/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/working-with-properties)). Comme HGLOBAL est spécifique à Windows, ces méthodes reçoivent à la place, dans le wrapper Java, le contenu du bloc de mémoire sous forme de byte\[]. Voir la liste de ces méthodes : * méthodes [LoadImageDocFromMemory](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/processing-methods/loadimagedocfrommemory-method) et [OpenImageFileFromMemory](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/processing-methods/openimagefilefrommemory-method) de l’objet [Engine](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface) * méthode [LoadFromMemory](/fr/fine-reader/engine/api-reference/supplementary-objects-and-methods/loadfrommemory-method) fournie par de nombreux objets * méthode [AddImageFileFromMemory](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilefrommemory-method) de l’objet [FRDocument](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument) * méthode [AddFromMemory](/fr/fine-reader/engine/api-reference/document-related-objects/pdfattachments/addfrommemory-method) de l’objet [PDFAttachments](/fr/fine-reader/engine/api-reference/document-related-objects/pdfattachments) En revanche, les méthodes qui renvoient un objet [Handle](/fr/fine-reader/engine/api-reference/supplementary-objects-and-methods/handle) le renvoient également dans le wrapper Java.
## Utilisation des énumérations
Les méthodes et les propriétés qui acceptent une combinaison de constantes d’énumération exigent que la valeur `int` soit transmise à la méthode ou à la propriété. Pour obtenir la valeur `int` d’une constante d’énumération, utilisez la méthode `getValue`, prise en charge par toutes les énumérations. Voici un exemple de code qui montre comment définir la propriété [BwPictureFormats](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfpicturecompressionparams#bwpictureformats) de l’objet [PDFPictureCompressionParams](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfpicturecompressionparams) : ``` IPDFExportParams pep = engine.CreatePDFExportParams(); IPDFPictureCompressionParams ppcp = pep.getPictureCompressionParams(); ppcp.setBwPictureFormats(BwPictureFormatsEnum.BWPF_Auto.getValue()); ``` Voir aussi [Différentes façons de charger l’objet Engine](/fr/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine) pour Windows [Développement multiplateforme en Java](/fr/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/cross-platform-development-in-java) pour Windows