Output Management in ABAP Cloud

kategorie

Integration

Veröffentlicht

Feb 14, 2026

autor

Output Management in ABAP Cloud unterscheidet sich grundlegend von On-Premise. Der klassische Spool mit Transaktionen wie SP01, SP02 und SPAD steht auf SAP BTP nicht zur Verfuegung. Stattdessen nutzt ABAP Cloud moderne, Cloud-native Konzepte fuer die Ausgabeverarbeitung.

Grundlegende Konzepte

In ABAP Cloud gibt es mehrere Wege, Dokumente auszugeben:

Konzept	Beschreibung	Anwendungsfall
SAP Cloud Print Manager	Cloud-basierter Druckdienst	Direkter Druck auf Netzwerkdrucker
PDF-Generierung	Dokumente als PDF erstellen	Download, E-Mail-Versand
Output Control	Zentrale Ausgabesteuerung	Formularbasierte Ausgabe
E-Mail-Versand	Dokumente per E-Mail senden	Rechnungen, Benachrichtigungen

Architektur-Uebersicht

┌─────────────────────────────────────────────────────────────────────────────┐
│                     Output Management in ABAP Cloud                          │
│                                                                              │
│  ┌────────────────────────────────────────────────────────────────────────┐ │
│  │                     RAP Business Object / Anwendung                     │ │
│  │                                                                          │
│  │  ┌─────────────────────┐                                                │ │
│  │  │   Output Request    │                                                │ │
│  │  │   (Druckauftrag)    │                                                │ │
│  │  └──────────┬──────────┘                                                │ │
│  └─────────────┼────────────────────────────────────────────────────────────┘ │
│                │                                                              │
│                ▼                                                              │
│  ┌─────────────────────────────────────────────────────────────────────────┐ │
│  │                     Ausgabeoptionen                                      │ │
│  │                                                                          │ │
│  │  ┌───────────────────┐  ┌───────────────────┐  ┌───────────────────┐   │ │
│  │  │  Cloud Print      │  │  PDF Download     │  │  E-Mail-Versand   │   │ │
│  │  │  Manager          │  │                   │  │                   │   │ │
│  │  │  - Print Queue    │  │  - RAP Action     │  │  - cl_bcs_mail    │   │ │
│  │  │  - Drucker        │  │  - Attachment     │  │  - Attachment     │   │ │
│  │  └───────────────────┘  └───────────────────┘  └───────────────────┘   │ │
│  └─────────────────────────────────────────────────────────────────────────┘ │
│                │                                                              │
│                ▼                                                              │
│  ┌─────────────────────────────────────────────────────────────────────────┐ │
│  │                          Ausgabeziele                                    │ │
│  │  - Netzwerkdrucker ueber Cloud Print                                     │ │
│  │  - Browser-Download                                                      │ │
│  │  - E-Mail-Postfach                                                       │ │
│  │  - Dokumentenmanagement (DMS)                                            │ │
│  └─────────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘

SAP Cloud Print Manager

Der SAP Cloud Print Manager ist der Cloud-native Ersatz fuer das klassische Spool-System. Er ermoeglicht den Druck auf physische Drucker aus der Cloud.

Komponenten

Komponente	Beschreibung
Cloud Print Manager	SAP BTP Service fuer Druckauftragsverwaltung
Print Queue	Warteschlange fuer Druckauftraege
Print Agent	On-Premise-Komponente, die Drucker anbindet
Printer	Konfigurierter Ausgabedrucker

Architektur mit Print Agent

