Monografia - Rodrigo Achilles Pereira - EnGSOFT13

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



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.



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.



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.



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.



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



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



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



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



X

LISTA DE TABELAS

TABELA 3-1 ..................................................................................................................................20 TABELA 3-2 ..................................................................................................................................21 TABELA 3-3 ..................................................................................................................................23



XI

LISTA DE ABREVIATURAS E SIGLAS

XP – Programação Extrema (eXtreme Programming)

IDE – Ambiente Integrado de Desenvolvimento (Integrated Development Environment)



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



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



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.



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

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



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();



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.


pela refatoração Mover Método.

class Project {

Person[] participants;

}

class Person {

int id;



8

boolean participate(Project p) {

for (int i = 0; i < p.participants.length; i++) {

if (p.participants[i].id == id)

return (true);

}

return (false);

}

}


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



9

fazendo um trabalho que deve ser feito por dois.


pela refatoração Extrair Classe.

class Person {

int id;

String name;

int areaCode;

int number;

boolean participate(Project p) {..}

}


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() {

}

}



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.


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() {



11

System.out.println(project.showInformation());

}

}

class Project {

String name;

public String showInformation() {..}

}


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.




12

pela refatoração Mover Classe.

package org.davison.ui

// imports

public class StringUtil

...


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



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.


pode atuar.


refatoração Descer Atributo (Obtida em (FOWLER, 2010))



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.


pode atuar.



15


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))



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.



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.



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)



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



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



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


Licença Apache 2.0 for Community Edition

Página oficial http://www.jetbrains.com/idea/

Tamanho 89,2 MB

Tabela 3-2





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



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


Licença FreewarePágina oficial http://netbeans.org/

Tamanho 243 MB

Tabela 3-3





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



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.



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.



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



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



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.



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.



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.



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.



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



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.



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



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.



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



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



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



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.



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.



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.

Monografia - Rodrigo Achilles Pereira - EnGSOFT13

Documents

Transcript of Monografia - Rodrigo Achilles Pereira - EnGSOFT13