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

domingo, 13 de março de 2011

GWT: A longa estrada

Em dezembro de 2009, decidi aprender GWT. Na época, estava interessado nas possibilidades desta escolha: apps mais inteligentes e interativas, menos round-trips no servidor, melhor tempo de resposta, envio de cálculos para serem feitos no lado cliente, deixando para o servidor apenas a responsabilidade de entregar os dados necessários para os cálculos, etc...

Porém o aprendizado não tem sido fácil. Em 2010, a principal referência de como arquitetar uma App GWT era a aprensentação de Ray Ryan, no Google I/O 2009. Ainda assim, os padrões apresentados mais pareciam peças de um quebra-cabeças, que precisavam ser experimentadas para encontrar o melhor encaixe, antes da grande figura se revelar e "cair a ficha" de como se tornar produtivo usando a tal caixinha de ferramentas...

Foi uma excelente experiência, onde extrapolei meus skills de programação, por 5 anos viciados no J2EE old-style modo de desenvolver. Este estudo rendeu frutos:
  • Artigos publicados na Revista MundoJ
    • Mar/2010 - Edição 40: Hello GWT!
    • Mai/2010 - Edição 41: GWT: Uma arquitetura MVP
    • Jan/2011 - Edição 45: GWT 2.1 e o Framework MVP Oficial da Google
    • Mai/2011 - Edição 47: Top Secret ("Aguarde e confie", parodiando o "grande trapalhão"...)
  • Sistemas Desenvolvidos:
Neste momento, estou tentando inserir a API RequestFactory na arquitetura. Já investi umas boas 30 horas tentando... Ela é mais intrusiva que as demais APIs - fornece facilidades tanto na integração com os Widgets, com a framework MVP, ainda que seu principal papel seja melhorar a comunicação cliente-servidor, viabilizando uma arquitetura baseada em DTOs. É uma API que dá um medo de começar a usar "de qualquer jeito", e criar pequenos frankesteins...

Para "piorar", sei que, depois desse aprendizado, ainda terei que investir mais umas boas horas para aprender a usar o GWT Designer e o Spring Roo, que prometem para o desenvolvedor benefícios tanto em usabilidade quanto em produtividade.

A API RequestFactory

De todos os desafios para aprender GWT, de longe o maior enigma está sendo a API Request Factory. Sua documentação é superficial, mostrando apenas como fazer a comunicação cliente-servidor. No release do GWT 2.2, a documentação foi complementada, mostrando como se usar uma abordagem ServiceLayer como alternativa à abordagem ActiveRecord introduzida pelo GWT 2.1. Mas a documentação ainda não ajuda muito a encaixar as peças da API com o restante do quebra-cabeças.

Depois de muito tentar e ainda não se sentir tão seguro com esta API, decidí debulhar a principal fonte de documentação disponível: o código-fonte da aplicação Expenses, distribuída no diretório samples do GWT. Minha expectativa é que, tentando refazer a aplicação, passo-a-passo, consiga finalmente compreender todo o poder e as facilidades que ela oferece.

O código-fonte será disponibilizado em https://github.com/fabiolnm/Expenses-GWT.

Happy GWTting!

segunda-feira, 28 de fevereiro de 2011

Sudoku Solver

Ontém, o amigo Edcana comentou no twitter que estava escrevendo um resolvedor de Sudokus. Sempre gostei desse jogo, mas nunca tinha passado pela cabeça em escrever um programa para resolvê-lo... E foi uma diversão interessante...

E foi uma diversão interessante... Abaixo uma versão parcial da aplicação, escrita em GWT, com 2 estratégias se solução (resolvem os níveis fácil e médio de problemas propostos no iGoogle). Já descobri uma terceira estratégia para resolver o nível hardest, mas ficará para a próxima semana.

O código está disponível em https://github.com/fabiolnm/Sudoku-Solver. A aplicação roda num iframe que mostra a app deployada no AWS (https://s3.amazonaws.com/mind_share/sudoku/index.html).

A primeira solução foi até tranquila... Porém o código mal-desenhado dificultou a adição de novas regras... Antes de conseguir adicionar uma segunda estratégia de solução, foi necessário fazer muitas refatorações no código. E sem testes, a solução de bugs só foi possível graças aos recursos de logging e debugging do plugin GWT para o Eclipse.

Nesta aplicação, me questinei se TDD seria útil... Minha compreensão sobre o problema mudou tanto e tantas vezes, que talvez se estivesse escrevendo testes antes, não teria conseguido avançar na velocidade desejada... Porém, quando precisei refatorar código, as alterações eram penosas. Sempre acrescentava bugs, que demorava para encontrar no debugger.

