Zelfstudie Dialoogprogrammering: Modulepool in SAP ABAP

Wat is dialoogprogrammering?

SAP-ABAP ondersteunt twee soorten programma's: Rapportprogramma en Dialoogprogramma.

Als uw ABAP-programma gebruikersinvoer vereist, wordt dialoogprogrammering gebruikt.

Een gebruikersdialoog is elke vorm van interactie tussen de gebruiker en het programma en kan elk van de volgende vormen aannemen:

• Gegevens invoeren
• Een menu-item kiezen
• Op een knop klikken
• Klikken of dubbelklikken op een item

Dialoogprogramma wordt ook gebruikt wanneer we heen en weer moeten navigeren tussen schermen

Dialoogprogramma's worden gemaakt met het type 'M' – Modulepool. Ze kunnen niet zelfstandig worden uitgevoerd en moeten gekoppeld zijn aan minimaal één transactiecode waarin u een beginscherm opgeeft.

Verschil tussen rapport- en dialoogprogramma's

Rapportprogramma:

Een rapport is een programma dat doorgaans gegevens in databasetabellen leest en analyseert zonder de gegevens te wijzigen databank.

Dialoogprogramma:

Met een dialoogprogramma kunt u interactief met het systeem werken en de inhoud van de databasetabellen wijzigen. Elk dialoogprogramma heeft een bepaalde reeks schermen die na elkaar door het systeem worden verwerkt.

De schermsequentie van een dialoogtransactie is gemakkelijker te volgen met een voorbeeld.

Een voorbeeld van transactieverwerking in dialoogprogrammering

Het diagram toont één transactie, van het eerste scherm tot de database-update. De gebruiker voert gegevens in op scherm 100, PAI valideert de invoer en bepaalt het volgende scherm, scherm 200 verzamelt de resterende gegevens en de update-taak schrijft de record uiteindelijk weg. Elk van deze stappen wordt uitgevoerd door de onderstaande componenten.

Onderdelen van het dialoogprogramma

Anders verslag wat doorgaans de creatie van één autonoom programma inhoudt dat onafhankelijk van andere objecten kan worden uitgevoerd, terwijl de ontwikkeling van dialoogprogramma's de ontwikkeling van meerdere objecten inhoudt die geen enkel object op zichzelf kunnen worden uitgevoerd. In plaats daarvan zijn alle objecten hiërarchisch gekoppeld aan het hoofdprogramma en worden ze uitgevoerd in een volgorde die wordt bepaald door het Dialoog Hoofdprogramma..

De componenten van een dialoogprogramma zijn:

Transactie code

• De transactiecode start een schermreeks.
• U maakt transactiecodes aan in de Repository Browser in de ABAP Workbench of met Transactie SE93.
• Een transactiecode is gekoppeld aan een ABAP-programma en een beginscherm.
• U kunt vanuit elk ABAP-programma een schermreeks starten met behulp van de instructie CALL SCREEN.

Screens

• Elk dialoogvenster in een SAP systeem wordt bestuurd door één of meerdere schermen.
• Schermen maak je met behulp van het Scherm Painter in de ABAP Workbench via transactie SE51
• Elk scherm behoort tot een ABAP-programma.
• Deze schermen bestaan ​​uit een "schermmasker" of "lay-out" en de bijbehorende flowlogica. Het scherm heeft een layout die de posities van invoer-/uitvoervelden en andere grafische elementen zoals selectievakjes en keuzerondjes bepaalt. Een flowlogica bepaalt de logische verwerking binnen het scherm.

GUI-status

• Elk scherm heeft een GUI-status(sen) die onafhankelijke componenten van een programma zijn.
• Dit bestuurt de menubalken, standaardwerkbalk, applicatiewerkbalk, waarmee de gebruiker functies in de applicatie kan kiezen.
• U maakt ze in de ABAP Workbench met behulp van het menu Painter.

ABAP-programma

• Elk scherm en GUI-status in het R/3-systeem behoort tot één ABAP-programma.
• Het ABAP-programma bevat de dialoogmodules die worden opgeroepen door de schermstroomlogica, en verwerkt ook de gebruikersinvoer vanuit de GUI-status.
• ABAP-programma's die gebruik maken van schermen worden ook wel dialoogprogramma's genoemd.
• In een modulepool (type M programma); het eerste verwerkingsblok dat moet worden opgeroepen, is altijd een dialoogmodule. U kunt schermen echter ook in andere ABAP-programma's gebruiken, zoals uitvoerbare programma's of functiemodules. Het eerste verwerkingsblok heet dan anders; bijvoorbeeld door de runtime-omgeving of een procedureaanroep. De schermreeks wordt vervolgens gestart met behulp van de CALL SCREEN-instructie.

