Formação ABAP - o Futuro - Parte 1 de 13

Prévia do material em texto

Pode ser difícil para um ovo se transformar em um pássaro: seria uma visão 
alegre mais difícil para ele aprender a voar enquanto permanece um ovo. 
Somos como ovos no momento. E você não pode continuar indefinidamente 
sendo apenas um ovo comum e decente. Devemos ser eclodidos ou ir mal. 
— C. S. Lewis 
 
 
 
 
Introdução 
 
Ovos são, sem dúvida, lugares adoráveis para estar dentro, cheios de comida e quentes 
da mamãe sentado em cima do ovo. No entanto, viver dentro de um ovo 
provavelmente não lhe dá uma ideia muito boa das mudanças que ocorrem no mundo 
exterior. No mundo da SAP, tal mudança pode ser horrivelmente assustadora: há um 
exército de programadores na SAP constantemente desgoring um fluxo de novas 
guloseimas. Desenvolvedores de todo o mundo provavelmente os amariam — mas 
muitas vezes 99% desses programadores permanecem escondidos dentro de seus 
ovos, alegremente ignorantes do novo baú de tesouros em seu porão do sistema SAP. 
Para evitar essa situação muito comum, o objetivo deste livro é iluminar tais 
melhorias. Como tal, é destinado a todo e qualquer desenvolvedor aquisitivo ABAP. 
Embora eu cubra novas tecnologias, também acoro alguns tópicos que podem não ser 
considerados "novos"; isso porque eu notei que muitas pessoas que desconhecem as 
melhorias entregues pela SAP que saíram há seis meses não têm conhecimento das 
melhorias que saíram há cinco anos. Vou dar um pouco de atenção a esses tópicos 
porque é muito possível que você esteja descobrindo-os pela primeira vez. 
A ideia deste livro vem de uma relutância observada em usar novas tecnologias e, ao 
mesmo tempo, uma compulsão de usar novas tecnologias. Uma das melhores postagens 
de blog de todos os tempos no site da SAP Community Network foi uma de Graham 
Robin, filho chamado "A Call to Arms for ABAP Developers". Neste post, Robinson 
fornece um exemplo (supostamente fictício) de um desenvolvedor da ABAP que se junta 
a uma empresa de consultoria no início da onda SAP no final dos anos noventa. Ele 
aprende tudo o que há para saber sobre o desenvolvimento da SAP como era naquele 
momento — tudo às custas do cliente — 
 
 
23 
Introduction 
 
 
e então, uma vez que o boom morre, consegue um emprego permanente em um dos 
antigos clientes. Por um tempo, tudo está bem, mas depois de 10 anos, o 
desenvolvedor percebe que não sabe nada sobre nenhuma das novas tecnologias 
que a SAP saiu, pois sempre foi possível passar usando as mesmas técnicas que 
funcionaram no ano 2000. 
Claro, se eu tivesse um dólar para cada vez que eu lesse as palavras "mudança de jogo" 
ou "ponto de inflexão " na imprensa de TI, então eu poderia usar essa pilha de dinheiro 
para construir uma rampa para a lua. Mas o que não pode ser negado é que nos últimos 
anos a SAP vem saindo com novas ideias radicais em um ritmo mais rápido e rápido. 
Grande parte dessa nova tecnologia não usa a linguagem ABAP ou o ambiente de 
desenvolvimento SE80, e o ritmo de mudança passou de se acostumar com uma nova 
versão de algo a cada cinco anos para se acostumar com uma nova versão de algo a 
cada 12 semanas. Qualquer uma dessas coisas isoladamente seria suficiente para 
assustar as pessoas que não estão acostumadas a mudar, e a combinação os faz se 
esconder debaixo do sofá e esperando que tudo isso vá embora. (Não vai.) Goste ou 
não, provavelmente é uma boa ideia, no mínimo, ter uma ideia aproximada do que 
todas essas coisas assustadoras — como o SAP HANA — são. A alternativa é cruzar 
os dedos e esperar muito que eles não te afetem por mais 10 anos. 
É claro que tentar acompanhar o fluxo ininterrupto de inovações que saem da SAP 
hoje em dia é como beber da mangueira de incêndio proverbial: Desde que a SAP 
adotou a metodologia ágil, o tempo entre os lançamentos de vários produtos diminuiu 
visivelmente, e a SAP é uma organização tão grande que os novos fea-tures vêm de 
todos os lados de uma vez. 
Ainda assim, se você tentar empurrar a mais recente e maior invenção SAP para seus 
colegas, você pode ouvir o seguinte: (a) você não deve usar isso apenas porque é novo; e 
(b) porque é novo, é arriscado, e provavelmente não vai funcionar de qualquer 
maneira. Como sempre, não há posição em preto e branco sobre isso. Muitos 
desenvolvedores gostam de usar coisas novas porque são novas, independentemente 
de ser apropriado. E algumas das coisas novas realmente são boas! 
Independentemente da tecnologia específica que está sendo discutida, você notará 
dois temas importantes que passam por este livro: programação orientada a objetos 
(OO) e programação anti-frágil. Para prepará-lo para isso, quero dizer algumas breves 
palavras sobre esses conceitos. 
 
 
 
 
24 
Introduction 
 
 
A SAP introduziu o ABAP Objects, a versão OO do ABAP, na versão 4.6, que saiu 
no ano 2000. Depois de 15 anos, você esperaria que a maioria, se não todos, 
programadores ABAP usassem esse estilo de programação. Pelo que vejo, nada 
poderia estar mais longe da verdade. Eu diria que mesmo agora a maioria dos novos 
códigos em sites cus-tomer (e um pouco justo da própria SAP) é escrito de forma 
processual. Alguns peo-ple ainda nem começaram a programação processual e 
escrevem tudo em um bloco enorme sem subrotinas. Houve enormes debates sobre 
a SAP Com-munity Network sobre se a programação de OO é melhor do que 
processual. Eu realmente acredito que é, mas independentemente do que eu penso, 
você vai descobrir que se você quiser tirar proveito de alguns dos últimos avanços da 
SAP que eu descrevo mais tarde neste livro, então você realmente não tem escolha. 
Se você é novo na OO, aqui vai uma dica: Os dois livros de destaque que li sobre a 
programação de OO que realmente me ajudaram no meu trabalho diário são Código 
Limpo e Head First Design Patterns (veja a caixa "Recom-mended Reading" no final 
deste introdução). Leia! 
O conceito de criar programas antifragile foi introduzido por Robert Martin (embora 
não nessas palavras exatas), que observou como o software de computador tende a 
apodrecer ao longo do tempo: As constantes mudanças que você tem que fazer 
tendem a adicionar cada vez mais lógica condicional e afins, inchando subrotinas e 
tornando o código cada vez mais complexo até que ninguém tenha ideia de como 
mantê-lo sem quebrar algo (ou seja, fica mais frágil com o passar do tempo ). Robert 
Martin quer que nós, pro-grammers, lutemos contra esse tipo de entropia aplicando 
a regra do escoteiro , que é "Sempre deixe o acampamento mais limpo do que você 
encontrou." A ideia é que, porque você tem que mudar o programa de qualquer 
maneira, fazer pequenas mudanças cada vez para a área que você está mudando para 
torná-lo mais claro (ou seja, renomear variáveis obscuras para você pode dizer o que 
eles fazem, dividir uma subrotina enorme em dois para que seja mais fácil de entender, 
e assim por diante). Com o tempo, sua base de código deve melhorar em vez de 
lentamente girar de aço para vidro. O que isso tem a ver com a lista de novos bens que 
vou discutir? Mais do que você pensa. A posição tradicional tem sido evitar novas 
ferramentas como a peste, porque elas são "arriscadas", ou seja, novas. Neste livro, 
em quase todos os capítulos você verá o argumento inverso aparecendo. Vou tentar 
mostrar como essas novas ferramentas podem ser usadas para tornar seus programas 
mais simples de ler ou mais robustos: em suma, mais resistentes à mudança. Por que 
é importante tentar proteger seus programas das mudanças que você tem que fazer? 
Talvez porque a taxa de mudança na TI já acelerou para uma velocidade de ruptura e 
só está chegando mais rápido. 
 
 
 
25 
Introduction 
 
 
 
 
 
 
Structure of the Book 
O livro é dividido em seções que espelham os grandes avanços que a SAP fez 
recentemente nas áreas de ferramentas de desenvolvimento,lógica de negócios, 
interfaces de usuário (UIs) e tecnologia de base de dados. Este livro não só explicará 
como usar esses novos technolo-gies — com um aplicativo de exemplo em execução 
para manter o foco concreto em vez de abstrato — mas também notará como essas 
tecnologias se encaixam com filosofias de programação de boas práticas. Além disso, 
quando apropriado, o livro destaca formas personalizadas de contornar problemas 
percebidos nessas novas ferramentas ou maneiras de melhorá-los. 
Este livro está organizado em quatro partes. Primeiro, você vai olhar para as 
ferramentas reais que você precisa ao escrever programas em primeiro lugar. Em 
seguida, as três últimas seções mir-ror as camadas de um aplicativo: a camada lógica 
de negócios, a camada de interface do usuário/apresentação e a camada de banco de 
dados. Cada parte e seus capítulos são descritos em mais detalhes em seguida. 
 
Part I: Programming Tools 
Chapter 1: ABAP in Eclipse 
O lugar óbvio para começar é o próprio ambiente de desenvolvimento, e nos últimos 
tempos a SAP tem pressionado seus clientes a começar a usar o Eclipse em oposição 
ao SE80. Você vai explorar por que isso é uma coisa boa e como esta ferramenta 
permite que você faça as mesmas coisas que você sempre fez, apenas mais rápido. 
Além disso, alguns dos novos assustadores 
 
 
26 
Eu acho que é bastante seguro dizer que nenhuma empresa no mundo depende apenas do seu 
sistema SAP para fazer negócios . Sempre haverá sistemas externos variados, alguns dos 
quais são interfaceados com o SAP ERP, outros não. A SAP em si tem uma grande variedade 
de produtos, desde a época logo após o ano 2000, quando apareceram os novos produtos de 
dimensão (como SAP CRM, SAP SCM, e assim por diante). 
 Onde eu trabalho, temos alguns produtos ERP não SAP em uso: SAP BW, SAP Business-
Objects BI, SAP PI e Ariba, para citar apenas alguns. Eu poderia facilmente falar sobre avanços 
nessas áreas também, mas eu vou me concentrar na parte no meio do diagrama de Venn: Este 
livro se concentrará nos recursos mais recentes relacionados à programação abap que você pode 
aproveitar se você tiver um sistema SAP ERP. Eu não vou falar sobre nada para o qual você 
precisa de um sistema licenciado separadamente fora do SAP ERP. 
 