Entender melhor o domínio, e só depois de um certo ponto adicionar testes, seria um pattern ou anti-pattern? Argumento pró: acelerar tentativas e erros (TDD freia um pouco o processo de aprendizado?). Argumento contra: depois que a funcionalidade está escrita, dá preguiça de escrever teste...

Minha conclusão, depois desse problema, foi: não importa se vc faz testes antes ou depois. Antes de refatorar, escreva testes! O custo e o aborrecimento de quebrar funcionalidades justificam ter testes antes de qualquer modificação significativa do código.

É um bom momento, pois com uma aplicação minima rodando, alguns conceitos já foram provados, e os bad smells começam a ficar evidentes. E como não se quer quebrar nada a partir desse ponto, é uma motivação para começar a escrever testes, e através deles remover os bad smells e pogs inevitavelmente praticados durante a primeira prova de conceito da aplicação.

sábado, 18 de dezembro de 2010

Hands-on: Dependency Management com Maven - Parte 1

"E disse: Maven, a vida é pra valer..."

Neste post, listarei algumas vantagens de se usar o maven em projetos Java - todas de situações que já vivenciei na pele, e que o Maven resolve com agilidade e elegância. No final, segue uma série de screenshots mostrando desde a instalação do Maven no Eclipse, à criação de um projeto e à configuração de algumas dependências.

Happy Maven!

A parte 2 está disponível aqui.

Por que usar Maven?

  • Organização da Aplicação: layout-padrão amplamente aceito entre desenvolvedores
    • classes principais em src/main/java
    • classes de teste em src/test/java
    • arquivos de configuração e recursos em src/main/resources e src/test/resources
    • arquivos de aplicações web (html, jsps, css, etc) em src/main/webapp
  • Baixar e configurar automaticamente as dependências do projeto
    • bibliotecas (jars)
    • os javadocs das dependências, úteis para recursos como auto-complete das IDEs
    • os códigos-fonte das dependências, úteis para debug
  • Configuração de Builds da Aplicação
    • Possui tarefas para compilar (mvn:compile), testar (mvn:test) e empacotar (mvn:package) a aplicação.
    • Build pode ser customizado (mvn:build)
  • Versionamento de código
    • Não coloca jars no controle de versão: Menor tamanho-util do projeto no SCM
    • O pom.xml armazena o histório de dependências
      • Se num determinado branch é usado GWT 1.7, e em outro branch é feito o upgrade para o GWT 2.0
      • Como o pom.xml é versionado, ao migrar entre os branches, o Maven saberá exatamente qual versão da dependência utilizar
  • Trabalho em equipes / Configurações de SO e IDE
    • Versionamento de configurações de IDE são muito frágeis
      • Atreladas ao Sistema Operacional (por exemplo, localização de bibliotecas no filesystem)
      • Atreladas à versão da IDE (pode dar conflito quando são usadas versões diferentes da mesma IDE)
      • Atreladas à IDE (impede que o desenvolvedor utilize sua IDE favorita)
    • Como o Maven pode ser utilizado independente de SO, IDE ou versão da IDE, ele resolve também estes problemas.

ATENÇÃO

Quando mal-configurado, faz "backup da internet inteira no seu micro" - culpa de quem o configurou!

Hands On

Instalar Plugin Maven no Eclipse

Help > Install new software

Digitar o update site do Maven e clicar em Add...

Fornecer um nome para o Repositório Maven (neste caso, M2E)

Selecionar o plugin para a instalação

Em seguida, basta aceitar a Licença de Uso do Maven, aguardar o download e instalação do plugin M2E e reiniciar o Eclipse.


Criar projeto Maven

Após reiniciar o Eclipse, vamos criar um projeto Maven

Ao tentar criar o projeto, o plugin M2E alerta que o Eclipse precisa estar rodando sobre uma JDK. Por padrão, o Eclipse roda sobre a JRE default do sistema, que é simplesmente uma Máquina Virtual Java. O Maven, porém, depende de bibliotecas do Kit de Desenvolvimento Java (JDK) para funcionar. 

Caso ainda não tenha feito, instale uma JDK em sua máquina (por exemplo OpenJDK ou a Oracle JDK), e siga os passos abaixo para o plugin M2E funcionar.

Configurando JDK para o Maven

JRE nas Preferências do Eclipse

