Todos nós sabemos que o MVC é um padrão de projeto muito consolidado no mundo Web, isso não é novidade, mas se te disser que podemos importar essa ideia para dentro do SAP e construir aplicações utilizando o MVC e tendo todos os seus benefícios?

Componentes

Primeiramente devemos entender como o MVC funciona para então aplicar ao nosso universo ABAP.

• MVC – Model (Modelo)
  • Responsável por gerenciar diretamente os dados, lógica e regras do aplicativo;
  • Toda a parte de banco dedados, regras de negócio, etc;
• MVC – View (Visão)
  • Qualquer representação gráfica fica implementada na camada de visão;
  • Nossos famosos ALVs, Screens, etc;
• MVC – Controller (Controlador)
  • Responsável pela comunicação entre o Model e a View;
  • Dentro do nosso universo ele vai deter os eventos da SAP (START-OF-SELECTION, etc);

Interações

O Model é responsável por gerenciar os dados do aplicativo. Ele recebe a entrada do usuário do Controller.

A View renderiza a apresentação do Model em um formato específico.

O Controller recebe a entrada, opcionalmente a valida e então passa a entrada para o Model.

Além disso o Controller é que vai direcionar a View respectiva do Model selecionado.

Implementação

"----- View -----
CLASS lcl_view DEFINITION.

  PUBLIC SECTION.
    METHODS:  initialization,
      end_of_selecion IMPORTING VALUE(_data) TYPE any TABLE.

ENDCLASS.

CLASS lcl_view IMPLEMENTATION.

  METHOD initialization.
  ENDMETHOD.

  METHOD end_of_selecion.

    CHECK _data[] IS NOT INITIAL.

    cl_salv_table=>factory(
        IMPORTING
          r_salv_table = DATA(alv)
        CHANGING
          t_table      = _data[] ).

    alv->display( ).

  ENDMETHOD.

ENDCLASS.
"----- View -----


"----- Model -----
CLASS lcl_model DEFINITION.

  PUBLIC SECTION.
    DATA: lt_sflight TYPE TABLE OF sflight.
    METHODS: start_of_selecion.

ENDCLASS.

CLASS lcl_model IMPLEMENTATION.

  METHOD start_of_selecion.

    SELECT *
      FROM sflight
      INTO TABLE lt_sflight.

  ENDMETHOD.

ENDCLASS.
"----- Model -----

"----- Controller -----
CLASS lcl_controller DEFINITION.

  PUBLIC SECTION.
    DATA: lo_view TYPE REF TO lcl_view,
          lo_model TYPE REF TO lcl_model.

    METHODS: constructor,
      initialization,
      start_of_selecion,
      end_of_selection.

ENDCLASS.

CLASS lcl_controller IMPLEMENTATION.

  METHOD constructor.
    lo_view  = NEW lcl_view( ).
    lo_model = NEW lcl_model( ).
  ENDMETHOD.

  METHOD initialization.
    lo_view->initialization( ).
  ENDMETHOD.

  METHOD start_of_selecion.
    lo_model->start_of_selecion( ).
  ENDMETHOD.

  METHOD end_of_selection.
    lo_view->end_of_selecion( lo_model->lt_sflight ).
  ENDMETHOD.

ENDCLASS.
"----- Controller -----


INITIALIZATION.
  DATA(lo_controller) = NEW lcl_controller( ).
  lo_controller->initialization( ).

START-OF-SELECTION.
  lo_controller->start_of_selecion( ).

END-OF-SELECTION.
  lo_controller->end_of_selection( ).

Temos aqui nossa View como agente principal:

• Note que tudo gira em torno no nosso Controller
  • Ele possui os eventos Standards dos Programas (Initialization, StartOfSelection, EndOfSelection);
  • Apesar de centralizar tudo no Controller, ele que decide para qual View e qual Model será iniciado no momento;
  • Com essa implementação podemos ter vários ALVs, Regras de negócio totalmente isolados, mantendo a organização, melhorando a manutenção, etc.
• Nosso Model detém o evento START-OF-SELECTION, já que ele é o responsável pelos dados
  • Pensando assim, poderíamos ter vários models e o Controller gerenciar quem será ativado na execução;
  • Assim como está implementado nós conseguimos isolar Modelos com suas respectivas responsabilidades, reduzindo assim o código e aplicando o conceito de Single-Responsibility Principle;
• Nossa View, assim como o Model possui sua responsabilidade de exibir os dados
  • Podendo também Validar Campos da Tela de Seleção, Validar Permissões de Acesso e etc;
  • Assim como o Model, podemos ter várias Views e assim o Controller decide o que exibir na execução;

Conclusão

Podemos concluir que o ABAP evoluiu muito ao longo dos anos e assim podemos extrair melhor os conceitos de Orientação a Objetos, tanto aplicando o MVC como o SOLID. Ambos os conceitos estão mais que testados e validados em outras linguagens de programação.