What I Am Not Going to Talk About 
Structure of the Book 
 
 
tecnologias desenvolvidas pela SAP (por exemplo, SAPUI5 e SAP HANA) 
exigem o uso de ABAP no Eclipse. Há também ferramentas especializadas de 
integração no Eclipse para alguns tópicos abordados em outras seções do livro, 
como o Business Object Processing Framework (BOPF) e web Dynpro ABAP 
(WDA). Portanto, se você realmente quer estar na vanguarda, então você precisa 
se familiarizar com o Eclipse com pressa. 
Chapter 2: New Language Features in ABAP 7.4 
Peixe não é bom sem batatas fritas, e ABAP no Eclipse também não seria muito 
bom sem ABAP. A boa notícia, para o nervoso entre nós, é que apesar de todas 
as novas ferramentas horríveis que a SAP inventou, você ainda vai fazer a maior 
parte do seu pro-gramming em ABAP. A melhor notícia é que o SAP continua a 
melhorar a linguagem ABAP. O capítulo 2 cobre inovações recentes antes do 
lançamento do 7.4 que ainda não parecem ser amplamente utilizados, e depois 
passa para as mudanças radicais na versão 7.4 que praticamente permitirá que 
você escreva programas com metade das linhas de código que você precisava 
antes. 
Chapter 3: ABAP Unit and Test-Driven Development 
 A Unidade ABAP existe há algum tempo, mas não é amplamente utilizada. Eu 
sinto que isso é uma vergonha, e é por isso que este tópico está perto do início do 
livro. A ideia é que você escreva seus testes primeiro antes de codificar qualquer 
lógica de negócio real , e se seguido corretamente, então você pode fazer suas 
aplicações de ferro fundido em relação à sua capacidade de não dobrar sob o fluxo 
constante de mudanças necessárias. 
Isso se aplica a todos os outros tópicos deste livro: Tudo o que você cria precisa 
ser testado. (Você vai descobrir que algumas tecnologias mencionadas no livro, 
como BOPF e BRFplus, têm suas próprias ferramentas de teste anexadas 
também, mas isso é apenas cereja no bolo de teste da unidade. O ABAP no Eclipse 
também tem excelente suporte para a Unidade ABAP, tanto para ajudá-lo a criar 
os testes e executá-los.) 
Chapter 4: ABAP Test Cockpit 
Quando você segue o ciclo de vida recomendado de desenvolvimento de um aplicativo 
(que eu não inventei, a propósito!), primeiro você escreve os testes, depois escreve 
código de produção até que esses testes passem, e então, uma vez que tudo está 
funcionando, você refatora o código (ou seja, torná-lo melhor sem alterar a função). 
 
 
 
27 
Introduction 
 
 
A primeira parte do refatoração pode ser uma verificação de código estático. A SAP 
criou o Cockpit de Teste ABAP, que é, em alguns sentidos, uma extensão do 
Extended Pro-gram Check e do Code Inspector, com bits extras no topo. Ele também 
pode ajudá-lo a preparar seus programas para migração para um banco de dados SAP 
HANA. 
 
Chapter 5: Debugger Scripting 
Depois de lidar com verificações estáticas de código na hora do projeto, você passa a 
depurar o código no tempo de execução. O depurador em ABAP sempre foi uma de 
suas características mais fortes, e neste capítulo você vai olhar para um aprimoramento 
relativamente novo: a abil-ity para escrever programas dentro do depurador para 
automatizar tarefas comuns ou de trabalho-inten-sive . A depuração também está 
disponível na ABAP no Eclipse e pode de fato fazer uma coisa incrível que a depuração 
na GUI SAP não pode. Curioso? Leia o Capítulo 5! 
 
Chapter 6: The Enhancement Framework and New BAdIs 
Eu não poderia deixar a área de ferramentas de desenvolvimento sem dar uma olhada 
rápida na estrutura de melhoria. Isso geralmente é visto apenas como um meio de furar 
saídas de usuários em todo o lugar, mas também tem um papel a desempenhar em seus 
próprios desenvolvimentos personalizados. 
 
Part II: Business Logic Layer 
Chapter 7: Exception Classes and Design by Contract 
À medida que você começa a escrever sua lógica de negócios, você já tem um monte 
de testes de unidade e realizou verificações de código estático e código de execução 
depurado. No entanto, você sabe que situações inesperadas são obrigadas a ocorrer e 
tem que decidir como lidar com isso em suas aplicações. A maneira técnica de lidar 
com tais problemas é fazer uso das classes de exceção que a SAP introduziu para 
substituir o manuseio de erros tradicionais por meio de códigos de devolução. Também 
falarei sobre uma maneira filosófica de olhar para este problema: o projeto por padrão 
de contrato inventado por Bertrand Meyer. 
 
Chapter 8: Business Object Processing Framework (BOPF) 
Ao longo dos anos, a SAP criou muitas maneiras de modelar objetos do mundo real 
dentro do sistema ABAP. O mais recente é o Business Object Processing Framework 
 
 
 
28 
Structure of the Book 
 
 
(BOPF), que fornece uma transação de modelagem na qual há lugares para todas as 
tarefas comuns, como consultas, verificações de consistência e valores derivados. 
 
Chapter 9: BRFplus 
Devido ao fato de que o SAP ERP é um aplicativo focado em negócios, você 
provavelmente está acostumado a ler constantemente valores das tabelas de configuração 
e do IMG, juntamente com suas próprias tabelas Z. A BRFplus é um mecanismo de regras 
de decisão, que em nível técnico amplia consideravelmente a capacidade da IMG de 
armazenar as regras reais de negócios de forma facilmente visualizada. Em um nível 
filosófico, devolve a responsabilidade por essas regras desde a TI até as pessoas que 
realmente as criam. 
 
Part III: User Interface Layer 
Chapter 10: ALV SALV Reporting Framework 
Até que os aplicativos web sejam executados tãorápido quanto os desktop, ainda 
haverá um lugar para relatórios que são executados dentro da GUI SAP. Diante desse 
fato, foi criado o quadro de relatórios SALV para acelerar o desenvolvimento de tais 
relatórios. Neste capítulo, você verá como criar uma estrutura reutilizável para 
automatizar as tarefas mais monótonas que precisam ser executadas ao criar um 
relatório SALV e ver como contornar algumas de suas limitações percebidas. Você 
também vai dar uma olhada rápida em uma nova versão da classe SALV que a SAP 
inventou especificamente para situações em que há um banco de dados SAP HANA 
no backend, mas você ainda está executando um relatório no estilo SALV. 
 
Chapter 11: ABAP2XLSX 
Apesar de anos de tentativas de impedir que as pessoas usem o Microsoft Excel, um 
grande número de usuários de negócios passam grande parte do seu dia de trabalho 
brincando com spread-folhas. Neste capítulo, você vai olhar para o projeto de código 
aberto ABAP2XLSX e como você pode melhorar enormemente a integração entre 
SAP ERP e Excel, economizando assim uma enorme quantidade de tempo. 
 
Chapter 12: Web Dynpro ABAP and Floorplan Manager 
Web Dynpro ABAP já existe há algum tempo, mas quantas pessoas estão realmente 
usando? O Floorplan Manager (uma tecnologia Especializada Web Dynpro) é ainda 
mais novo e ainda está evoluindo rapidamente. Neste capítulo, você vai olhar para 
como 
 
 
29 
Introduction 
 
 
O Web Dynpro ABAP trabalha com o padrão de design MVC (Model-view-controller, 
controlador de visualização de modelos) e, em seguida, obter uma introdução ao 
Floorplan Manager. 
 
Chapter 13: SAPUI5 
SAPUI5 é a mais recente e bem sucedida tentativa de curar a má reputação da SAP 
no espaço de interface do usuário. Você vai ver como o SAPUI5 também usa o padrão 
MVC, aplicado muito mais do que é com o Web Dynpro ABAP, e como ele parece 
melhor e funciona mais rápido também. Você também verá como expor dados que 
vivem no SAP ERP através do uso de um serviço SAP Gateway e como criar um 
aplicativo SAPUI5 para consumir esses dados. 
 
Part IV: Database Layer 
Chapter 14: Shared Memory 
Para aqueles que ainda não conseguem trabalhar com um banco de dados SAP HANA, 
vale a pena dar uma olhada na estrutura de memória compartilhada para ver se ela 
pode ajudar a evitar um monte de acesso de banco de dados não necessário. 
 
Chapter 15: ABAP Programming for SAP HANA 
As pessoas têm muitas vezes medo do SAP HANA; é retratado como tão novo e 
revoluçionário que os programadores da ABAP se perguntam se isso vai colocá-los 
fora de um emprego. Neste sujeito-ter, eu vou definir a mente de todos em repouso 
e explicar o que código pushdown realmente é e como suas habilidades de 
programação vão ser tão relevantes como sempre neste admirável mundo novo. 
 
 
The Example Application 
Para manter meus pés (e os seus) no chão, vou basear a aplicação de exame-ple usada 
ao longo deste livro em uma aplicação real em que trabalhei, com o assunto real 
escondido, mudando todos os nomes de classe, método e atrito via encontrar e 
substituir para proteger os inocentes e evitar revelar segredos comerciais. 
Dado que não posso dizer no que estou trabalhando e que não vou usar a boa e velha 
prática SAP de usar o SFLIGHT, o exemplo deste livro é baseado em um projeto durante 
 
 
30 
 
The Example Application 
 
 
Barão Frankenstein para criar um monstro melhor. Seus monstros anteriores não 
funcionavam muito bem, então a SAP o convenceu a se inscrever para seu serviço de 
implantação rápida para fazer monstros baseados em nuvem, móveis e na memória. 
Um milhão de LEU (a moeda na Transilvânia) mais tarde, ele percebeu que a solução 
fora da caixa não lhe deu tudo o que ele queria, então ele contratou você para escrever 
um programa de fabricação de monstros no SAP ERP. Nesta aplicação, ele inser todas 
as bundas que ele quer de um monstro, e seu programa usa algoritmos tão 
complicados quanto o projeto do genoma humano para preparar a final dados, que 
então é interfaceado com sua máquina de fazer monstros através de serviços web 
durante uma tempestade. 
Durante os capítulos seguintes, você verá (com exemplos de código) que, felizmente 
para o barão, você pode aproveitar as variadas novas inovações recentemente 
entregues da SAP para ajudar em sua busca de criação de monstros. 
Agora, é hora de levantar a cortina... 
 
 
 
 
PART I 
Programming Tools 
€ A Call to Arms for ABAP Developers: http://scn.sap.com/community/career-center/ 
blog/2012/10/24/a-call-to-arms-for-abap-developers (Graham Robinson) 
€ Clean Code: A Handbook of Agile Software Craftsmanship (Martin, Prentice Hall, 2008) 
€ Head First Design Patterns (Freeman et al., O’Reilly, 2004) 
€ Antifragile Software: http://scn.sap.com/community/abap/blog/2013/12/01/antifrag- 
ile-software (Vikas Singh) 
Recommended Reading 
http://scn.sap.com/community/career-center/blog/2012/10/24/a-call-to-arms-for-abap-developers
http://scn.sap.com/community/career-center/blog/2012/10/24/a-call-to-arms-for-abap-developers
http://scn.sap.com/community/abap/blog/2013/12/01/antifragile-software
http://scn.sap.com/community/abap/blog/2013/12/01/antifragile-software
É melhor não olhar para o sol durante um eclipse. 
— Jeff Goldblum 
 
 
 
 
1 ABAP in Eclipse 
 