Window > Preferences

Java > Installed JREs (note que o Eclipse está usando a jre6 por default). Selecione a jre6 e clique em Editar.

Altere a propriedade JRE home para o diretório onde sua SDK foi instalada, e a propriedade JRE name para jdk6 (ou outro de sua preferência).

Pronto, agora o Eclipse está configurado para usar a Máquina virtual da JDK ao invés da JRE padrão.

Parâmetro -vm no eclipse.ini

Resta apenas alterar a Máquina Virtual sobre a qual o Eclipse é inicializado, o que é feito no arquivo eclipse.ini. localizado no diretório do Eclipse.

Adicione, no início do arquivo, o parâmetro -vm, apontando para a localização do executável javaw.exe que existe no diretório bin da instalação da JDK.

Criar projeto Maven (continuação)

Ao tentar criar o projeto Maven novamente, a mensagem de erro do Maven rodar sobre JDK não mais deve aparecer, e a sequência é ilustrada pelas telas abaixo.

Na tela seguinte, marque a checkbox "Create a simple project", pois neste primeiro momento, não queremos trabalhar com nenhum arquétipo do Maven.

Ao prosseguir, é necessário informar os dados do projeto. Em Group Id, é uma boa prática colocar o nome do pacote do projeto, em Artifact Id, o nome do Projeto. Por enquanto, deixe as demais opções como estão e clique em Finalizar.


Resultado:

Note que o projeto criado pelo Maven foi configurado, por padrão, para usar um ambiente de execução Java 5. Isto pode ser consertado com alguns passos simples:

Clique com o botão direito sobre o nome da JRE do projeto, e selecione a opção Configure Build Path

Selecione a JRE e clique no botão Edit

Marque a opção "Workspace default JRE" ao invés de "Execution Environment / J2SE5"

Layout final do Projeto e o arquivo POM (Project Object Model)

Agora, com o projeto corretamente configurado, abra o arquivo pom.xml. Trata-se de um arquivo xml onde são feitas as configurações do projeto. O Eclipse possui editores visuais que facilitam a edição deste arquivo, evitando que tenha que escrever xml "à mão". O arquivo xml pode ser editado diretamente, na aba pom.xml, mas para este tutorial, usaremos os recursos visuais que o Eclipse oferece.



Adicionando algumas dependências no Projeto

Como em próximos artigos pretendo abordar o desenvolvimento de projetos GWT usando Maven, simularei a adição das bibliotecas gwt-user e gwt-servlet no projeto. O mesmo conceito é válido para adicionar a maioria das bibliotecas existentes, como Spring, Hibernate, Guice, Struts, etc... Na aba Dependency, clique em Add.

