Model-View -_____ apropriado


14

Estive lendo sobre o Model View Controller, o Model View Presenter, o Model View ViewModel, e assim por diante, e geralmente, o conceito subjacente parece bastante simples de entender: mantenha os visuais bonitos e as entranhas científicas tão separados e ignorantes um do outro quanto possível. Não é possível obter a lógica da manteiga de amendoim no chocolate de design; legal, eu gosto disso.

O problema é que ainda estou um pouco confusa quanto à terceira parte ... a que não é modelo ou visão. Todo mundo parece ter sua própria idéia de como chamá-lo, o que deve fazer, o que é adequado, o que está errado ... e estou ficando louco tentando descobrir quando um Apresentador se torna um ViewModel e quando um View não deve ' Não faça isso porque esse é o trabalho do apresentador e--

Estou divagando.

Em vez de pedir a alguém para explicar a diferença entre eles - porque isso já foi feito inúmeras vezes (eu sei; li mais artigos do que posso contar) - ficaria curioso em ouvir os pensamentos de um alguns programadores do modelo que eu mesmo fiz.

Dito isto, como você classificaria esse design como, e talvez mais importante, você vê algo sobre isso que obviamente é péssimo? Claro, eu adoraria ouvir que estou indo bem se esse design realmente for sólido, mas prefiro receber conselhos sólidos sobre elogios.

Nota: Eu vou usar "the Bridge" para a misteriosa terceira parte do Model-View-? para evitar sugestões subconscientes do que "deveria" ser.

Modelo

  • É a autoridade em dados.
  • Recebe informações sobre as mudanças solicitadas do Bridge.
  • Contém e executa toda a lógica de como os dados se relacionam com outros dados.
  • Informa o Bridge quando os dados são alterados (para dados nos quais o Bridge manifestou interesse). Edição de texto: permite que assinantes externos (sobre os quais nada sabe) monitorem seus resultados de estado ou cálculo.
  • Não tem conhecimento da vista.

Visão

  • Está preocupado em fornecer ao usuário uma maneira de visualizar e manipular dados.
  • Recebe informações sobre atualizações de dados do Bridge.
  • Contém e executa toda a lógica de como apresentar dados e controles ao usuário.
  • Informa o Bridge quando o usuário executou uma ação que (possivelmente) afeta o modelo.
  • Informa ao Bridge quais informações estão interessadas.
  • Não tem conhecimento do modelo.

Ponte

  • É o coordenador e tradutor entre o modelo e a visualização.
  • Faz as alterações de formatação apropriadas nas informações passadas entre o Modelo e a Visualização.
  • Mantém informações sobre "quem precisa saber o que".
  • Possui conhecimento do modelo e da visualização.

Notas Adicionais

  • Em programas mais complicados, é comum haver vários modelos. Nessa situação, o Bridge normalmente assume o trabalho de coordenar / traduzir entre os vários modelos e, portanto, se torna a autoridade sobre a qual modelos protocall / API / design devem ser construídos. (por exemplo, se você estiver construindo um programa de jogo de cartas e quiser criar um modelo de baralhamento alternado, use o Bridge para determinar quais funções são necessárias para a comunicação adequada com o Bridge.)
  • Em pequenos programas simples com apenas uma Visualização e Modelo, é comum o Bridge "assumir" que funcionalidade está disponível em ambos os lados. No entanto, à medida que os programas se tornam mais complexos, é recomendável que a (s) Visualização (ões) e Modelo (s) reportem sua funcionalidade ao Bridge, para evitar ineficiências e suposições de bugs.

Eu acho que isso cobre tudo. Por todos os meios, dou boas-vindas a todas as perguntas que você possa ter sobre o design que costumo usar e também encorajo quaisquer sugestões.

E como sempre, obrigado pelo seu tempo.


2
O bloco View apresenta um erro de copiar e colar. Eu acho que a última bala deve ler "Tem zero conhecimento do modelo". E a última frase da 1ª nota adicional provavelmente deve terminar com "modelo" e não "ponte"?
Johannes S.

Respostas:


7

Sua frase

"É o coordenador e tradutor entre o modelo e a visualização."

indica que seu Bridge é o Presenter em uma arquitetura MVP.

MVP e MVC são muito semelhantes, exceto que no MVP, apenas o Presenter observa o Modelo, enquanto no MVC a View também pode observar diretamente o Modelo (sem o Presenter como uma "Ponte").

Sua responsabilidade de modelo

"Informa o Bridge quando os dados são alterados (para dados nos quais o Bridge manifestou interesse)."

talvez seja pouco formulado ou talvez seja um erro: você não deseja que o Modelo dependa do Bridge / Presenter / Controller ou do View. Em vez disso, você usa um padrão Observador, Eventos ou Programação Reativa para permitir que o Bridge assine alterações no Modelo. E então você pode reformular sua responsabilidade como:

"Permite que assinantes externos (sobre os quais nada sabe) monitorem seus resultados de estado ou cálculo."

Se o seu modelo não possui dependências no seu controlador ou no modo de exibição, é mais fácil testar e muito mais portátil.


1
Se a principal diferença é se o View pode ou não observar o Modelo, então o design é definitivamente mais MVP; a View e o Model nunca podem falar diretamente no design que eu estou usando.
KoratDragonDen