O principal ambiente de desenvolvimento da ABAP, o ABAP Workbench (Transação 
SE80), melhorou a cada nova versão e muitas vezes adicionou recursos encontrados em 
outro ambiente de desenvolvimento integrado popular: o Eclipse. Agora, a SAP mordeu 
10 a bala e adotou o eclipse em si para a programação da ABAP. Na verdade, você verá 
que muitos dos tópicos abordados neste livro — o Cockpit de Teste ABAP, o Business 
Object Processing Framework (BOPF), o Web Dynpro, o Floorplan Manager e o SAPUI5 
— são suportados por ferramentas específicas dentro da ABAP no Eclipse. Algumas das 
funcionalidades SAP mais avançadas — como a criação de objetos relacionados ao ABAP 
para uso no SAP HANA — só podem ser feitas usando ABAP no Eclipse. 
Eclipse é um ambiente de desenvolvimento de código aberto que começou a vida em 
sua forma atual por volta de 2001. Ele começoua balançar em cerca de 2004, e desde 
então uma nova versão foi lançada perto do final de junho de cada ano, cada uma com 
o nome de um planeta ou um satélite. 
Para simplificar demais, o Eclipse tem sido tradicionalmente uma forma de 
desenvolvimento muito usada para programadores Java. (Para verificar se isso era 
verdade, perguntei a um programador java no pub se ela usava eclipse; ela me disse que 
sim, ela fez, e era "tops" — de modo que resolve isso.) Na verdade, eclipse até menciona 
Java em sua tela de carregamento. (Também menciona a Oracle; você pode imaginar o 
que a SAP pensa sobre isso.) Claro, o Eclipse não se limita a Java, e você deve verificar 
a Wikipédia se você está interessado em uma lista completa de idiomas compatíveis. (Meu 
favorito pessoal é Groovy, principalmente porque deve ser maravilhoso ir a uma festa e 
— no caso improvável de qualquer- cuidado com o corpo — ser capaz de dizer que você 
é um programador Groovy.) 
Há uma enorme comunidade de apoio ao Eclipse, desde conferências até revistas 
online. Para entender o porquê, você precisa perceber que os programadores ABAP 
foram bastante mimados por ter o ambiente de desenvolvimento da Transação SE80 
inteiramente dentro do repositório ABAP. Em outras línguas, mesmo relativamente 
 
 
1 ABAP no Eclipse 
 
 
 pequenos programas podem gerar um grande número de arquivos, que são 
inicialmente desenvolvidos e armazenados em sua máquina local. Então você tem que 
implantá-los em algum lugar e ter certeza, para grandes projetos, que as diferentes 
versões do programa em diferentes máquinas de otorrinolaringes não substituem umas 
às outras. Isso tudo soa bastante doloroso, e ninguém gosta de ser sobrecarregadocom tarefas mundanas enquanto desenvolve programas. Lá, antes, você precisa de 
um ambiente de desenvolvimento muito bom para cuidar dessas tarefas para você; 
Eclipse é esse ambiente. 
Se você está prestando atenção, você pode notar que os recursos mais recentes na bancada 
de trabalho ABAP parecem suspeitamente com recursos que você encontra no Eclipse 
(por exemplo, conclusão automática de código ou palavras-chave de colorir de forma 
diferente das variáveis). Eventualmente, a SAP decidiu dar o salto; em julho de 2012, o 
SAP NetWeaver Develop-ment Tools for ABAP (ADT) foi lançado. Todo mundo chama 
de "ABAP no Eclipse", porque (a) é isso que é e (b) o nome oficial faz você soar como se 
tivesse engolido um dicionário quando você diz isso. (Você pode estar familiarizado com 
este phe-nomenon de outro produto SAP nomes.) 
Embora o Eclipse seja um passo na direção certa, a mudança nem sempre é fácil, e a 
SAP suspeitava com razão que os desenvolvedores tradicionais da ABAP ficariam 
horrorizados com a própria ideia de não executar tarefas de desenvolvimento na 
Transação SE80 ou suas transações de subconjunto, como SE24, SE37 ou SE38. Para 
tentar amortecer o golpe, a SAP deu um aviso prévio de que estava prestes a lançar o 
ABAP no Eclipse cerca de um ano antes do lançamento, e naturalmente o site da SAP 
Community Network (SCN) explodiu com comentários "Prefiro morrer do que usar 
isso" (um pequeno exagero, mas apenas leve). Esses comentários eram praticamente 
sempre de pessoas que nunca tinham ouvido falar do Eclipse antes, muito menos o 
usavam para desenvolver uma aplicação. Como resposta, tive que ir e colocar um 
gato entre os pombos publicando um post muito curto no blog chamado "SE24 is 
Garbage" em que exaltava as virtudes do Eclipse. (SE24) não é lixo; Eu estava 
apenas agitando as pessoas.) Uma torrente de abusos desceu sobre minha cabeça — 
mas agora é apenas dois anos depois, e a julgar pelos blogs na SCN, a maré começou 
a mudar à medida que mais e mais pessoas tentam ABAP no Eclipse e descobrem 
eles gostam (embora para ser justo, mesmo agora ainda há um monte de comentários 
negativos). 
O objetivo deste capítulo é mostrar-lhe as características do ABAP no Eclipse e deixá-lo 
decidir por si mesmo se isso pode acelerar o seu trabalho diário. Meu posi-tion é - 
naturalmente - que ele vai, então vamos ver se eu posso convencê-lo. A Seção 1.1 
explicará o processo de instalação do Eclipse em sua máquina local e analisará o básico 
de como usá-lo. Uma vez que você tenha isso para baixo, você está pronto para a 
Seção 1.2, que examinará algumas das coisas que você pode fazer ao desenvolver 
programas ABAP no Eclipse que você não pode fazer em tudo (ou não fazer muito 
facilmente) ao formar as tarefas equivalentes na Transação SE80 dentro do SAP GUI. 
A Seção 1.3 falará sobre como o ABAP no Eclipse lida com uma parte vital do 
desenvolvimento pró-cess: os testes e a solução de problemas de seus programas 
personalizados. Finalmente, Seção 1.4 explica como estender a funcionalidade do 
Eclipse usando plug-ins personalizados para adicionar funcionalidade extra, seja 
usando ferramentas de código aberto disponíveis livremente ou criando suas próprias 
ferramentas. 
 
 
1.1 Installation 
Existem três partes para configurar um ambiente de desenvolvimento eclipse para que 
você possa usá-lo para criar e alterar programas ABAP: 
1. Instale o próprio Eclipse no seu PC local. 
2. Adicione as ferramentas específicas do SAP . 
3. Conecte seu ambiente local eclipse a um sistema SAP backend. Esta 
seção irá guiá-lo através de cada uma dessas etapas. 
 
1.1.1 Installing Eclipse 
Você pode começar visitando https://www.eclipse.org, onde verá muitos links para 
notícias sobre a conferência anual do Eclipse, boletins informativos, grupos 
comunitários e assim por diante; mais importante, você verá um grande botão 
marcado - Download. 
A pegadinha é que esta página lhe dará a versão mais recente do Eclipse, e o SAP 
normalmente roda cerca de três meses atrás; assim, pode ser que se você fizer 
download da versão mais recente do Eclipse, ela será literalmente boa demais para 
ser usada. Então, antes de se empolgar e apertar o excitante botão DOWNLOAD, 
visite https://tools.hana.ondemand.com/#abap; lá você verá qual é a última versão 
suportada do Eclipse e o link que você deve seguir para fazer o download (Figura 
1.1). 
Ao seguir o link—para Eclipse Kepler no exemplo mostrado na Figura 1.1—você 
chegará a uma versão ligeiramente diferente da tela mencionada no início desta 
seção, mas o importante é que ele ainda tem um grande botão de download para 
você clicar. Abaixo do botão de download, você é apresentado a uma deslumbrante 
variedade de opções. A Figura 1.2 mostra apenas os dois primeiros, mas você pode 
continuar a paginar e as opções continuam aparecendo. 
Qualquer uma das opções mostradas na Figura 1.2 está correta para usar o ABAP 
no Eclipse, mas, na verdade, é melhor escolher a chamada IDE para JAVA EE 
DEVELOPERS. No Capítulo 13, você precisará dos recursos extras que esta 
Para instalar o Eclipse, seu sistema backend precisa ser pelo menos um sistema SAP NetWeaver 7.31 
SP 4. Se você é um dos clientes SAP ainda no 7.02 ou abaixo, eclipse não é para você! Há uma razão 
para este livro se chamar ABAP para o Futuro, afinal . 
 
Warning: Houston, We Have a Problem 
Warning: Houston, We Have a Problem 
opção oferece ao começar a trabalhar com SAPUI5. 
 
 
 
 
Figure 1.1 Installing Eclipse: Part 1 
 
 
Cada opção tem uma opção de 32 bits e uma de 64 bits. Certifique-se de escolher aquele que 
seja compatível com a versão do Java que está sendo executada em sua máquina; ou seja, uma 
versão de 32 bits do Java e uma versão de 64 bits do Eclipse não funcionam bem. juntas. 
 
Figure 1.2 Installing Eclipse: Part 2 
 
Baixar este programa para sua máquina local é tão simples que não há 
necessidade de entrar em mais detalhes, então vamos direto ao que acontece 
quando a instalação é concluída e você tem um lindo ícone em forma de planeta 
em sua área de trabalho. 
 