┌───────────────────────────────────────────────────────────────────────────┐
│                    Cloud Print Architecture                                │
│                                                                            │
│  ┌─────────────────────────────────────────────────────────────────────┐  │
│  │                          SAP BTP                                     │  │
│  │                                                                      │  │
│  │  ┌───────────────────┐         ┌───────────────────┐                │  │
│  │  │   ABAP Cloud      │  ────►  │  Cloud Print      │                │  │
│  │  │   Anwendung       │  HTTP   │  Manager Service  │                │  │
│  │  └───────────────────┘         └─────────┬─────────┘                │  │
│  │                                          │                           │  │
│  └──────────────────────────────────────────┼───────────────────────────┘  │
│                                              │                              │
│                                              │ Cloud Connector              │
│                                              │ oder direkter Zugriff        │
│                                              ▼                              │
│  ┌─────────────────────────────────────────────────────────────────────┐  │
│  │                       On-Premise / Firmennetzwerk                    │  │
│  │                                                                      │  │
│  │  ┌───────────────────┐         ┌───────────────────┐                │  │
│  │  │   Print Agent     │  ────►  │   Netzwerk-       │                │  │
│  │  │   (SAP Software)  │  Print  │   Drucker         │                │  │
│  │  └───────────────────┘         └───────────────────┘                │  │
│  │                                                                      │  │
│  └─────────────────────────────────────────────────────────────────────┘  │
└───────────────────────────────────────────────────────────────────────────┘

Print Queue konfigurieren

Die Konfiguration erfolgt in der SAP BTP Cloud Foundry Umgebung:

Cloud Print Manager Service in BTP Subaccount aktivieren
Service Instance erstellen
Service Key fuer Authentifizierung generieren
Print Agent On-Premise installieren und konfigurieren

Code-Beispiel: Druckauftrag erstellen

" Druckauftrag ueber Cloud Print Manager
CLASS zcl_print_manager DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    TYPES:
      BEGIN OF ty_print_request,
        queue_name    TYPE string,
        document_name TYPE string,
        content       TYPE xstring,
        content_type  TYPE string,  " application/pdf, text/plain
        copies        TYPE i,
        duplex        TYPE abap_bool,
        color         TYPE abap_bool,
      END OF ty_print_request.

    TYPES:
      BEGIN OF ty_print_response,
        job_id     TYPE string,
        status     TYPE string,
        message    TYPE string,
        queue_name TYPE string,
      END OF ty_print_response.

    METHODS:
      constructor
        IMPORTING iv_comm_scenario TYPE string.

    METHODS:
      submit_print_job
        IMPORTING is_request        TYPE ty_print_request
        RETURNING VALUE(rs_response) TYPE ty_print_response
        RAISING   cx_http_dest_provider_error
                  cx_web_http_client_error.

    METHODS:
      get_print_queues
        RETURNING VALUE(rt_queues) TYPE string_table
        RAISING   cx_http_dest_provider_error
                  cx_web_http_client_error.

    METHODS:
      get_job_status
        IMPORTING iv_job_id       TYPE string
        RETURNING VALUE(rv_status) TYPE string
        RAISING   cx_http_dest_provider_error
                  cx_web_http_client_error.

  PRIVATE SECTION.
    DATA: mv_comm_scenario TYPE string.

    METHODS:
      get_http_client
        RETURNING VALUE(ro_client) TYPE REF TO if_web_http_client
        RAISING   cx_http_dest_provider_error
                  cx_web_http_client_error.

ENDCLASS.

