Consommer des services web SOAP dans ABAP Cloud

Catégorie

Integration

Publié

14. Feb. 2026

Auteur

Les services web SOAP restent répandus dans de nombreux environnements d’entreprise malgré la tendance vers REST. Dans ABAP Cloud, l’accès aux services SOAP s’effectue via le Service Consumption Model, qui génère des classes proxy typées à partir des fichiers WSDL.

SOAP dans ABAP Cloud vs. ABAP classique

L’intégration SOAP dans ABAP Cloud diffère fondamentalement de l’approche classique :

Aspect	ABAP classique	ABAP Cloud
Génération de proxy	SE80 / SPROXY	ADT Service Consumption Model
Configuration	SOAMANAGER	Communication Arrangement
Authentification	Dans SOAMANAGER	OAuth2, Certificats, Basic Auth
Import WSDL	En ligne ou local	Fichier local dans ADT
Transport	Ordre de transport	Basé sur Git (gCTS)
Runtime	ABAP Web Service Framework	Client SOAP cloud-native

Créer un Service Consumption Model

Le Service Consumption Model est l’élément central pour SOAP dans ABAP Cloud. Il génère à partir d’un fichier WSDL tous les artefacts nécessaires.

Aperçu des artefacts générés

┌──────────────────────────────────────────────────────────────┐
│  Service Consumption Model : Z_CURRENCY_SOAP                  │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  Généré depuis WSDL :                                        │
│  ├── Classe Proxy : ZCL_PRXY_CURRENCY_SERVICE                │
│  │   └── Méthodes pour chaque opération WSDL                 │
│  ├── Types de données (ABAP Dictionary)                      │
│  │   ├── ZST_CURRENCY_REQUEST                                │
│  │   ├── ZST_CURRENCY_RESPONSE                               │
│  │   └── ZST_CURRENCY_FAULT                                  │
│  └── Classe Exception                                        │
│      └── ZCX_PRXY_CURRENCY_SERVICE                           │
│                                                              │
│  À créer manuellement :                                      │
│  ├── Communication Scenario                                  │
│  ├── Communication System                                    │
│  └── Communication Arrangement                               │
└──────────────────────────────────────────────────────────────┘

Étape 1 : Obtenir le fichier WSDL

Le fichier WSDL décrit complètement le service SOAP :

<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
                  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
                  xmlns:tns="http://example.com/currency"
                  targetNamespace="http://example.com/currency">

  <wsdl:types>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
      <xs:element name="ConvertCurrencyRequest">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="Amount" type="xs:decimal"/>
            <xs:element name="FromCurrency" type="xs:string"/>
            <xs:element name="ToCurrency" type="xs:string"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
      <xs:element name="ConvertCurrencyResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="ConvertedAmount" type="xs:decimal"/>
            <xs:element name="ExchangeRate" type="xs:decimal"/>
            <xs:element name="Timestamp" type="xs:dateTime"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
    </xs:schema>
  </wsdl:types>

  <wsdl:message name="ConvertCurrencyInput">
    <wsdl:part name="parameters" element="tns:ConvertCurrencyRequest"/>
  </wsdl:message>
  <wsdl:message name="ConvertCurrencyOutput">
    <wsdl:part name="parameters" element="tns:ConvertCurrencyResponse"/>
  </wsdl:message>

  <wsdl:portType name="CurrencyServicePortType">
    <wsdl:operation name="ConvertCurrency">
      <wsdl:input message="tns:ConvertCurrencyInput"/>
      <wsdl:output message="tns:ConvertCurrencyOutput"/>
    </wsdl:operation>
  </wsdl:portType>

  <wsdl:binding name="CurrencyServiceBinding" type="tns:CurrencyServicePortType">
    <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
    <wsdl:operation name="ConvertCurrency">
      <soap:operation soapAction="ConvertCurrency"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>
  </wsdl:binding>

  <wsdl:service name="CurrencyService">
    <wsdl:port name="CurrencyServicePort" binding="tns:CurrencyServiceBinding">
      <soap:address location="https://api.example.com/currency"/>
    </wsdl:port>
  </wsdl:service>