Digite o nome da biblioteca que deseja localizar. Note que o Eclipse exibe o resultado da pesquisa exibindo o groupId (com.google,gwt) e o artifactId (gwt-user) do artefato localizado. Note também que, por padrão, o Eclipse realiza pesquisa de dependências no repositório central do maven (http://repo1.maven.org/).


É possível configurar o Eclipse para pesquisar dependências em outros repositórios - por exemplo https://repository.jboss.org/nexus/content/groups/public/. Para tal, é necessário configurar um arquivo MAVEN_HOME/settings.xml (isso será abordado em um outro artigo).

Importamos também a biblioteca GWT-Servlet:

Depois de adicionar as dependências e salvar o arquivo pom.xml, o plugin do Maven se encarrega de baixar as dependências e configurar o Build Path da aplicação.

Pronto! O projeto está configurado, e as bibliotecas do GWT disponíveis para desenvolvimento.
Note, ao lado das bibliotecas em Maven Dependencies, que o plugin do Maven as salvou no diretório HOME do usuário, em um subdiretório .m2. Este será o repositório de bibliotecas que o Maven utilizará para gerenciar as dependências dos projetos.

Por agora é só, espero que este tutorial seja esclarecedor e motive a utilizar essa ferramente poderosa que é o Maven!

segunda-feira, 1 de novembro de 2010

Familiarização com a API RequestFactory do GWT 2.1

Uma das novidades introduzidas pelo GWT 2.1 diz respeito a uma nova abordagem a serviços orientados a dados, responsáveis pelas operações CRUD da aplicação. Esta abordagem oferece formas de automatizar as tarefas relacionadas ao tratamento dos DTOs, responsáveis por trafegar os dados entre cliente e servidor.

Além disso, o GWT finalmente passa a oferecer uma solução para o binding entre os dados dos objetos e os widgets da UI. Outra vantagem de utilizar esta API é que ela oferece funcionalidade para cache de objetos; atualização das views quando perceber que um objeto na cache sofre alterações; menor payload na comunicação cliente-servidor, pois apenas as diferenças (deltas) são enviadas em cada requisição; e suporte a JSR-303 (Beans Validation).

Este post é a tradução que fiz para a documentação deste novo framework. Boa Leitura!

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

RequestFactory é uma alternativa ao GWT-RPC para criação de serviços orientados a dados. RequestFactory e suas interfaces relacionadas (RequestContext e EntityProxy) facilitam a construção de aplicações orientadas a dados (CRUD), projetada para ser usada em conunto com uma camada ORM como JPA ou JDO no lado servidor.

Benefícios

RequestFactory facilita a implementação de uma camada de acesso a dados tanto no lado cliente como no lado servidor. Ela permite que o lado servidor seja estruturado numa forma centrada nos dados, e provê um nível maior de abstração do que o GWT-RPC (uma vez que este último é orientado a serviços, e não orientado a dados). No lado cliente, RequestFactory gerencia os objetos que tenham sido modificados, enviando apenas as diferenças para o servidor, o que resulta em payloads de rede muito leves. Além disso, RequestFactory provê uma sólida fundação para batching automático e cache de solicitações.

Como ela se relaciona com GWT-RPC?

RequestFactory usa um servlet próprio, RequestFactoryServlet, e implementa seu protocolo próprio para troca de dados entre cliente e servidor. Não foi desenhada para serviços de propósito geral como o GWT-RPC, mas sim para serviços orientados a dados, conforme veremos a seguir. RequestFactory NÃO utiliza GWT-RPC, e nem pretende substituí-lo. Foi projetada especificamente para implementar uma camada de persistência tanto no lado cliente como no lado servidor.

Codificando com RequestFactory

Vamos dar uma olhada nos componentes de uma aplicação que utiliza RequestFactory (Entity, EntityProxies, Interface RequestFactory e Implementações no Servidor), e em seguida, olharemos como são utilizados.

Entities

Uma entidade é uma classe do domínio da aplicação que pode ser persistida em um datastore, por exemplo um banco de dados relacional, ou no datastore do Google AppEngine. Em frameworks de persistência como JPA e JDO, entidades são anotadas com @Entity. Esta anotação não é exigida pela RequestFactory, mas quando falarmos de entidades neste guia, é sobre estas classes de domínio que estamos nos referindo. Segue abaixo parte da definição de uma entidade da aplicação de exemplo Expenses, distribuída junto com o GWT.

Entity Proxies

Um entity proxy é uma representação client-side de uma entidade, também conhecida como DTO (Data Transfer Object). Deve estender a interface EntityProxy, indicando que um objeto pode ser gerenciado por uma RequestFactory. A RequestFactory popula automaticamente as propriedades entre as entidades no lado servidor e o proxy correspondente no lado cliente, simplificando o uso do pattern DTO. Além disso, a interface EntityProxy possibilita que a RequestFactory avalie e envie apenas as mudanças (deltas) para o servidor. Abaixo, está o EntityProxy correspondente à classe de domínio Employee que acabamos de mostrar.

Além de estender a interface EntityProxy, é necessário também utilizar a anotação @ProxyFor para referenciar a entidade do lado cliente que está sendo representada. Não é necessário representar todas as propriedades e métodos da entidade server-side no EntityProxy, apenas os getters e setters das propriedades que precisem ser acessadas no lado cliente. Note que, apesar desde exemplo mostrar um método getId(), normalmente o código cliente utilizará o método EntityProxy.stableId(), uma vez que o EntityProxyId retornado pela chamada stableId() é usado através pelas classes relacionadas ao RequestFactory. Note também que o método getSupervisor() retorna uma associação a uma classe Proxy. As associações no código cliente também devem ser implementadas como subclasses de EntityProxy. RequestFactory automaticamente converte os proxies para as entidades correspondentes no lado servidor.

A interface RequestFactory

Similar ao GWT-RPC, é necessário definir uma interface entre o código cliente e o código servidor. A interface RequestFactory da aplicação consiste em métodos que retornam stubs de serviços, como no exemplo Expenses:

E o stub do serviço EmployeeRequest:

Os stubs de serviço devem estender RequestContext, e usar a anotação @Service para indicar a classe correspondente da implementação do serviço no servidor. Ao invés dos métodos do stub de serviço retornarem diretamente as entidades, eles retornam objetos que são subclasses de com.google.gwt.requestfactory.shared.Request. Isto permite que os métodos nesta interface sejam invocados de forma assíncrona, pela chamada Request.fire(), de forma similar à passagem dos objetos AsyncCallback nos serviços GWT-RPC.

Da mesma forma que as chamadas GWT-RPC passam um AsyncCallback que implementa os métodos onSuccess e onFailure, Request.fire recebe um Receiver como argumento, que deve implementar o método Request.onSuccess(). Receiver é uma classe abstrata que já oferece uma implementação padrão para onFailure(), que simplesmente dispara uma RuntimeException. Para alterar a implementação padrão, pode-se estender Receiver e sobrescrever o método onFailure(). Receive possui também um método onViolation(), que retorna as violações de regras de validação (JSR 303) no servidor (veja Validação de Entidades no final do artigo).

Os métodos retornam objetos Request que são parametrizados genericamente com o tipo de retorno do método do serviço. Este será é justamente o tipo do objeto esperado como argumento pela chamada onSuccess do Receiver. Métodos que não retornam valor devem retornar Request<Void>. Requests podem ser parametrizados com os seguintes tipos:

  • Tipos-Valor: BigDecimal, BigInteger, Boolean, Byte, Enum, Character, Date, Double, Float, Integer, Long, Short, String, Void
  • Entidades: quaisquer subclasses de EntityProxy
  • Coleções: List<T> ou Set<T>, onde T é um tipo-valor ou uma subclasse de EntityProxy.

Note que tipos primitivos não são suportados, devendo-se usar os wrappers correspondentes. Métodos que operam sobre a entidade - por exemplo persist() e remove() retornam objetos do tipo InstanceRequest ao invés de request, o que será explicado na próxima seção.

Implementações no lado servidor

No lado servidor, os métodos definidos numa interface de serviço de uma entidade são implementados na classe definida na anotação @Service. Nestes exemplos, as implementações foram feitas nas próprias classes das entidades. Ao contrário dos serviços GWT-RPC (cujas implementações devem estender a interface RemoteService), os serviços não deverão implementar a interface RequestContext, pois os argumentos no lado-cliente retornam tipos para os proxies das entidades, enquanto que as implementações server side retornam os proprios objetos de domínio das entidades.

No lado servidor, o serviço deve implementar cada método definido na interface RequestContext, mesmo que isto não signifique implementar formalmente a interface em Java. O nome do método e a lista de argumentos são os mesmos tanto no cliente e no servidor, segundo as seguintes regras de mapeamento:

  • Métodos que no lado cliente retornam Request<T>, retornam apenas T no lado servidor. Por exemplo, se um método retorna Request<String> no cliente, a implementação do lado servidor retorna String.
  • O lado servidor retorna as entidades de domínio onde no lado cliente são retornados EntityProxies. Se o lado cliente retorna Request<List<EmployeeProxy>>, a implementação no lado servidor retornará List<Employee>
  • Métodos que retornam um objeto Request na interface cliente devem ser implementados como métodos estáticos na implementação no servidor como no exemplo Employee.findAllEmployees().
  • Métodos que operam sobre uma instância específica de uma entidade - por exemplo persist() e remove(), devem retornar um InstanceRequest na interface cliente. Estes métodos não recebem diretamente o objeto como argumento, ao invés disso, o objeto é passado em chamadas InstanceRequest.using().

Quantro métodos especiais são obrigatórios para todas as entidades que sejam usadas pelo servlet RequestFactory:

  1. Um construtor sem argumentos - pode ser omitido caso a classe não tenha nenhum construtr explícito, o construtor implícito é usado.
  2. id_type getId()
  3. static entity_type findEntity(id_type id)
  4. Integer getVersion()

O método getId() deve retornar o ID da entidade persistente, o qual deve ser do tipo String ou Long. Normalmente é um valor gerado automaticamente pela infra de persistência (JDO, JPA, Objectify, etc).

O método "find By Id" de uma entidade tem uma convenção de nomes especial. No lado cliente, há um método find() definido já na interface RequestFactory, que os serviços estendem. No servidor, deve haver um método find, seguido do nome da entidade (por exemplo, findEmployee para a entidade Employee), recebendo como argumento o ID da entidade (um String ou Long).

O método getVersion() é usado pela RequestFactory para inferir se uma entidade sofreu alterações. A framework de persistência (JPA, JDO, etc) será responsável por atualizar a versão, toda vez que o objeto for persistido. A RequestFactory chama callVersion() para saber se ocorreram mudanças no objeto.

Esta informação é usada em dois lugares. Primeiro, RequestFactoryServlet envia um evento UPDATE para o cliente caso a entidade seja modificada como resultado da execução de uma operação no servidor, por exemplo, quando ao persistir a entidade resultar em uma nova versão desta entidade, no servidor. Segundo, o cliente mantém uma cache das últimas entidades carregadas. Todas as vezes que a versão de uma entidade mudar, são disparados eventos UPDATE no event bus de modo que os listeners possam atualizar a view.

Juntando todas as peças

Uma vez criadas as entidades e seus proxies, a RequestFactory com suas interfaces de serviços, deve-se criar esta última através de uma chamada GWT.create, e inicializá-la injetando nela o EventBus:

Usando o requestFactory

Configurado o RequestFactory, vejamos como ele funciona. O método RequestContext.create() é usado para criar uma novo proxy de entidade no cliente, o qual é persistido usando um método definido na interface de serviço da entidade:

Todo o código do lado cliente deve usar os proxies das entidades, e não as entidades propriamente ditas. Desta forma, os objetos de domínio não precisam ser compatíveis com o GWT, diferentemente do GWT-RPC, onde o mesmo tipo concreto é usado tanto no cliente como no servidor.

EmployeeProxy é uma interface, não uma classe, devendo seus objetos serem instanciados através de chamadas requestContext.create(EmployeeProxy.class). O benefício desta abordagem possibilitar que RequestFactory gerencie a criação e modificação dos objetos, de forma que ela possa enviar apenas as diferenças para o servidor.

O método persist() não possui argumentos, o que é consistente com a implementação do método na entidade Employee. Na interface EmployeeRequest, este método retorna um objeto InstanceRequest, que por sua vez recebe o objeto a ser persistido através da chamada using().

Vejamos agora o código para salvar o objeto Employee no servidor:

Disparamos um request usando o Receiver, passando para ele um callback que notifica a aplicação quando a solicitação for completada.

Em objetos objetos que não tenham sido criados pela chamada RequestContext.create(), por exemplo aqueles recebidos em consultas ao servidor, é necessário habilitar a edição, através de uma chamada RequestFactory.edit(). Todos os proxies para relacionamentos de um proxy que jpa se encontra no estado editável será também editável.

O método edit() retorna uma nova cópia do proxy, que é inicialmente um objeto imutável, e o proxy original pode ser descartado. Para enviar as alterações para o servidor, deve-se criar um novo request. Todas as edições ocorrem dentro de um contexto específico, e quando este contexto é disparado, todas as edições são enviadas, quaisquer invocações de métodos resultarão em alterações a serem enviadas para o servidor.

Relacionamentos entre Entidades

Alterações nas entidades relacionadas podem ser persistidas em uma única requisição. Por exemplo, este código extraído da aplicação de exemplo DynatableRF, cria uma Pessoa e um endereço em uma única operação:

RequestFactory envia automaticamente o grafo completo do objeto em uma única requisição. Neste caso, a implementação de Person.persist() no servidor é responsável por persistir também a associação Address, o que pode ou não ocorrer automaticamente por regras de cascading, dependendo de qual framework ORM é utilizada e de como o relacionamento for definido usando esta framework. Note que RequestFactory ainda não suporta componentes @Embedded, pois ele espera que toda entidade exista independentemente, com seu próprio ID.

Ao realizar consultas no servidor, RequestFactory não popula automaticamente os relacionamentos no grafo de um objeto. Para carregar os relacionamentos, use o método with() no request, especificando os nomes das proproedades das relações que devem ser carregadas

Validação das Entidades

RequestFactory suporta validação com JSR 303. Isto torna possível manter as regras de validação no lado servidor e notificar o cliente quando uma entidade não puder ser persistida devido a erros de validação. Para usar, assegure-se que uma implementação da JSR-303 esteja disponível no servidor, e anote as entidades com as anotações javax.validation, como @Size e @NotNull. Antes de invocar o método do serviço no servidor, RequestFactory chamará a framework de validação e enviar as ConstraintViolation do servidor para o cliente, o qual chamará o método onViolation() no objeto Receiver usado no request.

Conclusão

RequestFactory está no cerne das novas funcionalidades de Binding no GWT 2.1. Em artigos futuros, estas funcionalidades integradas em Cell Widgets, Editors, ao Event Bus, e Activities e Places.

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.

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.