CLASS zcl_print_manager IMPLEMENTATION.

  METHOD constructor.
    mv_comm_scenario = iv_comm_scenario.
  ENDMETHOD.

  METHOD submit_print_job.
    " HTTP Client erstellen
    DATA(lo_client) = get_http_client( ).

    TRY.
        DATA(lo_request) = lo_client->get_http_request( ).

        " Pfad fuer Print Job API
        lo_request->set_uri_path( '/v1/print-jobs' ).
        lo_request->set_header_field(
          i_name  = 'Content-Type'
          i_value = 'application/json'
        ).

        " Request Body
        DATA(lv_content_base64) = cl_http_utility=>encode_base64( is_request-content ).

        DATA(lv_request_body) = |\{| &&
          |"queueName": "{ is_request-queue_name }",| &&
          |"documentName": "{ is_request-document_name }",| &&
          |"contentType": "{ is_request-content_type }",| &&
          |"content": "{ lv_content_base64 }",| &&
          |"numberOfCopies": { is_request-copies },| &&
          |"duplex": { COND #( WHEN is_request-duplex = abap_true THEN 'true' ELSE 'false' ) },| &&
          |"color": { COND #( WHEN is_request-color = abap_true THEN 'true' ELSE 'false' ) }| &&
          |\}|.

        lo_request->set_text( lv_request_body ).

        " API aufrufen
        DATA(lo_response) = lo_client->execute( if_web_http_client=>post ).

        DATA(lv_status) = lo_response->get_status( ).

        IF lv_status-code = 201 OR lv_status-code = 200.
          " Response parsen
          DATA(lv_response_json) = lo_response->get_text( ).

          " Job ID extrahieren (vereinfacht)
          rs_response-status = 'SUBMITTED'.
          rs_response-queue_name = is_request-queue_name.
          " Job ID aus JSON parsen...
        ELSE.
          rs_response-status = 'ERROR'.
          rs_response-message = lo_response->get_text( ).
        ENDIF.

      CATCH cx_web_http_client_error INTO DATA(lx_http).
        rs_response-status = 'ERROR'.
        rs_response-message = lx_http->get_text( ).
    ENDTRY.

    lo_client->close( ).
  ENDMETHOD.

  METHOD get_print_queues.
    DATA(lo_client) = get_http_client( ).

    TRY.
        DATA(lo_request) = lo_client->get_http_request( ).
        lo_request->set_uri_path( '/v1/queues' ).

        DATA(lo_response) = lo_client->execute( if_web_http_client=>get ).

        IF lo_response->get_status( )-code = 200.
          " Queues aus JSON parsen
          DATA(lv_json) = lo_response->get_text( ).
          " JSON-Parsing mit /ui2/cl_json...
        ENDIF.

      CLEANUP.
        lo_client->close( ).
    ENDTRY.
  ENDMETHOD.

  METHOD get_job_status.
    DATA(lo_client) = get_http_client( ).

    TRY.
        DATA(lo_request) = lo_client->get_http_request( ).
        lo_request->set_uri_path( |/v1/print-jobs/{ iv_job_id }| ).

        DATA(lo_response) = lo_client->execute( if_web_http_client=>get ).

        IF lo_response->get_status( )-code = 200.
          " Status aus JSON parsen
          rv_status = 'COMPLETED'. " vereinfacht
        ELSE.
          rv_status = 'UNKNOWN'.
        ENDIF.

      CLEANUP.
        lo_client->close( ).
    ENDTRY.
  ENDMETHOD.

  METHOD get_http_client.
    " Destination aus Communication Arrangement
    DATA(lo_destination) = cl_http_destination_provider=>create_by_comm_arrangement(
      comm_scenario  = mv_comm_scenario
      service_id     = 'PRINT_SERVICE'
    ).

    ro_client = cl_web_http_client_manager=>create_by_http_destination( lo_destination ).
  ENDMETHOD.

ENDCLASS.

Output Control - Zentrale Ausgabesteuerung

Fuer komplexe Szenarien mit verschiedenen Ausgabekanaelen bietet SAP Output Control (auch bekannt als PPF - Post Processing Framework).

Konzept

Output Control ermoeglicht:

Automatische Dokumentenausgabe basierend auf Regeln
Verschiedene Ausgabekanaele (Druck, E-Mail, EDI)
Timing-Steuerung (sofort, geplant, manuell)
Wiederholungslogik bei Fehlern

Output-Typen

Ausgabetyp	Beschreibung	Beispiel
Print	Physischer Druck	Lieferschein
Email	E-Mail-Versand	Auftragsbestaetigung
EDI	Elektronischer Datenaustausch	Bestellung an Lieferant
Archive	Archivierung	Rechnung ins DMS

Code-Beispiel: Output Request anlegen

" Output Request fuer Dokument anlegen
CLASS zcl_output_control DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    TYPES:
      BEGIN OF ty_output_request,
        document_id    TYPE string,
        document_type  TYPE string,
        output_type    TYPE string,  " PRINT, EMAIL, ARCHIVE
        output_channel TYPE string,
        recipient      TYPE string,
        priority       TYPE i,
        scheduled_time TYPE timestampl,
      END OF ty_output_request.

    METHODS:
      create_output_request
        IMPORTING is_request TYPE ty_output_request
        RETURNING VALUE(rv_request_id) TYPE string.

    METHODS:
      process_output_request
        IMPORTING iv_request_id TYPE string
        RAISING   zcx_output_error.

    METHODS:
      get_output_status
        IMPORTING iv_request_id TYPE string
        RETURNING VALUE(rv_status) TYPE string.

ENDCLASS.

CLASS zcl_output_control IMPLEMENTATION.

  METHOD create_output_request.
    " Output Request in Tabelle speichern
    DATA ls_request TYPE zoutput_request.

    ls_request-request_uuid = cl_system_uuid=>create_uuid_x16_static( ).
    ls_request-document_id = is_request-document_id.
    ls_request-document_type = is_request-document_type.
    ls_request-output_type = is_request-output_type.
    ls_request-output_channel = is_request-output_channel.
    ls_request-recipient = is_request-recipient.
    ls_request-priority = is_request-priority.
    ls_request-scheduled_time = is_request-scheduled_time.
    ls_request-status = 'PENDING'.
    ls_request-created_at = cl_abap_tstmp=>utclong_current( ).

    INSERT zoutput_request FROM @ls_request.

    rv_request_id = cl_system_uuid=>convert_uuid_x16_static(
      uuid = ls_request-request_uuid
    ).
  ENDMETHOD.

  METHOD process_output_request.
    " Request laden
    SELECT SINGLE *
      FROM zoutput_request
      WHERE request_uuid = @( cl_system_uuid=>convert_uuid_c36_static( iv_request_id ) )
      INTO @DATA(ls_request).

    IF sy-subrc <> 0.
      RAISE EXCEPTION TYPE zcx_output_error
        EXPORTING
          textid = zcx_output_error=>request_not_found.
    ENDIF.

    " Status auf Processing setzen
    UPDATE zoutput_request
      SET status = 'PROCESSING'
      WHERE request_uuid = @ls_request-request_uuid.

    TRY.
        " Je nach Output-Typ verarbeiten
        CASE ls_request-output_type.
          WHEN 'PRINT'.
            process_print_output( ls_request ).
          WHEN 'EMAIL'.
            process_email_output( ls_request ).
          WHEN 'ARCHIVE'.
            process_archive_output( ls_request ).
          WHEN OTHERS.
            RAISE EXCEPTION TYPE zcx_output_error
              EXPORTING
                textid = zcx_output_error=>unknown_output_type.
        ENDCASE.

        " Erfolg
        UPDATE zoutput_request
          SET status = 'COMPLETED',
              processed_at = @( cl_abap_tstmp=>utclong_current( ) )
          WHERE request_uuid = @ls_request-request_uuid.

      CATCH zcx_output_error INTO DATA(lx_error).
        " Fehler protokollieren
        UPDATE zoutput_request
          SET status = 'ERROR',
              error_message = @( lx_error->get_text( ) )
          WHERE request_uuid = @ls_request-request_uuid.

        RAISE EXCEPTION lx_error.
    ENDTRY.
  ENDMETHOD.

  METHOD get_output_status.
    SELECT SINGLE status
      FROM zoutput_request
      WHERE request_uuid = @( cl_system_uuid=>convert_uuid_c36_static( iv_request_id ) )
      INTO @rv_status.
  ENDMETHOD.

ENDCLASS.

E-Mail-Versand als Ausgabekanal

Der E-Mail-Versand ist eine gaengige Alternative zum Druck in ABAP Cloud.

Code-Beispiel: Dokument per E-Mail senden

" Dokument per E-Mail versenden
CLASS zcl_email_document_sender DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    TYPES:
      BEGIN OF ty_email_request,
        recipient      TYPE string,
        subject        TYPE string,
        body_text      TYPE string,
        attachment     TYPE xstring,
        attachment_name TYPE string,
        attachment_type TYPE string,
      END OF ty_email_request.

    METHODS:
      send_document
        IMPORTING is_request TYPE ty_email_request
        RAISING   cx_bcs_exception.

ENDCLASS.

CLASS zcl_email_document_sender IMPLEMENTATION.

  METHOD send_document.
    " E-Mail mit Attachment versenden
    DATA(lo_mail) = cl_bcs_mail_message=>create_instance( ).

    " Empfaenger setzen
    lo_mail->add_recipient( is_request-recipient ).

    " Betreff setzen
    lo_mail->set_subject( is_request-subject ).

    " Body setzen
    lo_mail->set_main(
      cl_bcs_mail_textpart=>create_instance(
        iv_content  = is_request-body_text
        iv_content_type = 'text/plain'
      )
    ).

    " Attachment hinzufuegen
    IF is_request-attachment IS NOT INITIAL.
      lo_mail->add_attachment(
        cl_bcs_mail_binarypart=>create_instance(
          iv_content      = is_request-attachment
          iv_content_type = is_request-attachment_type
          iv_filename     = is_request-attachment_name
        )
      ).
    ENDIF.

    " E-Mail senden
    lo_mail->send( ).
  ENDMETHOD.

ENDCLASS.

Integration mit RAP

" RAP Action fuer Dokumentenversand
METHOD sendDocument FOR MODIFY
  IMPORTING keys FOR ACTION Document~sendDocument RESULT result.

  " Dokumente laden
  READ ENTITIES OF zi_document IN LOCAL MODE
    ENTITY Document
    ALL FIELDS WITH CORRESPONDING #( keys )
    RESULT DATA(lt_documents).

  LOOP AT lt_documents INTO DATA(ls_document).
    TRY.
        " PDF generieren
        DATA(lo_pdf_gen) = NEW zcl_pdf_generator( ).
        DATA(lv_pdf) = lo_pdf_gen->generate_document_pdf( ls_document ).

        " Per E-Mail versenden
        DATA(lo_email_sender) = NEW zcl_email_document_sender( ).
        lo_email_sender->send_document(
          VALUE #(
            recipient       = ls_document-contact_email
            subject         = |Ihr Dokument: { ls_document-document_number }|
            body_text       = |Sehr geehrte Damen und Herren,\n\n| &&
                              |anbei erhalten Sie Ihr Dokument.\n\n| &&
                              |Mit freundlichen Gruessen|
            attachment      = lv_pdf
            attachment_name = |Dokument_{ ls_document-document_number }.pdf|
            attachment_type = 'application/pdf'
          )
        ).

        " Erfolgsmeldung
        APPEND VALUE #(
          %tky = ls_document-%tky
          %param = ls_document
        ) TO result.

      CATCH cx_bcs_exception INTO DATA(lx_mail).
        APPEND VALUE #(
          %tky = ls_document-%tky
          %msg = new_message_with_text(
            severity = if_abap_behv_message=>severity-error
            text     = lx_mail->get_text( )
          )
        ) TO reported-document.
    ENDTRY.
  ENDLOOP.