</wsdl:definitions>

Étape 2 : Créer le Service Consumption Model dans ADT

Clic droit sur le package → New → Other ABAP Repository Object
Sélectionner Connectivity → Service Consumption Model
Parcourir l’assistant :

┌──────────────────────────────────────────────────────────────┐
│  New Service Consumption Model                                │
├──────────────────────────────────────────────────────────────┤
│  Name :        Z_CURRENCY_SOAP                                │
│  Description : Currency Conversion SOAP Service               │
│  Package :     Z_INTEGRATION                                  │
│                                                              │
│  Service Type : ○ OData                                       │
│                 ● Web Service (SOAP)                          │
│                 ○ RFC                                         │
│                                                              │
│  WSDL File :   [Parcourir...] currency_service.wsdl          │
└──────────────────────────────────────────────────────────────┘

Étape 3 : Vérifier les artefacts générés

Après la génération, le Service Consumption Model contient :

Classe Proxy :

CLASS zcl_prxy_currency_service DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES if_proxy_client.

    METHODS constructor
      IMPORTING
        !destination TYPE REF TO if_http_destination OPTIONAL.

    METHODS convert_currency
      IMPORTING
        !input           TYPE zst_convert_currency_request
      RETURNING
        VALUE(result)    TYPE zst_convert_currency_response
      RAISING
        zcx_prxy_currency_service
        cx_ai_system_fault.
ENDCLASS.

Structure Request :

TYPES: BEGIN OF zst_convert_currency_request,
         amount        TYPE decfloat34,
         from_currency TYPE c LENGTH 3,
         to_currency   TYPE c LENGTH 3,
       END OF zst_convert_currency_request.

Structure Response :

TYPES: BEGIN OF zst_convert_currency_response,
         converted_amount TYPE decfloat34,
         exchange_rate    TYPE decfloat34,
         timestamp        TYPE timestamp,
       END OF zst_convert_currency_response.

Configurer le Communication Scenario

Pour la connexion SOAP, un Communication Scenario est nécessaire.

Créer le Communication Scenario

┌──────────────────────────────────────────────────────────────┐
│  Communication Scenario : Z_CURRENCY_SOAP_CS                  │
├──────────────────────────────────────────────────────────────┤
│  Communication Type : Outbound                                │
│                                                              │
│  Outbound Services :                                          │
│  └── Z_CURRENCY_SOAP_OS                                       │
│      ├── Service Type : SOAP                                  │
│      ├── Endpoint : /CurrencyService                          │
│      └── Authentication : Basic / OAuth2 / Certificate        │
│                                                              │
│  Supported Authentication Methods :                           │
│  ├── [x] Basic Authentication                                 │
│  ├── [x] OAuth 2.0 Client Credentials                         │
│  └── [x] Client Certificate                                   │
└──────────────────────────────────────────────────────────────┘

Configurer le Communication System

┌──────────────────────────────────────────────────────────────┐
│  Communication System : CURRENCY_API_SYSTEM                   │
├──────────────────────────────────────────────────────────────┤
│  General Data :                                               │
│  ├── System ID : CURRENCY                                     │
│  ├── System Name : Currency Conversion API                    │
│  └── System Type : External System                            │
│                                                              │
│  Technical Data :                                             │
│  ├── Host : api.currencyservice.com                           │
│  ├── Port : 443                                               │
│  └── Path Prefix : /soap/v1                                   │
│                                                              │
│  User for Outbound Communication :                            │
│  ├── Authentication Method : Basic Authentication             │
│  ├── User Name : API_USER                                     │
│  └── Password : ********                                      │
└──────────────────────────────────────────────────────────────┘

Activer le Communication Arrangement

┌──────────────────────────────────────────────────────────────┐
│  Communication Arrangement : Z_CURRENCY_SOAP_PROD             │
├──────────────────────────────────────────────────────────────┤
│  Communication Scenario : Z_CURRENCY_SOAP_CS                  │
│  Communication System : CURRENCY_API_SYSTEM                   │
│                                                              │
│  Outbound Services :                                          │
│  └── Z_CURRENCY_SOAP_OS : Active ✓                            │
│      ├── Service URL : https://api.currencyservice.com/soap   │
│      └── SOAP Action : Automatic                              │
│                                                              │
│  Connection Test : [Tester connexion]  ✓ Réussi               │
└──────────────────────────────────────────────────────────────┘