A responsabilidade do Modelo era uma redação ruim, eu acho. O Modelo realmente não tem idéia ou se importa com o que / o que / por que as coisas querem ouvi-lo, mas simplesmente publicará quaisquer alterações que tenham sido feitas aos seus assinantes. É perfeitamente conteúdo existir sozinho sem assinantes de qualquer tipo e não faz nenhuma tentativa de solicitar novos assinantes.
KoratDragonDen

1
Parece que você tem um bom design, então. PS O motivo para considerar o MVC sobre o MVP é que, sem disciplina, o apresentador pode ficar sobrecarregado.
Larry OBrien

1
+1 por simplesmente indicar a diferença entre MVC e MVP. Como o OP, o resto da internet me deixou completamente perdida sobre se essas siglas eram mesmo um pouco diferentes.
Ixrec

5

Suspeito que uma das coisas que o confunde é que existem dois padrões totalmente diferentes que são comumente chamados de model-view-controller.

Existe o original, implementado em smalltalk e que é útil para sistemas de GUI locais, e há o que costumo pensar em web-mvc, que troca algumas das responsabilidades de visualizações e controladores para que os controladores possam se sentar no servidor com visualizações estando no cliente (talvez como renderizado em html ou talvez via ajax).

Sua descrição me soa como se estivesse dentro da maioria das definições de web-mvc.


Isso poderia explicar por que tenho tido tantos problemas para entender o conceito. Obrigado; é bom saber que (provavelmente) não estou fazendo nada terrivelmente errado com o conceito de MVC.
KoratDragonDen

Para aplicativos modernos da Web de página única, voltamos ao padrão clássico do MVC no lado do cliente.
kevin Cline

2

Há muita discussão na comunidade de programação sobre essa nomenclatura exata. Ninguém parece concordar com muita coisa.

Para mim, como a ponte é conectada à exibição determina principalmente o nome.

  • Se houver uma coleção de visualizações por ponte, a ponte será um controlador.
  • Se sempre houver uma visualização por ponte, a ponte será um apresentador.
  • Se pode haver uma coleção de pontes por vista, a ponte é um modelo de vista.

Às vezes as coisas não são tão claras. Por exemplo, um apresentador pode ser conectado a uma visualização composta feita de várias subvisões ou um controlador pode ser criado sem o conhecimento de suas visualizações. Apesar disso, acho que minhas regras são um bom começo.


Como uma observação lateral, eu gosto de emparelhar as responsabilidades como esta:

Modelo

Responsabilidade Primária: Persistir dados
Funções Secundárias: Validar atualizações, notificar observadores sobre atualizações

Visão

Responsabilidade Primária: Apresentar dados
Funções Secundárias: Aceitar entrada, apresentar UX

Ponte

Responsabilidade principal: atualizar dados
Funções secundárias: entrada limpa, sincronização de dados e visualizações


0

Embora o padrão sugerido pareça correto na superfície e, sem dúvida, funcione para pequenas instâncias, à medida que o aplicativo se torna mais complexo, você enfrenta problemas nos quais não tem certeza sobre o que atualiza o que, quem ouve onde e por que estou tentando para controlar tantos modelos de tantas visualizações, todos que precisam acessar um ao outro etc.

Eu recomendo estender suas idéias usando o seguinte padrão (extraído da palestra de Amy Palamountain Enemy of the State ):

Modelos

  • Estado de sincronização com o armazenamento de dados
  • Lidar com a validação de dados novos / atualizados
  • Gerar eventos quando eles mudam de estado

Visualizações

  • Modelos de renderização
  • Manipular eventos de modelo
  • Manipular eventos DOM
  • Medeia a interação entre Model e DOM

Controladores

  • Gerencia no máximo alguns modelos e visualizações
  • Monitora as visualizações em um contêiner

Módulos

  • O agrupamento lógico de um controlador e suas visualizações e modelos
  • Testável
  • Pequeno e sustentável (responsabilidade única)
  • Coordena (via Controlador) o estado e os eventos das Vistas e modelos que ele contém
  • Livre para apresentar suas próprias visualizações
  • Não é livre para escolher onde apresentar seus pontos de vista

Gerenciador de layout

  • Responsável pela composição do layout
  • Define um shell de aplicativo no DOM com áreas em que os Módulos podem apresentar seu conteúdo

Expedidor

  • Escuta Eventos (via fluxo global do PubSub)
  • Responsável por carregar novos Módulos baseados em Eventos
  • Entregue módulos carregados ao Gerenciador de Layout
  • Gerencia toda a vida útil do módulo (criação, limpeza, cache, etc)
  • Exemplos de eventos:
    • Alterações de rota (incluindo rota de carregamento inicial)
    • Interação com o usuário
    • Evento de módulo com bolhas de um evento de modelo devido a alterações de estado do servidor, etc.

Inscrição

  • Responsável pela configuração geral, instancia coisas como:
    • Expedidor
    • Roteador
    • PubSub stream
    • Loggers
    • etc

Esse tipo de padrão permite que seu aplicativo seja comporável, testado por unidade, remove a complexidade que um Bridge criaria ao longo do tempo, mantém as preocupações bem separadas, etc.

Como aponta Amy: Cuidado para não criar um servidor no cliente. E tome cuidado para não cair na doutrina de "Estou criando uma estrutura MV *, portanto devo ___!" Em vez disso, pegue todas essas idéias (e as outras respostas aqui) e encontre o que funciona melhor para seu aplicativo e equipe.

Eu recomendo assistir a palestra de Amy Palamountain Enemy of the State (de onde essas idéias vieram), ou pelo menos olhar os slides da palestra .

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.