1.1.2 Installing the SAP-Specific Add-Ons 
Em qualquer tela do Eclipse, você pode escolher a opção de menu AJUDA • 
INSTALAR NOVO SOFTWARE, e uma caixa pop-up aparecerá, solicitando que 
você entre em um site. A URL tem o seguinte formato: 
https://tools.hana.ondemand.com/[nome da última versão suportada]. Para este 
exemplo, é https://tools.hana.ondemand.com/kepler. 
A Figura 1.3 mostra uma estrutura em árvore de todos os recursos possíveis que 
você pode instalar relacionados ao desenvolvimento SAP. Você poderia baixar 
tudo na árvore se quisesse (você certamente baixará as opções SAPUI5 mais tarde), 
mas por enquanto baixe tudo na seção Ferramentas de DESENVOLVIMENTO 
ABAP para SAP NETWEAVER. 
 
Figure 1.3 Installing SAP Add-Ons 
 
Se você tentar instalar os complementos do SAP para a versão Luna do Eclipse, 
poderá receber todos os tipos de mensagens de erro estranhas. Você pode corrigir 
o problema instalando primeiro o Eclipse Modeling Framework, que os 
complementos SAP parecem precisar; instale isso pelo mesmo caminho INSTALL 
NEW SOFTWARE, mas escolha o site de download principal do Eclipse nas 
opções suspensas. Procure uma opção com “EMF” e “SDK” no título e instale-a. 
Se você não receber uma mensagem de erro ao solicitar a instalação dos 
complementos SAP, a próxima coisa que você verá é uma lista de todas as opções 
escolhidas em um formato ligeiramente diferente (como parte de um prompt ARE 
YOU SURE). Em seguida vem o contrato de licença cada vez mais popular. Em 
seguida, você será perguntado se deseja reiniciar o Eclipse, o que você faz; caso 
contrário, as ferramentas SAP não estarão ativas. 
 
 
 
Agora, a página BEM-VINDO do Eclipse é aberta. Se você rolar para baixo, verá 
muitas opções específicas do SAP. Primeiro, existem vários específicosdo SAP 
HANA (é claro), e depois disso há a seção DESENVOLVIMENTO ABAP (Figura 
1.4). 
 
 
 
 
Figure 1.4 Eclipse Welcome Page with SAP-Specific Options 
 
Se você abrir uma dessas opções, por exemplo, QUICK LAUNCH, a ajuda on-
line será aberta e apresentará muitas informações. Uma parte considerável dos 
capítulos no lado esquerdo da tela endereça ABAP ou SAP HANA. 
 
1.1.3 Connecting Eclipse to a Backend SAP System 
Como mencionado anteriormente, você precisa de um sistema de back-end que seja pelo 
menos SAP NetWeaver 7.31 SP 4 para se conectar ao Eclipse. Para conectar esse backend ao 
Eclipse, siga o caminho de menu do Eclipse FILE • NEW • OTHER • ABAP • ABAP 
PROJECT. (Um “projeto” neste contexto é nada mais nada menos do que uma conexão com 
um sistema ABAP back-end.) 
 
 
 
Na Figura 1.5, você verá que o botão de opção SELECT CONNECTION from SAP LOGON 
está selecionado. Isso significa que quando você clica em BROWSE, aparece uma lista de 
sistemas SAP disponíveis em nosso painel de logon instalado localmente. Quando 
selecionamos um sistema, a metade inferior da caixa pop-up é preenchida com os detalhes do 
sistema. 
 
Figure 1.5 Connecting ABAP to Eclipse 
 
SELECT CONNECTION do SAP LOGON é a opção a ser tomada se os arquivos 
do seu SAP logon pad estiverem em sua máquina local e não em algum tipo de 
servidor central. Se o seu painel de logon tiver a lista de sistemas SAP armazenados 
centralmente em um servidor, você pode escolher a opção DEFINIR 
MANUALMENTE e preencher todas as caixas na caixa pop-up (servidor de 
aplicativos, etc.) com os valores necessários. 
Na próxima tela, digite o número do cliente e seu nome de usuário e senha. Clique 
em CONCLUIR. Na parte inferior da tela, você verá que o Eclipse está verificando 
se o sistema de destino é compatível ou não. Se for, aparece outra caixa pedindo 
pacotes favoritos e similares. Por enquanto, ignore essa caixa e clique em NEXT e 
depois em FINISH. Assim, você tem uma nova ferramenta para desenvolver seus 
vários objetos de repositório ABAP. 
 
 
 
 
 
1.2 Features 
Ao conectar seu sistema backend pela primeira vez ao Eclipse, você verá uma 
mensagem de boas-vindas no lado direito da tela (Figura 1.6). 
 
Figure 1.6 ABAP in Eclipse Feature Explorer 
Clicando CLIQUE AQUI PARA COMEÇAR! lança um tour do ABAP no Eclipse 
– um tour bastante abrangente, tão grande que você terá que dedicar algum tempo 
para trabalhar em tudo. Felizmente, você pode fazer isso no seu próprio ritmo, 
marcando cada área como “explorada” assim que tiver que lidar com ela para poder 
continuar em uma data posterior de onde parou. 
O tutorial cobre todo o tópico do ABAP no Eclipse com muito mais detalhes do 
que qualquer um poderia esperar cobrir em um capítulo de um livro, então o 
restante do capítulo não falará sobre como fazer no Eclipse as coisas que você já 
pode fazer. Faz; em vez disso, o foco principal será nas coisas que você pode fazer 
em ABAP no Eclipse que normalmente não pode fazer em um ambiente SE80. No 
entanto, antes de mergulhar nesses detalhes, você deve aprender como executar 
uma ação básica, mas muito importante, no Eclipse: chamar e modificar objetos de 
repositório. Com esses conceitos básicos, você estará melhor preparado para 
mergulhar nos recursos mais avançados que são o foco desta seção. 
Na Figura 1.7, você verá o lado esquerdo da primeira tela mostrada após conectar 
o Eclipse ao ABAP. Assim como no menu SAP, há uma árvore de FAVORITOS 
na parte superior para os pacotes Z em que você está trabalhando em um 
determinado momento e uma grande lista de cada pacote no sistema SAP na parte 
inferior. (Esta última peça não é muito útil, na verdade, porque a árvore é muito 
grande.) 
Assim como o menu de favoritos no sistema SAP normal, você pode clicar com o 
botão direito do mouse na estrela FAVORITE PACKAGES para adicionar um 
novo pacote de desenvolvimento. Uma entrada para objetos locais é adicionada 
automaticamente. 
Figure 1.7 Eclipse View of ABAP Packages 
 
Digamos que você queira alterar uma de suas classes Z e não consiga lembrar seu nome 
exato. Normalmente, você iria para o SE24, digitaria “ZCL_BC*” (como exemplo) e 
abriria o menu suspenso. (Se você for como eu, às vezes você não veria nenhum 
resultado. Então, de repente, você perceberia que estava no SE37 por engano.) A ação 
equivalente para procurar objetos personalizados no Eclipse é pressionar (CTRL) + 
(SHIFT ) + (A). Uma caixa de pesquisa é exibida. Você digita no início do seu objeto 
e, com cada letra que você adiciona, a lista de possíveis correspondências é reduzida 
(Figura 1.8). A velocidade com que o Eclipse pesquisa no repositório ABAP é muito 
mais rápida do que se poderia esperar, geralmente mais rápida do que a mesma pesquisa 
no sistema SAP real, o que parece magia negra. 
Selecione uma de suas classes Z, e a tela mostrada na Figura 1.9 aparecerá; espero que 
não pareça tão diferente do SE80 que você morra de choque cultural na hora. Você 
notará que existem várias janelas em uma visualização do Eclipse, e você pode fechá-
las ou redimensioná-las e até mesmo arrastá-las e soltá-las por toda a tela. O sistema 
lembrará o layout da janela se você sair do Eclipse e voltar mais tarde. 
 
 
Figure 1.8 Searching for an ABAP Repository Object 
 
Essa última parte é importante, porque geralmente você faz logoff do SAP no 
final do dia e, no dia seguinte, faz logon novamente e procura a linha do programa 
de onde parou ontem. No Eclipse, você começa de onde parou. 
 
Figure 1.9 Editing a Class in Eclipse 
 
 
 
 
 
 
Você notará que a classe é exibida no que seria a visualização do código-fonte 
dentro do SE24. O Eclipse sempre exibe objetos dessa maneira; não tem noção 
das telas formatadas como as do SE37 e SE24. Para o Eclipse, tudo é apenas um 
grande programa. Como exemplo, ao visualizar um módulo de função a 
assinatura aparece no início do código, conforme mostrado na Listagem 1.1. 
FUNCTION 
ZBC_GET_USERS_COUNTRY 
EXPORTING 
E_LAND LIKE TTZ5-LAND1. 
Listing 1.1 Signature at Start of Function Module Code 
 
Você altera a assinatura alterando o código-fonte exatamente como faria ao alterar a 
assinatura de uma rotina FORM no SE38 ou SE80, em vez de ter que pular entre 
diferentes guias no SE37. Outra coisa que levará algum tempo para se acostumar é 
que você está sempre no modo de mudança. Você também notará que seus 
comentários são verificados ortográficos. 
Neste ponto, chegou a hora de provar que isso é real e não algum tipo de sonho. 
Escolha uma de suas classes Z e adicione um comentário, como “Alterei este código 
no Eclipse”. Em seguida, clique no ícone ATIVAR na parte superior da tela. Um pop-
up com uma barra de progresso será exibido enquanto a alteração é propagada para 
o sistema SAP. Em seguida, entre nesse sistema SAP e use o SE24 para ver se a 
alteração realmente ocorreu. Você descobrirá que sim, e nesse ponto tudo se torna 
incrivelmente real. 
 
 
Neste ponto do capítulo, você aprendeu o básico absoluto: o que é o Eclipse, como 
instalá-lo e conectá-lo ao seu sistema de desenvolvimento ABAP e como chamar 
e alterar objetos de repositório ABAP via Eclipse. É bem provável que neste 
momento muitos desenvolvedores estejam pensando: “E daí? Isso se parece 
muito com o SE80. É muito esforço extra para fazer exatamente as mesmas 
mudanças que eu faria no SE80 nesta nova estrutura externa.” 
Se isso fosse verdade, você imaginaria que ninguém jamais desenvolveria 
programas usando ABAP no Eclipse duas vezes, muito menos continuamente. 
Portanto, agora é hora de examinar alguns dos recursos que facilitam a vida de 
um desenvolvedor ABAP de tal forma que o minuto extra gasto abrindo o Eclipse 
pela manhã enquanto você toma uma xícara de café é mais do que compensado 
por menos tempo de desenvolvimento gasto em tarefas comuns ao longo do dia. 
 
 
 
 
 
