[interação de padrões]

[Hponto 0]

Olá pessoal,

 

Olá pessoal, queria saber dos mais experientes em padrão de projeto se é PERMITIDO a interação de padrão de projetos, por exemplo utilizo o padrão COMMAND junto com o TEMPLATE METHOD.

 

public abstract class Command {

   public void before() {
   //pode verificar se o usuario tem permissão de executar o 'command'
       doBefore();
   }
   public abstract void doBefore();    

   public void run() {
       before();
       doRun();
       after();
   }
   public abstract void doRun();

   public void after() {
       doAfter();
   }
   public abstract void doAfter();
}



class DeleteCommand extends Command {

   public void doBefore() {
    //deve fazer alguma coisa antes do 'doRun' ser chamado
    //abertura de BD ou outra configuração
   }

   public void doRun() {        
    ///execução do command
   }

   public void doAfter() {
    //depois que 'doRun' for chamado, esse metodo deve ser chamado
    //fechamento de resources
   }
}

 

a chamada ficaria assim:

Command command = new DeleteCommand();
command.run()

 

eu sempre implemento assim, agora minha dúvida é: posso interagir nesse nível?

[Vergil 15]

Naturalmente que não há problema em misturar padrões. Desde que seja realmente necessário! No seu caso em específico não vi nenhuma vantagem em juntar os padrões Command e Template Method. Muito pelo contrário, acho que você perde muito na flexibilidade do código. E a implementação do Template Method não está 100% segura. Você deveria fazer com que pelo menos o método run() fosse final. Assim nenhuma subclasse seria capaz de sobrescrevê-lo, alterando o comportamento do método de template.

 

Acho que nesse caso seria muito melhor você ter uma interface ao invés de uma classe abstrata.

Ex.:

public interface ICommand {
  // Executa o comando.
  public abstract void execute();

  // Verifica se pode executar o comando.
  public abstract boolean canExecute();
}

 

public class Desfazer implements ICommand {

  public void execute() {
     if (this.canExecute()) {
        this.desfaz();
     }
  }

  public boolean canExecute() {
     // se alguma coisa foi alterada
     return true;
  }

  priva void desfaz() {
     // Desfaz ação do usuário
  }
}

 

ICommand comando = new Desfazer();
botao.setVisible(comando.canExecute());
comando.execute();

[Hponto 0]

No seu caso em específico não vi nenhuma vantagem em juntar os padrões Command e Template Method.

Vergil, esse exemplo que eu mostrei foi algo rápido, sem funcionalidades, por isso você não ver utilidade em juntar.

 

Muito pelo contrário, acho que você perde muito na flexibilidade do código.

Além de flexibilidade, eu tenho um código mais 'manutenivel', e mais 'reusavel'.

 

E a implementação do Template Method não está 100% segura.

ok, valew a dica, nunca olhava pra esse fato.

 

Acho que nesse caso seria muito melhor você ter uma interface ao invés de uma classe abstrata.

Não posso usar interface pelo fato do outro padrão (visando reuso de funcionalidades)