Introduction ABAP

#

Transaction codes essentiels

#

Qu’est-ce qu’un Transaction Code ?

#

Un Transaction Code (ou T-Code) est un raccourci textuel permettant d’accéder directement à une fonctionnalité SAP sans naviguer dans les menus. C’est l’équivalent d’une commande shell dans un terminal.

Saisir un Transaction Code

#

Pour utiliser un T-Code :

• Placez le curseur dans le champ de commande (en haut à gauche)
• Tapez le code de transaction
• Appuyez sur Entrée

┌─────────────────────────────┐
│ /nSE80                      │  ← Champ de commande
└─────────────────────────────┘

Syntaxe avancée

#

Transaction codes pour le développement

#

Voici les T-Codes incontournables pour débuter en ABAP :

Raccourcis clavier

#

Pourquoi maîtriser les raccourcis ?

#

Les raccourcis clavier peuvent multiplier par 3 votre vitesse de développement. Au lieu de naviguer dans les menus avec la souris, vous gardez les mains sur le clavier et restez concentré sur le code.

Raccourcis essentiels

#

Ordre de transport (OT) et création – SE10

#

Objectifs

#

• Comprendre le rôle d’un ORDRE DE TRANSPORT dans SAP
• Savoir créer un OT depuis la transaction SE10
• Identifier la structure d’un ORDRE DE TRANSPORT (TACHES, OBJETCS)
• Retenir les bonnes pratiques pour l’utilisation des OT

L’objectif est de maîtriser les OT pour transporter, organiser et suivre vos développements entre environnements SAP.

Définition

#

Un ORDRE DE TRANSPORT (OT) est un conteneur qui regroupe des objets de développement ou de configuration dans SAP.

Il permet de transporter ces objets d’un ENVIRONNEMENT à un autre.

Schéma visuel

DEV (Développement) ──> QUAL (Recette/Validation) ──> PROD (Production)

Vous mettez vos objets (programmes, tables…) dans un carton (OT), puis vous le transportez d’une maison (DEV) à une autre (QUAL/PROD). D’ailleurs, l’icône pour transporter un OT est un camion.

Un OT libéré est définitif et ne peut plus être modifié.

Pourquoi créer un OT ?

#

Créer un OT permet de :

• Suivre vos développements
• Sauvegarder vos modifications
• Transporter vos créations vers d’autres systèmes SAP

Penser à l’OT comme un carton contenant vos objets : tout ce qui est dans ce carton suit le même trajet.

Types d’ordre de transport

#

Workbench = code → DEV

Customizing = configuration → paramètres métiers.

Création d’un OT à partir de la transaction SE10

#

Étapes :

1. Entrer /nSE10 puis valider

2. Cliquer sur Créer (F6)

   

3. Choisir le type d’OT → Workbench ou Customizing → Valider

   

4. Donner une Description Synthétique et Enregistrer

   

5. Visualiser l’OT et la tâche créée automatiquement pour l’utilisateur courant

   

Schéma simplifié de l’OT et sa tâche :

OT (S4HK905579)
  └─ Tâche Utilisateur (S4HK905580)
       └─ Objets : Programmes, Tables, Includes

Une tâche correspond à ce que vous modifiez ou créez. Chaque utilisateur a sa propre tâche dans un OT global. Autrement dit, plusieurs devs peuvent enregistrer des modifications/création dans un même OT.

Structure d’un OT

#

• Requête de transport : regroupe plusieurs tâches sous un même ID
• Tâche / Ordre de travail : contient les objets créés/modifiés par un utilisateur

Visualisation

OT Global (ID)
├─ Tâche 1 (Utilisateur A) → Objets
├─ Tâche 2 (Utilisateur B) → Objets

Ne jamais mélanger des objets de projets différents dans le même OT.

Recherche d’un OT

#

• Par ID : filtrer dans SE10
• Par Auteur : filtrer pour voir les OT créés par un utilisateur
• Recherche multiple : combiner critères pour retrouver OT précis

Ces filtres permettent de rapidement localiser vos développements et comprendre leur historique.

Bonnes pratiques

#

Le nom et la structure de l’OT sont essentiels pour le suivi et la maintenance.

Exercice pratique

#

1. Créer un OT Workbench “ZAELION_TRI_2025” (TRI sera remplacé par ton trigramme (1ère lettre de ton prénom et le 2ères lettres de ton nom de famille))
2. Visualiser la structure OT et vérifier l’ID de tâche

