No ciência da computação, Data Access Object é um padrão para um objeto que fornece uma interface abstrata para algum tipo de banco de dados ou outro mecanismo de persistência e que permite separar regras de negócio das regras de acesso a banco de dados. A vantagem de usar objetos de acesso a dados é a separação simples e rigorosa entre duas partes importantes de uma aplicação que não devem e não podem conhecer quase que nada uma da outra, e que podem evoluir frequentemente e independentemente.
O DAO implementa o mecanismo de acesso necessário para trabalhar com a fonte de dados. A fonte de dados pode ser um armazenamento persistente como um RDBMS, um serviço externo, como uma troca de B2B, um repositório como um banco de dados LDAP, um serviço de negócios acessado via CORBA, Internet Inter-ORB Protocol (IIOP) ou soquetes de baixo nível. O componente de negócio que se baseia no DAO usa a interface mais simples exposta pelo DAO para seus clientes.
ABAP e DAO
O ABAP Objects possui conceitos comuns com o Java e utilizar o DAO Pattern que é um método padrão já consagrado para separar a camada de negocio da camada do banco de dados facilita muito a legibilidade e organização do código ABAP, visto que o SAP R/3 já comtempla uma arquitetura propicia em três camadas e um ambiente estabelecido onde podemos cortar certos caminhos, tornado simples, fácil e até mesmo divertido criar este tipo de programação, pois na pratica você tem uma classe para o objeto de negocio que contem as regras para cada método do objeto e uma classe para o objeto de dados que é responsável por manipular os dados no banco de dados e negocia-lo com o objeto de transferência que fica responsável pela comunicação com a interface de usuário.
O ABAP possui a vantagem de que não precisamos aplicar o Pattern Factory Method ao DAO, pois o Open SQL já nos possibilita uma função semelhante e podemos utiliza-lo em nosso objeto DAO, a vantagem é que outros desenvolvedores que utilizarão seu código já saberão onde está a regra e onde está a funcionalidade de acesso a dados e também possibilita uma sintaxe simples e homogênea na programação da GUI caso seu programa utilize alguma interface com o usuário
DAO – CRUD – ABAP
DAO Pattern
O DAO é um padrão flexível e não uma regra ele é utilizado em conjunto com Factory Pattern e Broker Pattern (veja Patterns relacionados no link abaixo) por isto é comum você encontrar algumas variações de sua implementação, o padrão possui quatro especificações para que possa ser utilizado corretamente elas são: DataAccessObject, DataSourceObject, BussinesObject e TransferObject.
- DataAccessObject – é o objeto principal desse padrão. O Data Access Object abstrai a implementação fundamental de acesso a dados para o Business Objects para permitir acesso transparente à fonte de dados.
- DataSourceObject – representa uma implementação da fonte de dados. Uma fonte de dados pode ser uma base de dados tal como um RDBMS, repositório XML, e assim por diante.
- BussinesObject – o objeto de negócios representa o dados do cliente. É o objeto que requer acesso à fonte de dados para obter e armazenar dados.
- TransferObject – representa um objeto de transferência usado como um suporte de dados. O Data Access Object pode usar um objeto de transferência para retornar dados para o cliente. O Data Access Object também pode receber os dados do cliente em um objeto de transferência para atualizar os dados na fonte de dados.
DAO Pattern: http://www.oracle.com/technetwork/java/dataaccessobject-138824.html
CRUD – DAO
CRUD acrónimo de Create, Read, Update e Delete, utiliza as quatro operações básicas para criação, consulta, atualização e exclusão de dados.
Através do padrão DAO vamos utilizar as operações CRUD para manipular dados no banco de dados. O DAO é um Pattern J2EE, mas como ele separa as regras de negocio do acesso a dados também podemos utiliza-lo com qualquer tipo de interface, seja pela linha de comando, uma GUI desktop ou aplicações web.
Criando um programa ABAP
1 – Crie uma tabela transparente chamada ZFUNCIONARIOS utilizando os elementos de dados e as referencias necessárias aos campos CURR do dicionário de dados ABAP:
Tabela transparente – ZFUNCIONARIOS
2 – Crie um menu e um titulo para o Status 100 com as funções necessárias para os eventos dos botões em seu programa e utilize a imagem abaixo para referencia:
Menu Painter
3 – Crie uma tela de numero 100 no Screen Painter para seu programa com o seguinte layout:
Screen Painter
Exemplo:
Neste exemplo usamos o Pattern DAO para criar operações CRUD utilizando uma interface gráfica. O DAO torna o código ABAP mais legível pois separa as classes em objetos distintos e proporciona aos desenvolvedores a utilização de uma sintaxe mais homogênea em seus programas.
O exemplo separa o programa principal do objeto de negocio e do objeto de acesso a dados entretanto colocamos as duas classes DAO em um único include, você pode utiliza-las do modo que achar melhor, como por exemplo utilizando-as como classes globais.
ABAP
GUI – ZDAAPP
*&//---------------------------------------------------------------------*
*&// Report ZDAAPP
*&//
*&//---------------------------------------------------------------------*
*&// Desenvolvimento Aberto
*&// DAO - DAAPP
*&//---------------------------------------------------------------------*
REPORT ZDAAPP.
*// Chama include
*// ZFUNCIONARIO é a classe de negocio
*// você pode incluir qualquer regra
*// para validação em seus métodos.
*//
*// ZFUNCIONARIODAO é a classe de acesso a dados
*// utiliza o OPEN SQL como o
*// Pattern Factory Method já
*// que ele faz um trabalho equivalente
INCLUDE ZFUNCIONARIO.
*// Define objetos e variáveis
DATA : funcionario TYPE REF TO ZFUNCIONARIO,
funcionarioDAO TYPE REF TO ZFUNCIONARIODAO,
resultado TYPE ABAP_BOOL,
TPESQUISAR TYPE string,
TID TYPE string,
tnome TYPE string,
tsobre TYPE string,
tcargo TYPE string,
tsalario TYPE string,
cid TYPE i,
csal TYPE ZSAL.
START-OF-SELECTION.
*// Cria objetos
CREATE OBJECT FUNCIONARIO.
CREATE OBJECT FUNCIONARIODAO.
*// Define eventos clique para os botões
DATA : OK_CODE LIKE SY-UCOMM,
clique_ok LIKE sy-ucomm.
*// chama tela numero 100
CALL SCREEN 100.
*// Modulo PBO
MODULE STATUS_0100 OUTPUT.
*// Define Menu e titulo do programa
SET PF-STATUS '100'.
SET TITLEBAR 'ZDAAPPT'.
*// Limpa evento de clique
clique_ok = ok_code.
CLEAR ok_code.
*// verifica ação dos botões
CASE clique_ok.
WHEN 'FPESQUISAR'.
"// Trasferencia de objeto
FUNCIONARIO = FUNCIONARIODAO->BUSCAFUNCIONARIO( TPESQUISAR ).
"// Recupera valores e alimenta GUI
tid = FUNCIONARIO->GETID( ).
tnome = FUNCIONARIO->GETNOME( ).
tsobre = FUNCIONARIO->GETSOBRENOME( ).
tcargo = FUNCIONARIO->GETCARGO( ).
tsalario = FUNCIONARIO->GETSALARIO( ).
WHEN 'FNOVO'.
" Limpa GUI
clear:
tid,
tnome,
tsobre,
tcargo,
tsalario.
WHEN 'FINSERIR'.
"// Converte valores para o objeto
cid = tid.
csal = tsalario.
"// Adicona valores ao objeto
FUNCIONARIO->SETID( cid ).
FUNCIONARIO->SETNOME( tnome ).
FUNCIONARIO->SETSOBRENOME( tsobre ).
FUNCIONARIO->SETCARGO( tcargo ).
FUNCIONARIO->SETSALARIO( csal ).
"// Insere dados no banco
RESULTADO = FUNCIONARIODAO->INSERIRFUNCIONARIO( FUNCIONARIO ).
"// Verifica resultados
IF ( RESULTADO EQ ABAP_TRUE ).
MESSAGE 'Dados inseridos com sucesso' TYPE 'S'.
ELSE.
MESSAGE 'Erro ao inserir dados' TYPE 'E'.
ENDIF.
*// Os evento subsequentes utilizam a mesma sintaxe do evento acima
*// criando um metodo simples e facil para gravar dados
*// uma vez que você tenha qualquer objeto de negocio
*// e um objeto de acesso a dados.
WHEN 'FALTERAR'.
cid = tid.
csal = tsalario.
FUNCIONARIO->SETID( cid ).
FUNCIONARIO->SETNOME( tnome ).
FUNCIONARIO->SETSOBRENOME( tsobre ).
FUNCIONARIO->SETCARGO( tcargo ).
FUNCIONARIO->SETSALARIO( csal ).
RESULTADO = FUNCIONARIODAO->ALTERARFUNCIONARIO( FUNCIONARIO ).
IF ( RESULTADO EQ ABAP_TRUE ).
MESSAGE 'Dados alterados com sucesso' TYPE 'S'.
ELSE.
MESSAGE 'Erro ao inserir dados' TYPE 'E'.
ENDIF.
WHEN 'FAPAGAR'.
cid = tid.
csal = tsalario.
FUNCIONARIO->SETID( cid ).
FUNCIONARIO->SETNOME( tnome ).
FUNCIONARIO->SETSOBRENOME( tsobre ).
FUNCIONARIO->SETCARGO( tcargo ).
FUNCIONARIO->SETSALARIO( csal ).
RESULTADO = FUNCIONARIODAO->APAGARFUNCIONARIO( FUNCIONARIO ).
IF ( RESULTADO EQ ABAP_TRUE ).
MESSAGE 'Dados apagados com sucesso' TYPE 'S'.
ELSE.
MESSAGE 'Erro ao inserir dados' TYPE 'E'.
ENDIF.
WHEN 'FSAIR'.
LEAVE PROGRAM.
ENDCASE.
ENDMODULE.
Include – Objeto negocio e Objeto dados
*&//---------------------------------------------------------------------*
*&// Desenvolvimento Aberto - DAO
*&// Objeto de Negocio
*&// Objeto de Dados
*&//
*&// Include ZFUNCIONARIO
*&//---------------------------------------------------------------------*
*// Cria classe Funcionário
class ZFUNCIONARIO definition.
public section.
*// Declara construtor com efeito Overload
methods CONSTRUCTOR IMPORTING
id TYPE i OPTIONAL
nome TYPE string OPTIONAL
sobrenome TYPE string OPTIONAL
cargo TYPE string OPTIONAL
salario TYPE ZSAL OPTIONAL.
*// Declara métodos Getter e Setter
*// Você pode incluir algumas validações
*// E criar eventos com um método de retorno para a GUI
methods SETID importing !ID type i .
methods GETID returning value(RESULTADO) type i .
methods SETNOME importing !NOME type STRING .
methods GETNOME returning value(RESULTADO) type STRING .
methods SETSOBRENOME importing !SOBRENOME type STRING .
methods GETSOBRENOME returning value(RESULTADO) type STRING .
methods SETCARGO importing !CARGO type STRING .
methods GETCARGO returning value(RESULTADO) type STRING .
methods SETSALARIO importing !SALARIO type ZSAL.
methods GETSALARIO returning value(RESULTADO) TYPE ZSAL.
*// Declara atributos privados
private section.
data ID type i.
data NOME type STRING .
data SOBRENOME type STRING .
data CARGO type STRING.
data SALARIO type ZSAL .
ENDCLASS.
*// Implementação da classe
CLASS ZFUNCIONARIO IMPLEMENTATION.
*// Construtor
METHOD CONSTRUCTOR.
me->ID = ID.
me->NOME = NOME.
me->SOBRENOME = SOBRENOME.
me->CARGO = CARGO.
me->SALARIO = SALARIO.
ENDMETHOD.
*// Metodos Getter e Setter
METHOD GETID.
RESULTADO = me->ID.
ENDMETHOD.
METHOD SETID.
me->ID = ID.
ENDMETHOD.
METHOD GETNOME.
RESULTADO = me->NOME.
ENDMETHOD.
METHOD SETNOME.
me->NOME = NOME.
ENDMETHOD.
METHOD GETSOBRENOME.
RESULTADO = me->SOBRENOME.
ENDMETHOD.
METHOD SETSOBRENOME.
me->SOBRENOME = SOBRENOME.
ENDMETHOD.
METHOD GETCARGO.
RESULTADO = me->CARGO.
ENDMETHOD.
METHOD SETCARGO.
me->CARGO = CARGO.
ENDMETHOD.
METHOD GETSALARIO.
RESULTADO = me->SALARIO.
ENDMETHOD.
METHOD SETSALARIO.
me->SALARIO = SALARIO.
ENDMETHOD.
ENDCLASS.
*&//---------------------------------------------------------------------*
*&// Desenvolvimento Aberto
*&// DAO - ZFUNCIONARIO DAO
*&//---------------------------------------------------------------------*
CLASS ZFUNCIONARIODAO DEFINITION.
*// Metodos DAO
PUBLIC SECTION.
METHODS BUSCAFUNCIONARIO IMPORTING ID TYPE STRING
RETURNING VALUE(FUNC) TYPE REF TO ZFUNCIONARIO.
METHODS INSERIRFUNCIONARIO IMPORTING FUNCIONARIO TYPE REF TO ZFUNCIONARIO
RETURNING VALUE(RESULTADO) TYPE ABAP_BOOL.
METHODS ALTERARFUNCIONARIO IMPORTING FUNCIONARIO TYPE REF TO ZFUNCIONARIO
RETURNING VALUE(RESULTADO) TYPE ABAP_BOOL.
METHODS APAGARFUNCIONARIO IMPORTING FUNCIONARIO TYPE REF TO ZFUNCIONARIO
RETURNING VALUE(RESULTADO) TYPE ABAP_BOOL.
ENDCLASS.
CLASS ZFUNCIONARIODAO IMPLEMENTATION.
METHOD BUSCAFUNCIONARIO.
"// Cria tabela interna
DATA tab TYPE ZFUNCIONARIOS.
"// Cria objeto
DATA FUNCIONARIO TYPE REF TO ZFUNCIONARIO.
CREATE OBJECT FUNCIONARIO.
"// Seleciona dados
SELECT * INTO tab FROM ZFUNCIONARIOS WHERE ID = ID.
ENDSELECT.
"// Alimenta objeto
FUNCIONARIO->SETID( tab-ID ).
FUNCIONARIO->SETNOME( tab-NOME ).
FUNCIONARIO->SETSOBRENOME( tab-SOBRENOME ).
FUNCIONARIO->SETCARGO( tab-CARGO ).
FUNCIONARIO->SETSALARIO( tab-SALARIO ).
"// Transfere objeto
FUNC = FUNCIONARIO.
ENDMETHOD.
METHOD INSERIRFUNCIONARIO.
"// Cria tabela
DATA tab TYPE ZFUNCIONARIOS.
"// Recupe dados do objeto e insere na tabela
tab-ID = FUNCIONARIO->GETID( ).
tab-NOME = FUNCIONARIO->GETNOME( ).
tab-SOBRENOME = FUNCIONARIO->GETSOBRENOME( ).
tab-CARGO = FUNCIONARIO->GETCARGO( ).
tab-SALARIO = FUNCIONARIO->GETSALARIO( ).
"// Insere dados na tabela transparente
INSERT INTO ZFUNCIONARIOS VALUES tab.
IF SY-SUBRC = 0.
RESULTADO = ABAP_TRUE.
ELSE.
RESULTADO = ABAP_FALSE.
ENDIF.
ENDMETHOD.
METHOD ALTERARFUNCIONARIO.
"// Cria tabela
DATA tab TYPE ZFUNCIONARIOS.
"// Recupe dados do objeto e insere na tabela
tab-ID = FUNCIONARIO->GETID( ).
tab-NOME = FUNCIONARIO->GETNOME( ).
tab-SOBRENOME = FUNCIONARIO->GETSOBRENOME( ).
tab-CARGO = FUNCIONARIO->GETCARGO( ).
tab-SALARIO = FUNCIONARIO->GETSALARIO( ).
"// Altera dados na tabela transparente
UPDATE ZFUNCIONARIOS
SET NOME = tab-NOME
SOBRENOME = tab-SOBRENOME
CARGO = tab-CARGO
SALARIO = tab-SALARIO
WHERE ID = tab-ID.
IF SY-SUBRC = 0.
RESULTADO = ABAP_TRUE.
ELSE.
RESULTADO = ABAP_FALSE.
ENDIF.
ENDMETHOD.
METHOD APAGARFUNCIONARIO.
"// Cria tabela
DATA tab TYPE ZFUNCIONARIOS.
"// Recupera ID do objeto
tab-ID = FUNCIONARIO->GETID( ).
"// Deleta dados da tabela transparente
DELETE FROM ZFUNCIONARIOS
WHERE ID = tab-ID.
IF SY-SUBRC = 0.
RESULTADO = ABAP_TRUE.
ELSE.
RESULTADO = ABAP_FALSE.
ENDIF.
ENDMETHOD.
ENDCLASS.
Ricardo Mantovani
Desenvolvimento Código Aberto 
Boa tarde,
você acha vantajoso criar classes para implementar o CRUD em tabelas STANDART? Por exemplo, nas criar as classes para a tabela de materiais (MARA), clientes/fornecedores e etc.
Olá Douglas,
O CRUD em si é só uma técnica para se trabalhar com banco de dados, pode ser criado com ou sem Design Patterns estes sim são padrões para desenvolvimento e possuem suas vantagens, como o caso do DAO que separa a regra de negocio do acesso a dados em partes distintas. Existem vários padrões de design que podem ser utilizado dependendo do tipo de projeto.
Em ABAP nem tudo é orientado a objeto, encontramos uma programação hibrida na maioria das vezes, misturando o paradigma procedural (programas mais antigos), declarativo (Open SQL) e orientado a objeto(Novos programas).
Também o próprio ABAP OO não possui recursos vantajosos para coleções como as linguagens de programação de mercado, remetendo o desenvolvedor geralmente a misturar os paradigmas em um único programa.
Reescrever programas já existentes pode ser muito trabalhoso e caro, visto que não utilizam somente uma tabela e sim toda uma modelagem de dados e consequentemente suas regras de negocio.
Mas existe o Flight Model que é o modelo padrão do Netweaver onde há toda uma modelagem de dados Standard para um modulo de venda de passagens aéreas cujo não possui uma interface definida no qual a SAP disponibiliza para que novos desenvolvedores aprendam utilizar o Abap e suas tecnologias.
Abraços.
Obrigado Ricardo, abraço!