Mostrando postagens com marcador MVP. Mostrar todas as postagens
Mostrando postagens com marcador MVP. Mostrar todas as postagens

domingo, 31 de outubro de 2010

Desenvolvimento GWT usando MVP com Activities e Places

Esta semana, foi anunciado o esperadíssimo lançamento do GWT 2.1. Neste release, o GWT finalmente incluiu um framework MVP baseado nas best practices recomendadas no Google I/O 2009.

Este post é a tradução que fiz para a documentação deste novo framework. Particularmente achei a documentação pouco didática e relaxada com os novos usuários.

Para os usuários já acostumados com o estilo GWT de desenvolver (baseado em MVP/EventBus para promover baixo acoplamento e facilitar o teste unitário, e PlaceManagers atuando como controllers que gerenciam o estado da aplicação e a URL do browser), a solução proposta é interessante e elegante, padroniza um estilo de programação que antes ficaria a cargo do desenvolvedor arquitetar e implementar.

Para os novos usuários, a documentação é deveras extensa, e ficaria bem melhor documentada se fosse recheada com imagens e diagramas ao invés de apenas descrições e código. Deixo como promessa aos colegas entusiastas do GWT que, nas próximas semanas, envidarei esforços para didatizar e criar diagramas que facilitem este aprendizado.

Boa Leitura!


Tradução da Documentação Oficial publicada em http://code.google.com/intl/pt-BR/webtoolkit/doc/latest/DevGuideMvpActivitiesAndPlaces.html


O GWT 2.1 traz inclusa uma framework para desenvolvimento MVP. Este artigo demonstra as Activities e Places no GWT 2.1, relacionadas aos aspectos View e Presenter do MVP. Num artigo futuro, olharemos mais a fundo as novas funcionalidades para o Model (RequestFactory, EntityProxy e Data Binding). As funcionalidades relacionadas à Model podem ser usadas independentemente das Activities e Places, ou podem ser usadas em conjunto, usando um ProxyPlace e classes relacionadas.

Se o MVP é um conceito novo para você, dê uma olhada nestes artigos:

Definições

Uma Activity no GWT 2.1 é análoga ao presenter, na terminologia MVP. Ela não contém widgets ou código da UI. Atividades são iniciadas e encerradas por um ActivityManager associado a um Widget. Um nova e poderosa feature no GWT 2.1 é que uma atividade pode automaticamente exibir um alerta de confirmação, quando a atividade está prestes a ser encerrada - por exemplo quando o usuário navega para um novo Place. Além disso, o ActivityManager alerta o usuário quando a janela está prestes a ser fechada.

Um Place no GWT 2.1 é um objeto Java representando um estado particular da UI. Um Place pode ser converdido em um token de histórico de navegação (veja o objeto GWT History), e vice-versa, ou seja, uma URL com token de navegação pode ser traduzida em um Place. Para tal, define-se um PlaceTokenizer para cada Place, e o PlaceHistoryHandler automaticamente atualiza o navegador com a URL correspondente a cada Place da aplicação.

O código referenciado neste artigo pode ser baixado nesta aplicação de exemplo, que consiste em um simples "Hello World!" com uma view adicional para ilustrar a nevegação.

Vamos dar uma olhada em cada uma das partes de uma aplicação GWT 2.1 usando Places e Activities.

Views

Um conceito chave do desenvolvimento MVP é que uma View é definida por uma interface. Isto permite que múltiplas implementações da View, baseadas em características do cliente (por exemplo, se ele é mobile ou desktop), e torna mais leve o teste unitário, pois avita o uso do GWTTestCase, cuja execução é mais demorada.

O GWT não obriga que as interfaces View da aplicação extendam ou implementem alguma classe ou interface. O GWT 2.1 introduz uma interface IsWidget, implementada pela maioria dos Widgets GWT. Quando uma view provê um widget, é recomendável que ela estenda IsWidget, como no exemplo abaixo:

A implementação correspondente extende Composite, evitando que sejam expostas dependências a Widgets específicos da implementação.

Abaixo, uma view um pouco mais complicada, que declara uma interface para o Presenter (Activity) correspondente:

A interface Presenter e o método Presenter permite uma comunicação Bidirecional entre View e Presenter, que simplifica as interações envolvendo widgets repedidos, além de permitir implementações a usarem UiBinder com métodos @UiHandler que delegam chamadas diretamente para o Presenter, como no exemplo abaixo.

Segue o template uiBinder desta implementação:

Devido ao fato que a criação de widgets envolve operações DOM, views têm um custo alto de criação. Uma boa prática, portanto, é torná-las reusáveis, e uma forma relativamente fácil de fazer isto é através de uma View Factory, a qual pode fazer parte de uma ClientFactory.

ClientFactory

Apesar de não ser estritamente necessário, é muito útil fazer uso de fábricas, ou frameworks de Injeção de Dependências com o Google GIN, para obtenção de referência aos objetos necessários à aplicação - por exemplo o Event Bus. Este exemplo faz uso de uma ClientFactory para prover implementações para um EventBus, um PlaceController e para as Views.

Usando ClientFactories em conjunto com o mecanismo de deferred binding do GWT, é possível obter diferentes implementações de objetos, baseadas em propriedades como o user.agent. Por exemplo, a aplicação pode usar uma MobileClientFactoryImpl ou uma DesktopClientFactory.

Para tal, a ClientFactory deve ser instanciada usando GWT.create:

As classes de implementação devem ser especificadas no descritor gwt:

A tag pode ser usada para especificar diferentes implementações de acordo com o user.agent, com o locale, ou por propriedades próprias da aplicação. Segue um exemplo de implementação de uma ClientFactory:

Activities

Classes Activity devem implementar a interface com.google.gwt.app.place.Activity. Por conveniência, pode-se também extender a classe AbstractActivity, que provê implementações default vazias para cada um dos métodos requeridos. segue o código de Helloactivity, que simplesmente diz olá para um usuário:

