> ## 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. # Verwenden von Java mit FRE unter Linux > Verwenden Sie ABBYY FineReader Engine aus Java unter Linux: Fügen Sie die Datei `com.abbyy.FREngine` `.jar` Ihrem classpath hinzu und rufen Sie InitializeEngine und DeinitializeEngine auf, um die Engine zu laden und zu entladen. Unter Linux finden Sie die vollständige Liste in der Developer's Help der Linux-Distribution. Eine wichtige Einschränkung besteht darin, dass Objekte, die IEngineLoader implementieren, unter Linux und macOS nicht verfügbar sind (siehe [Unterschiede zwischen ABBYY FineReader Engine 12 für Windows und Linux](/de/fine-reader/engine/specifications/differences-between-abbyy-finereader-engine-for-windows-and-linux)).
## Einbinden der FineReader Engine-Bibliothek in ein Java-Projekt
ABBYY FineReader Engine umfasst die Datei `com.abbyy.FREngine-%BUILD_ID%.jar`, die die Java-Klassenbibliothek für FineReader Engine enthält. Sie finden sie im Ordner Inc/Java. Der Pfad zu dieser Datei kann über den Parameter `classpath` in der Befehlszeile sowie in den Projekteinstellungen verschiedener Java-Entwicklungsumgebungen angegeben werden. Beispiel: ```csharp theme={null} $JDK/bin/javac -classpath /com.abbyy.FREngine-%BUILD_ID%.jar Hello.java ``` \$JDK ist der Pfad zum Java Development Kit. Eine Liste der unterstützten Java Development Kits finden Sie unter [Systemanforderungen](/de/fine-reader/engine/specifications/system-requirements).
## Laden und Entladen von FineReader Engine
Sie können die statische Engine-Klasse verwenden, um das [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface)-Objekt zu laden. Die Engine-Klasse stellt Methoden bereit, die den ABBYY FineReader Engine-[Funktionen](/de/fine-reader/engine/api-reference/functions) zum Laden und Entladen der Engine entsprechen: | Funktion | Methode der Engine-Klasse | Signatur der Methode der Engine-Klasse | | ------------------------------------------------------------------------------------------------ | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [InitializeEngine](/de/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](/de/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 { // Engine mit Online-Lizenz laden engine = Engine.InitializeEngine( path, customerProjectId, LicensePath, LicensePassword, "", "", false ); try { // Ein vordefiniertes Profil laden engine.LoadPredefinedProfile( "DocumentConversion_Accuracy" ); // Bilder verarbeiten IFRDocument document = engine.CreateFRDocument(); ... } finally { engine = null; System.runFinalization(); Engine.DeinitializeEngine(); } } catch( Exception ex ) { trace( ex.getMessage() ); } } private IEngine engine = null; ... } ``` Die Datei com.abbyy.FREngine-%BUILD\_ID%.jar ist ein selbstentpackendes Archiv, das bei der ersten Verwendung der FineReader Engine Java API auf Ihrem Computer entpackt wird. Standardmäßig wird der Inhalt in den Ordner Inc/Java entpackt. Wenn Sie einen anderen Ordner verwenden möchten, rufen Sie vor dem Laden der Engine mit einer der oben beschriebenen Methoden die Methode Engine.SetJNIDllFolder auf. Um festzustellen, welcher Ordner derzeit zum Entpacken des Archivs festgelegt ist, rufen Sie Engine.GetJNIDllFolder auf.
## Fehlerbehandlung
ABBYY FineReader Engine kann Ausnahmen der folgenden Typen auslösen: * java.lang.OutOfMemoryError * com.abbyy.FREngine.EngineException Die Ausnahme com.abbyy.FREngine.EngineException erbt von java.lang.Exception und enthält eine zusätzliche Methode `int getHResult`, die den HRESULT-Fehlercode des aufgetretenen Fehlers zurückgibt. Bei einer Ausnahme dieses Typs können Sie nicht nur die Fehlermeldung mit der Methode `getMessage()` abrufen, sondern auch den Fehlercode. ``` try { ... } catch( Exception ex ) { displayMessage( "Message = " + ex.getMessage() ); if( ex instanceof EngineException ) { displayMessage( "HResult = " + Integer.toString( ( ( EngineException )ex ).getHResult() ) ); } } ```
## Aufrufen von Methoden mit Out-Parametern
In der ABBYY FineReader Engine API gibt es mehrere Methoden mit Out-Parametern, die nach dem Methodenaufruf einen neuen Wert erhalten und per Referenz übergeben werden müssen. Diese Parameter sind in der Typbibliothek und in den Methodenbeschreibungen dieser Developer's Help als \[out] oder \[in, out] gekennzeichnet. Wenn Sie mit ABBYY FineReader Engine in Java arbeiten, müssen Sie eine spezielle Ref-Klasse verwenden, um einen Parameter per Referenz zu übergeben. Siehe die folgenden Beispiele. Beispiel, in dem die Out-Parameter per Referenz an die Methode [IFRPage::FindPageSplitPosition](/de/fine-reader/engine/api-reference/document-related-objects/frpage/findpagesplitposition-method) übergeben werden: ``` 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(); ``` Beispiel, in dem die In/Out-Parameter per Referenz an die Methode [ICoordinatesConverter::ConvertCoordinates](/de/fine-reader/engine/api-reference/image-related-objects/coordinatesconverter/convertcoordinates-method) übergeben werden: ``` 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(); ```
## Automatisches Freigeben von Ressourcen
FineReader Engine unterstützt die `AutoCloseable`-Schnittstelle, sodass Sie mit der `try`-Anweisung auf die von Objekten belegten Ressourcen zugreifen können. Das bedeutet, dass beim Verlassen des `try`-Blocks alle belegten Ressourcen automatisch geschlossen werden, ohne dass Schließmethoden explizit aufgerufen werden müssen. Wir empfehlen, die `try`-Anweisung für alle Objekte in Ihrem Code zu verwenden (siehe Beispiel unten): ```csharp theme={null} try( IFRDocument document = engine.CreateDocument() ) { // Bild zu einem Dokument hinzufügen document.AddImageFile( imagePath, null, null ); ... // Ergebnisse als PDF speichern document.Export( pdfExportPath, FileExportFormatEnum.FEF_PDF, pdfParams ); } ```
## Arbeiten mit Aufzählungen
Methoden und Eigenschaften, die eine Kombination von Aufzählungskonstanten akzeptieren, erfordern, dass der `int`-Wert an die jeweilige Methode bzw. Eigenschaft übergeben wird. Um den `int`-Wert einer Aufzählungskonstante zu erhalten, verwenden Sie die Methode `getValue`, die von allen Aufzählungen unterstützt wird. Im folgenden Codebeispiel wird gezeigt, wie die Eigenschaft [BwPictureFormats](/de/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfpicturecompressionparams#bwpictureformats) des Objekts [PDFPictureCompressionParams](/de/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfpicturecompressionparams) festgelegt wird: ``` IPDFExportParams pep = engine.CreatePDFExportParams(); IPDFPictureCompressionParams ppcp = pep.getPictureCompressionParams(); ppcp.setBwPictureFormats(BwPictureFormatsEnum.BWPF_Auto.getValue()); ```
## Verwendung des RMI-fähigen Wrappers
Es gibt eine separate Version des Java-Wrappers, die Remote Method Invocation (RMI) unterstützt. Alle Klassen erben von UnicastRemoteObject und unterstützen die Remote-Schnittstelle; alle Methoden können eine RemoteException auslösen. Standardmäßig leitet der RMI-fähige Wrapper Aufrufe zur PDF-Verarbeitung an einen separaten Thread mit initialisiertem PDFium weiter. Der RMI-fähige Wrapper erfordert das Java Development Kit. Eine Liste der unterstützten Java Development Kits finden Sie unter [System Requirements](/de/fine-reader/engine/specifications/system-requirements). Das Paket com.abbyy.rmi.FREngine enthält die von der Client-Anwendung verwendeten Remote-Schnittstellen; das Paket com.abbyy.rmi.server.FREngine wird auf der Serverseite verwendet. Aufgrund der Einschränkungen bei der Methodenüberladung müssen Sie außerdem anstelle von libFREngine.so eine andere dynamische Bibliothek verwenden: libFREngine.rmi\_server.so. Diese Pakete reichen für eine einfache Client-Server-Anwendung aus. FineReader Engine ist jedoch selbst nicht thread-sicher und erfordert daher zusätzlichen Aufwand seitens des Programmierers, um sicherzustellen, dass jeweils nur ein Worker-Thread auf eine Engine-Instanz zugreift. Eine vollständige wiederverwendbare Implementierung des serverseitigen Pools von Engines sowie eines Multithread-Clients, der sich damit verbindet, finden Sie in den im Distribution Package enthaltenen Codebeispielen ([rmiPoolServer](/de/fine-reader/engine/guided-tour/samples#rmipoolserver)- und [threadPoolClient](/de/fine-reader/engine/guided-tour/samples#threadpoolclient)-Beispiele, Pakete com.abbyy.rmi.pool.FREngine und com.abbyy.rmi.pool.impl.FREngine).
### Verwenden von Ereignissen und Callback-Schnittstellen
Beachten Sie, dass die vom Client implementierten Ereignisse und Callback-Schnittstellen nach Gebrauch aus der RMI-Runtime entfernt werden sollten: ``` java.rmi.server.UnicastRemoteObject.unexportObject( callback, true ); callback = null; ```