ENDMETHOD.

Alternativen zum klassischen Spool

Vergleich On-Premise vs. Cloud

Aspekt	On-Premise (Spool)	ABAP Cloud
Druckauftraege	SP01, Spool-Auftraege	Cloud Print Manager, Print Queues
Druckerkonfiguration	SPAD	BTP Cockpit, Print Agent
Formulare	SmartForms, Adobe Forms	SAP Forms Service, externe Services
Ausgabesteuerung	NACE, Output Types	Output Control, RAP Actions
Archivierung	ArchiveLink	SAP Document Management
Monitoring	SP02, SMX	Fiori Apps, Logging

Alternative 1: PDF-Download statt Druck

Die einfachste Alternative zum Druck ist der PDF-Download:

" PDF-Download via RAP Action
action downloadDocument
  parameter ZA_DownloadParams
  result [1] ZA_DownloadResult;

Der Benutzer kann das PDF dann lokal drucken.

Alternative 2: Browser-basierter Druck

" HTML mit Print-CSS generieren
CLASS zcl_browser_print DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    METHODS:
      generate_printable_html
        IMPORTING is_data        TYPE any
        RETURNING VALUE(rv_html) TYPE string.

ENDCLASS.

CLASS zcl_browser_print IMPLEMENTATION.

  METHOD generate_printable_html.
    " HTML mit optimiertem Print-CSS
    rv_html =
      |<!DOCTYPE html>| &&
      |<html>| &&
      |<head>| &&
      |<style>| &&
      |@media screen \{| &&
      |  .print-button \{ display: block; margin: 20px; padding: 10px; \}| &&
      |\}| &&
      |@media print \{| &&
      |  .print-button \{ display: none; \}| &&
      |  body \{ margin: 0; padding: 15mm; font-family: Arial; \}| &&
      |  @page \{ size: A4; margin: 15mm; \}| &&
      |  table \{ width: 100%; border-collapse: collapse; \}| &&
      |  th, td \{ border: 1px solid #000; padding: 5px; \}| &&
      |\}| &&
      |</style>| &&
      |</head>| &&
      |<body>| &&
      |<button class="print-button" onclick="window.print()">| &&
      |  Dokument drucken| &&
      |</button>| &&
      |<!-- Dokumentinhalt hier -->| &&
      |</body>| &&
      |</html>|.
  ENDMETHOD.

ENDCLASS.

Alternative 3: Third-Party Print Services

Fuer spezielle Anforderungen koennen externe Druckdienste genutzt werden:

" Integration mit externem Druckdienst
CLASS zcl_external_print_service DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    METHODS:
      submit_to_print_service
        IMPORTING iv_document     TYPE xstring
                  iv_printer_id   TYPE string
        RETURNING VALUE(rv_job_id) TYPE string
        RAISING   cx_web_http_client_error.

ENDCLASS.

Drucker-Konfiguration

Print Agent einrichten

Der Print Agent ist eine On-Premise-Komponente, die die Verbindung zwischen Cloud Print Manager und lokalen Druckern herstellt:

Download: Print Agent von SAP Software Center herunterladen
Installation: Auf einem Server im Firmennetzwerk installieren
Konfiguration: Verbindung zum BTP-Service herstellen
Drucker registrieren: Lokale Drucker am Agent registrieren

Drucker-Eigenschaften

" Drucker-Informationen abrufen
TYPES:
  BEGIN OF ty_printer_info,
    printer_id   TYPE string,
    printer_name TYPE string,
    queue_name   TYPE string,
    location     TYPE string,
    capabilities TYPE string_table,  " duplex, color, staple
    status       TYPE string,        " online, offline, error
  END OF ty_printer_info.

Druckerauswahl in der Anwendung

" Druckerauswahl fuer Benutzer
METHOD get_available_printers.
  DATA(lo_print_mgr) = NEW zcl_print_manager( 'Z_PRINT_COMM' ).

  " Queues abrufen
  DATA(lt_queues) = lo_print_mgr->get_print_queues( ).

  " In UI anzeigen (z.B. als Value Help)
  rt_printers = lt_queues.
ENDMETHOD.

Monitoring und Fehlerbehandlung

Druckauftraege ueberwachen

" Monitoring-Klasse fuer Druckauftraege
CLASS zcl_print_monitor DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    TYPES:
      BEGIN OF ty_job_info,
        job_id        TYPE string,
        document_name TYPE string,
        queue_name    TYPE string,
        status        TYPE string,
        submitted_at  TYPE timestampl,
        completed_at  TYPE timestampl,
        error_message TYPE string,
      END OF ty_job_info.

    METHODS:
      get_pending_jobs
        RETURNING VALUE(rt_jobs) TYPE STANDARD TABLE OF ty_job_info WITH KEY job_id.

    METHODS:
      get_failed_jobs
        RETURNING VALUE(rt_jobs) TYPE STANDARD TABLE OF ty_job_info WITH KEY job_id.

    METHODS:
      retry_failed_job
        IMPORTING iv_job_id TYPE string
        RAISING   zcx_output_error.

ENDCLASS.

Logging mit Application Log

" Ausgabe-Aktionen protokollieren
CLASS zcl_output_logger DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    METHODS:
      log_output_request
        IMPORTING iv_request_id TYPE string
                  iv_action     TYPE string
                  iv_status     TYPE string
                  iv_message    TYPE string OPTIONAL.

ENDCLASS.

CLASS zcl_output_logger IMPLEMENTATION.

  METHOD log_output_request.
    TRY.
        DATA(lo_log) = cl_bali_log=>create_with_header(
          header = cl_bali_header_setter=>create(
            object    = 'ZOUTPUT'
            subobject = 'PRINT'
          )
        ).

        DATA(lv_severity) = COND #(
          WHEN iv_status = 'ERROR'
            THEN if_bali_constants=>c_severity_error
          WHEN iv_status = 'WARNING'
            THEN if_bali_constants=>c_severity_warning
          ELSE if_bali_constants=>c_severity_status
        ).

        lo_log->add_item(
          item = cl_bali_message_setter=>create(
            severity = lv_severity
            id       = 'ZOUTPUT'
            number   = '001'
            variable_1 = CONV #( iv_request_id )
            variable_2 = CONV #( iv_action )
            variable_3 = CONV #( iv_message )
          )
        ).

        cl_bali_log_db=>get_instance( )->save_log( log = lo_log ).

      CATCH cx_bali_runtime.
        " Logging-Fehler ignorieren
    ENDTRY.
  ENDMETHOD.