Appeler le service SOAP

Appel simple

CLASS zcl_currency_converter DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    TYPES: BEGIN OF ty_conversion_result,
             amount        TYPE decfloat34,
             currency      TYPE waers,
             exchange_rate TYPE decfloat34,
             timestamp     TYPE timestamp,
           END OF ty_conversion_result.

    METHODS convert_currency
      IMPORTING
        iv_amount        TYPE decfloat34
        iv_from_currency TYPE waers
        iv_to_currency   TYPE waers
      RETURNING
        VALUE(rs_result) TYPE ty_conversion_result
      RAISING
        zcx_currency_error.
ENDCLASS.

CLASS zcl_currency_converter IMPLEMENTATION.
  METHOD convert_currency.
    " Obtenir la destination HTTP depuis le Communication Arrangement
    DATA(lo_destination) = cl_http_destination_provider=>create_by_comm_arrangement(
      comm_scenario  = 'Z_CURRENCY_SOAP_CS"
      service_id     = 'Z_CURRENCY_SOAP_OS' ).

    " Créer l'instance proxy avec la destination
    DATA(lo_proxy) = NEW zcl_prxy_currency_service(
      destination = lo_destination ).

    " Construire la requête
    DATA(ls_request) = VALUE zst_convert_currency_request(
      amount        = iv_amount
      from_currency = iv_from_currency
      to_currency   = iv_to_currency ).

    TRY.
        " Effectuer l'appel SOAP
        DATA(ls_response) = lo_proxy->convert_currency( input = ls_request ).

        " Mapper le résultat
        rs_result = VALUE #(
          amount        = ls_response-converted_amount
          currency      = iv_to_currency
          exchange_rate = ls_response-exchange_rate
          timestamp     = ls_response-timestamp ).

      CATCH zcx_prxy_currency_service INTO DATA(lx_proxy).
        " SOAP Fault du service
        RAISE EXCEPTION TYPE zcx_currency_error
          EXPORTING
            previous = lx_proxy
            textid   = zcx_currency_error=>soap_fault.

      CATCH cx_ai_system_fault INTO DATA(lx_system).
        " Erreur technique (réseau, timeout)
        RAISE EXCEPTION TYPE zcx_currency_error
          EXPORTING
            previous = lx_system
            textid   = zcx_currency_error=>system_error.
    ENDTRY.
  ENDMETHOD.
ENDCLASS.

Utilisation dans la logique applicative

" Dans une action RAP ou determination
TRY.
    DATA(lo_converter) = NEW zcl_currency_converter( ).

    DATA(ls_result) = lo_converter->convert_currency(
      iv_amount        = 100
      iv_from_currency = 'EUR"
      iv_to_currency   = 'USD' ).

    " Utiliser le résultat
    DATA(lv_usd_amount) = ls_result-amount.
    DATA(lv_rate) = ls_result-exchange_rate.

  CATCH zcx_currency_error INTO DATA(lx_error).
    " Gestion des erreurs
    APPEND VALUE #(
      %tky = ls_key-%tky
      %msg = new_message_with_text( text = lx_error->get_text( ) )
    ) TO reported-entity.
ENDTRY.

Méthodes d’authentification

Basic Authentication

La méthode la plus simple pour les services SOAP protégés :

Communication System :
├── User for Outbound Communication
│   ├── Authentication Method : Basic Authentication
│   ├── User Name : SOAP_API_USER
│   └── Password : ********

Les credentials sont automatiquement envoyés comme en-tête HTTP Basic Auth :

Authorization: Basic U09BUF9BUElfVVNFUjpwYXNzd29yZA==

OAuth 2.0 Client Credentials

Pour les services SOAP modernes avec authentification basée sur token :