A primeira coisa a se notar é que HelloActivity tem uma referencia HelloView. Uma forma de codificar MVP é definir a interface View no próprio Presenter. Apesar de ser um estilo perfeitamente legítimo, não há nenhuma razão fundamental para uma Atividade e sua interface View correspondente serem altamente acoplamas uma com a outra. Note que a atividade implementa a interface Presenter que foi declarada na View. Isto permite que a View possa chamar métodos da Atividade, o que fcilita o uso dos métodos @UiHandler do UiBinder.

O construtor de HelloActivity recebe dois argumentos: HelloPlace e ClientFactory. Nenhum é estritamente obrigatório para uma atividade. HelloPlace simplesmente facilita para HelloActivity a ontenção de propriedades d estado representado pelo HelloPlace (neste caso, o nome do usuário que estamos cumprimentando). A passagem de HelloPlace no construtor implica que uma nova HelloActivity deverá ser criada para cada HelloPlace.

No GWt 2.1, Activities são desenhadas para serem descartadas, enquanto as views, cujo custo de criação é mais caro devido às chamadas DOM envolvidas, devem ser reusáveis. Em concordância com esta idéia, ClientFactory é usada pela HelloActivity para obter as referências para HelloView, bem como ao eventBus e ao PlaceController, papel que pode também ser desempenhdo usando Injeção de Dependências com o Gin.

O método start é invocado pelo ActivityManager e coloca as coisas em ação. Ele atualiza a view e então a insere dentro do widget de conteúdo [da página de host], através da chamada

Ao implementar mayStop(), HelloView provê um alerta a ser mostrado para o usuário quando a atividade estiver prestes a ser encerrada devido ao fechamento da janela ou à navegação para outro Place. Caso retorne null, nenhum alerta será exibido.

Finalmente, o método goTo invoca o PlaceController para navegar para um novo Place. PlaceController, por sua vez, notifica o ActivityManager para encerrar a Activity atual, e encontrar / iniciar a Activity associada ao novo Place, além de atualizar a URL no PlaceHistoryHandler.

Places

Além de ser acessíveis via URL, uma Activity deve corresponder a um determinado Place, que deve estender com.google.gwt.app.place.Place, e ter um PlaceTockenizer que saiba como serializar seu estado para um token URL. Por padrão, a URML consiste no nome não-qualificado (sem prefixo referente ao nome pacote) do Place, seguido por dois pontos (:) e o token retornado pelo PlaceTokenizer.

É conveniente - apesar de não obrigatório - declarar o PlaceTokenizer como uma classe interna dentro do próprio Place. Porém, não é necessário ter um PlaceTokenizer para cada Place. Muitos Places da aplicação podem não precisar salvar estado na URL, então eles podem simplesmente estender BasicPlace, que declara um PlaceTokenizer que simplesmente retorna null.

PlaceHistoryMapper

É uma interface que serve para mapear todos os Places disponíveis na aplicação. Deve-se criar uma interface que estende PlaceHistoryMapper, e usa a anotação @WithTokenizers para listar cada uma das classes Tokenizer, como no exemplo abaixo:

Em tempo de compilação, o GWT gera uma classe baseada nesta interface, que é o elo entre os PlaceTokenizers da aplicação e os PlaceHistoryHandler do GWT que sincronizam a URL do navegador com o estado do Place.

Para se ter maior controle sobre o PlaceHistoryMapper, é possível usar uma anotação @Prefix para alterar a primeira parte da URL associada a um Place. Para um controle ainda maior, pode-se implementar um PlaceHistoryMapperWithFactory na aplicação para prover uma TokenizerFactory, que por sua vez provê os PlaceTokenizers.

ActivityMapper

Finalmente, a aplicação deve possuir um ActivityMapper para mapear Places em Activities. Segue um exemplo:

Uma implementação mais elegante do que esta cadeia de if/else's é realizar as configurações correspondentes em módulos do GIn.

Juntando as peças

O EntryPoint da aplicação ficará parecido com o exemplo abaixo:

Como isso tudo funciona

O ActivityMapper gerencia as Activities rodando no contexto de um determinado container widget [da página de host]. Ele escuta por PlaceChangeRequestEvents e notifica a atividade atual quando um novo Place é solicitado. Caso a Activity vigente permita a mudança do Place (quando Activity.mayStop() retorna null), ou quanto o usuário permite que o Place mude (ao clicar OK na caixa de diálogo), o ActivityManager descarta a Activity atual e inicia uma nova. Para determinar a nova Activity, o ActivityManager usa o ActivityMapper para obter a Activity associada ao novo Place solicitado.

Justamente com o ActivityManager, duas outras classes trabalham para gerenciar os Places da aplicação. PlaceController inicia a navegação para um novo Place, sendo responsável por alertar ao usuário sobre as transições entre Places. PlaceHistoryHandler provê um mapeamento bidirecional entre Places e a URL. Toda vez que a aplicação navega para um novo Place, a URL será atualizada com um novo token, representando o Place, de forma que ele pode ser salvo na lista de favoritos do navegador, bem como a URL seja adicionada ao histórico de navegação - permitindo que os botões voltar e avançar sejam corretamente interpretados pela aplicação. Inversamente, quando uma determinada URL é solicitada pelo navegador - seja ela digitada, clicada na lista de favoritos, ou respondendo a ao clique nos botões avançar ou voltar do navegador, o PlaceHistoryHandler assegura que a aplicação carregue o Place correspondente.

Como navegar

Para navegar para um novo Place na aplicação, basta chamar o método goTo() no PlaceController, fato que é ilustrado na chamada HelloActivity.goTo(). Através de um PlaceRequestEvent, PlaceController alerta avisa à Activity atual que ele deve estar parando, e uma vez que isto seja autorizado, dispara um PlaceChangedEvent, com o novo Place. O PlaceHistoryHandler escuta por PlaceChangeEvents e atualiza o token de histórico da URL da forma apropriada. O ActivityManager também escuta por PlaceChangeEvents, usando o ActivityMapper da aplicação para iniciar a Activity associada ao novo Place.

