5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 1/53
FERRAMENTAS DE REFATORAÇÃO: Uma Análise Comparativa
Rodrigo Achilles Pereira
Universidade Federal do Rio de Janeiro
Curso de Pós Graduação
MBA em Engenharia de Software
Orientador: Eduardo Bezerra, D.Sc.
Rio de Janeiro
2011
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 2/53
II
FICHA CATALOGRÁFICA
Pereira, Rodrigo Achilles
Ferramentas de refatoração: Uma Análise Comparativa / RodrigoAchilles Pereira – Rio de Janeiro, 2011.
xi, 42 f.: il.
Monografia (MBA em Engenharia de Software) – UniversidadeFederal do Rio de Janeiro - UFRJ, Escola Politécnica, 2011.
Orientador: Eduardo Bezerra
Capítulo 1: Introdução. Capítulo 2: Visão Geral de Refatoração. Capítulo3: Principais Ferramentas de Refatoração. Capítulo 4: Conclusão. I.Bezerra, Eduardo (Orient.). II. Universidade Federal do Rio de Janeiro.Escola Politécnica. III. Título.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 3/53
III
AGRADECIMENTOS
A Deus em primeiro lugar e a toda a minha família pela compreensão e
incentivo em todas as fases do meu curso.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 4/53
IV
RESUMO
Ferramentas de refatoração auxiliam no desenvolvimento de sistemas de
software com qualidade. Este trabalho consiste em uma análise comparativa
das principais ferramentas de refatoração existentes, considerando sistemas
escritos em linguagem Java. Apresentamos uma visão geral da Refatoração e
técnicas que são usadas para o comparativo entre as ferramentas.
Apresentamos uma reflexão sobre esse comparativo e a importância do auxílio
das ferramentas automáticas para a refatoração.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 5/53
V
ABSTRACT
Refactoring tools assist in developing quality software systems. This
study is a comparative analysis of the main tools for refactoring existing
systems considering written in Java. Here's an overview of Refactoring and
techniques that are used for the comparison between the tools. We present a
comparative reflection on this and the importance of the aid of automatic tools
for refactoring.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 6/53
VI
SUMÁRIO
FICHA CATALOGRÁFICA ............................................................................................................II AGRADECIMENTOS ..................................................................................................................III RESUMO.................................................................................................................................... IV ABSTRACT ................................................................................................................................. V SUMÁRIO................................................................................................................................... VI LISTA DE FIGURAS ................................................................................................................. VIII LISTA DE TABELAS .................................................................................................................... X LISTA DE ABREVIATURAS E SIGLAS ...................................................................................... XI CAPÍTULO 1. INTRODUÇÃO ...............................................................................................1 1.1.
CONTEXTUALIZAÇÃO ................................................................................................. 1
1.2. JUSTIFICATIVA ............................................................................................................. 1 1.3. OBJETIVOS .................................................................................................................. 2 1.4. METODOLOGIA............................................................................................................ 2 1.5. ORGANIZAÇÃO DOS CAPÍTULOS .............................................................................. 2 CAPÍTULO 2. VISÃO GERAL DE REFATORAÇÃO .............................................................4 2.1. REFATORAR É NECESSÁRIO? ................................................................................... 4 2.1.1. REFATORAR MELHORA O PROJETO DO SOFTWARE ............................................. 4 2.1.2. REFATORAR TORNA O SOFTWARE MAIS FÁCIL DE ENTENDER ........................... 5 2.1.3. REFATORAR AJUDA A ENCONTRAR FALHAS ........................................................... 5 2.1.4. REFATORAR AJUDA A PROGRAMAR MAIS RAPIDAMENTE .................................... 5 2.2. TÉCNICAS DE REFATORAÇÃO .................................................................................. 6 2.2.1. EXTRAIR MÉTODO (EXTRACT METHOD) ................................................................. 6 2.2.2. MOVER MÉTODO (MOVE METHOD) .......................................................................... 7 2.2.3. EXTRAIR CLASSE (EXTRACT CLASS) ....................................................................... 8 2.2.4. ENCAPSULAR ATRIBUTO (ENCAPSULATE FIELD) ................................................. 10 2.2.5. RENOMEAR MÉTODO (RENAME METHOD) ............................................................ 10 2.2.6. MOVER CLASSE (MOVE CLASS) ............................................................................. 11 2.2.7. DESCER MÉTODO (PUSH DOWN METHOD) .......................................................... 12 2.2.8. DESCER ATRIBUTO (PUSH DOWN FIELD) .............................................................. 13 2.2.9. EXTRAIR SUPERCLASSE (EXTRACT SUPERCLASS) ............................................ 14 CAPÍTULO 3. PRINCIPAIS FERRAMENTAS DE REFATORAÇÃO ....................................16 3.1. CRITÉRIOS TÉCNICOS PARA UMA FERRAMENTA DE REFATORAÇÃO ............... 16 3.1.1. BANCO DE DADOS DO PROGRAMA ....................................................................... 16 3.1.2. ÁRVORES DE ANÁLISE SEMÂNTICA ....................................................................... 17 3.1.3. ACURÁCIA.................................................................................................................. 17 3.2. CRITÉRIOS PRÁTICOS PARA UMA FERRAMENTA DE REFATORAÇÃO ................ 18
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 7/53
VII
3.2.1. VELOCIDADE ............................................................................................................. 18 3.2.2. DESFAZER ................................................................................................................. 18 3.2.3. INTEGRADA COM FERRAMENTAS .......................................................................... 18 3.3.
ECLIPSE IDE .............................................................................................................. 19
3.4. INTELLIJ IDEA ............................................................................................................ 21 3.5. NETBEANS IDE .......................................................................................................... 22 3.6. TESTES REALIZADOS............................................................................................... 24 3.6.1. RENOMEANDO .......................................................................................................... 25 3.6.2. MOVENDO UMA CLASSE .......................................................................................... 27 3.6.3. ENCAPSULANDO UM ATRIBUTO ............................................................................. 28 3.6.4. EXTRAIR SUPERCLASSE ......................................................................................... 30 3.6.5. EXTRAINDO UM MÉTODO ........................................................................................ 32 3.6.6. EM LINHA (INLINE) .................................................................................................... 34 3.6.7. COMANDO “DESFAZER” (CTRL+Z) .......................................................................... 35 3.6.8. TÉCNICAS DE REFATORAÇÃO NÃO UTILIZADAS .................................................. 37 3.7. DESTAQUES .............................................................................................................. 37 3.7.1. FUNCIONALIDADE “HISTÓRICO” ............................................................................. 37 3.7.2. FUNCIONALIDADE “EXCLUSÃO SEGURA”.............................................................. 39 CAPÍTULO 4. CONCLUSÃO ..............................................................................................40 4.1. ANÁLISE RETROSPECTIVA ...................................................................................... 40 4.2. TRABALHOS FUTUROS ............................................................................................ 41 REFERÊNCIAS ..........................................................................................................................42
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 8/53
VIII
LISTA DE FIGURAS
FIGURA 2-1 DIAGRAMA REPRESENTANDO UM EXEMPLO DE CLASSES EM QUE PODEMOS APLICAR A
REFATORAÇÃO DESCER MÉTODO (OBTIDA EM (FOWLER, 2010)) ...................................................12 FIGURA 2-2 DIAGRAMA REPRESENTANDO AS CLASSES QUE FORAM APLICADAS A REFATORAÇÃO DESCER
MÉTODO (OBTIDA EM (FOWLER, 2010)) .......................................................................................13 FIGURA 2-3 DIAGRAMA REPRESENTANDO UM EXEMPLO DE CLASSES EM QUE PODEMOS APLICAR A
REFATORAÇÃO DESCER ATRIBUTO (OBTIDA EM (FOWLER, 2010)) ..................................................13 FIGURA 2-4 DIAGRAMA REPRESENTANDO AS CLASSES QUE FORAM APLICADAS A REFATORAÇÃO DESCER
ATRIBUTO (OBTIDA EM (FOWLER, 2010)) .....................................................................................14 FIGURA 2-5 DIAGRAMA REPRESENTANDO UM EXEMPLO DE CLASSES EM QUE PODEMOS APLICAR A
REFATORAÇÃOE
XTRAIRS
UPERCLASSE(O
BTIDA EM(FOWLER,
2010)) ..........................................15
FIGURA 2-6 DIAGRAMA REPRESENTANDO AS CLASSES QUE FORAM APLICADAS A REFATORAÇÃO EXTRAIR
SUPERCLASSE (OBTIDA EM (FOWLER, 2010)) ..............................................................................15 FIGURA 3-1 ÁRVORE SEMÂNTICA PARA O MÉTODO “ALÔ MUNDO!” (OBTIDA EM (FOWLER, 2004)) .....17 FIGURA 3-2 MENU DO ECLIPSE ......................................................................................................20 FIGURA 3-3 MENU DO INTELLIJ ......................................................................................................22 FIGURA 3-4 MENU DO NETBEANS ..................................................................................................24 FIGURA 3-5 FERRAMENTA PARA APLICAR A TÉCNICA DE REFATORAÇÃO RENOMEAR NO ECLIPSE ..........25 FIGURA 3-6 PAINEL DE PRÉ-VISUALIZAÇÃO DO ECLIPSE MOSTRANDO AS FUTURAS ALTERAÇÕES PARA A
TÉCNICA DE REFATORAÇÃO RENOMEAR ..........................................................................................26 FIGURA 3-7 PAINEL DO ECLIPSE PARA A SELEÇÃO DO PACOTE FUTURO ONDE SERÁ MOVIDA A CLASSE
DESEJADA ....................................................................................................................................27 FIGURA 3-8 CÓDIGO-FONTE DE COMO ERA ANTES DA REFATORAÇÃO ENCAPSULAR UM ATRIBUTO .......28 FIGURA 3-9 CÓDIGO-FONTE DE COMO FICOU APÓS A REFATORAÇÃO ENCAPSULAR UM ATRIBUTO ........28 FIGURA 3-10 PAINEL DE PRÉ-VISUALIZAÇÃO DO ECLIPSE MOSTRANDO AS FUTURAS ALTERAÇÕES PARA A
TÉCNICA DE REFATORAÇÃO ENCAPSULAR ATRIBUTO ........................................................................29 FIGURA 3-11 PAINEL DO INTELLIJ QUE MOSTRA ATRIBUTOS E SUAS INFORMAÇÕES QUE PODERÃO SER
ENCAPSULADAS............................................................................................................................30 FIGURA 3-12 CÓDIGO-FONTE DE COMO ERA ANTES DA REFATORAÇÃO EXTRAIR SUPERCLASSE...........31 FIGURA 3-13 CÓDIGO-FONTE DE COMO FICOU APÓS A REFATORAÇÃO EXTRAIR SUPERCLASSE ...........32 FIGURA 3-14 CÓDIGO-FONTE DE COMO ERA ANTES DA REFATORAÇÃO EXTRAIR MÉTODO ...................33 FIGURA 3-15 CÓDIGO-FONTE DE COMO FICOU APÓS A REFATORAÇÃO EXTRAIR MÉTODO....................33 FIGURA 3-16 CÓDIGO-FONTE DE COMO ERA ANTES DA REFATORAÇÃO EM LINHA ...............................34 FIGURA 3-17 CÓDIGO-FONTE DE COMO FICOU APÓS A REFATORAÇÃO EM LINHA ................................35 FIGURA 3-18 MENU DO NETBEANS ONDE MOSTRA O COMANDO DESFAZER DESABILITADO E O SUB-MENU
DESFAZER ADICIONADO NO MENU REFATORAR.................................................................................36 FIGURA 3-19 MENU DO ECLIPSE PARA ACESSO À FUNCIONALIDADE HISTÓRICO .................................37
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 9/53
IX
FIGURA 3-20 PAINEL DE EXIBIÇÃO DA FUNCIONALIDADE “HISTÓRICO” NO ECLIPSE .............................38 FIGURA 3-21 PAINEL DO NETBEANS UTILIZADO PARA A REFATORAÇÃO EXCLUSÃO SEGURA ................39
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 10/53
X
LISTA DE TABELAS
TABELA 3-1 ..................................................................................................................................20 TABELA 3-2 ..................................................................................................................................21 TABELA 3-3 ..................................................................................................................................23
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 11/53
XI
LISTA DE ABREVIATURAS E SIGLAS
XP – Programação Extrema (eXtreme Programming)
IDE – Ambiente Integrado de Desenvolvimento (Integrated Development Environment)
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 12/53
1
CAPÍTULO 1. INTRODUÇÃO
1.1. CONTEXTUALIZAÇÃO
A Programação Extrema (eXtreme Programming , XP) é uma proposta
de desenvolvimento ágil e iterativa. O método visa ser um processo de
desenvolvimento leve, centrado no desenvolvimento iterativo e com a entrega
constante de pequenas partes da funcionalidade do software. Essas partes
devem ser incrementadas e requerem a melhoria constante do código (re-
trabalho). Segundo (BECK, 2000) XP é uma maneira leve, eficiente, de baixo
risco, flexível, previsível, científica e divertida de desenvolver software.Uma das práticas recomendadas da Programação extrema é a
refatoração visando melhorar o código deixando mais limpo e fácil
compreensão. Refatoração ganhou força atualmente, pois ajuda na integração
das entregas das funcionalidades do software, na manutenção e no
entendimento do código.
Imagine refatorar um sistema no qual o desenvolvedor não tem
conhecimento de refatoração e não se preocupou em organizar e arrumar oscódigos por ele produzidos. Para ele o que importa é apenas no hoje, no modo
de funcionamento do sistema sem se preocupar com a manutenção que
ocorrerá. Manutenção essa que poderá ser realizada por outros
desenvolvedores ou até mesmo o responsável pelo desenvolvimento desse
código. Um sistema simples pode não ter a necessidade disso, mas um
sistema coorporativo com grade número de linhas de códigos e com inúmeras
classes interligadas terá mais necessidade de refatoração.
1.2. JUSTIFICATIVA
Em uma empresa de grande porte sistemas são desenvolvidos e
manutenidos por diversos desenvolvedores com jeitos diferentes em codificar
os códigos de um sistema. Uma boa escolha na ferramenta de
desenvolvimento vem para ajudar que esses desenvolvedores minimizem suas
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 13/53
2
manias e padronizem, ao máximo, os códigos descritos. Com métodos
existentes de refatoração e com o auxílio de ferramentas automatizadas uma
empresa poderá criar uma identidade na codificação de seus sistemas.
Este trabalho visa auxiliar à escolha da ferramenta de refatoração que
dentre os aspectos apresentados se adaptaria à realidade da empresa.
1.3. OBJETIVOS
O objetivo principal deste trabalho é fazer um comparativo entre as
ferramentas de refatoração mais usadas no mercado para auxiliar e
automatizar a refatoração. Essa análise envolve pesquisar o desempenho dasferramentas e mostrar os critérios técnicos e práticos de cada uma delas.
1.4. METODOLOGIA
Foi escolhido um sistema acadêmico simples, que foi utilizado como
um exemplo prático, para que sejam aplicadas as técnicas de refatoração. Ao
aplicar as técnicas, serão colhidos dados significativos para a análisecomparativa entre as ferramentas automatizadas apresentadas.
A idéia é melhorar o código fonte do sistema proposto e saber se as
técnicas de refatoração aliadas com as ferramentas obtiveram seus resultados
esperados.
1.5. ORGANIZAÇÃO DOS CAPÍTULOS
Esta monografia está dividida em quatro capítulos, conforme descrito a
seguir.
Neste 0 foi apresentado o contexto na qual o trabalho se encontra a
justificativa pela qual foi feita sua escolha, os objetivos que se pretende
alcançar após sua conclusão e a metodologia de trabalho que foi utilizada.
No CAPÍTULO 2 encontra-se uma visão geral de refatoração e suas
principais técnicas, pois é através deste que as ferramentas construídas estão
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 14/53
3
baseadas.
No CAPÍTULO 3 é feito uma análise das principais ferramentas
existentes no mercado que auxiliam de forma automatizada os processos de
refatoração.
Por fim, no 0, é apresentada uma reflexão sobre o que foi discutido
além de um comparativo das ferramentas demonstradas.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 15/53
4
CAPÍTULO 2. VISÃO GERAL DE REFATORAÇÃO
Este Capítulo apresenta uma visão geral sobre os conceitos e técnicas
de refatoração. A Seção 2.1 apresenta de modo geral a real necessidade de se
refatorar, mostrando o que temos a ganhar com isso. A Seção 2.2 apresenta
algumas das principais técnicas de refatoração existentes.
Refatoração é o processo de transformação de um código confuso para
um código limpo e claro utilizando técnicas e padronização no
desenvolvimento. Vale ressaltar que a intenção da refatoração não é atuar no
funcionamento do sistema e sim na estrutura de como foi desenvolvimento
internamente para melhorar futuras manutenções no código do sistema. Um
aspecto importante de uma refatoração é que ela melhora o design sem mudar
a semântica do design; uma refatoração não adiciona nem remove
funcionalidade.
Segundo (FOWLER, 2004), refatoração é o processo de alteração de
um sistema de software de modo que o comportamento externo do código não
mude, mas que sua estrutura interna seja melhorada.
Podemos citar outro ponto da idéia de (FOWLER, 2004), refatorar équando descobre que a decisão de ontem não faz sentido hoje, você muda
essa decisão. Agora você pode fazer o trabalho de hoje. Amanhã, parte da sua
compreensão atual parecerá ingênua, então você irá alterá-la também.
2.1. REFATORAR É NECESSÁRIO?
Para responder tal pergunta precisamos olhar pro código e avaliarquais os benefícios da refatoração, qual ganho em alterar o código que muitas
vezes está “funcionando conforme o esperado”.
Abaixo é visto alguns benefícios da refatoração:
2.1.1. REFATORAR MELHORA O PROJETO DO SOFTWARE
Quando se fala em melhora no projeto de software, se fala em
melhorar o entendimento do código para futuras manutenções. Um projeto sem
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 16/53
5
refatoração tende a deteriorar, ficando cada vez mais difícil a sua manipulação.
Segundo (FOWLER, 2004), quanto mais difícil é visualizar o projeto a
partir do código, mais difícil será preservá-lo e mais rapidamente ele se
desestruturará.
Na refatoração para que não haja essa deterioração do código é
desejável que seja eliminado todas as duplicações no código. Eliminando as
cópias de código, é garantido que este desempenhará o seu papel correto no
lugar certo apenas uma vez, facilitando também a reutilização.
2.1.2. REFATORAR TORNA O SOFTWARE MAIS FÁCIL DE ENTENDER
Muitas vezes nos deparamos com códigos difíceis de entender, códigos
esses que às vezes foram escritos por nós mesmos. Com o passar do tempo,
numa futura manutenção, nós não conseguimos lembrar-se da real
funcionalidade, com isso perdemos um tempo enorme para reaprender aí sim
alterá-lo.
A refatoração é essencial nesse caso, pois ajuda a esclarecer o código,
deixando-o mais limpo e inteligível.
2.1.3. REFATORAR AJUDA A ENCONTRAR FALHAS
Com códigos bem estruturados e com sua função bem definida
achamos falhas com rapidez e eficácia. Para que isso ocorra é necessário que
esteja refatorado.
Em um projeto de porte grande, com muitos desenvolvedores
envolvidos, cada um com seu jeito de programar, é fundamental que haja umapadronização na codificação. Problemas sempre surgirão e para que isso não
atrapalhe uma futura manutenção precisamos ter essa disciplina. Segundo
Kent Beck, apud (FOWLER, 2004) "Não sou um grande programador; sou
apenas um bom programador com ótimos hábitos."
2.1.4. REFATORAR AJUDA A PROGRAMAR MAIS RAPIDAMENTE
Quando um código está mais fácil de entender, quando encontramos
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 17/53
6
falhas rapidamente, quando um projeto está bem estruturado conseguimos
nesse caso produzir novas funcionalidades com facilidade.
O desenvolvimento fica agilizado quando utilizamos todas as técnicas
disponíveis. Temos enormes ganhos na refatoração. Um dos pontos fortes é a
reusabilidade na qual utilizamos classes e métodos bem definidos.
Para consolidar a real necessidade da refatoração podemos citar Kent
Beck (FOWLER, 2004), se você consegue fazer hoje o trabalho de hoje, mas o
faz de uma maneira na qual possivelmente não conseguirá fazer amanhã o
trabalho de amanhã, é considerado perdido.
2.2. TÉCNICAS DE REFATORAÇÃO
As técnicas de refatoração não são simplesmente modelos para
manutenção de códigos. Ao aplicar uma técnica o comportamento do sistema
deve-se manter inalterado sem perdas na estrutura do programa.
As técnicas de refatoração incluem, entre outras coisas, metodologias
para detectar possíveis problemas no código.
Para aplicar refatoração podemos utilizar inúmeras técnicas. SegundoMartin Fowler existe mais de 70 técnicas para refatorar um código, entre elas
podemos destacar:
2.2.1. EXTRAIR MÉTODO (EXTRACT METHOD)
Extrair Método é uma operação de refatoração que fornece uma
maneira fácil de criar um novo método a partir de um fragmento de código em
um membro existente. Isso ocorre porque você tem um fragmento de código
que pode ser agrupado.
Abaixo podemos ver um exemplo de um código-fonte transformado
pela refatoração Extrair Método.
void printOwing() {
printBanner();
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 18/53
7
// print details
System.out.println("name: " + _name);
System.out.println("amount " + getOutstanding());
}
Após a refatoração o código deverá se transformar como mostrado
abaixo.
void printOwing() {
printBanner();
printDetails(getOutstanding());
}
void printDetails(double outstanding) {
System.out.println("name: " + _name);
System.out.println("amount " + outstanding);
}
2.2.2. MOVER MÉTODO (MOVE METHOD)
Mover Método é uma operação de refatoração que fornece uma
maneira de criar um novo método em um corpo semelhante na classe que ele
usa mais. Ou transformar o velho método em uma simples delegação, ou
removê-lo completamente. Isso ocorre porque um método será usado por mais
recursos de outra classe do que a classe em que ela está definida.
Abaixo podemos ver um exemplo de um código-fonte transformado
pela refatoração Mover Método.
class Project {
Person[] participants;
}
class Person {
int id;
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 19/53
8
boolean participate(Project p) {
for (int i = 0; i < p.participants.length; i++) {
if (p.participants[i].id == id)
return (true);
}
return (false);
}
}
Após a refatoração o código deverá se transformar como mostrado
abaixo.
class Project {
Person[] participants;
boolean participate(Person x) {
for (int i = 0; i < participants.length; i++) {
if (participants[i].id == x.id)
return (true);
}
return (false);
}
}
class Person {
int id; }
2.2.3. EXTRAIR CLASSE (EXTRACT CLASS)
Extrair Classe é uma operação de refatoração que fornece uma
maneira de criar uma nova classe e mover os atributos relevantes e métodos
da classe antiga para a nova classe. Isso ocorre porque você tem uma classe
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 20/53
9
fazendo um trabalho que deve ser feito por dois.
Abaixo podemos ver um exemplo de um código-fonte transformado
pela refatoração Extrair Classe.
class Person {
int id;
String name;
int areaCode;
int number;
boolean participate(Project p) {..}
}
Após a refatoração o código deverá se transformar como mostrado
abaixo.
class Person {
int id;
String name;
TelephoneNumber telephone = new TelephoneNumber();
boolean participate(Project p) {..}
}
class TelephoneNumber {
public int areaCode; public int number;
public TelephoneNumber() {
}
}
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 21/53
10
2.2.4. ENCAPSULAR ATRIBUTO (ENCAPSULATE FIELD)
Encapsular Atributo é uma operação de refatoração que fornece uma
maneira de tornar um atributo privado e fornecer acessibilidade a esse atributo.Isso ocorre porque há um atributo público.
Abaixo podemos ver um exemplo de um código-fonte transformado
pela refatoração Encapsular Atributo.
public String _name
Após a refatoração o código deverá se transformar como mostradoabaixo.
private String _name;
public String getName() {return _name;}
public void setName(String arg) {_name = arg;}
2.2.5. RENOMEAR MÉTODO (RENAME METHOD)
Renomear Método é uma operação de refatoração que fornece uma
maneira de alterar o nome do método. Isso ocorre porque o nome do método
não revela o seu propósito. Esta operação é a mais usada na refatoração e
nela possibilita que todo o sistema esteja coerente com a nova nomenclatura. É
muito útil utilizar uma ferramenta automatizada evitando erros gerados
desnecessariamente.Abaixo podemos ver um exemplo de um código-fonte transformado
pela refatoração Renomear Método.
class Department {
Project project = new Project();
public void showProjects() {
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 22/53
11
System.out.println(project.showInformation());
}
}
class Project {
String name;
public String showInformation() {..}
}
Após a refatoração o código deverá se transformar como mostrado
abaixo.
class Department {
Project project = new Project();
public void showProjects() {
System.out.println(project.show());
}
}
class Project {
String name;
public String show() {..}
}
2.2.6. MOVER CLASSE (MOVE CLASS)
Mover Classe é uma operação de refatoração que fornece que mova a
classe para um pacote mais relevante a sua funcionalidade. Isso ocorre porque
há uma classe que está em um pacote que não está relacionado com a função
que ele exerce.
Abaixo podemos ver um exemplo de um código-fonte transformado
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 23/53
12
pela refatoração Mover Classe.
package org.davison.ui
// imports
public class StringUtil
...
Após a refatoração o código deverá se transformar como mostrado
abaixo.
package org.davison.util
// imports
public class StringUtil
...
2.2.7. DESCER MÉTODO (PUSH DOWN METHOD)
Descer método é uma operação de refatoração que fornece uma
maneira de mover o método para as subclasses. Isso ocorre porque o
comportamento em uma superclasse é relevante apenas para algumas de suas
subclasses.
Na Figura 2-1 podemos ver um exemplo de caso em que a refatoração
pode atuar.
Figura 2-1 Diagrama representando um exemplo de classes em que podemos aplicar a
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 24/53
13
refatoração Descer Método (Obtida em (FOWLER, 2010))
Após a refatoração, perceba na Figura 2-2 que o método foi transferido
para a classe escolhida, no caso para uma de suas classes filhas na herança.
Figura 2-2 Diagrama representando as classes que foram aplicadas a refatoração Descer
Método (Obtida em (FOWLER, 2010))
2.2.8. DESCER ATRIBUTO (PUSH DOWN FIELD)
Descer atributo é uma operação de refatoração que fornece umamaneira de mover o atributo para as subclasses. Isso ocorre porque um
atributo é usado apenas por algumas subclasses.
Na Figura 2-3 podemos ver um exemplo de caso em que a refatoração
pode atuar.
Figura 2-3 Diagrama representando um exemplo de classes em que podemos aplicar a
refatoração Descer Atributo (Obtida em (FOWLER, 2010))
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 25/53
14
Após a refatoração, perceba na Figura 2-4 que o atributo foi transferido
para a classe escolhida, no caso para uma de suas classes filhas na herança.
Figura 2-4 Diagrama representando as classes que foram aplicadas a refatoração Descer
Atributo (Obtida em (FOWLER, 2010))
Esta refatoração é muito parecida com o item 2.2.7, elas tem a mesma
idéia, porém muda apenas a sua finalidade. Enquanto uma refatoração se
referencia no método esta tem o foco no atributo.
2.2.9. EXTRAIR SUPERCLASSE (EXTRACT SUPERCLASS)
Extrair superclasse é uma operação de refatoração que fornece uma
maneira de criar uma superclasse e mover as características comuns para a
superclasse. Isso ocorre porque você tem duas classes com características
semelhantes.
Na Figura 2-5 podemos ver um exemplo de caso em que a refatoração
pode atuar.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 26/53
15
Figura 2-5 Diagrama representando um exemplo de classes em que podemos aplicar a
refatoração Extrair Superclasse (Obtida em (FOWLER, 2010))
Após a refatoração, perceba na Figura 2-6 que as duas classes do
exemplo viraram filhas de uma terceira. Foi utilizada a herança para auxiliar no
melhor entendimento das classes.
Figura 2-6 Diagrama representando as classes que foram aplicadas a refatoração Extrair
Superclasse (Obtida em (FOWLER, 2010))
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 27/53
16
CAPÍTULO 3. PRINCIPAIS FERRAMENTAS DE REFATORAÇÃO
Neste Capítulo, apresentaremos uma visão geral sobre as ferramentas
de refatoração que iremos comparar e os testes realizados para a análise da
comparação. Na Seção 3.1 apresenta alguns critérios técnicos que uma
ferramenta de refatoração deve conter. Na Seção 3.2 apresenta alguns critérios
práticos que uma ferramenta de refatoração deve conter. Na Seção 3.4
apresenta uma visão geral da ferramenta IntelliJ IDEA e o suporte à refatoração
que nela é disponibilizada. Na Seção 3.5 apresenta uma visão geral da
ferramenta NetBeans e o suporte à refatoração que nela é disponibilizada. Na
Seção 3.3 apresenta uma visão geral da ferramenta Eclipse e o suporte à
refatoração que nela é disponibilizada. Na Seção 3.6 mostra os testes
realizados com as ferramentas e suas análises.
3.1. CRITÉRIOS TÉCNICOS PARA UMA FERRAMENTA DE REFATORAÇÃO
Nesta seção, apresentamos alguns critérios técnicos de como uma
ferramenta deve se comportar para desenvolver as refatorações sem perdaspara o funcionamento do projeto.
3.1.1. BANCO DE DADOS DO PROGRAMA
Esse item é importante para identificar a semântica da linguagem de
programação no projeto a ser refatorado. Por exemplo, saber identificar que o
atributo busca é diferente do método busca e que a alteração deste método
não altere os atributos com o mesmo nome no contexto do projeto, onde há
inúmeras classes interligadas.
Para isso a ferramenta deve conter todas as informações armazenadas
referente ao projeto e cada alteração deve ser alterada sem que haja perda de
desempenho. Esse processo deve ser transparente para o usuário.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 28/53
17
3.1.2. ÁRVORES DE ANÁLISE SEMÂNTICA
Árvores de análise semântica são estruturas de dados referentes ao
código fonte do projeto. Nela encontramos as ligações e representações detodo código e é por ela que a ferramenta deve se basear para a busca de um
determinado.
Com um exemplo simples considere o seguinte método:
public void alo() {
System.out.println(“Alô Mundo!”);
}
A árvore de análise semântica correspondente a esse código se parece
com a Figura 3-1, mostrada abaixo.
Figura 3-1 Árvore semântica para o método “Alô Mundo!” (Obtida em (FOWLER, 2004))
3.1.3. ACURÁCIA
É a preservação do comportamento do projeto, da funcionalidade, sem
que a refatoração automatizada gere um erro inesperado.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 29/53
18
Quando acontecer problemas na refatoração, esta deve ser feita de
forma manual e com a atenção para que o erro não volte a acontecer.
3.2. CRITÉRIOS PRÁTICOS PARA UMA FERRAMENTA DE REFATORAÇÃO
Serão discutidos a seguir alguns critérios práticos de como uma
ferramenta deve se comportar para desenvolver as refatorações sem perdas
para o funcionamento do projeto.
3.2.1. VELOCIDADE
Critério importante para se fazer uma refatoração automatizada, pois
isso pode ser fundamental para que o mercado continue utilizando uma
determinada ferramenta. Quanto mais tempo perdido numa refatoração, menos
o desenvolvedor confiará na ferramenta.
3.2.2. DESFAZER
Uma ferramenta de refatoração deve contar a opção de desfazer quesignifica voltar o código fonte como era antes da refatoração em todas as
classes alteradas. Essa opção é fundamental para que a ferramenta passe
confiabilidade e segurança ao fazer uma refatoração.
Segundo (Fowler, 2004) a ferramenta Refactoring Browser, a primeira
utilizada por ele, não tinha essa opção de desfazer. Caso o desenvolvedor se
arrependesse da refatoração por algum motivo, mesmo se o comportamento do
sistema não fosse alterado e a refatoração estivesse correta, não conseguiriavoltar atrás.
Nesse caso é ruim, pois refatorações sem sentido acarretariam em
mais problemas em vez de ajudar o desenvolvedor.
3.2.3. INTEGRADA COM FERRAMENTAS
As ferramentas de refatoração devem estar acopladas a um Ambiente
de Desenvolvimento Integrado (IDE - Integrated Development Environment)
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 30/53
19
facilitando o desenvolvimento e a refatoração. Isso auxilia para que o
desenvolvedor não sofra com as refatorações, se tornando cada vez mais
comum tanto quanto desenvolver. Refatorações não serão vistas como algo
custoso e trabalhoso, com tempo fará parte do cotidiano dos projetos.
Atualmente a maioria dos Ambientes de Desenvolvimento já contém
essa ferramenta de refatoração integrada, com todas as facilidades. Serão
apresentados alguns dos principais Ambientes abaixo.
A ferramenta Refactoring Browser é citada por (FOWLER, 2004) que
nada mais é que um editor que automatiza refatorações. Essa ferramenta por
ser antiga e as IDEs atuais já vem com plug-ins para a refatoração não
apresentaremos nesse trabalho.
3.3. ECLIPSE IDE
Eclipse é uma comunidade de fonte aberta, cujos projetos estão
focados na construção de uma plataforma de desenvolvimento aberta
composta por extensíveis frameworks, ferramentas e tempos de execução para
a construção, implementação e gerenciamento de software em todo o ciclo devida.
O projeto Eclipse foi originalmente criado pela IBM em Novembro de
2001 e apoiado por um consórcio de fornecedores de software. A Fundação
Eclipse foi criado em janeiro de 2004 como uma corporação sem fins lucrativos
independente para atuar como o mordomo da comunidade Eclipse. Hoje, a
comunidade Eclipse consiste de indivíduos e organizações a partir de uma
seção transversal da indústria de software.Para o comparativo foram feitos testes com a configuração do software
mostrada na Tabela 3-1.
Eclipse
Desenvolvedor Eclipse Foundation
Plataforma x64
Versão utilizada 3.7
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 31/53
20
Escrito em Java
Sistema Operacional Microsoft Windows 7
Licença Licença Pública Eclipse
Página oficial http://www.eclipse.org/
Tamanho 212 MB
Tabela 3-1
Na Figura 3-2 mostramos o suporte às técnicas de refatoração que a
ferramenta disponibiliza em sua IDE.
Figura 3-2 Menu do Eclipse
Como visto na imagem o Eclipse apresenta uma grande variedade de
técnicas de refatoração e um ótimo suporte para ajudar o desenvolvedor de
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 32/53
21
maneira rápida e simples na codificação.
3.4. INTELLIJ IDEA
IntelliJ IDEA é uma ferramenta comercial de Java IDE construída pela
empresa JetBrains em janeiro de 2001, na época a única IDE disponível com
avançado código de navegação e refatoração de código integradas. A
ferramenta é divida em duas IDEs a IntelliJ IDEA Ultimate (comercial e testável
por 30 dias) e a IntelliJ IDEA Community Edition (livre e aberta ao público).
Para o comparativo utilizamos nos testes a IntelliJ IDEA Community
Edition com a configuração do software mostrada na Tabela 3-2.
IntelliJ IDEA
Desenvolvedor JetBrains
Plataforma x64
Versão utilizada 10.5.1
Escrito em Java
Sistema Operacional Microsoft Windows 7
Licença Apache 2.0 for Community Edition
Página oficial http://www.jetbrains.com/idea/
Tamanho 89,2 MB
Tabela 3-2
Na Figura 3-3 mostramos o suporte às técnicas de refatoração que a
ferramenta disponibiliza em sua IDE.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 33/53
22
Figura 3-3 Menu do IntelliJ
Como falado anteriormente, a primeira IDE que deu suporte a
refatoração, a IntelliJ IDEA não poupou esforços em manter a grande maioria
das técnicas de refatoração superando as outras IDEs. Nela são apresentadas
as principais técnicas e um suporte excelente ao desenvolvedor.
3.5. NETBEANS IDE
NetBeans é um projeto Open Source com uma ampla base de
usuários, uma comunidade crescente, perto dos 100 parceiros pelo mundo. A
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 34/53
23
Sun Micro system fundou o projeto Open Source NetBeans em junho de 2000 e
continua sendo seu principal patrocinador.
O NetBeans IDE é um ambiente de desenvolvimento - uma ferramenta
para programadores escrever, compilar, depurar e implantar programas. É
escrito em Java - mas pode suportar qualquer linguagem de programação.
Existe também um enorme número de módulos para aprimorar o NetBeans
IDE. O NetBeans IDE é um produto gratuito sem restrições de como ser
utilizado.
Para o comparativo foram feitos testes com a configuração do software
mostrada na Tabela 3-3.
NetBeans
Desenvolvedor Oracle Corporation
Plataforma x64
Versão utilizada 7.0
Escrito em Java
Sistema Operacional Microsoft Windows 7
Licença FreewarePágina oficial http://netbeans.org/
Tamanho 243 MB
Tabela 3-3
Na Figura 3-4 mostramos o suporte às técnicas de refatoração que a
ferramenta disponibiliza em sua IDE.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 35/53
24
Figura 3-4 Menu do NetBeans
Apesar da IDE ser robusta em vários aspectos para o desenvolvedor
seu suporte à refatoração é pouco explorado, com técnicas reduzidas em
comparação as outras ferramentas. O foco da refatoração é somente das
principais técnicas.
3.6. TESTES REALIZADOS
Os testes realizados nas ferramentas são simples e visa analisar o
comportamento de todas as IDE com o resultado esperado, com a usabilidade,
com a velocidade das alterações e com o suporte a determinada técnica de
refatoração.
Como algumas técnicas de refatoração não são suportadas pelo
NetBeans vamos demonstrar nesse primeiro momento as técnicas em comum
as três IDEs. Por fim, comentaremos das técnicas que estão faltando na
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 36/53
25
ferramenta que por esse motivo, não puderam ser testadas.
3.6.1. RENOMEANDO
A refatoração Renomear é uma das mais úteis técnicas utilizadas
atualmente. Ela permite renomear variáveis, classes, métodos, pacotes, pastas
e quase todos os identificadores. Ao renomear um identificador, todas as
referências a esse identificador também são renomeadas.
Na IDE Eclipse o atalho para se utilizar a refatoração Renomear é o
Alt+Shift+R. Ao invocar o atalho em um método, no editor Eclipse, uma
pequena caixa mostra, dentro do próprio editor, onde é possível alterar o nome
do método, como mostra a Figura 3-5. Digitando o novo nome e pressionando
Enter, todas as referências a esse método também são alteradas.
Figura 3-5 Ferramenta para aplicar a técnica de refatoração Renomear no Eclipse
Um dos destaques para a refatoração é o painel de pré-visualização
como mostra a Figura 3-6. São mostradas com detalhes todas as classes e
chamadas a esse método, assim como o código fonte de como será após a
refatoração. Isto é uma excelente opção para confirmar o trabalho que será
realizado antes da sua efetivação. Sua utilização não é obrigatório o que facilita
na velocidade e praticidade da refatoração.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 37/53
26
Figura 3-6 Painel de pré-visualização do Eclipse mostrando as futuras alterações para a
técnica de refatoração Renomear
Na IDE IntelliJ o atalho para utilizar a refatoração Renomear é Shift+F6.
Diferentemente do que aconteceu com o Eclipse ao acionar o atalho aparecerá
uma caixa de diálogo para que seja incluído um novo nome. Nesse caso seperde um pouco a questão da praticidade e dinamismo do software.
Assim como no Eclipse, a IDE disponibiliza para o desenvolvedor a
opção de pré-visualização, porém não tão detalhada quanto.
Na IDE NetBeans o atalho para utilizar a refatoração Renomear é
Ctrl+R. Ao acionar o atalho a refatoração acontece exatamente igual ao Eclipse
no que tange a questão de alteração dentro do próprio editor, porém não existe
a possibilidade de pré-visualização. A pré-visualização estará disponível
somente quando é acessado pelo sub-menu Renomear dentro do menu
Refatorar. Esta opção não perde em nada para o Eclipse que também mostra
as futuras alterações, o antes e o depois da efetivação da refatoração além da
opção de prosseguir ou cancelar a ação.
A refatoração em todas as IDEs foi realizada como esperada e sem
problemas em sua execução. Destaque para o Eclipse e NetBeans que
pudemos renomear no próprio editor de maneira rápida e eficiente.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 38/53
27
3.6.2. MOVENDO UMA CLASSE
A refatoração Mover também é muito útil e utilizamos para mover uma
classe de um pacote para outro. Ela move fisicamente a classe para a pastaque corresponde ao pacote e também altera todas as referências à classe para
se referir ao novo pacote.
No Eclipse o atalho para se utilizar a refatoração Mover é Alt+Shift+V.
Ao acessar o atalho aparecerá um painel para a seleção do futuro pacote com
a opção de pré-visualização como mostra a Figura 3-7.
Figura 3-7 Painel do Eclipse para a seleção do pacote futuro onde será movida a classe
desejada
Na IDE IntelliJ foi realizado o procedimento através do atalho F6 de
forma rápida e prática bastando selecionar em uma caixa de diálogo o pacote
que será movida a classe.
Pela ferramenta IDE NetBeans o atalho para a realização da
refatoração seria através do comando Ctrl+M, porém não funcionou e a
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 39/53
28
operação foi realizada através do caminho normal Refatorar > Mover.
Para todas as IDEs é possível também arrastar e soltar uma classe
para um novo pacote na visualização Package Explorer, e a refatoração
ocorrerá automaticamente. Isso é de grande valia e acontece de forma natural.
A refatoração em todas as IDEs foi realizada como esperado e sem
problemas em sua execução.
3.6.3. ENCAPSULANDO UM ATRIBUTO
A refatoração Encapsular Atributo, como já foi visto anteriormente, é
uma operação que transforma um atributo público em privado e fornece
acessibilidade a esse atributo.
Na Figura 3-8 podemos ver um atributo em que poderíamos aplicar a
refatoração.
Figura 3-8 Código-fonte de como era antes da refatoração Encapsular um Atributo
Note abaixo na Figura 3-9 que o código-fonte após a refatoração ficou
maior, mas isso não é um problema. Estamos garantindo que estamos usando
o encapsulamento que é fundamental para a proteção do atributo e
assegurarmos a integridade da classe e o isolamento do atributo.
Figura 3-9 Código-fonte de como ficou após a refatoração Encapsular um Atributo
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 40/53
29
Na IDE Eclipse foi realizado o procedimento deixando o cursor,
obrigatoriamente, em um atributo que deverá ser encapsulado, caso contrário
ocorrerá um mensagem de alerta pedindo a sua seleção. Ponto forte é seu
reconhecimento da variável simplesmente colocando o cursor focado na
variável para que seja feita a refatoração.
Como já foi falado para nos itens anteriores para esta refatoração
também existe esta ótima opção de pré-visualização antes de efetivar a técnica
como mostra a Figura 3-10.
Figura 3-10 Painel de pré-visualização do Eclipse mostrando as futuras alterações para a
técnica de refatoração Encapsular Atributo
Na IDE IntelliJ, ao contrário do Eclipse, ao clicar no sub-menu
Encapsular Atributo não é necessário selecionar o atributo e caso o cursor
esteja em um atributo a ferramenta verifica se o atributo necessita de
refatoração. Ao clicar no menu aparece um painel contendo todos os atributos
da classe com suas respectivas informações como mostra a Figura 3-11. Neste
caso é uma vantagem, pois o desenvolvedor poderá escolher qual atributo se
deseja encapsular além de poder selecionar mais de um atributo.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 41/53
30
Figura 3-11 Painel do IntelliJ que mostra atributos e suas informações que poderão ser
encapsuladas
A opção de pré-visualização perde em relação à opção do Eclipse que
detalha mais e é bastante visual a modificação de como será a refatoração.
Na IDE NetBeans o tratamento do encapsulamento do atributo é
exatamente idêntico ao IntelliJ. Nessa refatoração também existe o ótimo
suporte da pré-visualização bem definida e detalhada.
A refatoração em todas as IDEs foram realizadas como esperada esem problemas em sua execução.
3.6.4. EXTRAIR SUPERCLASSE
A refatoração Extrair Superclasse é similar à refatoração Extrair
Interface. Se a classe já usa uma superclasse, a classe mais recentemente
gerada terá essa classe como sua superclasse, mantendo a hierarquia de
classes.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 42/53
31
Na Figura 3-12 podemos ver um possível código-fonte em que
poderíamos aplicar a refatoração.
Figura 3-12 Código-fonte de como era antes da refatoração Extrair Superclasse
Note que na Figura 3-13 foi criada uma classe na qual se tornou pai da
classe mostrada na Figura 3-12. Este foi um clássico exemplo de como é
esperado que a ferramenta de refatoração extraia uma superclasse.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 43/53
32
Figura 3-13 Código-fonte de como ficou após a refatoração Extrair Superclasse
Na IDE Eclipse para usar essa refatoração foi preciso certificar que o
cursor estivesse em uma das declarações ou um dos campos de método da
classe. Uma caixa de diálogo é exibida e permite que você nomeie a nova
superclasse e selecione os métodos e campos que serão colocados na
superclasse.
Na IDE IntelliJ e na IDE NetBeans os testes executaram e obtiveram o
mesmo resultado, incluindo a caixa de diálogo.
3.6.5. EXTRAINDO UM MÉTODO
A refatoração Extrair Método permite selecionar um bloco de código e
convertê-lo em um método. Isso é útil quando um método é muito grande e
você deseja subdividir seus blocos em diferentes métodos. Isso também é útil
se você tiver um pedaço de código que é reutilizado em muitos métodos.
Na Figura 3-14 como podemos observar há uma replicação no código e
nesse caso poderíamos aplicar a refatoração com segurança.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 44/53
33
Figura 3-14 Código-fonte de como era antes da refatoração Extrair Método
Veja na Figura 3-15 que após a refatoração foi criado um novo método
deixando o método refatorado mais limpo e visualmente mais claro. Tivemos
um ganho no que diz respeito a repetição do código, ao reuso. Se por um
acaso tiver um método que solicite a mesma funcionalidade que o métodocriado não precisaria copiar o código, basta utilizar o método que foi criado.
Figura 3-15 Código-fonte de como ficou após a refatoração Extrair Método
Na IDE Eclipse foi realizado o procedimento através do atalho
Alt+Shift+M. Primeiramente devemos certificar que o seu cursor esteja em um
trecho de código possível de ser extraído. Após o acionamento do atalho uma
caixa de diálogo é exibida e permite que você nomeie um nome para o método.
A IDE descobre automaticamente os argumentos e os valores de retorno
corretos. Por fim, automaticamente são alteradas todas as chamadas com a
mesma nomenclatura do trecho de código selecionado.
Na IDE IntelliJ foi realizado o procedimento através do atalho
Ctrl+Alt+M. Ao acionar o atalho, aparece uma caixa de diálogo para que seja
colocado o nome do nove método a ser criado. O interessante notar que a pré-
visualização é mostrada na mesma caixa de diálogo, possibilitando uma rápida
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 45/53
34
noção do que será alterado.
Outro ponto positivo na ferramenta é passado ao usuário a informação
que além do trecho de código selecionado foi encontrado outro trecho que
poderá ser utilizado e espera que o usuário decida qual melhor maneira de
proceder, se é alterando o código encontrado ou não.
Na IDE NetBeans não pudemos realizar os testes necessários, pelo
fato de não ter sido disponibilizado o suporte à essa técnica de refatoração
Extrair Método.
Em todas as IDEs, com exceção da IDE NetBeans, foram realizadas os
testes como esperado e sem problemas em sua execução.
3.6.6. EM LINHA (INLINE)
A refatoração Em Linha pode sequenciar uma referência a uma variável
ou um método. Quando usada, ela substitui a referência à variável ou ao
método pelo valor designado à variável ou à implementação do método,
respectivamente. Isso pode ser útil para limpar o código quando um método for
chamado somente uma vez por outro método e fizer mais sentido como um
bloco de código ou quando uma expressão parecer mais limpa em uma linha,
em vez de dividi-la em várias linhas designando valores para variáveis
diferentes.
Na Figura 3-16 podemos observar um desperdício de memória,
alocando em uma variável antes de retornarmos o valor para a saída do
método. Esse é um exemplo clássico de refatoração Variável Local Em Linha.
Figura 3-16 Código-fonte de como era antes da refatoração Em Linha
A Figura 3-17 mostra o mesmo código após ter realizado a refatoração
Em Linha. Observe que onde eram duas linhas de código agora se ajusta
claramente em uma única linha de código.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 46/53
35
Figura 3-17 Código-fonte de como ficou após a refatoração Em Linha
Na IDE Eclipse foi realizado o procedimento através do atalho
Alt+Shift+I. Para usar esta refatoração, o cursor deverá estar posicionado em
uma variável local ou um método. Uma caixa de diálogo é exibida solicitando a
confirmação da refatoração.
Na IDE IntelliJ foi realizado o procedimento através do atalho
Ctrl+Alt+N. A refatoração Em Linha para uma variável local e em um métodofunciona exatamente igual à IDE Eclipse. Somente em um teste em que um
método não podia ser feito a refatoração, na IDE Eclipse demorou um tempo
considerável para que fosse informado que não poderia ser feita a refatoração.
Em contra partida, na IDE IntelliJ não foi informado mensagem alguma, porém
de alguma forma a ferramenta já havia guardado essa informação e por isso
não prosseguiu para a realização da refatoração.
Na IDE NetBeans não pudemos realizar os testes necessários, pelofato de não ter sido disponibilizado o suporte à essa técnica de refatoração Em
Linha.
Assim como o item 3.6.5 os testes foram realizados como esperado e
sem problemas em sua execução com exceção da IDE NetBeans.
3.6.7. COMANDO “DESFAZER” (CTRL+Z)
O comando “desfazer” é muito utilizado nos editores de texto. Este
comando foi criado por volta de 1976 quando duas pessoas: Lance A. Miller e
John C. Thomas, que trabalhavam na IBM, deram a idéia em um relatório de
pesquisa da IBM de poder voltar aquilo que foi alterado anteriormente. Depois
disso, os programadores do instituto de pesquisa Xerox PARC decidiram
atribuir a combinação de teclas “Ctrl+Z” para a função “desfazer” (undo, termo
em inglês).
Pensando nisso fizemos um teste caso alguma refatoração indesejada
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 47/53
36
tenha acontecido e queiramos voltar como era antes da refatoração ter sido
efetuada.
Na IDE Eclipse o comando desfazer foi realizado com perfeição em
todos os casos acima demonstrado. Os testes foram feitos diretamente com
extrema rapidez.
Na IDE IntelliJ também não tivemos problemas na execução tanto no
menu desfazer quanto no atalho que funcionaram conforme esperado de forma
rápida e eficaz.
Na IDE NetBeans houve uma particularidade nesse caso. O comando
desfazer é separado da aplicação. Conforme a Figura 3-18 para voltarmos a
refatoração é feito de forma separada. O atalho Ctrl+Z não funcionou, pois fazparte do editor e não da refatoração. Isso é um erro gravíssimo de usabilidade.
Figura 3-18 Menu do NetBeans onde mostra o comando desfazer desabilitado e o sub-menu
desfazer adicionado no menu Refatorar
Como já comentado o desenvolvimento e a refatoração devem
caminhar lado a lado. A refatoração deve, com o tempo, fazer parte do
cotidiano do desenvolvedor. Separando esse comando estamos indo de
encontro a essa idéia.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 48/53
37
3.6.8. TÉCNICAS DE REFATORAÇÃO NÃO UTILIZADAS
Algumas técnicas de refatoração não puderam ser utilizadas, pois a
IDE NetBeans oferece pouco suporte, como podemos ver na Figura 3-4. Poresse motivo não pudemos apresentar uma análise comparativa entre as
ferramentas. No item 3.6.6 vimos que não foi possível praticar a mesma técnica
em todas as IDEs.
Abaixo citamos algumas das técnicas de refatoração que não
conseguimos reproduzir na ferramenta NetBeans:
Descer Método
Em Linha Extrair Método
Extrair Variável Local
Mover Método
Subir Método
3.7. DESTAQUES
Avaliando todas as IDEs podemos destacar um suporte de grande
ajuda ao usuário no que se refere à refatoração. Podemos destacar duas
funcionalidades: Histórico na IDE do Eclipse e Exclusão Segura nas IDEs
IntelliJ e NetBeans.
3.7.1. FUNCIONALIDADE “HISTÓRICO”
No Eclipse podemos acessar a funcionalidade “Histórico” (menu“History”) como vemos na Figura 3-19.
Figura 3-19 Menu do Eclipse para acesso à funcionalidade Histórico
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 49/53
38
Essa funcionalidade corresponde ao histórico das mudanças
produzidas pelas refatorações ao longo de todo o desenvolvimento do projeto.
Podemos obter um relatório de todas as mudanças feitas. Clicando sobre um
dos itens do histórico é possível ver detalhes, como por exemplo, a data da
mudança, de qual para qual classe foi feita a operação, se a refatoração for um
método, superclasse ou interface extraída, e qual o nome e tipo de acesso
desse novo componente, entre outras informações que nos auxilia sobre o que
aconteceu no projeto, podendo inclusive remover a refatoração efetuada em
determinada época.
Na Figura 3-20 mostra todos os detalhes das alterações de refatoração
organizados pela data.
Figura 3-20 Painel de exibição da funcionalidade “Histórico” no Eclipse
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 50/53
39
3.7.2. FUNCIONALIDADE “EXCLUSÃO SEGURA”
A funcionalidade Exclusão Segura podemos encontrar tanto na IDE
IntelliJ quanto na IDE NetBeans. É uma ótima ferramenta para excluir todas aschamadas a determinada classe, interface, atributo, método e até mesmo
qualquer tipo de variável.
Na Figura 3-21 vemos um exemplo de Exclusão Segura de uma classe
“Negocio” do sistema testado. A IDE procura e excluí todas as chamadas
utilizadas no sistema sem afetar seu funcionamento.
Figura 3-21 Painel do NetBeans utilizado para a refatoração Exclusão Segura
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 51/53
40
CAPÍTULO 4. CONCLUSÃO
Neste Capítulo, apresentaremos um resumo final sobre as
considerações apresentadas nos testes de forma a reforçar o que foi mostrado.
4.1. ANÁLISE RETROSPECTIVA
Pode-se concluir que refatorar exige um conhecimento das técnicas
tanto para a refatoração manual quanto pelo uso de ferramentas
automatizadas.
Através do testes realizados podemos avaliar que as IDEs que se
destacaram quanto ao completo suporte à refatoração foram a IDE Eclipse e a
IDE IntelliJ. Podemos perceber uma maturidade alta no suporte a refatoração,
com flexibilidade nos comandos, atalhos bem simples, refatorações de maneira
ágil e abrangendo um maior número de refatorações possíveis.
Todas as IDEs mostravam uma visualização prévia da refatoração
antes de realmente efetivá-la. Esse item é importante para que possa ser
mostrado ao usuário o que será feito na refatoração e nesse quesito asferramentas apresentavam gráficos e o passo a passo das alterações com
mais detalhamento do Eclipse e NetBeans.
A IDE NetBeans deixou a desejar em fornecer algumas refatorações
automatizada e no que diz respeito ao comando “Desfazer”. Como comentado
anteriormente, no quesito usabilidade mais uma vez pecou ao ser pouco
intuitivo ao usuário final. Em relação ao suporte à refatoração a IDE precisa
melhorar para se igualar as outras.Segundo (FOWLER, 2004) o uso de ferramentas de refatoração
automática é a melhor maneira de gerenciar a complexidade que aparece
quando um projeto de software evolui. Sem ferramentas para lidar com esta
complexidade, o software se torna inchado, frágil e com erros.
Como pode ser notado o auxílio das ferramentas obtém a rapidez na
refatoração, com isso há um ganho no desenvolvimento não só no presente,
mas também numa futura manutenção.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 52/53
41
4.2. TRABALHOS FUTUROS
A abordagem empreendida nesse trabalho não se pretendeu exaustiva.
Dessa forma, é necessário que haja uma investigação mais profunda sobretodas as técnicas de refatoração nas três IDEs citadas. Ainda é cedo para que
uma IDE chegue a maturidade ideal que traga de forma completa todas as
técnicas empregadas na refatoração.
Assim sendo, merece um aprofundamento nas investigações de cada
IDE. Como vimos a IDE NetBeans ainda merece reparos no que diz respeito ao
suporte às técnicas de refatoração. Quando atingir um nível esperado de
maturidade, essa deverá ser avaliada de modo a se equiparar com as outrasIDEs e ser melhor avaliada.
5/9/2018 Monografia - Rodrigo Achilles Pereira - EnGSOFT13 - slidepdf.com
http://slidepdf.com/reader/full/monografia-rodrigo-achilles-pereira-engsoft13 53/53
42
REFERÊNCIAS
ASSOCIAÇÃO BRASILEIRA DE NORMAS TÉCNICAS. Informação e
documentação - Trabalhos Acadêmicos - Apresentação. Rio de Janeiro:
ABNT NBR 14724, 2011. 11 p.
BECK, K. Programação extrema explicada: acolha as mudanças. Porto
Alegre: Bookman, 2000. 186 p.
DEVA, P. Explore Funções de Refatoração no Eclipse JDT. developerWorks -
IBM, 07 Dezembro 2009. Disponivel em:
<http://www.ibm.com/developerworks/br/opensource/library/os-eclipse-
refactoring/>. Acesso em: 28 jul. 2011.
FOWLER, M. Refatoração Aperfeiçoando o Projeto de Código Existente.
Tradução de Acauan Fernandes. Porto Alegre: Bookman, 2004. 366 p.
FOWLER, M. Refactoring. Refactoring Home Page, 2010. Disponivel em:
<http://www.refactoring.com/>. Acesso em: 28 jul. 2011.
PRESSMAN, R. S. Engenharia de Software. 6ª Edição. ed. [S.l.]: McGraw-Hill,
2006. 720 p.
REFATORAÇÃO com Netbeans e Eclipse. Blog Javaelinux, 2011. Disponivelem: <http://javaelinux.wordpress.com/2011/03/21/refatoracao-com-netbeans-e-
eclipse/>. Acesso em: 28 jul. 2011.
WELLS, D. Extreme Programming: A gentle introduction. Extreme
Programming, 2009. Disponivel em: <http://www.extremeprogramming.org/>.
Acesso em: 28 jul. 2011.