La libération de l’OT fera l’objet d’un module propre

Resume

#

• Un OT est un conteneur pour vos objets SAP
• Permet de transporter vos développements entre environnements
• Créé via SE10 et rattache vos programmes et objets
• Structure : OT global → tâches utilisateurs → objets
• Respecter les bonnes pratiques pour éviter erreurs et confusion

Chaque OT est un carton contenant vos créations, transporté de maison en maison (DEV → QUAL → PROD) de façon sécurisée et traçable.

Création d’un PACKAGE via SE80 ou SE21

#

Objectifs

#

• Comprendre le rôle d’un PACKAGE dans l’organisation des développements SAP
• Savoir créer un PACKAGE via SE80 ou SE21
• Comprendre la différence entre PACKAGE local et transportable
• Organiser ses objets pour faciliter maintenance et transport

Les objectifs visent à maîtriser la structuration des objets ABAP pour simplifier transport, maintenance et collaboration.

Definition

#

Un PACKAGE (anciennement DEVELOPMENT CLASS) est un conteneur logique qui regroupe les objets de développement ABAP.

Le PACKAGE est comme un classeur avec des tiroirs : chaque programme, table ou Include est rangé dans un tiroir identifié.

Visualisation PACKAGE : ZAELION_TRI_2025 ├─ Programme ZTRI_AELION_01 ├─ Include ZTRI_AELION_01_TOP ├─ Table ZT_AELION_2025

Un PACKAGE facilite le regroupement par projet ou module fonctionnel et est indispensable pour transporter des objets.

Pourquoi créer un PACKAGE ?

#

Créer un PACKAGE permet :

• Organiser les développements par thème ou projet
• Éviter les conflits entre objets similaires
• Simplifier les transports via un OT cohérent

Un objet créé dans $TMP ne peut pas être transporté.

Z/Y = client → transportable ; $TMP = test → local uniquement.

Creation d’un PACKAGE avec SE80

#

1. Entrer /nSE80

2. Dans la liste déroulante, choisir PACKAGE

3. Saisir le nom du PACKAGE (ex. ZAELION_TRI_PACKAGE) → Entrer

   

4. Confirmer la création via popup

   

5. Renseigner la Description synthétique et valider

   TRI - PACKAGE SPECIFIC AELION 2025

   

6. Associer ton OT

   

   

7. Valider

   

   

   

PACKAGE ZAELION_TRI_PACKAGE └─ OT associé (ex. S4HK905579) └─ Tâches (ex. S4HK905580) └─ Objets

Creation d’un PACKAGE avec SE21

#

1. Entrer /nSE21
2. Saisir le nom du PACKAGE → Entrer
3. Renseigner Titre et PACKAGE parent si applicable
4. Sauvegarder et associer un OT si transportable

SE21 est plus direct, SE80 permet de visualiser l’arborescence complète des objets.

Bonnes pratiques

#

Un PACKAGE bien structuré réduit les erreurs, facilite la collaboration et maintient l’historique clair.

Exercice pratique

#

1. Créer un PACKAGE transportable ZAELION_TRI_PACKAGE
2. Associer ton OT
3. Vérifier dans SE80 l’arborescence du PACKAGE

Resume

#

• Le PACKAGE est un classeur logique pour regrouper objets ABAP
• Permet d’organiser, maintenir et transporter les objets
• On le crée via SE80 ou SE21
• Types : local ($TMP) ou transportable (Z/Y)
• Toujours associer un OT pour le transport sécurisé

Chaque PACKAGE est un classeur où chaque tiroir contient vos programmes et Includes, organisé pour être facilement transporté et retrouvé.

Creation de programme – SE38 / SE80

#

Objectifs

#

• Comprendre ce qu’est un PROGRAMME ABAP et son rôle dans SAP
• Créer un PROGRAMME via SE38 ou SE80
• Connaître les types de PROGRAMMES disponibles
• Lancer, sauvegarder et transporter un PROGRAMME ABAP

L’objectif est de comprendre comment structurer, créer et exécuter un PROGRAMME ABAP dans SAP, tout en respectant l’organisation par PACKAGE et OT.

Definition

#

Un PROGRAMME ABAP est un ensemble d’instructions exécutables par SAP.
Il sert à traiter des données, afficher des résultats ou automatiser des actions.