Ao invés de usar PlaceController.goTo(), pode=se também criar um hiperlink contendo o token para o novo Place. Quando o usuário navegar para a nova URL (seja via hiperlink, botões voltar/avançar, lista de favoritos, etc), PlaceHistoryHandler captura ValueChangeEvent do objeto History e chama o PlaceHistoryMapper para transformar o token no Place correspondente, e então invocar laceController.goTo() com o novo Place.

E caso aplicações que tenham múltiplos painéis na mesma janela, cujos estados devem ser todos salvos na mesma URL? GWT 2.1 não tenta prover uma implementação genérica de um Composite Plac; Porém, sua aplicação pode criar um CompositePlace, uma CompositeActivity, e um CompositePlaceTokenizer, delegando a eles esta responsabilidade. Neste caso, apenas os objetos composite deverão ser necessários para registro no ActivityMapper e PlaceHistoryMapper da aplicação.

quarta-feira, 4 de agosto de 2010

Fontes dos Artigos sobre GWT publicados na MundoJ 40 e 41


Pra galera que leu e gostou dos artigos, segue repositório onde coloquei o código da aplicação de exemplo.

http://code.google.com/p/gwt-mundoj/

Cada commit corresponde a um conceito que foi desenvolvido nos artigos, então é possível acompanhar o artigo baixando sequencialmente cada revisão do repositório, à medida que avançar na leitura da revista.

Espero que possa ser útil a quem desejar conhecer os conceitos-core do GWT, e torne o aprendizado mais suave e divertido.

segunda-feira, 15 de fevereiro de 2010

Classicismo Tecnológico

Em Arte, o Classicismo refere-se, geralmente, à valorização da Antiguidade Clássica como padrão por excelência (...), que os classicistas pretendem imitar.

Até 2 semanas atrás, estava estudando / exercitando GWT 2.0 em um módulo de uma aplicação web que desenvolvo.

Naquele momento, o cliente fez uma solicitação que demandaria processamento local, algo como o usuário selecionar arquivos em sua máquina e os enviar para um servidor FTP. Porém esta funcionalidade deveria ser disponibilizada e integrada com as telas / workflows da aplicação (não bastava ensinar ao usuário como usar um cliente FTP).

Apesar de nunca ter desenvolvido applets para sistemas em produção, escolhi esse caminho. "Forçado" a desbravar o mundo das applets, fiquei surpreso com o grau de similaridade entre as API do GWT e do Swing. Foi possível usar uma arquitetura semelhante, adotar os mesmos padrões, etc...

Gostei de trabalhar com o Swing também pelo fato de as IDEs (Netbeans ou Eclipse VE) possuirem suporte visual para construção das UIs.

Caso a view seja pouco acoplada com o resto da aplicação (por exemplo adotando o padrão MVP), é possível desenhar toda a UI através desses editores visuais, sem que isso afete a lógica da aplicação.

Desta forma, foi possível construir toda a aplicação, desacoplada da View; enquanto, na base da experimentação, tentativa/erro, fazia e refazia a UI, até que ela chegasse ao formato desejado.

Algumas conclusões no final do trabalho - No Swing:

  • A curva de aprendizado pareceu menor (API madura e boa disponibilidade de documentação);
  • O suporte das IDEs (tanto Netbeans quanto Eclipse/VE) é bom;
  • Pode-se usar recursos locais da máquina do usuário - coisa difícil de se obter em uma aplicação web;
  • O tempo de download do applet (tanto pela página quanto pelo JWS) é similar ao tempo de download das bibliotecas-base do GXT;
  • Swing parece estável, enquanto no GXT já experimentei alguns bugs;
  • Menos problemas com licenças (o GXT é GPL);
  • O produto final ficou muito bom - visualmente e funcionalmente;
  • A barreira de instalação da JVM parece ser da mesma ordem de grandeza quanto a barreira de instalar o Flash ou de garantir que a aplicação se comportará de forma idêntica entre todos os navegadores disponíveis.

Depois de listar tantas qualidades, comecei a procurar defeitos, daí nasceu a pergunta que originou esse post no RioJUG.

Em nenhum momento estou dizendo que uma abordagem é boa e a outra ruim; apenas não consegui entender o porquê de uma tecnologia tão madura como Swing / JWS / Applets ser pouco utilizada nas aplicações atuais.

Também fiquei surpreso ao perceber que novas tecnologias, como o GWT/GXT se assemelham às antigas, e que as decisões de design para programar numa (web) ou noutra (swing) são muito parecidas.

Estaríamos vivenciando um momento de classicismo tecnológico, buscando inspiração em tecnologias do passado para ajudar a resolver os problemas do futuro?

quarta-feira, 16 de dezembro de 2009

MVC x MVP: Resumo

No artigo Considerações Históricas sobre o padrão MVC, tradução de "MVC (Model View Controller) Design Pattern", você encontra uma série de 4 posts explicando as origens do MVC e suas variações, mostrando também como as interações entre Modelo, View e Controller são reorganizadas dando origem ao padrão MVP. Em resumo:

O MVC surgiu no início dos anos 80 e inspirou muitas frameworks na época. Cada elemento na tela possuia dois componentes: uma view, responsável pela sua exibição, e um controller, responsável por interpretar os eventos disparados pelos usuários. O controller comandava o modelo, que podia enviar notificações (indiretas) para a view poder se atualizar.

Para evitar o alto acoplamento entre o modelo e a View, surgiu o Application Model MVC, ou AM-MVC. Basicamente era uma camada intermediária, que permitia blindar melhor o modelo com relação à camada de apresentação (view e controllers).

Com o surgimento de novas tecnologias nos anos 90, o papel do controller caiu em desuso, pois os próprios widgets da view passaram a ter meios melhores de lidar com os eventos realizados pelos usuários. Além disso, em alguns casos, era conveniente o Modelo, ou o AM, poderem alterar diretamente a view, sem a necessidade de mecanismos indiretos.

