ALE-Schnittstelle generieren: Vorgehen und Programmiermodell 
Prozess
Gehen Sie folgendermaßen vor um eine ALE-Schnittstelle aus einem komplexen Datentyp zu generieren:
Starten Sie die Transaktion über den Transaktionscode BDFG.
Geben Sie den Funktionsbaustein und das Business-Objekt ein, die der Schnittstelle zu Grunde liegen.
Um eine Schnittstelle zu pflegen, anzuzeigen, zu prüfen oder zu löschen, wählen Sie im Menü Schnittstelle eine der Optionen, oder klicken Sie auf ein entsprechendes Symbol.
Folgende Funktionen stehen zur Verfügung:
Schnittstelle anlegen
Die Namen der zu generierenden Objekte werden vorgeschlagen. Sie können diese ändern.
Geben Sie einen Namen für den Nachrichtentyp an.
Bestätigen Sie Ihre Eingabe.
Im nachfolgenden Dialogfenster können Sie folgende Angaben vornehmen:
IDoctyp
Funktionsbaustein im Ausgang
Funktionsbaustein im Eingang
Die vorgeschlagene Entwicklungsklasse und die Funktionsgruppe sind die, zu denen der Funktionsbaustein gehört. Sie sollten bei Ihrer eigenen Schnittstellengenerierung eigene Entwicklungsklassen und Funktionsgruppen verwenden.
Folgende Optionen stehen für die ALE-Eingangsseite zur Verfügung:
In Update Task
Wenn die Datenbankänderungen durch den Baustein über die Verbuchung durchgeführt werden, dann muss diese Option gewählt werden.
Massenfähige Verarbeitung
Wenn Sie eine Massenverarbeitung von IDocs zulassen möchten, müssen Sie diese Option wählen. Der zugehörige Anwendungsbaustein muss massenverarbeitungsfähig sein.
Sie können nur den Nachrichtentyp (Muss-Feld) und den IDoctyp (Muss-Feld), oder nur einen der Funktionsbausteine (Kann-Felder) generieren, indem Sie das Feld, für das kein Objekt generiert werden soll, leer übergeben.
Bestätigen Sie Ihre Eingabe.
Sollte eine Struktur mehr als 1000-Bytes lang sein, dann wird sie während der Generierung in ein Vatersegment mit Kindsegmenten abgebildet.
Die generierten Objekte werden in einer Baumdarstellung ausgegeben. Von dort kann in die einzelnen Objekt gesprungen werden. Alle Änderungen werden in Transportaufträgen erfasst.
Schnittstelle ändern
Wählen Sie Ändern, um nach einer Änderung des Bausteins die Objekte einer bereits existierenden ALE-Schnittstelle erneut zu generieren. Der IDoctyp und die IDoc-Segmente werden nur dann neu generiert, wenn sich die Schnittstellenstrukturen geändert haben. Die Funktionsbausteine werden immer neu generiert.
Ähnlich wie beim Anlegen erscheint beim Ändern ein Dialogfenster. In diesem Dialogfenster werden die Objekte angezeigt, die bereits im System vorhanden sind. Sie sind nicht eingabebereit.
Falls ein Feld leer ist, können Sie das entsprechende Objekt generieren.
Schnittstelle anzeigen
Wählen Sie Anzeigen, um alle existierenden Objekte zu dieser Schnittstelle anzuzeigen. Sie erhalten einen Überblick über den Zusammenhang zwischen dem Baustein und der ALE-Schnittstelle. Sollte der Anwendungsbaustein nicht mehr vorhanden sein, werden die Objekte trotzdem angezeigt.
Schnittstelle löschen
Wählen Sie Löschen, um eine ALE-Schnittstelle zu löschen.
Die Funktionsbausteine (Ausgang und Eingang) werden in jedem Fall gelöscht, sofern sie im System vorhanden sind. Die IDoc-Struktur wird gelöscht, wenn sie noch nicht freigegeben ist. Die IDoc-Segmente werden nur dann gelöscht, wenn sie nicht freigegeben sind und nicht in anderen IDocs verwendet werden.
Zum Schluss wird der Nachrichtentyp gelöscht, wenn er keine Zuordnung mehr zum IDoctyp hat.
Schnittstelle prüfen
Wählen Sie Prüfen, um zu prüfen, ob alle Objekte bezüglich dieser ALE-Schnittstelle bereits im System vorhanden sind. Es wird auch geprüft, ob Objekte (IDoctyp und Segmente) bereits freigegeben sind. Der Status der Freigabe für Objekte kann geändert werden (siehe Freigabe setzen und Freigabe aufheben unten ). Sollte der Anwendungsbaustein nicht mehr vorhanden sein, wird eine Warnung im Protokoll ausgegeben.
Schnittstelle freigeben
Entwickler können den Status der Freigabe von IDoctyp und Segmenten ändern.
Bei der Freigabe wird zunächst geprüft, ob die generierte Schnittstelle unter dem Baustein den aktuellen Status hat. Wenn nicht, kann sie nicht freigegeben werden. Es wird ermittelt, welche Segmente und welcher IDoctyp für die Freigabe relevant sind. Für noch nicht freigegebene Objekte wird dann der neue Status eingesetzt.
Während der Entwicklung kann die Freigabe jederzeit zurückgenommen werden. Diese Aktion ist an das Transportwesen angeschlossen.
Die generierten Funktionsbausteine werden nicht freigegeben.
Programmiermodell
Schnittstelle von Anwendungen zur ALE-Schicht auf der Ausgangsseite
Der generierte Ausgangsbaustein zur ALE-Schicht, der von Anwendungen auf der Ausgangsseite aufgerufen wird, sieht wie folgt aus:
Syntax
*"-------------------------------------------------------------------- *"*"Verbuchungsfunktionsbaustein: *" *"*"Lokale Schnittstelle: *" IMPORTING *" VALUE(APPLICATION_OBJECTS) TYPE COMPLEX_DATA_TYPE *" VALUE(RECEIVERS) TYPE BDI_RCVT OPTIONAL *" TABLES *" COMMUNICATION_DOCUMENTS TYPE COMM_RETS OPTIONAL *" EXCEPTIONS *" ERROR_CREATING_IDOCS *"--------------------------------------------------------------------
Die Schnittstelle enthält neben dem Parameter des Anwendungsbausteins APPLICATION_OBJECTS die folgenden zusätzlichen Parameter:
RECEIVERS
Dieser Parameter ist optional.
Falls dieser Parameter keinen Wert enthält, werden die Kommunikationspartner bezüglich des Nachrichtentyps nach dem ALE-Verteilungsmodell ermittelt. Werden keine gültigen Kommunikationspartner gefunden, wird zwar ein IDoc aufgebaut, aber keine Nachricht versendet. Ansonsten wird ein IDoc aufgebaut und die Nachricht an die Partner versendet. In diesem Zusammenhang sind alle Kommunikationspartner logische Systeme.
Falls dieser Parameter Werte enthält (Partnernummer und Partnerart als Kommunikationspartner), dann wird immer ein IDoc aufgebaut und versucht, die Nachricht an die Kommunikationspartner zu versenden, ohne das ALE-Verteilungsmodell abzufragen.
COMMUNICATION_DOCUMENTS
Sofern der Baustein nicht in der Update Task aufgerufen wird und IDocs aufgebaut werden, wird dieser Rückgabeparameter gefüllt. Er hat je nach Verarbeitungsart unterschiedliche Strukturen:
Einzelverarbeitung, d.h., der Funktionsbaustein kann nur ein einzelnes Objekt verarbeiten. In diesem Fall enthält die Rückgabetabelle die IDoc-Nummer im Feld OBJKEY, die zum Partner unter den Feldern RCVPRN und RCVPRT versendet wurde.
Massenfähige Verarbeitung, d.h., der Funktionsbaustein kann mehrere Objekte verarbeiten. Es wird die Information über Kommunikation wie bei der Einzelverarbeitung zurückgegeben, zusätzlich noch ein Index unter Feld OBJ_INDEX für jedes einzelne Objekt, das von der Reihenfolge der übergebenen Objekte bestimmt wird.
Das heisst, Anwendungsprogramme können durch die Rückgabe-Parameter COMMUNICATION_DOCUMENTS Information zu den aufgebauten IDocs abfragen, die auf der Datenbank abgelegt sind. Beispielsweise kann über die Felder RCVPRN und RCVPRT der Kommunikationspartner ermittelt werden, oder über OBJKEY die entsprechende IDoc-Nummer. Falls dieser Parameter keinen Wert enthält (Aufruf des Bausteins nicht in Update Task), wird kein IDoc aufgebaut.
Es sollte im Prinzip auf der ALE-Ausgangsseite rein technische Fehler geben, welche die Ausnahme ERROR_CREATING_IDOCS auslösen. Schwere Fehler wie Eigenes logisches System nicht definiert, Kein Nachrichtentyp vorhanden, Fehlender oder falscher IDoctyp, oder Keine Datensätze übergeben, werden von der ALE-Schicht mit einer A-Meldung (Abbruch) direkt ausgegeben. Für anderen Fälle ist das aufrufende Programm zuständig. In der Regel führt ein Abbruch automatisch zu einem Zurückrollen der Datenbankänderungen (Rollback Work).
Wird der Baustein in der Update Task aufgerufen, wird der Rückgabeparameter COMMUNICATION_DOCUMENTS nicht gefüllt und auch keine Ausnahme ERROR_CREATING_IDOCS ausgelöst.
Kommunikationspartner und ALE-Verteilungsmodell bzw. Partnervereinbarung
Nach dem Erweiterungskonzept können für einen Anwendungsbaustein mit komplexem Datentyp mehrere ALE-Schnittstellen vorhanden sein, die von Partnern oder Kunden generiert wurden. Welche ALE-Schnittstelle während der Laufzeit zu welchem Kommunikationspartner aufgerufen wird, wird durch einen der Nachrichtentypen bestimmt, die im ALE-Verteilungsmodell definiert sind. D.h., die Anwendungen sollen zunächst durch die von ALE bereitgestellte Schnittstelle diese Information ermitteln und dann die ALE-Schnittstelle aufrufen:
Syntax
FUNCTION ale_model_determine_outbound. *"-------------------------------------------------------------------- *"*"Lokale Schnittstelle: *" IMPORTING *" VALUE(APPL_FUNCTION) TYPE RS38L_FNAM *" EXPORTING *" VALUE(PARAM_OUTBOUND) TYPE BDI_OUTBT *" EXCEPTIONS *" OWN_SYSTEM_NOT_DEFINED *" NO_AUTHORITY *"--------------------------------------------------------------------
Ähnlich können auch die Ausgangsparameter durch Partnervereinbarung ermittelt werden:
Syntax
FUNCTION ale_pprof_determine_outbound. *"------------------------------------------------------------------ *"*"Lokale Schnittstelle: *" IMPORTING *" VALUE(APPL_FUNCTION) TYPE RS38L_FNAM *" EXPORTING *" VALUE(PARAM_OUTBOUND) TYPE BDI_OUTBT *"-------------------------------------------------------------------
Über den Parameter APPL_FUNCTION wird der Anwendungsbausteinname übergeben, aus dem die ALE-Schnittstellen generiert wurden. Sofern entsprechende Nachrichten im ALE-Verteilungsmodell gepflegt sind, wird der Rückgabe-Parameter PARAM_OUTBOUND gefüllt. Aus dem Feld FUNCNAME des Parameters PARAM_OUTBOUND (referenziert auf Tabellentyp) erfährt die Anwendung, welcher ALE-Ausgangsbaustein aufzurufen ist, aus dem Feld MESTYPE, welcher Nachricht er entspricht. Weiterhin erfährt die Anwendung aus dem Feld RECEIVER, ob der Aufruf mehrere, einen oder keine gültigen Kommunikationspartner betrifft. Wenn Sie die Kommunikationspartner über das ALE-Verteilungsmodell ermitteln lassen möchten, dann rufen Sie den ermittelten Ausgangsaustein mit entsprechenden Daten auf, ohne explizit die Kommunikationspartner durch Parameter RECEIVERS zu übergeben. Wenn Sie die Nachricht jedoch nur an bestimmte Kommunikationspartner versenden möchten, sollten Sie die Kommunikationspartner mittels des Parameters RECEIVERS übergeben.
Commit Work
Nach dem Aufruf des generierten Ausgangsbausteins ist explizite Programmierung mit COMMIT WORK in der Anwendung obligatorisch. Es schließt die aktuelle Transaktion ab und startet weitere Tasks wie Update Task und Background Task, durch die eine Datenbankänderung durch Verbuchung, oder ein IDoc-Versand durch tRFC oder Dateischnittstellen durchgeführt wird.
Der COMMIT WORK muss nicht sofort nach dem Aufruf, sondern kann auch in höheren Aufrufebenen oder nach mehreren Aufrufen des Ausgangsbausteins erfolgen. Da im Schritt COMMIT WORK viele Prozesse durchzuführen sind, darf die Sperrung der IDocs, die beim Aufruf des Ausgangsbausteins aufgebaut sind, nicht vor dem COMMIT WORK aufgehoben werden. Damit werden unerwartete Aktivitäten mit solchen IDocs verhindert.
Schnittstelle der ALE-Schicht zu Anwendungen auf der Eingangsseite
Der generierte Eingangsbaustein, der von der ALE-Schicht auf der Eingangsseite aufgerufen wird, hat folgende Standard-Schnittstelle:
Syntax
*"---------------------------------------------------------------------- *"*"Lokale Schnittstelle: *" IMPORTING *" VALUE(INPUT_METHOD) LIKE BDWFAP_PAR-INPUTMETHD *" VALUE(MASS_PROCESSING) LIKE BDWFAP_PAR-MASS_PROC *" EXPORTING *" VALUE(WORKFLOW_RESULT) LIKE BDWF_PARAM-RESULT *" VALUE(APPLICATION_VARIABLE) LIKE BDWF_PARAM-APPL_VAR *" VALUE(IN_UPDATE_TASK) LIKE BDWFAP_PAR-UPDATETASK *" VALUE(CALL_TRANSACTION_DONE) LIKE BDWFAP_PAR-CALLTRANS *" TABLES *" IDOC_CONTRL STRUCTURE EDIDC *" IDOC_DATA STRUCTURE EDIDD *" IDOC_STATUS STRUCTURE BDIDOCSTAT *" RETURN_VARIABLES STRUCTURE BDWFRETVAR *" SERIALIZATION_INFO STRUCTURE BDI_SER *" EXCEPTIONS *" WRONG_FUNCTION_CALLED *"----------------------------------------------------------------------
In diesem Eingangsbaustein wird der Anwendungsbaustein mit Anwendungsdaten aufgerufen. Wie im Abschnitt Schnittstelle und Namenskonvention beschrieben, darf der Anwendungsbaustein kein COMMIT WORK absetzen. Darüber hinaus soll die Anwendung die Verarbeitungsergebnisse durch den Rückgabeparameter zurückgeben, mit dem entsprechende IDocs den richtigen Status bekommen.
Anwendungen können auch die Kommunikationsdaten der IDocs erfahren, indem sie in ihrem Baustein den folgenden Baustein aufrufen:
Syntax
FUNCTION ALE_IDOC_INFO_IMPORT. *"---------------------------------------------------------------------- *"*"Lokale Schnittstelle: *" TABLES *" IDOC_INFO STRUCTURE EDIDC *"----------------------------------------------------------------------