Un PROGRAMME est comme une recette : chaque ligne de code est une instruction pour obtenir un résultat final. Le PACKAGE est votre classeur de recettes, et l’OT le carton pour transporter les recettes.

• Lire une table client
• Calculer des totaux, traiter des chaîne de caractère
• Afficher un rapport à l’écran

Types de programmes

#

Le type détermine l’usage et l’interface du PROGRAMME.

Creation d’un programme avec SE80

#

1. Entrer /nSE80

   

2. Choisir Programme

   

3. Saisir le nom du PROGRAMME → Entrer

   ZAELION_FGI_HELLOWORLD

   

4. Confirmer la création via les popups

   

   

5. Vérifier Titre et Type Programme exécutable et Sauvegarder

   

6. Associer PACKAGE et OT

   

   

7. Valider

   

8. Ouvrir le PROGRAMME (double clique)

   

9. Passer en mode Modifiable (Ctrl+F1)

SE80 offre la visualisation arborescente : PROGRAMME → Includes → Tables → Fonctions.

Creation d’un programme avec SE38

#

1. Entrer /nSE38
2. Saisir le nom du PROGRAMME (ex. ZAELION_TRI_HELLOWORLD)
3. Renseigner le Titre
4. Sélectionner Programme exécutable
5. Sauvegarder et choisir le PACKAGE (ex. ZAELION_2025_FGI)
6. Associer un OT et valider
7. Passer en mode Modifiable (Ctrl+F1)

Suivre toujours le flux : Nom Z/Y → PACKAGE → OT → Activer → Exécuter.

Premier pas dans le programme

#

PROGRAMME généré automatiquement :

    *&---------------------------------------------------------------------*
    *& Report ZAELION_TRI_HELLOWORLD
    *&---------------------------------------------------------------------*
    REPORT ZAELION_TRI_HELLOWORLD.

Ajouter le code :

    WRITE: 'Bonjour le monde !'.

Tu devrais avoir :

    *&---------------------------------------------------------------------*
    *& Report ZAELION_TRI_HELLOWORLD
    *&---------------------------------------------------------------------*
    *&
    *&---------------------------------------------------------------------*
    REPORT ZAELION_TRI_HELLOWORLD.

    WRITE: 'Bonjour le monde !'.

WRITE affiche du texte à l’écran. Cela permet de vérifier que le programme fonctionne avant d’ajouter des traitements complexes.

Etapes d’execution

#

1. Enregistrer (Ctrl+S)

   

   

2. Activer (Ctrl+F3)

   

   

3. Exécuter (F8)

   

   

4. Retour arrière (F3)

Suivre toujours l’ordre : Enregistrer → Activer → Exécuter pour éviter erreurs de compilation.

Bonnes pratiques

#

Exercice pratique

#

1. Créer un PROGRAMME ZAELION_TRI_HELLOWORLD
2. Ajouter un WRITE simple
3. Sauvegarder, Activer, Exécuter
4. Vérifier le message affiché
5. Observer la structure PACKAGE + OT dans SE80

Resume

#

• Un PROGRAMME ABAP est une suite d’instructions exécutables
• Sert à traiter des données, afficher des résultats, automatiser des actions
• Types : Exécutable, Module pool, Include, Function group, Class pool
• Créé via SE38 ou SE80
• Doit être sauvegardé dans un PACKAGE et associé à un OT
• Execution : Enregistrer → Activer → Exécuter
• Commencer simple avec WRITE pour vérifier fonctionnement

Le PROGRAMME est la recette, le PACKAGE le classeur des recettes, et l’OT le carton pour transporter vos recettes vers d’autres systèmes.

Creation d’un INCLUDE – SE38 / SE80

#

Objectifs

#

• Comprendre le rôle d’un INCLUDE dans un programme ABAP
• Créer un INCLUDE via SE38 ou SE80
• Savoir l’intégrer dans un programme principal
• Organiser son code ABAP pour plus de clarté et de réutilisation

L’objectif est de modulariser le code ABAP afin de le rendre plus lisible, réutilisable et facile à maintenir, tout en permettant le travail collaboratif.

Definition

#

Un INCLUDE est un fichier de code réutilisable inséré dans un ou plusieurs programmes ABAP.
Il permet de séparer le code pour le rendre plus lisible et modulaire.

Un INCLUDE est comme un chapitre d’un livre : le programme principal est le livre complet, et chaque INCLUDE est un chapitre que l’on peut écrire ou réutiliser ailleurs.