7.4 vs. 7.31 
 
 
1.2.1 Workingon Multiple Objects at the Same Time 
O número máximo de sessões que você pode abrir no SAP GUI é sete. (Os 
designers originais provavelmente pensaram que isso era mais do que suficiente. 
Afinal, os seres humanos podem fazer apenas uma coisa de cada vez, então você 
não poderia estar trabalhando em oito ou mais coisas diferentes 
simultaneamente). - os operadores muitas vezes querem poder ver muitas coisas 
diferentes ao mesmo tempo: talvez vários métodos que chamam uns aos outros 
em uma cadeia enquanto também têm objetos semelhantes abertos para verificar 
como eles (ou outra pessoa) realizaram o mesmo tipo de tarefa antes da. Então, é 
claro, alguém pode aparecer atrás de você para perguntar algo e, para resolver o 
problema, você precisa abrir um programa não relacionado e não deseja encerrar 
nada em que esteja trabalhando no momento. Antes que você perceba, você atinge 
o número máximo de sessões e precisa decidir o que deseja fechar. Este não é o 
fim do mundo, mas seria bom ter tantos objetos abertos quanto você quisesse 
apenas para economizar um pouco de tempo (porque, é claro, a sessão que você 
encerrou acaba sendo aquela que você de repente tem uma necessidade urgente 
de olhar novamente). Além disso, você provavelmente terá a necessidade de 
analisar duas ou mais sessões de uma só vez sem precisar alternar entre elas. Nos 
últimos anos, a resposta para isso foi ter dois monitores ou até três. Suponho que 
você poderia encher a parede com monitores, se quisesse. Tudo isso é 
maravilhoso, mas pode ser descrito como uma solução de hardware para um 
problema de software. 
Naturalmente, eu não teria trazido tudo isso à tona se o Eclipse não oferecesse 
uma solução para esse problema - o que, é claro, oferece. Como você não está no 
SAP GUI, você pode ter quantas janelas contendo objetos de programa quiser e 
pode arrastar e soltar e redimensionar as janelas para ver quantas você quiser a 
qualquer momento (Figura 1.10). 
 
 
A tela da Figura 1.10 parece muito cheia, mas ao programar você não está tão 
interessado em beleza, apenas em ver o máximo de informações que você precisa 
em um determinado ponto. Naturalmente, se você tiver dois (ou mais) monitores, 
também poderá enchê-los com caixas (como os programas policiais na TV em 
que enchem a parede com pistas do crime). 
Quando novos recursos do Eclipse são lançados em novas versões do SAP NetWeaver, eles 
são lançados primeiro na nova versão e, em seguida, são transferidos para versões 
anteriores posteriormente. Por exemplo, os recursos que foram adicionados no 7.4 SP 5 
foram posteriormente portados para o 7.31 no SP 
11. Assim, a maioria dos recursos discutidos nesta seção funcionará em 7.31 e 7.4. No 
entanto, se este não for o caso, será mencionado especificamente. 
Você pode notar que uma das caixas abertas na captura de tela da Figura 1.10 não 
era um programa ABAP, mas um programa JavaScript de um aplicativo SAPUI5 
que você desenvolverá posteriormente neste livro. O ponto a ser feito aqui é que, 
à medida que o SAP evolui, você se verá desenvolvendo partes do aplicativo em 
linguagens (gasp) diferentes do ABAP. Esse conceito pode enchê-lo de horror, 
mas com o passar do tempo é cada vez mais provável que você se encontre em 
tal situação e, se o fizer, provavelmente verá o benefício de poder trabalhar em 
todas as partes do programa. no mesmo ambiente de desenvolvimento, em vez de 
ter que ficar alternando entre os ambientes. 
 
Figure 1.10 Busy Eclipse Screen Full of Objects 
 
1.2.2 Bookmarking 
A qualquer momento, você realmente nunca está trabalhando em apenas uma 
coisa, mas em um número (espero) finito de construções ABAP (chamadas 
“artefatos” no Eclipse): programas, classes e módulos de função e similares. No 
entanto, o número pode ser bastante grande em um projeto de desenvolvimento 
complexo, e nós humanos temos uma tendência horrível de esquecer o nome 
exato de uma classe - mesmo que trabalhemos com ela vinte dias seguidos - e 
precisar procurá-la em SE24. 
 
No ABAP no Eclipse, você pode clicar com o botão direito do mouse no artefato 
que deseja marcar e, quando fizer isso, verá um enorme menu de contexto, com 
ADD BOOKMARK próximo à parte inferior (Figura 1.11). 
 
Figure 1.11 Bookmarking an ABAP Artifact 
 
Então, algumas horas ou dias depois, você pode clicar em uma pequena caixa à direita da tela 
que diz BookmARks quando você passa o cursor sobre ela; a caixa mostrada na Figura 1.12 
aparece. 
 
Figure 1.12 List of Bookmarks 
Clique duas vezes no que você deseja e - bingo - ele se abre e você pode começar 
a mudar as coisas para o conteúdo do seu coração. 
 
 
 
 
1.2.3 Creating a Method from the Calling Code 
O ABAP Objects foi introduzido com a versão 4.6C do SAP e, desde então, o 
SAP vem pressionando os desenvolvedores a usá-lo. Mesmo agora, há muita 
resistência. Se a SAP quer que os programadores mudem para a programação 
orientada a objetos (OO), então a programação OO tem que ser tão ou mais fácil 
do que a programação procedural a que os programadores estão acostumados. 
Infelizmente, mesmo depois de todos esses anos, em seu ambiente SE80 há uma 
coisa que você pode fazer com programação procedural que não pode fazer com 
programação OO usando métodos locais: rotinas FORM. Por exemplo, considere 
o código de procedimento de amostra na Listagem 1.2, que chama uma rotina 
FORM. 
PERFORM create_monster USING ld_number_of_heads 
CHANGING ld_monster_number. 
Listing 1.2 FORM Routine 
 
Se não houvesse tal rotina FORM, então quando você clicar duas vezes em 
CREATE_MONSTER o sistema perguntará se você deseja criar aquela rotina 
FORM ausente. Em seguida, ele o criaria para você, junto com a assinatura 
(embora você tivesse que codificar manualmente os TYPES dos parâmetros de 
assinatura). 
Agora, considere o código orientado a objetos chamando um método na Listagem 
1.3. 
 
ld_monster_number = lo_laboratory->create_monster( ld_number_of_heads). 
Listing 1.3 Method 
 
Você pode esperar que, se não houvesse tal método, exatamente a mesma coisa 
aconteceria, e uma implementação e definição de método esqueleto seriam 
criadas para você quando você clicasse duas vezes no método 
CREATE_MONSTER. Você estaria, infelizmente, errado. 
As pessoas reclamaram e reclamaram sobre isso na Internet por 14 anos sem 
sucesso. O que acontece quando você tenta a mesma coisa em ABAP no Eclipse? 
Em primeiro lugar, escreva um pequeno programa (Listagem 1.4). 
 
 
 
 
 
 
CLASS lcl_laboratory DEFINITION. PUBLIC 
SECTION. 
METHODS: main. 
ENDCLASS. "Laboratory Definition CLASS 
lcl_laboratory IMPLEMENTATION. 
METHOD main. 
* Local Variables 
DATA: ld_monster_number TYPE i, 
ld_number_of_heads TYPE i. 
 
create_monster( id_number_of_heads = ld_number_of_heads ). 
 
ENDMETHOD. 
 
ENDCLASS. "Laboratory Implementation 
Listing 1.4 Sample Program with Missing Method 
 
As you can see, the create_monster method does not exist. In the past, you couldn’t 
just double-click it; you had to create a definition, and then create an 
implementation, and then find your way back to the place you first started, mak- 
ing you think that maybe FORM routines weren’t so bad after all. 
In Eclipse, you put your cursor on the not-yet-extant CREATE_MONSTER and press 
(CTRL) + (1). A little box appears and asks you if you want to automatically create 
the missing method. I know I do; I have been waiting 14 years for this, so I say 
yes. 
In Figure 1.13, the definition of the IMPORTING parameter came from the variable 
definition you made in the code, which is one better than the FORM-based equiva- 
lent in which you have to manually add the variable type. 
Sadly, you may have to manually add the RETURNING parameter; in my version of 
ABAP in Eclipse, the autocreation did not work if I entered ld_monster_number = 
create_monster( ld_number_of_heads ). Nonetheless, that is probably just a bug which willbe fixed in time. In any event, the end result is as shown in Listing 1.5. 
 
 
 
 
 
 
CLASS lcl_laboratory DEFINITION. 
 
PUBLIC SECTION. 
METHODS: main. 
PRIVATE SECTION. 
METHODS create_monster 
 
IMPORTING 
id_number_of_heads TYPE i 
RETURNING 
value(rd_monster_number) TYPE i. 
ENDCLASS. "Laboratory Definition 
CLASS lcl_laboratory IMPLEMENTATION. 
METHOD main. 
* Local Variables 
DATA: ld_monster_number TYPE i, 
ld_number_of_heads TYPE i. 
 
ld_monster_number = create_monster( ld_number_of_heads ). 
 
ENDMETHOD. 
METHOD create_monster. 
ENDMETHOD. 
ENDCLASS. "Laboratory Implementation 
Listing 1.5 Automatically Created Method Implementation 
 
Figure 1.13 Autocreation of a Method 
A definição e a implementação foram criadas para você, o cursor pula para a 
implementação do método (que, claro, é onde você quer estar), e finalmente os 
métodos locais alcançaram as rotinas FORM e até avançaram devido à assinatura 
TYPE definições sendo extraídas das declarações de variáveis. Você também 
pode criar a implementação do método depois de ter criado a definição do método 
através do mesmo caminho de menu—(CTRL) + (1)—algo que estava faltando 
no ABAP Workbench padrão. 
 
 
1.2.4 Extracting a Method 
A programação é uma batalha contra o código que apodrece com o tempo, e parte 
do princípio antifrágil discutido na introdução do livro é que os programadores 
devem constantemente procurar maneiras de tornar seus programas resistentes ao 
mar cada vez maior de mudanças que esses programas devem sofrer. Uma das 
principais causas da fragilidade do programa é o código duplicado. É tão fácil 
recortar e colar um grande pedaço de código de um lugar para outro e apenas 
alterar as variáveis, deixando a lógica exatamente a mesma. Antes que você 
perceba, você tem o mesmo pedaço de código repetido em todo o programa ou, 
pior ainda, em muitos programas diferentes. 
Então vem a mudança: a lógica precisa ser ajustada. Agora você tem que fazer 
essa mudança em 54 lugares diferentes, e é claro que você vai esquecer de fazer 
a mudança em alguns deles. Isso pode levar a resultados imprevisíveis. O usuário 
experimentará um comportamento diferente ao fazer a mesma coisa em diferentes 
contextos; em outras palavras, a mudança quebrou o programa em dois, como um 
galho de vidro sendo saltado para cima e para baixo por um elefante durante um 
terremoto. 
 
 
Figure 1.14 Quick Assist View 
 