Neste cenário, a IBM propôs o MVP, uma variação do MVC que seria mais adequada. Os adeptos do Smalltalk simplificaram o modelo da IBM e utilizaram no Smalltalk/Dolphin. No MVP, as responsabilidades que eram do Controller são redistribuídas entre a View e o Presenter. A View se encarrega de lidar com as entradas dos usuários, enquanto o Presenter se encarrega de interagir com o Modelo. Além disso, o Application Model do AM-MVC é substituído pelo Presenter, a quem é dado o direito de interagir diretamente com a View.

Martin Fowler catalogou o MVP na forma de dois padrões distintos:

  • Supervising Presenter: nesta forma, o presenter interpreta os eventos da View e comanda o modelo, alterando seu estado. Para atualizar sua exibição na tela de modo a refletir o novo estado do modelo, a view pode interagir diretamente com objetos do modelo, e obter os dados necessários. O modelo até pode se comunicar com a view, porém indiretamente, através de eventos, segundo o padrão Observer Synchronization.
  • Passive View: nesta forma, a view e o modelo são totalmente desacoplados, e todas as interações são realizadas por meio do Presenter. É uma abordagem que favorece o teste da aplicação, pois facilita o uso de mock views.

No novo milênio, o MVC ressurgiu com força total, quase um dogma em aplicações Web. De tão usado, seus conceitos acabaram se tornando difusos, às vezes mal interpretados, e confundidos com Arquitetura em Camadas. Leia MVC versus Camadas para entender melhor a diferença.

Uma limitação do MVC em aplicações web é a dificuldade de testar a camada de apresentação (view e controllers). O MVP parece mais adequado nestes casos, e seu uso tem sido encorajado em aplicações GWT (Google Web Toolkit).

Para concluir, a grande diferença entre MVC e MVP é a forma como o Modelo, a View e o Controller interagem, de modo a prover uma solução mais adequada, de acordo com a tecnologia utilizada e os objetivos desejados. Uma comparação mais detalhada entre o AM-MVC e o MVP/Passive view pode ser encontrada no artigo Do MVC para o MVP.

terça-feira, 15 de dezembro de 2009

Padrão MVP para Aplicações Web Cliente-Servidor

Este post é o quarto e último de uma série de traduções de artigos do blog Design Codes, que falam um pouco sobre a evolução do padrão MVC desde o final dos anos 70, até chegar aos dias de hoje, momento em que uma de suas variações - o MVP - está se popularizando, tendo inclusive sido citado como uma best practice no Google I/O 2009 para o desenvolvimento de aplicações GWT.


Clique Aqui Clique Aqui Clique Aqui


O padrão Model-View-Presenter foi publicado em 1996 por Mike Potel, para se tornar o modelo de programação da próxima geração de aplicações Java e C++ da época. A arquitetura MVP era baseada no modelo de programação MVC clássico do Smalltalk, que era o mais comum naquele tempo, e que inspirou muitas outras bibliotecas e frameworks. Potel descreveu o MVP como um modelo unificado que era adaptável a aplicações multi-camadas e a múltiplas arquiteturas cliente-servidor.

Este artigo revisa o padrão MVP proposto por Potel, focando em sua implementação em aplicações Cliente-Servidor. Use os links acima para conhecer mais sobre a evolução do MVC. Ao final do artigo, existem links para blogs que dão exemplos de implementações do padrão MVP.

MVP em aplicações Desktop

O MVP de Potel inclui seis abstrações: View, Interactor, Presenter, Command, Selection, and Model.

É possível criar uma aplicação usando todas as seis abstrações:

  • Model: serve para interagir com o banco de dados, e armazenar informações.
  • Selection: usado para definir um subconjunto de dados selecionados.
  • Command: executar operações em uma Selection.
  • View: Desenhar a aplicação na tela.
  • Interactor: lidar com os eventos do usuário e invocar o Command apropriado.
  • Presenter: criar o Model, a View, as Selections, os Commands e Interactors, e gerenciar as interações entre eles para prover as funcionalidades da aplicação.

O modelo mais simples possível é ter apenas entidades Presenter, acumulando as responsabilidades do Model, da View e do Interactor. A View pode ser adicionada em seguida, para blindar o Presenter das responsabilidades de desenhar a aplicação na tela; Um próximo passo seria adicionar Interactors para tratar os eventos do usuário; e assim por diante, os elementos podem ser incrementalmente adicionados, sob demanda, à arquitetura.

Os desenvolvedores do Smalltalk adotaram uma variação MVP/Dolphin, que contém apenas os elementos Model, View e Presenter, com o Presenter acumulando as responsabilidades do Interactor, Command e Selection, ficando encarregado de responder aos eventos dos usuários, manter uma seleção de dados, e executar operações sobre esta seleção. Mais detalhes em Do MVC para o MVP.

Colaboração

Vejamos como o MVP pode ser usado como modelo base para uma GUI simples de uma aplicação chamada "Impressão de Registros". Há apenas um caso de uso: o usuário clica no botão imprimir, e o registro selecionado é impresso.

A modelagem MVP para esta GUI terá apenas uma View para desenhar a lista de registros, e um botão Imprimir; dois Interactors - um para capturar o clique do botão, e um para capturar a seleção de um registro na lista; um Command, para enviar o registro selecionado para a impressora (Model); um Selection, para armazenar o registro selecionado, e um Presenter, para criar a View, o Command, os Interactors, e realizar as interações entre cada entidade.

  • O usuário seleciona "Record-1"
  • o Interactor da lista captura o clique e faz a Selection apontar para Record-1
  • A view é atualizada para destacar o registro selecionado
  • O usuário clica no Botão Imprimir
  • O Interactor do Botão intercepta o clique e executa o PrintCommand
  • O Command verifica a Selection atual e envia para a impressora

MVP em aplicações cliente/servidor

