Entkopplung in ABAP

Decoupling in ABAP — Object Oriented

Erstellt mit Adobe Firefly by urcm

Entkopplung bezieht sich darauf, verschiedene Teile des Codes zu trennen, um die Abhängigkeiten zwischen ihnen zu reduzieren. Normalerweise erfolgt dies mit Hilfe von Schnittstellen, abstrakten Klassen oder Funktionsbausteinen. Durch Decoupling wird die Modularität, Flexibilität und Wartbarkeit deines Codes verbessert.

Hier ist, warum du in ABAP in Betracht ziehen solltest, Decoupling zu verwenden:

Flexibilität: Durch Decoupling ist es möglich, einen Teil deines Codes zu modifizieren, ohne andere Teile zu stören. Das Decoupling der Datenbankzugriffslogik von dem Rest des Programms ermöglicht es beispielsweise, auf ein anderes Datenbanksystem umzusteigen, ohne andere Teile des Codes ändern zu müssen.

Testbarkeit: Tests sind oft einfacher mit entkoppelten Codes, weil du einzelne Komponenten isolieren und unabhängig voneinander testen kannst. Das macht es einfacher, Fehler zu erkennen und zu beheben.

Wiederverwendbarkeit: Die Förderung des Decouplings führt zur Erstellung von wiederverwendbaren Komponenten, die in verschiedenen Teilen Ihrer Anwendung oder sogar in anderen Anwendungen verwendet werden können. Das Decoupling in ein separates Modul ermöglicht die Wiederverwendung von Hilfsfunktionen, die in mehreren Programmen verwendet werden, ohne Code-Duplizierung.

Wartbarkeit: Es ist im Allgemeinen einfacher, entkoppelten Code zu warten, weil er modularer und verständlicher ist. Du musst nur die relevanten Teile des Codes ändern, wenn eine Änderung erforderlich ist, ohne dich um unbeabsichtigte Seiteneffekte in anderen Teilen der Anwendung zu kümmern.

Decoupling ist insgesamt eine bewährte Praxis (sowie in anderen Programmiersprachen), da sie die Entwicklung von saubererem, modularerem Code fördert, der einfacher zu warten und im Laufe der Zeit zu erweitern ist.

Um Entkopplung in ABAP zu verwenden, kannst du:

• Schnittstellen (Interfaces) : die Abhängigkeit zwischen verschiedenen Komponenten zu definieren.
• Abstrakte Klassen : gemeinsame Funktionalitäten zu kapseln, ohne sich auf bestimmte Implementierungen festzulegen.
• Funktionsbausteine : logische Einheiten von Code zu erstellen, die unabhängig voneinander aufgerufen werden können.
• Dependency Injection (Abhängigkeitsinjektion) : die Abhängigkeiten zwischen verschiedenen Komponenten dynamisch zu konfigurieren und austauschbar zu machen.

Entcouplung mit Interface:

*&------------------------------------------------ ---------------------*
*& interface for animals
*&------------------------------------------------ ---------------------*
interface zif_animal.
   methods make_sound.
endinterface.

*&------------------------------------------------ ---------------------*
*& class for cats
*&------------------------------------------------ ---------------------*
class lcl_cat definition.
   public section.
     interfaces: zif_animal.
endclass.

class lcl_cat implementation.
   method zif_animal~make_sound.
     write: / 'Meow!'.
   final method
endclass.

*&------------------------------------------------ ---------------------*
*& class for dogs
*&------------------------------------------------ ---------------------*
class lcl_dog definition.
   public section.
     interfaces: zif_animal.
endclass.

class lcl_dog implementation.
   method zif_animal~make_sound.
     write: / 'Woof!'.
   final method
endclass.

*&------------------------------------------------ ---------------------*
*& main program
*&------------------------------------------------ ---------------------*
start of selection.
   data: lo_animal type ref to zif_animal.

   create object lo_animal type lcl_cat.
   lo_animal->make_sound( ).

   create object lo_animal type lcl_dog.
   lo_animal->make_sound( ).

Entkopplung mit Abstrakte Klasse:

*&---------------------------------------------------------------------*
*& Abstrakte Klasse für Tiere
*&---------------------------------------------------------------------*
class lcl_animal definition abstract.
  public section.
    methods make_sound abstract.
endclass.

*&---------------------------------------------------------------------*
*& Klasse für Katzen
*&---------------------------------------------------------------------*
class lcl_cat definition inheriting from lcl_animal.
  public section.
    methods make_sound redefinition.
endclass.