You won’t need to have such a screen area open once you’re used to all the things ABAP 
in Eclipse can do for you, but at the start this is very helpful to remind you that not 
everything has to be done manually any longer. 
The Eclipse term for (CTRL) + (1) is Quick Assist. You can open an area of the screen (view), 
leave it open in the bottom-left corner or wherever you want, and then you can see what 
proposals the system has for you in regard to creating missing things automat- ically or 
other types of refactoring (Figure 1.14). 
Quick Assist 
 
A solução óbvia é que quando você deseja copiar e colar um pedaço de código e 
fazer algumas pequenas alterações, você deve extrair a maior parte do código em 
seu próprio método, com parâmetros IMPORTING para as partes que variam. 
Isso soa bem e elegante em princípio, mas é um pouco trabalhoso, e é muito mais 
fácil destacar o código e fazer o truque (CTRL) + (C)/(CTRL) + (V), e as pessoas 
estão em pressa, então é isso que eles fazem, sem perceber que acabaram de fazer 
uma vara para suas próprias costas (e de seus colegas, presentes e futuras). 
Felizmente, o ABAP no Eclipse oferece uma ferramenta para extrair 
automaticamente pedaços de código em seus próprios métodos. A Listagem 1.6 
mostra um código de exemplo que você pode perceber de repente que precisa em 
muitos lugares diferentes, com as variáveis alteradas, mas a lógica a mesma. 
CLASS lcl_monster IMPLEMENTATION. 
 
METHOD main. 
* Local Variables 
DATA: ld_monster_madness1 TYPE i, 
ld_monster_madness2 TYPE i, 
ld_monster_madness3 TYPE i, 
ld_description1 TYPE string, 
ld_description2 TYPE string, 
ld_description3 TYPE string. 
 
ld_monster_madness1 = 25. 
ld_monster_madness2 = 50. 
ld_monster_madness3 = 100. 
 
* Derive Monster Sanity 
IF ld_monster_madness1 LT 30. ld_description1 
= 'FAIRLY SANE'. 
ELSEIF ld_monster_madness1 GT 90. 
 
 
 
 
 
ld_description1 = 'BONKERS'. 
ELSE. 
ld_description1 = 'AVERAGE SANITY'. 
ENDIF. 
 
IF ld_monster_madness2 LT 30. ld_description2 
= 'FAIRLY SANE'. 
ELSEIF ld_monster_madness2 GT 90. 
ld_description2 = 'BONKERS'. 
ELSE. 
ld_description2 = 'AVERAGE SANITY'. 
ENDIF. 
 
IF ld_monster_madness3 LT 30. ld_description3 
= 'FAIRLY SANE'. 
ELSEIF ld_monster_madness3 GT 90. 
ld_description3 = 'BONKERS'. 
ELSE. 
ld_description3 = 'AVERAGE SANITY'. 
ENDIF. 
ENDMETHOD. 
ENDCLASS. 
Listing 1.6 Sample Code with Changing Variables 
 
Quantas vezes você já viu código assim – a mesma construção repetidas vezes, 
apenas com as variáveis mudando? Isso é de fato um comportamento criminoso 
- e a vítima é o programador que escreveu o código - quando há tantas maneiras 
de facilitar sua vida (por exemplo, macros). 
Para corrigir este problema, destaque o primeiro bloco IF/THEN/ELSE—
certifique-se de começar com a linha de comentário—e pressione (ALT) + 
(SHIFT) + (M), ou escolha a opção de menu SOURCE • EXTRACT METHOD. 
Aparece a caixa mostrada na Figura 1.15. Você pode se perguntar de onde veio o 
nome proposto; é de fato a linha de comentário, por isso era importante incluir o 
comentário no bloco destacado. Você pode não ter nenhum comentário ou um 
comentário bizarro, então é claro que você pode alterar o nome proposto. 
Você notará que o Eclipse examinou as variáveis na seção destacada e as 
transformou em parâmetros. Às vezes fica confuso, mas geralmente o resultado é 
bastante bom. Você pode alterar o nome dos parâmetros propostos e a direção. 
Neste caso, você não quer mudar o nível de loucura do monstro, então transforme 
a proposta em um IMPORTING parameter. 
 
 
 
 
 
 
Figure 1.15 Extracting a Method 
 
Em seguida, você verá uma caixa solicitando uma solicitação de transporte (se 
este não for um objeto local) e se deseja ativar tudo após a conclusão da extração. 
A parte final — e talvez a melhor — é que, antes de fazer a alteração, você vê 
uma comparação entre antes e depois, mostrando como ficará seu código depois 
que a alteração proposta for feita (Figura 1.16). Se você não gostar da aparência 
do que o sistema está prestes a fazer, você pode cancelar. 
Após a extração, três alterações foram feitas. Primeiro, foi criada uma definição 
de um novo método privado (Listagem 1.7). 
PRIVATE SECTION. 
 
METHODS derive_monster_sanity 
IMPORTING 
id_monster_madness1 TYPE i. 
Listing 1.7 Definition of New Private Method 
 
Next, the block of code you highlighted has been replaced by a method call (List- 
ing 1.8). 
ld_monster_madness1 = 25. 
ld_monster_madness2 = 50. 
ld_monster_madness3 = 100. 
 
derive_monster_sanity( ld_monster_madness1 ). 
Listing 1.8 Method Call Replacement 
 
 
 
 
 
 
 
 
Figure 1.16 Extracting a Method: Before and After Comparison 
 
Por último, é claro, há uma nova implementação de método (Listing 1.9). 
 
METHOD derive_monster_sanity. 
DATA ld_description1 TYPE string. 
* Derive Monster Sanity 
IF id_monster_madness1 LT 30. ld_description1 
= 'FAIRLY SANE'. 
ELSEIF id_monster_madness1 GT 90. 
ld_description1 = 'BONKERS'. 
ELSE. 
ld_description1 = 'AVERAGE SANITY'. 
ENDIF. 
ENDMETHOD. 
Listing 1.9 New Method Implementation 
 
Observadores cuidadosos notarão que o Extraction Wizard não é tão inteligente 
assim, porque você realmente queria a descrição como um parâmetro 
EXPORTING e não precisa mais do seu comentário - mas isso é um pequeno 
detalhe. É bastante fácil alterar o método recém-criado e certamente esse processo 
envolve muito menos esforço do que criar manualmentea implementação e a 
definição. 
Além disso, é provável que em versões superiores você possa dizer ao Eclipse 
para procurar blocos idênticos e substituí-los todos por chamadas para seu novo 
método (ou seja, no exemplo anterior, todas as três construções IF/THEN/ELSE 
teriam sido substituídas com chamadas de método). 
 
1.2.5 Deleting Unused Variables 
Um mantra de programação comum é “Primeiro faça funcionar – depois faça 
bom”. Seguir esse princípio significa mexer até conseguir o que está funcionando 
e, em seguida, limpar a bagunça que você fez enquanto experimentava. 
Tradicionalmente, ao programar dentro do SAP GUI usando SE80 ou uma 
transação relacionada, a verificação de programa estendido padrão (SLIN) é boa 
para ajudar nisso; você recebe uma lista de variáveis que foram declaradas, mas 
nunca são usadas. Isso acontece porque você precisou das variáveis em algum 
momento enquanto o programa estava evoluindo, mas excluiu o código que as 
usava porque não precisava mais desse código. Variáveis não utilizadas são ruins, 
porque ocupam um pouco de memória em tempo de execução sem nenhum 
propósito e também porque sobrecarregam o código, dificultando a leitura, o que 
é um pecado capital. 
Digamos que, como parte de seu projeto monstruoso, você seja chamado a 
escrever um programa para realizar a operação matemática mais complicada do 
mundo. Leva meses de suor e lágrimas, mas no final você tem um programa que 
apresenta o resultado correto; parece com a Listagem 1.10. 
METHOD main. 
* Local Variables 
DATA: ld_use_this TYPE i, 
ld_also_this TYPE i, ld_result 
TYPE i, ld_not_used TYPE i, 
ld_not_used2 TYPE i, 
ld_not_used3 TYPE i. 
 
ld_use_this = 1. 
ld_also_this = 1. 
 
 
 
ld_result = ld_use_this + ld_also_this. 
 
ENDMETHOD. 
Listing 1.10 Most Complicated Mathematical Operation in the World 
 
O resultado agora está correto, mas ao longo das milhares de versões deste programa 
você criou algumas variáveis que não são usadas. Dentro do SAP, você normalmente 
executa a verificação de sintaxe estendida, que fornece uma lista dessas variáveis não 
utilizadas, e então você entra em cada uma, uma de cada vez, e as exclui. 
No Eclipse, você escolhe a opção de menu SOURCE • DELETE UNUSED VARIables (All), e 
em um milionésimo de segundo todos os seus amigos não utilizados desaparecem, 
chorando por todo o caminho que seu propósito na vida desapareceu. Você também 
tem a opção de excluir variáveis não utilizadas apenas na área que você destacou. 
 
 
1.2.6 Creating Instance Attributes and Method Parameters 
Outro recurso valioso do Eclipse é a capacidade de criar atributos de instância e 
parâmetros de método. Por exemplo, digamos que você escreveu o código dentro 
de um método sem declarar nenhum IMPORTING parameters para o método ou 
qualquer variável na definição de classe (Listing 1.11). 
METHOD howl_at_moon. 
 
DO md_howls TIMES. 
MESSAGE 'Oooooooooooo' TYPE 'I'. 
ENDDO. 
 
ENDMETHOD. "howl_at_moon 
Listing 1.11 Missing IMPORTING Parameters and Variables 
 
If Se você posicionar o cursor na variável MD_HOWLS e pressionar (CTRL) + 
(1), verá uma lista de opções. Você pode optar por tornar MD_HOWLS um 
atributo de classe, caso em que uma declaração DATA é criada na seção 
PRIVATE da definição de classe (como o TYPE é escolhido é magia negra), ou 
você pode dizer que a variável é um IMPORTING ou CHANGING ( ou qualquer 
outro) e, em seguida, a assinatura do método na definição da classe é alterada de 
acordo. 
 