No artigo descrevendo MVP, Potel sentencia que uma vasta gama de arquiteturas cliente-servidor podem ser modeladas através de variações simples do modelo MVP: em aplicações "fat-client", onde consultas SQL geradas no próprio cliente são mandadas através da rede; e em aplicações "thin-client", onde comandos são mandados para o servidor, e este atua sobre os comandos, para gerar o SQL apropriado.

Fatorando o Modelo

Uma forma de implementar a arquitetura MVP em aplicações Cliente-Servidor é dividir o modelo entre ao lado cliente e o lado servidor. Ou seja, haverão classes, em ambos os lados, representando um mesmo modelo conceitual. As entidades MVP residiriam todas no lado cliente, e o Modelo em si no servidor. Os modelos no lado cliente agem como proxies para os modelos reais que residem no lado servidor, nos quais ocorre a interação com os bancos de dados, e outras interações da lógica de negócio.

Nas aplicações atuais, o Interactor não mais é necessário, desde que os próprios Widgets sejam capazes de lidar com os eventos dos usuários (leia mais a respeito no tópico "problema da aplicabilidade" neste artigo). Já o Command e o Selection podem ser encapsulados no Presenter. Esta abordagem MVP simplificada é comum em arquiteturas de aplicações rich-client.

Em muitas aplicações de TI, o modelo reside inteiramente no lado cliente, enquanto o servidor é meramente um Sistema Gerenciador de Banco de Dados (SGBD), ou um web-service que encapsula o banco de dados.


Fatorando o Presenter

Outra forma de implementar uma arquitetura MVP em aplicações cliente-servidor é dividir o Presenter entre o cliente e o servidor: em arquiteturas fat-client, a lógica de negócios reside na parte do presenter que reside no lado cliente, com um presenter mais simples rodando no servidor; Em arquiteturas thin-client, a parte simples do presenter fica no lado cliente, enquanto o presenter no lado servidor lida com a lógica de negócios.

Em aplicações cliente-servidor onde o presenter onde o Interactor reside no lado cliente e o Command no lado servidor, o Interactor não tem como se comunicar diretamente com o Command. Neste caso, o interactor captura os eventos do usuário, e delega à contraparte cliente do presenter para lidar com eles. O presenter no lado cliente interpreta o evento e envia uma mensagem apropriada para sua contraparte no servidor, e esta sim executa o Command.

Exemplos de Aplicação MVP

Links Relacionados

domingo, 13 de dezembro de 2009

Do MVC para o MVP (Model-View-Presenter)

Este post é o segundo de uma série de traduções de artigos do blog Design Codes, que falam um pouco sobre a evolução do padrão MVC desde o final dos anos 70, até chegar aos dias de hoje, momento em que uma de suas variações - o MVP - está se popularizando, tendo inclusive sido citado como uma best practice no Google I/O 2009 para o desenvolvimento de aplicações GWT.


Clique Aqui Clique Aqui Clique Aqui


Neste artigo, iremos olhar mais de perto o design pattern MVP (Model-View-Presenter) e revisar a forma na qual ele evoluiu desde seus predecessores no Smalltalk ( "MVC Clássico" e "Application Model MVC"). Espero que, depois desta revisão, sejamos capazes de distinguir o MVP do MVC e endender o porquê de a discussão MVC x MVP deixar tanta gente confusa.

Abstract

O primeiro artigo sobre MVP foi pulicado em 1996 por 'Mike Potel' e declarado como a nova geração do modelo de programação C++ e Java da IBM. Era construído com base no modelo de programação do MVC Clássico do Smalltalk, com o intuito de se adaptar melhor aos novos sistemas que foram introduzidos na época e para suportar aplicações cliente-servidor (Leia mais em Web MVC).

O Smalltalk, que duas décadas antes inspirou muitas frameworks e bibliotecas com o MVC, buscava por uma nova arquitetura para a sua próxima geração de frameworks, chamada "Dolphin Smalltalk". Eles analisaram o 'Application Model MVC' (a partir de agora referenciado, neste artigo, por AM-MVC), que era a variação mais recente do MVC, e concluiram que ele não atenderia às suas necessidades. Continuaram procurando, até descobrirem o artigo da IBM descrevendo o MVP, muito similar ao AM-MVC, mas com a guinada certa que o tornava mais adequado ao que estavam procurando. Eles o lapidaram ainda mais, e chegaram a um MVP simplificado.

O modelo MVP do Dolphin Smalltalk ainda atende bem às frameworks atuais e tem sido usado como arquitetura base para aplicações Rich-Client e Thin-Client do .Net Framework (nota do tradutor: no Google I/O 2009, o MVP foi apresentado como uma best-practice para usar com o GWT). Leia mais em Web MVP.

Em 2006, Martin Fowler renomeou o "Dolphin MVP" para Supervising Controller, dando um passo atrás em direção ao AM-MVC, e apresentou uma outra variação do MVP chamada Passive View.

Este artigo foca no MVP/Dolphin e não no MVP/IBM por dois motivos:

  • Primeiro, por ser uma tendência atual. O MVP/IBM possui raizes extras como Interactor, Command e Selection desnecessários nos dias de hoje.
  • Segundo, este artigo tenta distinguir o MVP do MVC, apresentando-os lado a lado, e explicando a forma como o MVP evoluiu a partir do MVC.

Os adeptos do Dolphin apresentam o MVP como uma evolução do AM-MVC, onde o Presenter substitui o Application Model; A IBM, por sua vez, apresenta o MVP como uma evolução do MVC Clássico, onde o Presenter substitui o Controller. De fato, o MVP/IBM é o original, mas a abordagem do Dolphin é mais atraente e fácil de explicar, uma vez que o AM-MVC é muito mais próximo do MVP do que o Controller do MVC Clássico.

O Conceito MVC

A idéia por trás do MVC é fazer uma clara separação entre os objetos do domínio (model) e os objetos da apresentação (view/controller). Ele utiliza o mecanismo Observer-Synchronization para suportar múltiplas apresentações (observadores) de um mesmo objeto de domínio (observável), e para manter os objetos de domínio completamente desacoplados dos seus respectivos objetos de apresentação.