┌──────────────────────────────────────────────────────────────┐
│  Communication System : CURRENCY_API_OAUTH                    │
├──────────────────────────────────────────────────────────────┤
│  OAuth 2.0 Settings :                                         │
│  ├── Grant Type : Client Credentials                          │
│  ├── Token Endpoint : https://auth.api.com/oauth/token        │
│  ├── Client ID : abap-cloud-client                            │
│  ├── Client Secret : ********                                 │
│  └── Scope : currency.read currency.convert                   │
│                                                              │
│  Le token est automatiquement récupéré et mis en cache        │
└──────────────────────────────────────────────────────────────┘

Certificat client

Pour les environnements hautement sécurisés avec authentification TLS mutuelle :

Communication System :
├── User for Outbound Communication
│   ├── Authentication Method : Client Certificate
│   └── Certificate : [Upload X.509 Certificate]
│
└── Trust Configuration
    └── Server Certificate : [Upload CA Certificate]

Gestion des erreurs

Traiter les SOAP Faults

Les services SOAP peuvent retourner des messages d’erreur structurés (Faults) :

CLASS zcx_currency_error DEFINITION
  PUBLIC
  INHERITING FROM cx_static_check
  FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES if_t100_message.

    CONSTANTS:
      BEGIN OF soap_fault,
        msgid TYPE symsgid VALUE 'Z_CURRENCY',
        msgno TYPE symsgno VALUE '001',
        attr1 TYPE scx_attrname VALUE 'MV_FAULT_CODE',
        attr2 TYPE scx_attrname VALUE 'MV_FAULT_STRING',
        attr3 TYPE scx_attrname VALUE '',
        attr4 TYPE scx_attrname VALUE '',
      END OF soap_fault,
      BEGIN OF system_error,
        msgid TYPE symsgid VALUE 'Z_CURRENCY',
        msgno TYPE symsgno VALUE '002',
        attr1 TYPE scx_attrname VALUE '',
        attr2 TYPE scx_attrname VALUE '',
        attr3 TYPE scx_attrname VALUE '',
        attr4 TYPE scx_attrname VALUE '',
      END OF system_error,
      BEGIN OF timeout_error,
        msgid TYPE symsgid VALUE 'Z_CURRENCY',
        msgno TYPE symsgno VALUE '003',
        attr1 TYPE scx_attrname VALUE '',
        attr2 TYPE scx_attrname VALUE '',
        attr3 TYPE scx_attrname VALUE '',
        attr4 TYPE scx_attrname VALUE '',
      END OF timeout_error.

    DATA mv_fault_code TYPE string READ-ONLY.
    DATA mv_fault_string TYPE string READ-ONLY.

    METHODS constructor
      IMPORTING
        !textid       LIKE if_t100_message=>t100key OPTIONAL
        !previous     LIKE previous OPTIONAL
        !fault_code   TYPE string OPTIONAL
        !fault_string TYPE string OPTIONAL.
ENDCLASS.

CLASS zcx_currency_error IMPLEMENTATION.
  METHOD constructor.
    super->constructor( previous = previous ).
    mv_fault_code = fault_code.
    mv_fault_string = fault_string.

    IF textid IS INITIAL.
      if_t100_message~t100key = soap_fault.
    ELSE.
      if_t100_message~t100key = textid.
    ENDIF.
  ENDMETHOD.
ENDCLASS.

Évaluation détaillée des erreurs

