Sommaire

Démonstration de la structure modulaire d’un programme ABAP
#

Vue d’ensemble
#

Ce programme ABAP est un exemple pédagogique qui illustre la structure modulaire d’un programme ABAP et l’ordre d’exécution des différents blocs d’événements. Il démontre l’utilisation des includes et des événements ABAP standards.

Structure du Programme
#

Le programme est composé de 4 fichiers :

ZADA_PROG_UNIT_02 - Programme principal avec les blocs d’événements
ZADA_PROG_UNIT_02_TOP - Include pour les déclarations globales
ZADA_PROG_UNIT_02_SCR - Include pour l’écran de sélection
ZADA_PROG_UNIT_02_F01 - Include pour les sous-programmes (FORM routines)

Ordre d’Exécution du Programme
#

Lorsque ce programme s’exécute, voici l’ordre chronologique des affichages :

00 - INITIALIZATION
02 - INCLUDE _TOP
03 - INCLUDE _SCR
04 - INCLUDE _F01
     A - PERFORM report_initialization
05 - START-OF-SELECTION
     A - PERFORM report_subprocess_01
     B - PERFORM report_subprocess_02
99 - END-OF-SELECTION

Code Détaillé
#

1. Programme Principal (ZADA_PROG_UNIT_02.txt)
#

REPORT ZADA_PROG_UNIT_02.

WRITE:/ '01 - REPORT...',
      / '     WARNING: Ne jamais implémenter de code ici !',
      / '-------------------------------------------------'.

INCLUDE ZADA_PROG_UNIT_02_TOP.
INCLUDE ZADA_PROG_UNIT_02_SCR.
INCLUDE ZADA_PROG_UNIT_02_F01.

INITIALIZATION.
  WRITE:/ '00 - INITIALIZATION du programme...',
        / '     TYPE: Bloc d''événement',
        / '     WARNING: Activation unique au lancement',
        / '-------------------------------------------------'.
  PERFORM report_initialization.

START-OF-SELECTION.
  WRITE:/ '05 - START-OF-SELECTION du programme...',
        / '     TYPE: Bloc d''événement',
        / '     INFO: Traitement principal du REPORT',
        / '-------------------------------------------------'.

  PERFORM report_subprocess_01.
  PERFORM report_subprocess_02.

END-OF-SELECTION.
  WRITE:/ '99 - END-OF-SELECTION du programme...',
        / '     TYPE: Bloc d''événement',
        / '     INFO: Traitement de fin du REPORT',
        / '-------------------------------------------------'.

2. Include TOP (ZADA_PROG_UNIT_02_TOP.txt)
#

WRITE:/ '02 - INCLUDE _TOP...',
      / '     NOTE: Je suis un TIROIR de programme',
      / '     INFO: Spécifique aux déclarations globales',
      / '-------------------------------------------------'.

Usage typique : Déclarer les variables globales, tables internes, types de données, constantes, etc.

3. Include SCR (ZADA_PROG_UNIT_02_SCR.txt)
#

WRITE:/ '03 - INCLUDE _SCR...',
      / '     NOTE: Je suis un TIROIR de programme',
      / '     INFO: Spécifique à l'écran de sélection',
      / '-------------------------------------------------'.

Usage typique : Définir les paramètres de sélection (PARAMETERS, SELECT-OPTIONS) et les variantes d’écran.

4. Include F01 (ZADA_PROG_UNIT_02_F01.txt)
#

WRITE:/ '04 - INCLUDE _F01...',
      / '     NOTE: Je suis un TIROIR de programme',
      / '     INFO: Spécifique aux traitements du prog',
      / '-------------------------------------------------'.

FORM report_initialization.
  WRITE:/ '     A - PERFORM report_initialization...',
        / '         INFO: Sous-process de l''initialisation',
        / '-------------------------------------------------'.
ENDFORM.

FORM report_subprocess_01.
  WRITE:/ '     A - PERFORM report_subprocess_01...',
      / '         INFO: Sous-process 01 du REPORT',
      / '-------------------------------------------------'.
ENDFORM.

FORM report_subprocess_02.
  WRITE:/ '     B - PERFORM report_subprocess_02...',
      / '         INFO: Sous-process 02 du REPORT',
      / '-------------------------------------------------'.
ENDFORM.

Usage typique : Contenir toutes les routines (FORM…ENDFORM) et sous-programmes du programme.

Les Blocs d’Événements ABAP
#

1. INITIALIZATION
#

Quand : Exécuté une seule fois au démarrage du programme, avant l’affichage de l’écran de sélection
Usage : Initialiser les valeurs par défaut des paramètres de sélection, charger des données de configuration
Ordre : Premier bloc exécuté (00)

2. START-OF-SELECTION
#

Quand : Exécuté après validation de l’écran de sélection
Usage : Contient la logique principale du programme (requêtes, calculs, traitements)
Ordre : Bloc principal (05)

3. END-OF-SELECTION
#