ENDCLASS.

Best Practices

Empfehlungen fuer Output Management

Aspekt	Empfehlung
Einfache Dokumente	PDF-Download mit Browser-Druck
Regelbmaessiger Druck	Cloud Print Manager mit Print Agent
Massenausgabe	Asynchrone Verarbeitung mit Background Jobs
Nachverfolgung	Application Logging fuer alle Ausgaben
Fehlerbehandlung	Retry-Logik und Benachrichtigungen

Checkliste fuer Output-Implementierung

Ausgabekanal definieren: Druck, E-Mail, Download?
Dokumentformat festlegen: PDF, HTML, andere?
Drucker/Ziele konfigurieren: Print Agent, E-Mail-Server
Fehlerbehandlung implementieren: Retries, Benachrichtigungen
Monitoring einrichten: Logging, Status-Tracking
Berechtigungen pruefen: Wer darf was ausgeben?

Weiterfuehrende Themen

PDF-Generierung in ABAP Cloud - Dokumente als PDF erstellen
HTTP Client - Kommunikation mit externen Services
Background Jobs - Asynchrone Ausgabeverarbeitung
Application Logging - Ausgaben protokollieren

Zusammenfassung

Output Management in ABAP Cloud erfordert neue Ansaetze:

Cloud Print Manager ersetzt den klassischen Spool und ermoeglicht Cloud-zu-On-Premise-Druck
Print Agent verbindet die Cloud mit lokalen Netzwerkdruckern
PDF-Download ist die einfachste Alternative zum direkten Druck
E-Mail-Versand eignet sich fuer automatisierte Dokumentenzustellung
Output Control steuert komplexe Ausgabeszenarien mit verschiedenen Kanaelen
Monitoring und Logging sind essentiell fuer produktive Systeme

Die Wahl der richtigen Ausgabemethode haengt von deinen Anforderungen ab: Fuer einfache Szenarien reicht PDF-Download, fuer Enterprise-Anforderungen ist Cloud Print Manager die robuste Loesung.