Es soll auf Daten aus dem SAP System zugegriffen werden, ohne die Datenbank direkt anzusprechen.<\/p>\n
Durch die Verwendung des Java-Connectors (JCo) werden Funktionsbausteine \/ BAPIs als SAP Schnittstellen verwendet. Die Funktionsbausteine k\u00f6nnen \u00fcber die SAP GUI mit dem BAPI-Explorer gesucht und mit der TA 37 getestet werden. Der nachfolgende Artikel besch\u00e4ftigt sich mit dem Aufruf von einem Java-Server. Der JCo kann im Market Place von SAP kostenlos heruntergeladen werden.<\/p>\n
Ein Remote Function Call (RFC) ist die SAP-Implementierung von Remote Procedure Calls (RPC). \u00dcber einen RFC lassen sich Funktionsbausteine, bzw. BAPI’s aufrufen. <\/p>\n
Ein RFC verwendet die Kommunikationsregeln des CPI-C-Protokolls, welches auf TCP\/IP oder LU 6.2 basiert. LU 6.2 war dabei das Kommunikationsprotokoll von R\/2-Mainframe-Systemen und wurde bei R\/3 durch den einheitlichen TCP\/IP-Standard ersetzt.<\/p>\n
RFC’s nehmen ausschlie\u00dflich Call-By-Value-Parameter entgegen, da die \u00dcbergabe von Zeigern und Speicheradressen hier keinen Sinn macht. In einem fremden System w\u00fcrde die Speicheradresse auf einen Speicher-Bereich zeigen, in dem keine oder Daten von anderen Anwendungen vorhanden sind. <\/p>\n
Der Java Connector unterst\u00fctzt den Aufruf von RFC’s, bzw. BAPIs aus einer externen Java-Umgebung (SAP-inbound-call), sowie den Aufruf externer JAVA-Funktionalit\u00e4ten aus ABAP-Programmen heraus (SAP-outbound-call). F\u00fcr die letztgenannte Variante existiert im Example-Verzeichnis des JCo ein Beispiel, in dem ein JCo-Server implementiert wird. Der JCo-Server muss dem SAP-System \u00fcber die Transaktion SM59 bekanntgemacht werden.<\/p>\n
Bei einem SAP-Inbound-Call ist die Vorgehensweise die folgende:<\/p>\n
1.) Anmeldung der Java-Applikation am R\/3-System<\/p>\n
\r\nJCO.Client Conection = JCO.createClient(Mandant,\r\n Username,\r\n Password,\r\n Language,\r\n Hostname,\r\n Systemnummer);\r\n\r\nConnection.connect();\r\n<\/pre>\n2.) Herunterladen des Repository f\u00fcr den Funktionsbaustein<\/p>\n
\r\nIRepository rep = JCO.createRepository("MyRepository", Connection);\r\nIFunctionTemplate template = rep.getFunctionTemplate("BAPI_NAME");\r\nJCO.Function funktion = new JCO.Function(template);\r\n<\/pre>\n3.) Holen einer Referenz auf die \u00dcbergabeparameter<\/p>\n
\r\nJCO.ParameterList import = funktion.getImportParameterList();\r\nJCO.ParameterList table = funktion.getTableParameterList();\r\n<\/pre>\n4.) Bef\u00fcllen des Bausteins <\/p>\n
5.) Funktionsbaustein ausf\u00fchren<\/p>\n
\r\nConnection.execute(funktion);\r\n<\/pre>\n6.) Hole Referenz auf R\u00fcckgabeparameter<\/p>\n
\r\nJCO.ParameterList export = funktion.getExportParameterList();\r\nJCO.ParameterList table = funktion.getTableParameterList();\r\n<\/pre>\n7.) Auslesen des Bausteins <\/p>\n
Es werden synchrone (sRFC), asynchrone (aRFC) und transaktionale Aufrufe (tRFC, qRFC), sowie Connection-Pooling unterst\u00fctzt (auf JAVA- wie auf ABAP-Seite).<\/p>\n
SAP lobt zwar die Plattformunabh\u00e4ngigkeit des Connectors, jedoch st\u00f6\u00dft man bei einfachem Kopieren des Bytecodes auf Probleme, da hier eine plattformabh\u00e4ngige Bibliotheksdatei gekapselt wird, die bei h\u00f6heren Releases nicht mehr funktioniert. Unter Windows wird die Datei librfc32.dll und unter Linux die Datei librfccm.so gekapselt.<\/p>\n
Durch die Kapselung der Datei ist es ohne weiteres m\u00f6glich, Konnektoren f\u00fcr nicht unterst\u00fctzte Programmiersprachen zu implementieren.<\/p>\n
Ein Tutorial der Zeitschrift „Der Entwickler“, welches Online zur Verf\u00fcgung steht, zeigt durch Verwendung dieser Bibliothek, wie man Delphi an SAP-Systeme andocken kann. Der Artikel tr\u00e4gt den Namen „Delphi goes SAP“. Da es f\u00fcr Delphi keine Konnektoren wie den Java Connector gibt, ist die Kapselung dieser Datei notwendig.<\/p>\n
Parameter von Funktionsbausteinen<\/h1>\n
Da die meisten SAP-Anwendungen im ABAP-Stack implementiert worden, greift man mit dem JAVA Connector haupts\u00e4chlich auf remotef\u00e4hige Funktionsbausteine zu. Diesen werden entweder ausgef\u00fcllte Tabellen, oder Import-Parameter zur Verarbeitung \u00fcbergeben. Als Ausgabe liefert ein Funktionsbaustein Fehler-Parameter, Export-Parameter, neue Tabellen oder auch die \u00fcbergebenen Tabellen mit neuen Werten zur\u00fcck. Hierf\u00fcr ist es notwendig den syntaktischen Aufbau von JCO-Syntax zu kennen. <\/p>\n
Import-Parameter<\/h2>\n
Import-Parameter kann man sich wie einfache \u00dcbergabeparametern aus bekannten Programmiersprachen vorstellen. Ein Import-Parameter entspricht einem Feld, was einen Datentyp beinhaltet (Char, Integer, String, Double…). Es kann keine Array’s, Listen oder Tabellen entgegennehmen.<\/p>\n
SAP kennzeichnet hauseigene Funktionsbausteine mit einem vorangehenden I f\u00fcr „Import“. Mit der Transaktion SE16 ist es m\u00f6glich sich die notwendigen Import-Parameter anzusehen. <\/p>\n
Nicht alle Import-Parameter sind erforderlich, es gibt auch optionale Parameter. Nicht jeder Funktionsbaustein hat Import-Parameter.<\/p>\n
Der nachstehende Code zeigt, wie mit Hilfe des JAVA Connectors der Funktionsbaustein „CFX_API_USER_GETDETAIL“, der die Detaildaten eines cFolders-Benutzers zur\u00fcckgibt bef\u00fcllt wird:<\/p>\n
\r\npublic String gibListeVonUsern()\r\n{\r\n IRepository repository = JCO.createRepository("MYRepository", client);\r\n IFunctionTemplate ftemplate = repository\r\n .getFunctionTemplate("CFX_API_USER_GETDETAIL");\r\n Function func = ftemplate.getFunction();\r\n\r\n JCO.ParameterList input = func.getImportParameterList();\r\n input.setValue("KARPBJ01", "I_USER_ID");\r\n\r\n \/\/ Funktion aufrufen\r\n client.execute(func);\r\n (...)\r\n}\r\n<\/pre>\nExport-Parameter<\/h2>\n
Nachdem die Funktion ausgef\u00fchrt wurde, kann \u00fcber die Export-Parameter iteriert werden um die R\u00fcckgabewerte auszulesen. Dazu hat die Klasse ParameterList die Methode getFieldCount(), welche die Anzahl der R\u00fcckgabeparameter zur\u00fcckliefert. Die Methode getString(index) erm\u00f6glich \u00fcber den inkrementellen Index die Iteration mit einer Schleife. Dadurch lassen sich alle Parameter dynamisch auslesen.<\/p>\n
Nachfolgend wird aus der aufgerufenden Funktion \u00fcber die Export-Parameterliste iteriert und das Ergebnis an den String „informationen“ angehangen.<\/p>\n
\r\n\r\npublic String gibListeVonUsern()\r\n{\r\n (...) \/\/Hier war der Funktionsaufruf\r\n\r\n JCO.ParameterList output = func.getExportParameterList();\r\n\r\n for (int i = 0; i < output.getFieldCount(); i++)\r\n {\r\n informationen = informationen + output.getString(i) + "\\n";\r\n }\r\n return informationen;\r\n}\r\n\r\n<\/pre>\nChanging-Parameter<\/h2>\n
Im Gegensatz zu Import- und Export-Parametern funktionieren Changing-Parameter in beide Richtungen (bidirektional). Der Aufruf ist dabei Call-By-Reference-\u00e4hnlich, da sich nach dem Ausf\u00fchren des Funktionsbausteins mit dem Befehl client.execute(func); der Wert im Feld \u00e4ndern kann. Das Bef\u00fcllen und auslesen funktioniert dabei wie bei den Import- und Export-Parametern.<\/p>\n
Table-Parameter<\/h2>\n
Table-Parameter sind bidirektional. Die Referenz auf eine Tabelle kann geholt werden, bevor die Funktion ausgef\u00fchrt wurde. Hat man die Referenz auf die Tabelle, so l\u00e4sst sich diese folgenderma\u00dfen bef\u00fcllen:<\/p>\n
\r\n\r\n \/\/ Iteration \u00fcber einen Vector\r\n for (int i = 0; i < vector.size(); i++)\r\n {\r\n \/\/ Neue Zeile an Tabelle anh\u00e4ngen und auf\r\n \/\/ neue Zeile wechseln\r\n table.appendRow();\r\n\r\n \/\/ schreibe in erste Spalte\r\n table.setValue((String)vector.get(i),0);\r\n\r\n \/\/ schreibe in zweite Spalte\r\n table.setValue((String)vector.get(i),1);\r\n }\r\n\r\n<\/pre>\nNachdem eine Funktion ausgef\u00fchrt wurde, also nachdem Connection.execute(funktion); ausgef\u00fchrt wurde, kann eine neue Tabelle zur\u00fcckgeliefert werden, oder eine bereits bef\u00fcllte Tabelle neue Werte beinhalten. <\/p>\n
Um \u00fcber eine R\u00fcckgabetabelle zu iterieren, gibt es die Funktion setRow(index). Das folgende Beispiel zeigt die Suche nach einem bestimmten String in der 3. Spalte und liefert das Feld „ID“ zur\u00fcck:<\/p>\n
\r\n\r\n String rueckgabe = null;\r\n for (int i=0;i<outputtabelle.getNumRows();i++)\r\n {\r\n outputtabelle.setRow(i);\r\n\r\n if (outputtabelle.getString(2).equals(suche) )\r\n {\r\n rueckgabe = outputtabelle.getString("ID");\r\n }\r\n }\r\n\r\n<\/pre>\nWie ersichtlich wird, l\u00e4sst sich die Spalte nicht nur anhand des inkrementellen Indexes ansprechen, sondern auch \u00fcber den Spaltennamen. <\/p>\n
In manchen F\u00e4llen ist es n\u00f6tig eine eigene Tabelle zu erzeugen und diese an einen Funktionsbaustein zu \u00fcbergeben. Zum Beispiel funktioniert die Zuweisung einer bef\u00fcllten Ergebnistabelle an eine \u00dcbergabetabelle nicht, in diesem Fall muss man die Daten in einer Schleife einfach rauskopieren. <\/p>\n
Eine eigene Tabellendefinition erzeugt man in diesem Fall so:<\/p>\n
\r\n\r\n JCO.MetaData smeta = new JCO.MetaData("DIS");\r\n\r\n smeta.addInfo("DOKAR", JCO.TYPE_STRING, 3, 0, 0);\r\n smeta.addInfo("DOKVR", JCO.TYPE_STRING , 2, 0, 0);\r\n smeta.addInfo("DOKTL", JCO.TYPE_STRING , 3, 0, 0);\r\n smeta.addInfo("DOKNR", JCO.TYPE_STRING , 3, 0, 0);\r\n\r\n JCO.Structure structure = new JCO.Structure(smeta); \r\n JCO.Table table = new JCO.Table(structure);\r\n\r\n<\/pre>\nStruktur-Parameter<\/h2>\n
Strukturen geh\u00f6ren zu den Tabellen-Typ-Parametern und sind Sonderf\u00e4lle. Eine Struktur kann innerhalb einer Tabelle, in Import- oder Export-Parametern auftreten. Hierbei handelt es sich lediglich um eine weitere Aufteilung innerhalb eines einzigen Feldes. <\/p>\n
Der folgende Code zeigt, wie eine Referenz auf eine Inputstruktur und auf einen normalen Import-Parameter geholt wird . <\/p>\n
\r\n\r\nJCO.Structure struktur =\r\nfunc.getImportParameterList().getStructure("SELECT_DOCUMENTDATA");\r\nJCO.ParameterList inputdata = func.getImportParameterList();\r\nstruktur.setValue(art, "DOCUMENTTYPE");\r\ninputdata.setValue("X", "GETCLASSIFICATION");\r\nOutput.execute(funktion);\r\n\r\n<\/pre>\nFortsetzung folgt …<\/p>\n