Este conceito foi largamente experimentado nas últimas três décadas, de forma que mesmo com as significativas melhorias que o MVP introduz, no final das contas o conceito continua o mesmo.

O MVC Clássico e o 'Application Model' MVC (AM-MVC)

Antes de continuar, é interessante ler sobre os predecessores do MVP, no primeiro artigo desta série, que fala sobre o Padrão MVC. Em resumo: Tanto no 'MVC Clássico' como no 'AM-MVC', a view é um widget da tela, e cada view tem como par um controller, que processa as entradas do usuário (por exemplo cliques de mouse e digitação no teclado), e comanda o modelo conforme apropriado. O AM-MVC introduz o 'Application Model', que age como uma classe intermediária entre o modelo e a apresentação (view/controllers), de forma a proteger o modelo de detalhes da apresentação.

O que há de errado com o AM-MVC?

Os adeptos do Dolphin Smalltalk esbarraram com o fato de que o AM-MVC não seria mais aplicável, e que ele tinha alguns problemas de usabilidade.

  • Não era mais aplicável, pois não mais havia necessidade por um controller para escutar aos eventos do mouse e teclado. Isso ocorreu após sistemas operacionais como o MS Windows diponibilizassem conjuntos nativos de widgets com os quais a UI podia ser construída. Os próprios widgets capturavam os eventos de mouse e teclado, tornando o controller desnecessário.
  • O maior problema de usabilidade era que, apesar do AM ser responsável por lógica da view, ele não podia acessá-la diretamente: Se por um lado, o AM deveria estar desacoplado da view através do mecanismo Observer Synchronization, ao mesmo tempo ele é responsável por funcionalidades da view, por exemplo alterar cores para destacar erros de validação, habilitar e desabilitar widgets, etc. Por isso, ele às vezes precisa ter acesso à view, o que rompe o padrão observer.

MVP - A guinada

Como mencionado acima, o MVC não é para ser meramente substituído. Podemos notar que o problema do MVC não está em seu conceito, e sim no papel que suas entidades (model-view-controller) desempenham. Ao invés de substituí-lo, o Dolphin deu uma guinada de 60° para o MVP.

Entidades

View é um conjunto de widgets, que respondem às ações dos usuários e deixando para o presenter o tratamento desses eventos. Seu propósito é exibir dados do modelo.

Presenter se encarrega da lógica de apresentação, comanda o modelo e altera a apresentação de acordo com as regras da aplicação. É altamente acoplada com a View

Model são os objetos de negócio que representam o domínio do problema, armazenando os dados, interagindo com o banco de dados e serviços externos, lidando com a lógica de negócio. É totalmente ignorante da UI (portanto desacoplada do view/presenter).

Colaboração

Como mencionado antes, o MVP/Dolphin se assemelha muito ao Supervising Controller.

  • User triggered action: a view delega as entradas do usuário para o presenter;
  • Update display: o presenter executa alguma operação relacionada a UI, alterando seu estado interno, e a atualizando diretamente
  • Command: o presenter comanda o modelo da forma apropriada
  • Event (State Changed): o modelo atualiza o seu estado e dispara um evento apropriado
  • A view trata o evento - e (Query) pega os dados relevantes diretamente do modelo, para poder atualizar sua exibição.

Dando um passo atrás em direção ao AM-MVC, temos o padrão Passive View

  • User triggered action: a view delega as entradas do usuário para o presenter;
  • Update display: o presenter executa alguma operação relacionada a UI, alterando seu estado interno, e a atualizando diretamente
  • Command: o presenter comanda o modelo da forma apropriada
  • Event (State Changed): o modelo atualiza o seu estado e dispara um evento apropriado
  • O presenter trata o evento - ele obtém os dados relevantes do modelo, e atualiza a exibição da view.

Revisitando os problemas do MVC

  • O Dolphin resolveu o problema da aplicabilidade do controller, movendo suas responsabilidades para a view e para o presenter. A view ficou com a responsabilidade de responder aos eventos de mouse e teclado (entradas do usuário), enquanto o presenter ficou com a responsabilidade de comandar o modelo quando apropriado.
  • O Dolphin resolveou o problema da usabilidade, substituindo o Application Model pelo Presenter, o qual tem permissão para se comunicar diretamente com a view quando necessário.

Note que a view no MVP/Dolphin (Supervising Controller) se comunica com o modelo e se registra com seus eventos, enquanto no AM-MVC toda interação entre a view e o model é intermediada pelo 'Application Model'. O padrão Passive View (Fowler) é descrito de forma semelhante, com a intermediação view/model sendo feita através do presenter.

Interação

Vamos colocar os conceitos em prática, revisando a GUI de controle de volume que usamos na primeira parte desta série.

Relembrando: o usuário clica no botão "aumentar volume", e em caso de sucesso, o volume é aumentado em uma unidade, e a caixa de texto exibe o valor do volume atualizado. Se o volume exceder 12, a cor da caixa de texto deve ser mudada para vermelho.

O diagrama abaixo mostra como o MVP (Passive View) lida com este caso de uso.

Vimos na primeira partedesta série que o Application Model (AM) lidava com as regras lógicas (alterar a cor) já que a lógica de apresentação fazia parte de suas responsabilidades, e vimos também que o fato de o AM não poder mudar a cor da caixa de texto diretamente levava a um código deselegante, com o AM tendo que disparar um evento para o caixa de texto.

No MVP, o presenter se encarrega da lógica de apresentação, sendo o único a ter que lidar com a regra: agora, o presenter pode mudara cor da caixa de texto diretamente, e nenhum código adicional é necessário.

