Aplicativos

Essa semana durante uma sessão de refatoração, tive a idéia de sempre que me deparar com situações de códigos que precisam ser alterados afim de se adequarem a alguns princípios de boas práticas de desenvolvimento de software, vou compartilhar aqui, explorando os pontos negativos do código e as vantagens de se adequar a um desses princípios, falando também um pouco sobre eles, um caso de cada vez, começando agora com OCP (Open-Closed Principle).

The Open-Closed Principle

Este princípio é a fundação para construção de códigos reutilizáveis e de fácil manutenção. Módulos que se adequam a este princípio são, ao mesmo tempo, abertos para serem extendidos, de maneira que se comporte de maneiras diferentes, a medida que surgem novos requisitos para a aplicação, ou a medida que estes são modificados. E fechados para modificação, o que significa que o código fonte deste módulo não pode ser violado, ninguém pode fazer mudanças neste código fonte.

A descrição deste princípio pode parecer conflitante, já que para extender a funcionalidade de um módulo, é necessário modificá-la, logo deduzimos que uma funcionalidade que não pode ser alterada é dada como fixa. Como este conflito pode ser resolvido? A melhor maneira de demonstrar é através de um exemplo.

No projeto CartolaFC, que estou trabalhando atualmente, existe um gerenciador de tarefas que é responsável pela execução assíncrona de tarefas enfileiradas pela aplicação. Basicamente ele percorre uma lista de pendencias, executando cada uma das tarefas, na ordem em que aparecem. O código abaixo está modificado em relação ao original, para podermos visualizar com mais facilidade.

public class GerenciadorDeTarefas {

    public List<Tarefas> pendentes;

    public void executaTarefasPendentes() {
	for (int i=0; i<pendentes.length; i++) {
	    Tarefa tarefa = pendentes[i];

	    switch (tarefa.tipo()) {
	    case calculoTrofeus:
	    	engine.calculaTrofeus();
	    	break;

	    case calculoEstatisticas:
	    	engine.calculaEstatisticas();
	    	break;
	    }

	    case fechamentoDeMercado:
	    	engine.fechaMercado();
	    	break;
	    }

	    case aberturaDeMercado:
	    	engine.abreMercado();
	    	break;
	    }

	    // .... e assim continua ....
	}
    }
}

O método executaTarefasPendentes() não se adequa ao Open-Closed Principle, pois não está fechado para novos tipos de implementação. Se um dia o cliente decidir extender esta funcionalidade para incluir novas tarefas a serem executadas, que é o que acontece hoje em dia, o método terá que ser modificado para atender este requisito, incluindo mais um bloco “case”, que já não é nada elegante, e assim continuará, para cada novo tipo de tarefa.

O código, na vida real é ainda pior, atualmente são 18 blocos “case”, o que torna a implementação de novas tarefas uma prática intrusiva, suja e acoplada (imagine se todos os métodos a serem executados para as tarefas ficassem espalhados… quantos objetos teríamos que instânciar no gerenciador de tarefas…)

O código a seguir mostra a solução que pretendo dar para este problema, uma solução que se adequa ao Open-Closed Principle. Resumindo, a classe Tarefa se torna abstrata e acrescentamos a ela um método abstrato chamado executar(). Com esse approach, TODOS os tipos de tarefas criados, serão classes concretas que derivam desta classe, implementando seu método abstrato.

public class abstract Tarefa {
    public abstract void executar();
}

public class CalculoDeTrofeus extends Tarefa {
    public void executar() {
	// lógica para cálculo de troféus...
    }
}

public class CalculoDeEstatisticas extends Tarefa {
    public void executar() {
	// lógica para cálculo de estatísticas...
    }
}

E a partir de agora, para o nosso gerenciador de tarefas, o ato de invocar as tarefas pendentes fica totalmente transparente. Tudo que ele precisa fazer é percorrê-las, e para cada uma, invocar seu método executar(), tornando o código não intrusivo, limpo e desacoplado.

public class GerenciadorDeTarefas {

    public List<Tarefas> pendentes;

    public void executaTarefasPendentes() {
	for (int i=0; i<pendentes.length; i++) {
	    Tarefa tarefa = pendentes[i];
	    tarefa.executar();
	}
    }
}

Agora, se quisermos extender a funcionalidade de executarTarefasPendentes() do nosso gerenciador para que passe a executar uma tarefa nova qualquer, tudo o que precisamos fazer é adicionar uma nova implementação para a classe abstrata Tarefa. O nosso método executarTarefasPendentes() não precisa ser alterado, se adequando ao Open-Closed Principle. Seu comportamento pode ser extendido, sem que ele seja alterado.