class lcl_cat implementation.
  method make_sound.
    write: / 'Miau!'.
  endmethod.
endclass.

*&---------------------------------------------------------------------*
*& Klasse für Hunde
*&---------------------------------------------------------------------*
class lcl_dog definition inheriting from lcl_animal.
  public section.
    methods make_sound redefinition.
endclass.

class lcl_dog implementation.
  method make_sound.
    write: / 'Wuff!'.
  endmethod.
endclass.

*&---------------------------------------------------------------------*
*& Hauptprogramm
*&---------------------------------------------------------------------*
start-of-selection.
  data: lo_animal type ref to lcl_animal.

  create object lo_animal type lcl_cat.
  lo_animal->make_sound( ).

  create object lo_animal type lcl_dog.
  lo_animal->make_sound( ).

Entkopplung mit Functionbausteine:

*&---------------------------------------------------------------------*
*& Funktionbaustein für Tiere
*&---------------------------------------------------------------------*

function zmake_animal_sound.
*"----------------------------------------------------------------------
*"*"Lokale Schnittstelle:
*"  IMPORTING
*"     REFERENCE(IV_ANIMAL_TYPE) TYPE  STRING
*"  EXPORTING
*"     REFERENCE(EV_SOUND) TYPE  STRING
*"----------------------------------------------------------------------

  case iv_animal_type.
    when 'CAT'.
      ev_sound = 'Miau!'.
    when 'DOG'.
      ev_sound = 'Wuff!'.
    when others.
      ev_sound = 'Unbekanntes Tier!'.
  endcase.

" oder mit Konstruktorausdruck
" ev_sound = switch string( iv_animal_type when  'CAT'
"                                              then 'Miau!'
"                                          when  'DOG'
"                                              then 'Wuff!'
"                                            else 'Unbekanntes Tier!' ).

endfunction.

*&---------------------------------------------------------------------*
*& Hauptprogramm
*&---------------------------------------------------------------------*

data: lv_animal_type type string,
      lv_sound       type string.

start-of-selection.

  lv_animal_type = 'CAT'.

  call function 'ZMAKE_ANIMAL_SOUND'
    exporting
      iv_animal_type = lv_animal_type
    importing
      ev_sound       = lv_sound.
  write: / lv_sound.

  lv_animal_type = 'DOG'.
  call function 'ZMAKE_ANIMAL_SOUND'
    exporting
      iv_animal_type = lv_animal_type
    importing
      ev_sound       = lv_sound.
  write: / lv_sound.

Entkopllung mit Dependency Injection:

*&---------------------------------------------------------------------*
*& Schnittstelle für Tiere
*&---------------------------------------------------------------------*
interface zif_animal.
  methods: make_sound returning value(result) type string.
endinterface.

*&---------------------------------------------------------------------*
*& Klasse für Katzen
*&---------------------------------------------------------------------*
class lcl_cat definition.
  public section.
    interfaces: zif_animal.
endclass.

class lcl_cat implementation.
  method zif_animal~make_sound.
    result = 'Miau!'.
  endmethod.
endclass.

*&---------------------------------------------------------------------*
*& Klasse für Hunde
*&---------------------------------------------------------------------*
class lcl_dog definition.
  public section.
    interfaces: zif_animal.
endclass.

class lcl_dog implementation.
  method zif_animal~make_sound.
    result = 'Wuff!'.
  endmethod.
endclass.

*&---------------------------------------------------------------------*
*& Klasse für DI
*&---------------------------------------------------------------------*
class lcl_animal_sound definition.
  public section.
    methods: play_sound importing io_animal type ref to zif_animal.
endclass.

class lcl_animal_sound implementation.
  method play_sound.
    write: / io_animal->make_sound( ).
  endmethod.
endclass.

*&---------------------------------------------------------------------*
*& Hauptprogramm
*&---------------------------------------------------------------------*
start-of-selection.
  data: lo_sound  type ref to lcl_animal_sound,
        lo_animal type ref to zif_animal.

  create object lo_sound.

  create object lo_animal type lcl_cat.
  lo_sound->play_sound( io_animal = lo_animal ).

  create object lo_animal type lcl_dog.
  lo_sound->play_sound( io_animal = lo_animal ).

Fazit:

Entkopplung ist entscheidend bei der Entwicklung von robusten, wartbaren und wiederverwendbaren ABAP-. Indem Sie die oben genannten Techniken anwenden, können sie Code erstellen, der leichter zu verstehen, zu ändern, zu testen und wiederzuverwenden ist.