Quand : Exécuté après le START-OF-SELECTION
Usage : Traitements finaux, affichage des résultats, nettoyage
Ordre : Dernier bloc (99)

Concepts Clés Illustrés
#

1. Architecture Modulaire
#

Le programme démontre la séparation des responsabilités :

Include	Responsabilité	Contenu Typique
_TOP	Déclarations	Variables, tables internes, types, constantes
_SCR	Interface utilisateur	PARAMETERS, SELECT-OPTIONS
_F01	Logique métier	FORM routines, fonctions, algorithmes

2. Sous-Programmes (FORM Routines)
#

FORM nom_routine.
  " Code du sous-programme
ENDFORM.

Avantages :

Réutilisabilité du code
Meilleure lisibilité
Facilite la maintenance
Permet la modularité

Appel :

PERFORM nom_routine.

3. La Commande WRITE
#

WRITE: / 'Texte à afficher'.

/ : Nouvelle ligne
WRITE: : Affichage à l’écran (liste)

Avertissement Important
#

Le programme contient un avertissement crucial :

'WARNING: Ne jamais implémenter de code ici !'

Explication : Le code placé directement après REPORT et avant les includes s’exécute lors du chargement du programme, avant même INITIALIZATION. C’est une mauvaise pratique car :

L’ordre d’exécution devient confus
Difficile à maintenir
Viole les conventions ABAP

Bonne pratique : Toujours placer le code dans les blocs d’événements appropriés ou dans les includes.

Flux d’Exécution Complet
#

┌─────────────────────────────────────┐
│ 1. Chargement du programme          │
│    - REPORT déclaration             │
│    - Chargement des INCLUDES        │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│ 2. INITIALIZATION                   │
│    - Initialisation des valeurs     │
│    - PERFORM report_initialization  │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│ 3. Affichage écran de sélection     │
│    (si paramètres définis)          │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│ 4. START-OF-SELECTION               │
│    - Traitement principal           │
│    - PERFORM report_subprocess_01   │
│    - PERFORM report_subprocess_02   │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│ 5. END-OF-SELECTION                 │
│    - Traitements finaux             │
│    - Affichage des résultats        │
└─────────────────────────────────────┘

Exemple Pratique d’Utilisation
#

Voici comment ce modèle pourrait être utilisé pour un programme réel :

_TOP : Déclarations
#

TABLES: mara, marc.  " Tables de la base de données

DATA: BEGIN OF gs_material,
        matnr TYPE mara-matnr,
        maktx TYPE makt-maktx,
        werks TYPE marc-werks,
      END OF gs_material.

DATA: gt_materials TYPE TABLE OF gs_material.

_SCR : Écran de sélection
#

SELECTION-SCREEN BEGIN OF BLOCK b1 WITH FRAME TITLE text-001.
  PARAMETERS: p_werks TYPE marc-werks OBLIGATORY.
  SELECT-OPTIONS: s_matnr FOR mara-matnr.
SELECTION-SCREEN END OF BLOCK b1.

_F01 : Sous-programmes
#

FORM get_materials.
  SELECT m~matnr t~maktx c~werks
    FROM mara AS m
    INNER JOIN makt AS t ON m~matnr = t~matnr
    INNER JOIN marc AS c ON m~matnr = c~matnr
    INTO TABLE @gt_materials
    WHERE c~werks = @p_werks
      AND m~matnr IN @s_matnr.
ENDFORM.

FORM display_materials.
  LOOP AT gt_materials INTO gs_material.
    WRITE: / gs_material-matnr, 
             gs_material-maktx,
             gs_material-werks.
  ENDLOOP.
ENDFORM.

Programme principal
#

INITIALIZATION.
  p_werks = '1000'.  " Valeur par défaut

START-OF-SELECTION.
  PERFORM get_materials.
  
END-OF-SELECTION.
  PERFORM display_materials.

Conventions de Nommage
#

Programme:        Z<PREFIX>_<NOM>_<TYPE>_<NN>
Include TOP:      Z<PREFIX>_<NOM>_<TYPE>_<NN>_TOP
Include SCR:      Z<PREFIX>_<NOM>_<TYPE>_<NN>_SCR
Include F01:      Z<PREFIX>_<NOM>_<TYPE>_<NN>_F01

Variables:        lv_<nom>  (local variable)
                  gv_<nom>  (global variable)
Tables internes:  lt_<nom>  (local table)
                  gt_<nom>  (global table)
Structures:       ls_<nom>  (local structure)
                  gs_<nom>  (global structure)

Conclusion
#

Ce programme est un excellent exemple pédagogique qui illustre :

La structure modulaire standard d’un programme ABAP
L’ordre d’exécution des blocs d’événements
L’utilisation des includes pour organiser le code
Les bonnes pratiques de programmation ABAP

Il sert de template ou modèle pour créer des programmes ABAP bien structurés et maintenables. Les développeurs peuvent s’en inspirer pour organiser leurs propres programmes de manière professionnelle.