Outra coisa a se notar é que o presenter responde ao evento "VolumeChanged" e delega este evento para a view, ao invés de alterar diretamente a caixa de texto para atualizar o valor do volume. A razão para mostrar isso é estressar o fato de que nem todas as atualizações precisam ser iniciadas diretamente pelo presenter. Este deve acessar a view diretammente apenas para comportamentos que não se encaixem no padrão Observer Synchronization (foi o caso da mudança de cor de um widget específico, como resposta a uma lógica da aplicação).

MVC x MVP

Há dois MVC's - MVC Clássico e Application Model MVC, assim como dois MVP's - Supervising Controller and Passive View.

Desta forma, há 4 tipos de combinações MVC x MVP:

1) MVC Clássico x MVP PassiveView

2) MVC Clássico x MVP SupervisingController

3) AM-MVC x MVP PassiveView

4) AM-MVC x MVP SupervisingController

Se entendermos as diferenças entre o MVC Clásico e o AM-MVC; bem como as diferenças entre o MVP-PV e o MVP-SC, uma comparação entre o AM-MVC e o MVP-PV deve ser suficiente para entender as quatro variações.

AM-MVC x MVP-PV

View

No AM-MVC (assim como no MVC Clássico), todo widget é uma view. No MVP, a view é a tela em si. A view do MVP é uma composição de widgets, agrupados em um container de widgets, onde a tela em si é um agrupamento de widgets ou de containers de widgets.

Presenter

O ApplicationModel no AM-MVC e o presenter no MVP-PV são ambos responsáveis pela lógica de apresentação, e ambos agem como classes intermediárias entre o modelo e a view. A grande diferença é que o presenter é altamente acoplado à view, podendo modificá-la diretamente, enquanto o AM é pouco acoplado à view, devendo se comunicar com ela somente através de eventos.

olhando de relance, pode parecer que o AM-MVC foi fracamente projetado. Se o AM está encarregado da lógica de apresentação, como pode estar pouco acoplado à view?? A razão disso é que o AM lidava com um número indeterminado de pares view-controller, então o comportamento padrão era agir como um observer - assim ele não tinha que ser alterado cada vez que um novo widget fosse adicionado à tela. Já o MVP lida com uma única view (a própria tela), de modo que o presenter pode ficar altamente acoplado à sua view.

Ainda que o padrão para o AM era o baixo acoplamento com relação à view, em aplicações reais frequentemente isto era burlado, e por comodidade se permitia o AM ganhar acesso às suas views, quebrando o padrão observer.

Model

O modelo desempenha o mesmo papel em ambas as abordagens, uma vez que ele está desacoplado das responsabilidades de apresentação.

Ainda confuso?

O principal motivo para tanta confusão é o uso exagerado e às vezes errôneo do termo controller.

Algums pessoas não levam em consideração o fato que o Controller MVC versa sobre processar a entrada do usuário e traduzí-la em comandos do modelo. Ele não versa sobre mediar a comunicação entre o modelo e a view. Este equívoco é a razão pela qual o controller é frequentemente referido como 'Application Model' (ou 'Application Layer'), da mesma forma como o MVP é usado, porém sob a denominação de MVC.

É importante entender que a principal função do controller é interceptar a entrada do usuário, outras funções como comandar o modelo e alterar a view são apenas subprodutos desta função principal; da mesma forma, a função do presenter é lidar com lógica da aplicação, e funções como interpretar eventos são subprodutos de sua função principal.

Com a introdução das aplicações web, a necessidade de processar entradas do usuário ressurgiu. Agora, as entradas são enviadas para o servidor na forma de pedidos HTTP, e o controller ressurge na forma de novos padrões:

  • Application Controller: lida com aspectos relacionados ao fluxo entre páginas (page flow);
  • Page Controller lida com pedidos para uma página específica; e
  • Front Controller lida com todos os pedidos de uma aplicação Web.

MVP ou não MVP? Eis a questão!

Em sistemas que possuiem um domain model complexo, um application model e muitas views que espelham os dados do modelo, pode fazer sentido pagar o preço do MVP (aprender o padrão, analisar o design, etc). Ao escolher o MVP, devemos nos responder se é possível separar o presenter da view. Algumas perguntas podem ajudar na decisão:

  1. Espera-se que o sistema tenha suporte tanto para aplicações desktop como web? Neste caso, faz todo sentido usar um Presenter para interagir com os dois tipos de view.
  2. O sistema tem muitas views requerindo mais de um presenter? Neste caso, é mais racional criar uma única view, com vários presenters, que podem ser substituídos "on-the-fly".
  3. Quando não for suficiente testar somente o domain model e quisermos testar também o Application Model.

Caso as considerações acima não sejam aplicáveis, o presenter pode ser embutido na própria View. Também depende do ponto de vista do desenvolvedor.

Para alguns, o MVP melhora a usabilidade, a leitura e a facilidade de busca / navegação no código da aplicação. É mais fácil entender métodos "PlayButtonClicked" no presenter do que onPlayButtonClicked na view. Também é cômodo fazer a view lidar apenas com questões de visualização, deixando o presenter lidar com a maior parte da lógica de reagir aos eventos do modelo.

sábado, 12 de dezembro de 2009

Considerações Históricas sobre o Padrão MVC

Este post é o primeiro de uma série de traduções de artigos do blog Design Codes, que falam um pouco sobre a evolução do padrão MVC desde o final dos anos 70, até chegar aos dias de hoje, momento em que uma de suas variações - o MVP - está se popularizando, tendo inclusive sido citado como uma best practice no Google I/O 2009 para o desenvolvimento de aplicações GWT

A História do Padrão MVC (Model View Controller)

Neste artigo, caminharemos nas duas primeiras fases da evolução do MVC. Iremos revisar o padrão MVC Clássico desenvolvido por Trygve Reenskaug para o Smalltalk no final dos anos 70, e ver como ele evoluiu para o Application Model MVC (a partir de agora referenciado, neste artigo, por AM-MVC; uma tradução conveniente seria MVC com Modelo de Aplicação).

Clique Aqui Clique Aqui Clique Aqui


O Conceito MVC