METHOD call_soap_with_error_handling.
  TRY.
      DATA(lo_destination) = cl_http_destination_provider=>create_by_comm_arrangement(
        comm_scenario  = 'Z_CURRENCY_SOAP_CS"
        service_id     = 'Z_CURRENCY_SOAP_OS' ).

      DATA(lo_proxy) = NEW zcl_prxy_currency_service( destination = lo_destination ).
      DATA(ls_response) = lo_proxy->convert_currency( input = ls_request ).

    CATCH zcx_prxy_currency_service INTO DATA(lx_soap_fault).
      " SOAP Fault - Erreur métier du service
      " ex. devise invalide, montant hors plage
      DATA(lv_fault_code) = lx_soap_fault->get_fault_code( ).
      DATA(lv_fault_string) = lx_soap_fault->get_fault_string( ).

      CASE lv_fault_code.
        WHEN 'INVALID_CURRENCY'.
          RAISE EXCEPTION TYPE zcx_currency_error
            EXPORTING
              textid       = zcx_currency_error=>soap_fault
              fault_code   = lv_fault_code
              fault_string = lv_fault_string.

        WHEN 'RATE_NOT_AVAILABLE'.
          " Retry avec une autre date ou taux par défaut
          rs_result = get_fallback_rate( ls_request ).

        WHEN OTHERS.
          RAISE EXCEPTION TYPE zcx_currency_error
            EXPORTING previous = lx_soap_fault.
      ENDCASE.

    CATCH cx_http_dest_provider_error INTO DATA(lx_dest).
      " Destination non trouvée ou mal configurée
      RAISE EXCEPTION TYPE zcx_currency_error
        EXPORTING
          textid   = zcx_currency_error=>system_error
          previous = lx_dest.

    CATCH cx_ai_system_fault INTO DATA(lx_system).
      " Erreur technique : Réseau, Timeout, Parsing
      IF lx_system->get_text( ) CS 'timeout'.
        RAISE EXCEPTION TYPE zcx_currency_error
          EXPORTING textid = zcx_currency_error=>timeout_error.
      ELSE.
        RAISE EXCEPTION TYPE zcx_currency_error
          EXPORTING
            textid   = zcx_currency_error=>system_error
            previous = lx_system.
      ENDIF.
  ENDTRY.
ENDMETHOD.

Logique de retry pour erreurs transitoires

CLASS zcl_soap_retry_handler DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    CONSTANTS: c_max_retries  TYPE i VALUE 3,
               c_retry_delay  TYPE i VALUE 1000,  " ms
               c_backoff_mult TYPE decfloat16 VALUE '1.5'.

    METHODS call_with_retry
      IMPORTING
        is_request       TYPE zst_convert_currency_request
      RETURNING
        VALUE(rs_result) TYPE zst_convert_currency_response
      RAISING
        zcx_currency_error.
ENDCLASS.

CLASS zcl_soap_retry_handler IMPLEMENTATION.
  METHOD call_with_retry.
    DATA: lv_retries TYPE i,
          lv_delay   TYPE i.

    lv_delay = c_retry_delay.

    WHILE lv_retries < c_max_retries.
      TRY.
          DATA(lo_destination) = cl_http_destination_provider=>create_by_comm_arrangement(
            comm_scenario = 'Z_CURRENCY_SOAP_CS"
            service_id    = 'Z_CURRENCY_SOAP_OS' ).

          DATA(lo_proxy) = NEW zcl_prxy_currency_service( destination = lo_destination ).
          rs_result = lo_proxy->convert_currency( input = is_request ).

          " Succès - retour immédiat
          RETURN.

        CATCH cx_ai_system_fault INTO DATA(lx_system).
          " Retry uniquement pour erreurs transitoires
          IF is_transient_error( lx_system ).
            lv_retries = lv_retries + 1.

            IF lv_retries < c_max_retries.
              " Backoff exponentiel
              cl_abap_session_context=>sleep( lv_delay ).
              lv_delay = CONV i( lv_delay * c_backoff_mult ).
            ENDIF.
          ELSE.
            " Erreur permanente - pas de retry
            RAISE EXCEPTION TYPE zcx_currency_error
              EXPORTING previous = lx_system.
          ENDIF.

        CATCH zcx_prxy_currency_service INTO DATA(lx_soap).
          " Les SOAP Faults sont des erreurs métier - pas de retry
          RAISE EXCEPTION TYPE zcx_currency_error
            EXPORTING previous = lx_soap.
      ENDTRY.
    ENDWHILE.

    " Max retries atteint
    RAISE EXCEPTION TYPE zcx_currency_error
      EXPORTING textid = zcx_currency_error=>timeout_error.
  ENDMETHOD.

  METHOD is_transient_error.
    " Erreurs transitoires : Timeout, connexion interrompue, service temporairement indisponible
    DATA(lv_text) = to_lower( ix_error->get_text( ) ).

    rv_result = xsdbool(
      lv_text CS 'timeout' OR
      lv_text CS 'connection' OR
      lv_text CS '503' OR
      lv_text CS 'temporarily' ).
  ENDMETHOD.