Schermstroomlogica

De logica van Screen Flow bestaat hoofdzakelijk uit vier componenten.

• Proces vóór uitvoer (PBO) gebeurtenis: welke wordt verwerkt voordat het scherm wordt weergegeven
• Proces na invoer (PAI) gebeurtenis: die wordt verwerkt na een gebruikersactie op het scherm
• Verwerken op hulpverzoek (POH): die wordt verwerkt wanneer F1 wordt ingedrukt
• Verwerken op waardeaanvraag (POV):die wordt verwerkt wanneer F4 wordt ingedrukt

POH en POV worden uitgebreid uitgelegd op de betreffende pagina. proces voor waardeverzoeken en proces voor hulpverzoeken.

Dynpro

• Een scherm, samen met de bijbehorende stroomlogica, wordt een Dynpro genoemd ("Dynamisch Programma", omdat de stroomlogica van het scherm de programmastroom beïnvloedt).
• Elke dynpro bestuurt precies één stap van uw Dialoogprogramma.
• De schermen die bij een programma horen zijn genummerdDe schermvolgorde kan lineair of cyclisch zijn. Vanuit een schermketen kun je zelfs een andere schermketen aanroepen en na de verwerking ervan terugkeren naar de oorspronkelijke keten. Je kunt het statisch gedefinieerde volgende scherm ook overschrijven vanuit de dialoogmodules van het ABAP-programma.

ABAP-modulepool

• Bij een PBO- of PAI-gebeurtenis roept een Dynpro een ABAP-dialoogprogramma aan. Een verzameling van dergelijke programma's wordt de ABAP-modulepool genoemd.
• Modules die bij de PAI-gebeurtenis worden aangeroepen, worden bijvoorbeeld gebruikt om de gebruikersinvoer te controleren en om geschikte dialoogstappen te activeren, zoals de updatetaak.
• Alle dynpro's zijn van binnenuit op te roepen een transactie verwijzen naar een gemeenschappelijke modulepool.

Structuur van een dialoogprogramma

Het structuurdiagram laat zien hoe de transactiecode, de schermen, de GUI-status en de modulepool aan hetzelfde hoofdprogramma zijn gekoppeld.

Processtroom voor een dialoogprogramma

Het processtroomdiagram toont de afwisseling tussen het scherm en het ABAP-programma: PBO vult de schermvelden in, de gebruiker voert een actie uit en PAI verwerkt de invoer voordat het volgende scherm wordt opgeroepen.

Hoe maak je een modulepoolprogramma?

De bovenstaande componenten worden in een vaste volgorde aangemaakt. De onderstaande stappen bouwen een werkende transactie op vanuit een lege modulepool.

1. Maak de modulepool aan: Maak in SE80 of SE38 een programma aan waarvan de naam begint met SAPMZ en stel het programmatype in op M – ModulepoolHet type kan later niet meer worden gewijzigd zonder het object te verwijderen.
2. Geef de wereldwijde gegevens vrij: Plaats de TABLES-instructie en de globale variabelen in de TOP-include, die door elke dialoogmodule van de pool kan worden gelezen.
3. Ontwerp het scherm: Maak scherm 100 met het scherm Painter (SE51), plaats de invoervelden op de lay-out en voer het volgende schermnummer in bij de schermkenmerken.
4. Schrijf de stroomlogica: Roep op het tabblad 'Flow logic' één module aan voor PBO en één voor PAI, zoals hieronder weergegeven.
5. Bouw de GUI-status op: Maak een status aan met het menu. Painter (SE41) en stel dit in de PBO-module in met de SET PF-STATUS-instructie, zodat Opslaan, Terug en Afsluiten het programma bereiken als functiecodes.
6. Een transactiecode koppelen: Maak in transactie SE93 een dialoogtransactie aan, geef de modulepool een naam en voer 100 in als beginscherm.

* Screen 100, flow logic
PROCESS BEFORE OUTPUT.
  MODULE status_0100.

PROCESS AFTER INPUT.
  MODULE user_command_0100.

* Module pool SAPMZDEMO
MODULE status_0100 OUTPUT.
  SET PF-STATUS 'STATUS_100'.
  SET TITLEBAR 'TITLE_100'.
ENDMODULE.

MODULE user_command_0100 INPUT.
  CASE sy-ucomm.
    WHEN 'SAVE'.
      PERFORM save_data.
    WHEN 'BACK' OR 'EXIT'.
      LEAVE TO SCREEN 0.
  ENDCASE.
ENDMODULE.

💡Tip: LEAVE TO SCREEN 0 beëindigt het huidige scherm en keert terug naar het aanroeppunt. Dit is de standaardmanier om een ​​dialoogtransactie netjes af te sluiten.

Veelgestelde vragen