Les INCLUDES ne peuvent être exécutés seuls. Ils doivent être intégrés dans un programme principal.

Pourquoi utiliser des INCLUDES ?

#

Toujours penser “un INCLUDE = un rôle précis” (top, écran, logique) pour éviter la confusion.

Types d’INCLUDES

#

Le type n’est pas imposé par SAP, c’est une convention pour structurer votre programme ABAP.

Creation d’un INCLUDE via SE80

#

      *&---------------------------------------------------------------------*
      *& Report ZAELION_TRI_HELLOWORLD
      *&---------------------------------------------------------------------*
      *&
      *&---------------------------------------------------------------------*
      REPORT ZAELION_TRI_HELLOWORLD.

      WRITE: 'Bonjour le monde !'.

1. Ajouter dans le programme :

    INCLUDE ZAELION_TRI_HELLOWORLD_TOP.

Tu devrez avoir ceci :

         *&---------------------------------------------------------------------*
         *& Report ZAELION_FGI_HELLOWORLD
         *&---------------------------------------------------------------------*
         *&
         *&---------------------------------------------------------------------*
         REPORT ZAELION_TRI_HELLOWORLD.

         WRITE: 'Bonjour le monde !'.

         INCLUDE ZAELION_TRI_HELLOWORLD_TOP.

2. Double-cliquer sur le nom de l’INCLUDE → popup de création → valider → sauvegarder si demander

   

   

   

3. Ajouter un WRITE pour tester :

         WRITE: 'Bonjour le monde depuis l''INCLUDE TOP !'.

Tu devrez avoir ceci :

         *&---------------------------------------------------------------------*
         *& Include          ZAELION_FGI_HELLOWORLD_TOP
         *&---------------------------------------------------------------------*

         WRITE: 'Bonjour le monde depuis l''INCLUDE TOP !'.

4. Sauvegarder, Activer les objets, Exécuter le programme principal pour voir le résultat

   

   

   

   

   

Vérifier toujours l’intégration : un INCLUDE non activé empêche l’exécution correcte du programme principal.

Bonnes pratiques

#

Exercice pratique

#

1. Modifier le WRITE (ajout de / après le WRITE:)

         WRITE:/ 'Bonjour le monde !'.

1. Créer l’INCLUDE ZAELION_TRI_HELLOWORLD_TOP

         INCLUDE ZAELION_TRI_HELLOWORLD_TOP.

1. Ajouter le WRITE dans l’INCLUDE:

         WRITE:/ 'Bonjour le monde depuis l''INCLUDE TOP !'.

1. Sauvegarder, Activer les objets
2. Exécuter le programme principal et vérifier l’affichage
3. Faite de même avec les INCLUDES ZAELION_TRI_HELLOWORLD_SCR et ZAELION_TRI_HELLOWORLD_F01

SOLUTION

---

REPORT ZAELION_TRI_HELLOWORLD

      *&---------------------------------------------------------------------*
      *& Report ZAELION_TRI_HELLOWORLD
      *&---------------------------------------------------------------------*
      *&
      *&---------------------------------------------------------------------*
      REPORT ZAELION_TRI_HELLOWORLD.

      WRITE:/ 'Bonjour le monde !'.

      INCLUDE ZAELION_TRI_HELLOWORLD_TOP.
      INCLUDE ZAELION_TRI_HELLOWORLD_SCR.
      INCLUDE ZAELION_TRI_HELLOWORLD_F01.

INCLUDE ZAELION_TRI_HELLOWORLD_TOP

      *&---------------------------------------------------------------------*
      *& Include          ZAELION_FGI_HELLOWORLD_TOP
      *&---------------------------------------------------------------------*

      WRITE:/ 'Bonjour le monde depuis l''INCLUDE TOP !'.

INCLUDE ZAELION_TRI_HELLOWORLD_SCR

      *&---------------------------------------------------------------------*
      *& Include          ZAELION_TRI_HELLOWORLD_SCR
      *&---------------------------------------------------------------------*

      WRITE:/ 'Bonjour le monde depuis l''INCLUDE SCR !'.

INCLUDE ZAELION_TRI_HELLOWORLD_F01

      *&---------------------------------------------------------------------*
      *& Include          ZAELION_TRI_HELLOWORLD_F01
      *&---------------------------------------------------------------------*

      WRITE:/ 'Bonjour le monde depuis l''INCLUDE F01 !'.