Como teste, certifiquei-me de que, se adicionasse ##NEEDED no final de uma declaração 
de variável não utilizada, ela não seria removida, e de fato não é, o que é bom. Antes de 
usar esta opção, então, certifique-se de que todas as variáveis que são acessadas 
dinamicamente tenham tal pragma ao lado delas. 
Just How Clever is the Refactoring Tool in Eclipse? 
1.2.7 Creating Class Constructors 
Uma regra orientada a objetos comum é que você nunca deve criar objetos usando 
a instrução CREATE OBJECT; em vez disso, você deve ter um método de fábrica 
que forneça o objeto. A vantagem disso é que se sua variável de classe for 
referenciada a uma interface em vez de uma classe concreta, então o método de 
fábrica decidirá a subclasse exata para você, o que torna o programa mais 
resistente a mudanças. 
No ABAP no Eclipse, se você colocar o cursor no nome da classe e pressionar 
(CTRL) + (1), obterá várias opções, incluindo a criação do método fábrica, a 
criação de um construtor de classe ou a criação de um construtor de instância 
(Figure 1.17). 
 
Figure 1.17 Automatically Generating a Constructor 
 
Além disso, se você tiver declarado algumas variáveis na definição de classe antes 
de fazer isso, um assistente aparecerá e perguntará quais dessas variáveis você 
deseja ter como IMPORTING parameters no constructor. Portanto, se você tivesse 
variáveis de membro para uma classe de registro e o nome do inventor, por 
exemplo, que desejasse passar toda vez que uma nova instância fosse criada, você 
as escolheria na lista apresentada. O resultado gerado se pareceria com a Listagem 
1.12. 
CLASS zcl_monster DEFINITION. 
CONSTRUCTOR IMPORTING i_logger TYPE REF TO zcl_bc_logger 
i_inventor_name TYPE zde_inventor_name. 
 
CLASS zcl_monster IMPLEMENTATION. 
METHOD constructor. 
Super->constructor( ). me-
>logger = i_logger. 
me->inventor_name = i_inventor_name. 
ENDMETHOD. 
Listing 1.12 Automatically Generated Constructor 
 
 
 
 
Criar automaticamente um método de fábrica que retorna uma instância da classe 
também é um recurso muito útil. Todos os puristas dizem que você deve tentar 
colocar suas instruções CREATE OBJECT dentro de classes de fábrica para que você 
possa retornar uma subclasse sem perturbar o programa de chamada. Este é um dos 
recursos que está disponível apenas em alguns níveis superiores do ABAP 
Workbench padrão; você precisa de um sistema 7.4 (SP 5) até que esses recursos 
sejam retroportados para 7.31 (que está em 
7.31 SP 11). O ponto aqui é que os recursos estão disponíveis no Eclipse antes de 
chegarem ao ABAP Workbench “real”, geralmente com bastante antecedência. 
Convenientemente, este é um ponto que conduz muito bem à próxima seção. 
 
1.2.8 Getting New IDE Features 
Como acabamos de mencionar, em certos casos, qual funcionalidade você obtém - por 
exemplo, no Extraction Wizard - depende tanto do nível ABAP no Eclipse em que 
você está (você pode atualizar para a versão mais recente 10 segundos após o 
lançamento, pois vive no seu PC) e qual é a sua versão de back-end do SAP 
NetWeaver (você está um pouco mais preso aqui). 
Por exemplo, quando você chama o assistente para extrair um método, no canto 
inferior esquerdo há um ponto de interrogação, que abre a ajuda online. Aqui, você 
pode navegar por todas as coisas maravilhosas que pode fazer, com exemplos de 
código, mas também verá uma matriz listando o nível mínimo que seu sistema ABAP 
precisa estar para aproveitar cada recurso (Figura 1.18). 
Isso pode ser bastante frustrante, porque significa que qualquer versão do ABAP no 
Eclipse que você tenha tem a possibilidade de fazer muito mais do que seu sistema 
ABAP backend permite, e novas versões do ABAP no Eclipse são lançadas com 
bastante frequência. 
No entanto, há novos recursos adicionados ao ABAP no Eclipse que não estão 
vinculados ao nível de versão de back-end e, mais importante, o Eclipse como uma 
estrutura recebe uma nova versão principal a cada ano e, como todos os projetos de 
código aberto, recebe atualizações menores regularmente. Portanto, você pode 
aproveitar continuamente os novos recursos relacionados ao ambiente de 
desenvolvimento como um todo, em vez de ter que esperar de cinco a sete anos para 
que sua empresa faça uma atualização SAP que melhorará sua experiência com o 
SE80 -produto (por algum motivo, as empresas não realizam atualizações com base 
no que os desenvolvedores desejam). Como exemplode quão rápido o ABAP no 
Eclipse avança, quando comecei a escrever este capítulo eu queria ter certeza de que 
tinha a versão mais recente do ABAP no Eclipse, então baixei em uma terça-feira – e 
uma nova versão saiu naquela quinta. (Isso foi uma coincidência, mas as novas versões 
são lançadas com muito mais frequência do que uma vez por ano e, às vezes, com 
apenas dois meses de intervalo.) 
 
 
 
Figure 1.18 Feature Availability Matrix 
 
Para tornar a ideia de melhorias relacionadas ao ambiente de desenvolvimento 
um pouco mais real, é hora de um exemplo específico. Se você baixar a versão 
Luna do Eclipse, verá uma página de boas-vindas contendo uma seção 
WHAT’s NEW, que fornece uma lista das melhorias mais importantes entre 
esta nova versão do Eclipse e a última. Como seria de esperar, a maioria dos 
itens desta lista não tem nada a ver com SAP—mas quando se trata de melhorias 
em como você pode personalizar o layout da tela no Eclipse e novos recursos 
para o editor de código, essas são realmente melhorias que nós pode aproveitar. 
Um dos novos recursos adicionados ao Luna é a capacidade de mostrar (e 
editar) diferentes partes do mesmo programa de uma só vez (Figura 1.19). Se 
você pressionar (CTRL) + (SHIFT) + (-), o editor será dividido em dois 
verticalmente, e se você pressionar (CTRL) + (SHIFT) + (¡), ele será dividido 
em dois horizontalmente. No primeiro caso, você pode querer ter as declarações 
de variáveis no início de um método na caixa superior e o código que usa essas 
variáveis na segunda caixa. Isso ajuda a evitar paginar para cima e para baixo 
ou clicar duas vezes em uma variável para alcançar sua definição. 
 
 
 
 
 
 
Figure 1.19 Splitting the Source Code Editor 
 
Essas melhorias se aplicam a todas as linguagens de programação usadas pelo 
Eclipse. Como o ABAP agora é um membro dessa família feliz, você pode 
aproveitar essas melhorias no instante em que elas forem lançadas, sem esperar 
por uma atualização do seu sistema de back-end. 
 
 
1.3 Testing and Troubleshooting 
Ao longo deste livro, você verá um tema recorrente: novas ferramentas ABAP 
permitem que você teste melhor seus programas, depure-os e analise o que deu 
terrivelmente errado. Esta seção examina cada uma dessas três áreas e discute o 
que o ABAP no Eclipse traz para a mesa. 
 
1.3.1 Unit Testing Code Coverage 
No Capítulo 3, você aprenderá detalhadamente sobre testes unitários em ABAP e 
desenvolvimento orientado a testes como uma filosofia. Em vez de ficar à frente das coisas e 
discutir por que os testes de unidade são uma coisa boa (eles são; eles são a melhor coisa do 
mundo), esta seção falará sobre como o ABAP no Eclipse enfrenta dois dos principais 
problemas com a escrita de unidades testes. 
 
Problem 1: Creating Test Methods is Difficult 
Como você verá, no SE80 existe um assistente para criar métodos de teste a partir 
de seus métodos reais. No entanto, esse é o caminho errado - você deseja criar os 
métodos de teste primeiro. 
 
 
 
Para fazer isso no Eclipse, crie uma nova classe global. Na parte inferior há uma série de 
guias, uma das quais é TEST CLASS. Observe que você ainda não criou nada na classe 
real. Agora, vá para a aba TEST CLASS, digite a palavra “teste” e pressione (CTRL) 
+ (ESPAÇO). 
Você recebe uma pergunta sobre se deseja criar uma solicitação de transporte ou uma 
classe de teste. A classe de teste é a resposta correta e, se você escolher essa opção, verá 
o conteúdo da Listagem 1.13. 
*"* use this source file for your ABAP unit test classes 
CLASS ltcl_definition FINAL FOR TESTING 
DURATION SHORT 
RISK LEVEL HARMLESS. 
 
PRIVATE SECTION. 
METHODS: 
first_test FOR TESTING RAISING cx_static_check. 
ENDCLASS. 
 
 
CLASS ltcl_ IMPLEMENTATION. 
METHOD first_test. 
cl_abap_unit_assert=>fail( 'Implement your first test here' ). ENDMETHOD. 
ENDCLASS. 
Listing 1.13 Source File for ABAP Unit Test Class 
 
Criar um modelo de esqueleto para uma classe de teste não é o santo graal da criação 
de testes de unidade, mas segue o desenvolvimento orientado a testes muito melhor 
do que o processo padrão SE80. Naturalmente, você precisa alterar o código gerado 
para preencher o nome de sua classe de teste e método de teste e adicionar métodos 
de teste extras conforme necessário. O ponto é que você está criando os métodos de 
teste primeiro e depois copiando a definição para a classe real. 
Como você viu na Seção 1.2.3, uma vez que você tenha uma definição, você pode 
gerar o esqueleto da implementação apenas pressionando (CTRL) + (1). O que a 
geração automática deve fazer é adicionar uma definição, como DATA: mo_cut 
TYPE REF TO ycl_ monster_unit_tests. (Isso realmente não funcionou para mim, 
não importa o que eu tentei, então adicionei manualmente. A documentação indica 
que isso deve ser feito automaticamente, então provavelmente será corrigido em uma 
versão posterior. 
No primeiro teste de unidade de monstro renomeado, primeiro defina o resultado 
do teste e, em seguida, adicione a linha mo_cut->first_monster( )., )., que é um método 
na classe principal que ainda não existe. Se você pressionar (CTRL) + (1), será 
perguntado se deseja criar o método na classe real, o que você faz. Lembre-se, 
você criou o teste antes de criar o método real, que é o desenvolvimento orientado 
a testes. 
Em resumo, todo o processo de desenvolvimento orientado a testes é mais rápido 
e fácil (e do jeito certo) ao usar o ABAP no Eclipse do que ao usar o procedimento 
equivalente no ABAP Workbench tradicional. 
Problem 2: You Cannot Tell How Much of the Program Is Being Tested 
O objetivo do teste de unidade é ter a maior certeza humanamente possível de que, 
quando você altera uma parte do seu programa — seja uma correção de bugs ou 
adiciona funcionalidade extra — a mudança não quebra outras partes do programa. 
Na vida real, as pessoas tendem a achar que uma mudança em uma área sempre 
quebra algo em outra área, o que deve ser uma bandeira vermelha para indicar que 
talvez haja algo de errado em criar programas tão frágeis. 
Os testes unitários permitem que você realize testes automatizados de regressão para 
que, quando você alterar até mesmo uma linha de código, você possa ter certeza de 
que você não quebrou algo em outro lugar. Naturalmente, você só pode ser realmente 
seguro se você sabe que cada linha de código sin-gle em cada rotina e método em sua 
aplicação está sujeito a tal regressão teste. Criar tais testes em primeiro lugar não é 
a coisa mais fácil do mundo, e é por isso que tão poucas pessoas fazem isso — isso 
será discutido muito mais no Capítulo 3. No entanto, se você viu a luz e deseja criar 
tais testes, a próxima tarefa é ver quanto do seu código está realmente sendo testado. 
Se essa fig-ure for inferior a 100%, então veja o que pode ser feito sobre isso. 
 Há uma ferramenta disponível em Java chamada Clover, que mede a porcentagem de 
