Utilizando Padrões De Design No Desenvolvimento Rápido De Aplicações De Software

Zalkind Lincoln Dantas RochaJair Cavalcanti Leite

Objetivo

Mostrar o impacto do uso de padrão de design na arquitetura deste software bem como as dificuldades de implementá-lo utilizando uma linguagem em ambiente de desenvolvimento rápido de aplicações (RAD - Rapid Application Development)

Conteúdo

Patho Control - Descrição Problemas enfrentados Padrões de design Soluções encontradas

Etapas do Laudo

Modelo de navegação

Ir diretamente para as etapas de recepção, macroscopia, conclusão e entrega;

Navegar por estas etapas voltando ou avançando pelas telas que já percorreu;

Movimentar-se através de botões, opções de menu ou teclas de atalho.

Configuração de Ambiente Adequar comandos de acordo com a etapa. Exemplo:

Enviar um exame para entrega somente após ter sido concluído;

Excluir exame apenas na recepção e na entrega;

Comandos de voltar e avançar desabilitados quando na primeira e última etapa visitada.

Problema:

Construir uma arquitetura que: i) suporte o modelo de navegação

projetado; ii) permita implementar o recurso de

avançar e voltar; iii) facilite a configuração de

ambiente de acordo com a etapa.

Padrões de design

Um padrão de design é uma solução para um problema num determinado contexto.

Surgiu originalmente na arquitetura através dos trabalhos de Christopher Alexander.

Padrões de design

O objetivo é capturar a experiência acumulada de projetistas que perceberam padrões de solução para determinados problemas, catalogando e nomeando estas soluções testadas para serem reutilizadas mais facilmente.

Padrões de design

Alguns autores, como o grupo dos quatro, adaptaram este conceito, originalmente aplicado à arquitetura, para descrever soluções simples e elegantes para problemas específicos no design de softwares orientados a objetos.

Padrão Command

Parametrizar objetos por uma ação executa de modo a ser implementada em outro local;

Suportar a funcionalidade de desfazer comandos.

Padrão Command

ComandoExecute()

Chamador

ComandoConcretoEstado

Execute()

Cliente

RecebedorAção()

recebedor->Ação()

recebedor

Padrão Command (Aplicado)

Mudanças de etapas podem ser comandos;

Avançar e voltar podem ser desfazer e refazer;

Portanto o padrão COMMAND resolveria os problemas i e ii.

Padrão Command (Aplicado)

TCommand

Execute()UnExecute()Reversible()

TNotebook(from Unresolved References)

TfmPrincipal(from Main)

+nbAreaDeTrabalho

TIrParaCommand_ToPage : String_FromPage : String

Create()CreateNew()Execute()UnExecute()Reversible()<<Property>> FromPage()

-_NoteBook

+cmIrParaConteudo+cmIrParaRequisicao

+cmIrParaMacroscopia+cmIrParaMicroscopia

+cmIrParaConclusao+cmIrParaEntrega

Padrão Command (Aplicado)

TIrParaHistory_Index : Integer

Create()Present()Add()Next()Prior()Clear()

TList(from Classes)

-_HistoryList

Padrão Observer

Alterar um objeto requer mudanças em outros e não se sabe quantos objetos precisam ser mudados.

Padrão Observer

AssuntoVincular(Observador)Desvincular(Observador)Notificar()

ObservadorAtualizar()

*

for all o in observadores{ o->Atualizar() }

ObservadorConcretoEstado

Atualizar()

AssuntoConcretoEstado

GetEstado()SetEstado()

Assunto

Observadores

Retorna o Estado

Estado = assunto->GetEstado()

*

Padrão Observer (Aplicado)

Os controles podem ser observadores e é possível criar assuntos cujos estados indiquem quando estes controles devem ser habilitados ou desabilitados.

O padrão OBSERVER seria adequado para resolver o problema iii.

Padrão Observer (Aplicado)

TList(from Classes)

TSubject

Attach()Detach()Notify()

THistoryIrParaAtFirstSubject_AtFirst : boolean

SetState()Notify()<<Property>> AtFirst()

THistoryIrParaAtLastSubject_AtLast : boolean

SetState()Notify()<<Property>> AtLast()

T IrParaSubject_Page : String

FinalizarPosts()SetState()Notify()<<Property>> Page()

-_SubjectList

Considerações Finais

Os padrões realmente apresentaram soluções para problemas de design.

Adequações precisaram ser efetuadas: O padrão Subject perdeu o acoplamento

abstrato. Acoplar as modificações nos observadores concretos dentro do método Notify gerou altíssimo acoplamento.

Considerações Finais

Outras nem tanto: O padrão Command foi implementado

quase sem modificações em relação ao padrão proposto.

Novos assuntos e novos comandos foram acrescentados, inclusive fora do contexto de interface, sem implicação às classes já existentes.

Considerações Finais

Essas adaptações aos padrões originais para a solução dos problemas na linguagem utilizada podem contribuir na descrição de padrões mais específicos, chamados idiomas, podendo ser reutilizados em novos projetos

Contatos:

Zalkind Lincolnzalkind@ipso.com.br

Jair Cavalcanti Leitejair@dimap.ufrn.br