Exécution :

Resume

#

• Un INCLUDE contient du code réutilisable dans un ou plusieurs programmes
• Se crée via SE38 ou SE80 et s’intègre dans un programme avec INCLUDE
• Permet de rendre le code plus clair, modulaire et facile à maintenir
• Doit être sauvegardé dans un PACKAGE et associé à un OT

Chaque INCLUDE est un chapitre du livre que constitue votre programme. On peut le modifier, le réutiliser et le transporter sans toucher au reste du livre.

Gestion des dumps et du débogueur – ST22

#

Objectifs

#

• Comprendre ce qu’est un DUMP dans SAP
• Savoir analyser un DUMP via la transaction ST22
• Découvrir le débogueur ABAP et apprendre à l’utiliser
• Identifier la différence entre débogage via /H et POINTS D'ARRET

L’objectif est d’apprendre à diagnostiquer les erreurs ABAP et à suivre l’exécution du code pour corriger les anomalies.

Définition

#

Un DUMP (ou ABAP Runtime Error) est une erreur fatale qui arrête un programme ABAP pour protéger le système.
SAP enregistre alors un rapport détaillé dans ST22 pour analyser la cause.

C’est comme un écran bleu sur un ordinateur, mais SAP fournit toutes les informations nécessaires pour comprendre et corriger le problème.

Exemples de DUMPs courants

#

Les DUMPS sont souvent causés par des valeurs inattendues ou des erreurs de code. Les lire attentivement permet de trouver la source exacte.

Analyse d’un DUMP avec ST22

#

1. Entrer /nST22

2. Choisir la période (“Today” ou filtrer par utilisateur/programme)

   

3. Cliquer sur le DUMP à analyser

   

4. Examiner les sections clés :

   

   

Double-cliquer sur une ligne du Source Code Extract ouvre directement SE38 à la ligne fautive.

Utiliser le DEBUGUEUR ABAP

#

Le débogueur permet d’exécuter le code ligne par ligne, inspecter/modifier les variables et comprendre le comportement du programme.

Débogage d’une transaction – /H

#

1. Entrer /H dans la barre de commande → Debugging switched on
2. Exécuter la transaction à analyser
3. SAP ouvre automatiquement le débogueur avant l’exécution

Activer /H avant de cliquer ou valider un formulaire pour observer le flux complet.

Débogage d’un programme – SE38 / SE80

#

1. Ouvrir le programme via SE38 ou SE80

2. Ajouter un point d’arrêt sur une ligne (cliquer dans la marge → point rouge)

   

3. Sauvegarder et exécuter le programme (F8)

   

   

Les variables peuvent être modifiées directement dans le débogueur pour tester des scénarios.

Bonnes pratiques

#

Exercice pratique

#

1. Générer volontairement un DUMP simple (ex. DIVISION BY ZERO)

          *&---------------------------------------------------------------------*
          *& Report ZAELION_FGI_HELLOWORLD
          *&---------------------------------------------------------------------*
          *&
          *&---------------------------------------------------------------------*
          REPORT zaelion_fgi_helloworld.

          WRITE:/ 'Bonjour le monde !'.

          INCLUDE zaelion_fgi_helloworld_top.
          INCLUDE zaelion_fgi_helloworld_scr.
          INCLUDE zaelion_fgi_helloworld_f01.

          *&---------------------------------------------------------------------*
          *& DUMP
          *&---------------------------------------------------------------------*

          DATA: lv_num TYPE i,
               lv_den TYPE i,
               lv_res TYPE i.

          lv_num = 10.
          lv_den = 0.

          lv_res = lv_num / lv_den.

          WRITE: / 'Résultat :', lv_res.

2. Exécuter
3. Analyser le DUMP dans ST22
4. Ajouter un point d’arrêt dans ton programme, exécuter et observer les variables

Résumé

#

• Un DUMP est une erreur fatale ABAP qui arrête le programme et génère un rapport dans ST22
• ST22 permet d’analyser : message, code fautif, variables, call stack
• Débogueur ABAP : exécuter ligne par ligne, inspecter/modifier variables
• Accès : /H pour transactions, point d’arrêt pour programmes
• Fonctions clés : F5 (suivant), F6 (sauter), F8 (continuer), breakpoints dynamiques

ST22 = carnet d’incidents, débogueur = microscope pour suivre ligne par ligne ce que fait le programme.