código coberta por testes unitários. Quando li sobre isso, achei que seria muito bom 
para a ABAP e que talvez eu devesse escrever algo nesse sentido. Acontece que eu 
não preciso, porque abap no Eclipse tem apenas uma ferramenta (e, para ser justo, o 
SE80 também nos últimos lançamentos do SAP NetWeaver). 
Na última seção, você criou um método de teste. Agora, você criará o método real, 
que será testado, e então criará outro método real, que não terá um teste de unidade 
correspondente — como se você estivesse sendo impertinente e tentando enganar a si 
mesmo a pensar que criar métodos sem testes economizará tempo. (Eles! Vontade! 
Não!) 
 
 
 
 
 
 
 
Dizem que pequenas coisas agradam às pequenas mentes, mas tenho grande 
prazer em poder escrever a definição do método para o método que não será 
testado, press-ing (CTRL) + (1) e ter a implementação criada para mim, e ter o 
cursor saltar para a implementação. Outro clichê diz que cada segundo conta, e 
se essas ferramentaseconomizam alguns segundos aqui e ali durante todo o seu 
dia de trabalho, então com o tempo tudo isso faz sentido. 
CLASS ycl_monster_unit_tests IMPLEMENTATION. 
 
METHOD first_monster. 
WRITE:/ 'I am the First Monster'. 
ENDMETHOD. 
 
METHOD second_monster. 
WRITE:/ 'I am the Second Monster'. 
ENDMETHOD. 
 
ENDCLASS. "Monster Unit Tests Implementation 
Listing 1.14 The Method that Will Not Be Tested 
 
 Se você estivesse em SE80, agora você f ollow th e menu path PROGRAM • TEST • 
UNIT TEST; o equivalente in ABAP in Eclipse é pressionar (CTRL) + (SHIFT) + (F10). 
Tha t's wonderful; você vai ee any errors that may have cropped up as a result de 
qualquer changes você might ter feito. No entanto, você quer levar thé para o 
próximo nível, então em vez de pressionar (CTRL) + (SHIFT) + (F11). (Eleven é 
obviously a better number than 10, in the same way that they s tarted c alling 
hotéis hotéis seis estrelas sercause cinco stars foram n't god o suficiente anmais.) 
Agora, você verá dois resultados (Figura 1,20). Primeiro, todo o código testado é 
destacado; mais importante, você verá uma exibição resumida, que indica qual 
porcentagem de cada método foi testada pelos testes automatizados da unidade. 
 
Figure 1.20 Unit Test Coverage 
 
Este é o tipo de informação que você quer enfiada em seu rosto como uma torta 
de creme, primeiro porque você quer ter certeza de que todas as partes vitais do 
seu programa estão cobertas por testes de regressão e segundo para se mover 
para garantir que cada linha de código obtenha cobertura de teste. 
 
 
 
 
1.3.2 Debugging 
Uma das melhores características da Bancada abap é o depurador, e o Capítulo 
5 dará uma rápida olhada nas últimas características que entraram no depurador 
recentemente que você pode desconhecer. No momento, porém, o foco está no 
ABAP no Eclipse, então você pode estar se perguntando que relevância a 
depuração tem em um ambiente de desenvolvimento puro. Isso volta aos testes 
da unidade novamente: se você tiver um erro, então você quer depurar o programa 
para ver o que está acontecendo de errado. 
 Há más notícias e boas (embora estranhas) notícias aqui. A má notícia é que, a 
partir do tempo de escrita, o depurador em ABAP no Eclipse não pode fazer tudo 
o que o depurador em um sistema SAP real pode fazer, embora, é claro, com o 
passar do tempo essas lacunas estão sendo plugadas. Agora, a boa notícia — 
embora quando eu lhe digo qual é a boa notícia que você pode pensar "Isso não 
pode ser verdade, ele deve estar drogado" - a boa notícia é que é possível mudar 
o código fonte enquanto ele está em processo de depuração. 
No próximo exemplo, você colocará um erro óbvio em seu código e, em seguida, 
depurar-lo para ver o que está errado. No Reino Unido, usamos a frase "quantos 
feijões fazem cinco", para a qual a resposta é, chocantemente, cinco. Em seu 
programa, você quer adicionar monstros até chegar a cinco, mas você perdeu um e 
por isso só acaba com quatro, o que é um erro claro (Listagem 1. 15). 
CLASS lcl_how_many_monsters DEFINITION. PUBLIC 
SECTION. 
METHODS how_many_make_five RETURNING VALUE(rd_how_many) TYPE i. 
ENDCLASS. "How Many Monsters Definition 
 
CLASS lcl_how_many_monsters IMPLEMENTATION. 
METHOD how_many_make_five. 
DO 100 TIMES. 
ADD 1 TO rd_how_many. IF 
rd_how_many = 4. 
RETURN. 
ENDIF. 
ENDDO. 
ENDMETHOD. 
ENDCLASS. "How Many Monsters implementation 
 
DATA: ld_how_many TYPE i, 
 
 
 
 
lo_counter TYPE REF TO lcl_how_many_monsters. 
 
START-OF-SELECTION. 
CREATE OBJECT lo_counter. 
ld_how_many = lo_counter->how_many_make_five( ). WRITE:/ ld_how_many. 
Listing 1.15 Only Four Monsters 
 
Isso faz com que o teste da unidade falhe, então você depura-o. Enquanto você 
está no depurador, torna-se óbvio o que está errado: você precisa adicionar outra 
linha de código. Neste ponto, normalmente você sairia do depurador, mudaria 
seu programa e, em seguida, testaria ou depuraria novamente após a correção. 
No ABAP no Eclipse, no entanto, é de fato possível alterar o código-fonte enquanto 
ele está sendo depurado; ou seja, você pode adicionar a linha que falta para adicionar 
o monstro final enquanto estiver no depurador e, em seguida, pisar na nova linha para 
ver se tudo funciona como esperado. Esta é uma mudança radical, e quando você vê 
isso pela primeira vez você se pergunta se alguém colocou um pouco de LSD em sua 
bebida. No entanto, isso se encaixa na categoria "estranho, mas verdadeiro" — e 
assim que a SAP trouxe o resto do depurador em ABAP no Eclipse até igual ao 
depurador padrão, esta instalação será um ponto claro no ABAP a favor do Eclipse . 
Assim como no editor abap normal, you pode control onde o programa vai mudar 
para depurargger mode when the pr ogram é run. Você pode adicionar pontos 
macios breakpoints se você assim desire, através do menu ou (CTRL) + (SHIFT) + (
); você também pode put em hard b reak-p oints, such como BREAK BLOGGSJ. 
Quando você run o programa (opção de menu EXECUTAR • EXECUTAR COMO ABAP 
APPLIcATION) ou executar the un tests, como assimon como a breakpoint é reached 
a box will appera and a sk se você want para look no program no modo depuração. 
Como stupid perguntas ir, thé leva o ca k e; obviously você faz, então você diz sim 
e marcar a caixa que faz o sistema lembrar thé wond erful de cision you made. 
A tela do depurador se abre; parece ligeiramente diferente do que você foi usado no 
passado (Figura 1.21). É possivelmente um pouco mais fácil alterar os valores das 
variáveis no tempo de execução (clique duas vezes na caixa em que o valor atual é 
exibido para alterar um valor). 
 
 
 
 
 
 
Se o sistema SAP backend não estiver em um nível alto o suficiente — ou seja, o kernel tem 
que ser pelo menos 721 — você receberá uma mensagem de erro dizendo algo como "ABAP em 
eclipse depuração não está disponível no sistema XYZ, por favor depurar dentro o SAP GUI." 
 
Warning: Houston, We Have a Problem 
 
Figure 1.21 Debugging in Eclipse 
 
Você pode ver o erro; o código sai com um valor de 4, não 5. Mude o estado para 
dizer SE RD_HOW_MANY = 5. Isso não tem efeito sobre a execução atual (que 
seria magia negra), mas quando você terminar e executar o programa novamente, 
tudo está ok; a correção fez efeito. 
Os resultados aparecem no que é chamado de "SAP GUI incorporado", que é uma 
tela SAP padrão que aparece em uma janela Eclipse (Figura 1.22). Você verá 
isso muitas vezes ao trabalhar com o Eclipse; sempre que o Eclipse não puder 
exibir algo (como os resultados de uma instrução WRITE) ele terceirizará a 
tarefa para o SAP GUI. 
 
Figure 1.22 Embedded SAP GUI 
 
 
 
 
 
 
 
 
1.3.3 Runtime Analysis 
De todas as grandes características discutidas até agora, o que realmente se 
destaca sobre o ABAP no Eclipse é a visão gráfica da análise de tempo de 
execução de um programa ABAP. O famoso ditado observa que "uma imagem 
vale mil palavras", mas tradicionalmente a SAP não é conhecida pela qualidade dos 
gráficos dentro da GUI SAP. Você provavelmente está acostumado com a análise de 
tempo de execução dentro da bancada de trabalho ABAP — Trans- ação SE30 ou 
mais recentemente SAT - que fornece informações detalhadas sobre como um 
determinado aplicativo gasta seu tempo de processamento. O problema é que há tanta 
informação que você tende a ficar atolado. Você verá um bom conjunto de três barras 
indicando se o maior tempo é gasto no banco de dados ou no servidor de aplicativos, 
e se acontece que o servidor é o problema, então você tem que tentar lidar com a 
árvore grande que indica quanto tempo é gasto em cada rotina. 
Isso não é o fim do mundo, mas leva algum tempo para se acostumar, e o equiv-alent 
em ABAP no Eclipse é muito mais amigável aos olhos. Para demonstrar isso, a seguir 
é um exemplo bobo no qual uma pequena fração do programa realiza