ENDCLASS.

Intégration avec RAP

Custom Entity pour données SOAP

@EndUserText.label: 'Taux de change (externe)"
@ObjectModel.query.implementedBy: 'ABAP:ZCL_CE_CURRENCY_RATES"
define custom entity ZCE_CURRENCY_RATES
{
  key FromCurrency : abap.char(3);
  key ToCurrency   : abap.char(3);
      ExchangeRate : abap.dec(15,6);
      LastUpdated  : timestamp;
}

Implémentation Query

CLASS zcl_ce_currency_rates DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES if_rap_query_provider.
ENDCLASS.

CLASS zcl_ce_currency_rates IMPLEMENTATION.
  METHOD if_rap_query_provider~select.
    " Évaluer les filtres
    DATA(lt_filters) = io_request->get_filter( )->get_as_ranges( ).

    " Appeler le service SOAP
    TRY.
        DATA(lo_converter) = NEW zcl_currency_converter( ).
        DATA lt_result TYPE STANDARD TABLE OF zce_currency_rates.

        " Pour chaque combinaison de filtre récupérer le taux
        LOOP AT lt_filters INTO DATA(ls_filter)
          WHERE name = 'FROMCURRENCY'.

          DATA(lr_from) = ls_filter-range.
          DATA(lr_to) = VALUE #( lt_filters[ name = 'TOCURRENCY' ]-range OPTIONAL ).

          " Appeler SOAP et mapper le résultat
          DATA(ls_soap_result) = lo_converter->convert_currency(
            iv_amount        = 1
            iv_from_currency = CONV #( lr_from[ 1 ]-low )
            iv_to_currency   = CONV #( lr_to[ 1 ]-low ) ).

          APPEND VALUE #(
            FromCurrency = lr_from[ 1 ]-low
            ToCurrency   = lr_to[ 1 ]-low
            ExchangeRate = ls_soap_result-exchange_rate
            LastUpdated  = ls_soap_result-timestamp
          ) TO lt_result.
        ENDLOOP.

        io_response->set_total_number_of_records( lines( lt_result ) ).
        io_response->set_data( lt_result ).

      CATCH zcx_currency_error INTO DATA(lx_error).
        RAISE EXCEPTION TYPE cx_rap_query_provider
          EXPORTING previous = lx_error.
    ENDTRY.
  ENDMETHOD.
ENDCLASS.

Action RAP avec appel SOAP

" Behavior Definition
define behavior for ZI_ORDER alias Order
{
  action convertCurrency parameter ZA_CURRENCY_PARAM result [1] $self;
}

" Behavior Implementation
CLASS lhc_order DEFINITION INHERITING FROM cl_abap_behavior_handler.
  PRIVATE SECTION.
    METHODS convert_currency FOR MODIFY
      IMPORTING keys FOR ACTION Order~convertCurrency RESULT result.
ENDCLASS.

CLASS lhc_order IMPLEMENTATION.
  METHOD convert_currency.
    " Lire les commandes
    READ ENTITIES OF zi_order IN LOCAL MODE
      ENTITY Order
        FIELDS ( OrderID TotalAmount Currency )
        WITH CORRESPONDING #( keys )
      RESULT DATA(lt_orders).

    TRY.
        DATA(lo_converter) = NEW zcl_currency_converter( ).

        LOOP AT lt_orders INTO DATA(ls_order).
          DATA(ls_key) = keys[ %tky = ls_order-%tky ].

          " Conversion de devise via SOAP
          DATA(ls_conversion) = lo_converter->convert_currency(
            iv_amount        = ls_order-TotalAmount
            iv_from_currency = ls_order-Currency
            iv_to_currency   = ls_key-%param-TargetCurrency ).

          " Mettre à jour l'entité
          MODIFY ENTITIES OF zi_order IN LOCAL MODE
            ENTITY Order
              UPDATE FIELDS ( TotalAmount Currency )
              WITH VALUE #( (
                %tky        = ls_order-%tky
                TotalAmount = ls_conversion-amount
                Currency    = ls_key-%param-TargetCurrency ) ).

          " Retourner le résultat
          APPEND VALUE #(
            %tky   = ls_order-%tky
            %param = CORRESPONDING #( ls_order )
          ) TO result.
        ENDLOOP.

      CATCH zcx_currency_error INTO DATA(lx_error).
        LOOP AT keys INTO ls_key.
          APPEND VALUE #(
            %tky = ls_key-%tky
            %msg = new_message_with_text( text = lx_error->get_text( ) )
          ) TO reported-order.
        ENDLOOP.
    ENDTRY.
  ENDMETHOD.