A idéia por trás do MVC é fazer uma clara separação entre os objetos do domínio (model) e os objetos da apresentação (view/controller). Ele introduz o mecanismo "Observer-Synchronization" para
  • suportar múltiplas apresentações (observadores) de um mesmo conjunto de objetos de domínio (observáveis); e
  • para manter os objetos de domínio completamente desacoplados dos seus respectivos objetos de apresentação.
Este conceito foi largamente experimentado nas últimas três décadas, e mesmo com algumas significativas melhorias que foram introduzidas com o MVP, no final das contas o conceito permanece inalterado.

MVC Clássico

View

Os componentes view são os widgets da tela, podem ser botões, labels, etc. Seu propósito é exibir dados do modelo (usualmente um de seus campos). No MVC Clássico, componentes view se comunicam diretamente com o modelo.
Tenha em mente que estamos falando de widgets dos anos 80, não importando se eles eram clicados por mouse ou pressionados através do teclado.

Controller

Um controller é a entidade lógica que sempre tem uma view (widget) como par. Ele processa a entrada vinda dos dispositivos como teclado e mouse, e comanda o modelo conforme apropriado. O controller também se comunica diretamente com o modelo.

Model

O modelo diz respeito aos objetos de negócio que representam o domínio do problema. Geralmente, estes objetos armazenam dados, interagem com bancos de dados e serviços, e lidam com a lógica do negócio. Eles são completamente ignorantes com relação à UI, portanto eles não sabem absolutamente nada sobre a view nem sobre o controller.

Colaboração

O diagrama abaixo mostra como os objetos MVC colaboram entre si. Os objetos no diagrama representam uma UI bem simples, que possui apenas dois widgets (representados pelos pares "view widget"/controller) e um objeto de negócio (representado pelo modelo).
  • O controller recebe as entradas do usuário,
  • Se a entrada for relevante para o seu par widget (view), ele comanda o modelo,
  • O modelo executa alguma operação, altera seu estado, e dispara um evento.
  • O widget (view) responde ao evento, pega os dados relevantes do modelo, e altera a sua exibição.
image_thumb9
O que não é mostrado na figura:
  • A view está acoplada a um método do modelo, de forma que ela possa obter os dados toda vez que houver alguma alteração.
  • O controller e a view podem se comunicar diretamente um com o outro.

    • Nota do tradutor: A view, portanto, está acoplada ao controller, e o controller à view.

Interação

A GUI controle de volume mostrada abaixo tem um único caso de uso.
  • Gatilho: O usuário clica no botão "Aumentar Volume"
  • Cenário Normal: O volume é aumentado em uma unidade e a caixa de texto é atualizada de modo a exibir o volume atual.
A modelagem para esta GUI terá um par view-controller para cada elemento visual (botão, caixa de texto, label) e um objeto modelo para memorizar o volume. O diagrama abaixo mostra como os objetos MVC interagem.

Application Model MVC (AM-MVC ou MVC com Modelo de Aplicação)

À medida que o Smalltalk evoluia, uma nova entidade denominada 'Application Model' (AM ou modelo da aplicação) foi adicionada de modo a proteger o modelo e a view das responsabilidades da lógica de apresentação. O AM age como uma classe intermediária entre o modelo e os objetos da apresentação (view/controller), que deixam de acessar diretamente o modelo (domínio). Ao invés disso, eles acessam o modelo da aplicação (AM), e se registram para os eventos do AM.

Colaboração

  • O controller recebe as entradas do usuário,
  • Se a entrada for relevante para o seu widget, ele comanda o AM,
  • O AM por sua vez, executa alguma operação relacionada à UI, alterando o estado interno da mesma,
  • O AM comanda o modelo, o qual executa alguma operação de negócio, altera seu estado e dispara algum evento
  • O AM responde ao evento do modelo, propagando-o para o widget.
  • O widget responde ao evento do AM, peg os dados relevantes no AM e alterando a sua vizualização

Pra que a mudança?

Vimos que o MVC clássico funciona bem com a GUI do "Controle de Volume". O problema é que na vida real, a UI provavelmete terá casos de uso mais complexos. Para ilustrar, adicionemos um caso de uso a esta GUI: se o volume exceder 12 unidades, então a cor da caixa de texto deve mudar para vermelho. A questão é: quem deve ser responsável por este pedaço da lógica de apresentação?
Podemos empurrar isto para o modelo, de modo que dele dispare algum evento especial quando o limite exceder 12 (mas isso parece inadequado). Podemos extender o widget da caixa de texto, de modo que ela verifique o seu valor e, quando aplicável, altere sua própria cor. Soa melhor, porém ainda é preferível manter os widgets genéricos e ignorantes de qualquer tipo de lógica.
Exatamente por este tipo de situações que o AM foi inventado.
O diagrama abaixo mostra como o AM lida com a nova regra.

  • O usuário clica no botão "Aumentar Volume",
  • O controller comanda o AM para aumentar o volume,
  • O AM delega o comando para o modelo,
  • O modelo comanda o auto-falante e dispara o evento "DataChanged",
  • AM respond and delegate the event to the widget,
  • O widget verifica com o AM qual o volume atual,
  • O AM checa o volume com o modelo, retornando o valor para o widget, que atualiza seu estado.
  • O AM checa se o valor é maior que 12, neste caso dispara um evento ColorChanged, ao qual o widget responde alterando sua cor.
Um benefício de usar o AM é que ele pode armazenar dados da view, como a cor atual do widget, qual item em uma lista está atualmente selecionado, quais widgets estão habilitados ou desabilitados, e assim por diante.

Qual o problema com o AM?

O AM possui uma limitação: ele não tem permissão para manipular sua view diretamente, NÃO pode simplesmente mudar a cor da caixa de texto, ao invés disso, precisa disparar o evento "ColorChanged", e deixar que o widget responda ao evento.
O próximo post, 'Do MVC para o MVP', será mostrado como o Padrão MVP soluciona este problema.