ENDCLASS.

Scénarios SOAP complexes

SOAP avec pièces jointes (MTOM)

Certains services SOAP utilisent MTOM (Message Transmission Optimization Mechanism) pour les données binaires :

" WSDL avec pièce jointe MTOM
" La classe proxy générée gère MTOM automatiquement

METHOD upload_document.
  DATA(ls_request) = VALUE zst_upload_doc_request(
    file_name    = 'report.pdf"
    content_type = 'application/pdf"
    binary_data  = lv_pdf_xstring ).  " XSTRING envoyé comme MTOM

  DATA(ls_response) = lo_proxy->upload_document( input = ls_request ).
ENDMETHOD.

SOAP avec WS-Security

Pour les services SOAP avec en-tête WS-Security :

Communication System :
├── Security Settings
│   ├── WS-Security : Enabled
│   ├── Username Token : API_USER
│   ├── Password Type : PasswordText / PasswordDigest
│   └── Timestamp : Include (validity 5 min)

L’enveloppe SOAP générée contient alors :

<soap:Envelope>
  <soap:Header>
    <wsse:Security>
      <wsse:UsernameToken>
        <wsse:Username>API_USER</wsse:Username>
        <wsse:Password Type="PasswordText">...</wsse:Password>
        <wsse:Nonce>...</wsse:Nonce>
        <wsu:Created>2026-02-14T10:00:00Z</wsu:Created>
      </wsse:UsernameToken>
      <wsu:Timestamp>
        <wsu:Created>2026-02-14T10:00:00Z</wsu:Created>
        <wsu:Expires>2026-02-14T10:05:00Z</wsu:Expires>
      </wsu:Timestamp>
    </wsse:Security>
  </soap:Header>
  <soap:Body>...</soap:Body>
</soap:Envelope>

Bonnes pratiques

Sujet	Recommandation
Versionnement WSDL	Versionner le fichier WSDL dans le repository Git
Régénération proxy	Régénérer le Service Consumption Model lors des changements WSDL
Gestion des erreurs	Toujours distinguer SOAP Faults et System Faults
Retry	Uniquement pour erreurs transitoires, pas pour SOAP Faults
Timeout	Définir des timeouts appropriés dans le Communication Arrangement
Logging	Journaliser tous les appels SOAP pour le débogage
Tests	Utiliser des services mock pour les tests unitaires
Sécurité	Credentials jamais dans le code, toujours dans Communication System

Erreurs courantes et solutions

Erreur	Cause	Solution
CX_AI_SYSTEM_FAULT	Erreur technique	Vérifier réseau, valider WSDL
SOAP Fault: Invalid Request	Données invalides	Vérifier structure request par rapport à WSDL
HTTP 401	Authentification	Vérifier credentials dans Comm. System
HTTP 403	Autorisation	Vérifier les autorisations dans le système cible
Timeout	Service lent	Augmenter timeout, éventuellement traiter en async
Certificate Error	Problème TLS	Certificat serveur dans Trust Store

Sujets connexes

HTTP Client - Alternative pour les APIs REST
RAP External API Consumption - Intégrer des APIs externes dans RAP
SAP Destination Service - Configurer les destinations
RFC dans ABAP Cloud - Communication RFC pour les systèmes SAP