Perguntas sobre MVC Desktop! Existe solução? (+ MVP,MVC WEB,Observer e Exception's)

Numa aplicação desktop, a visão muda assim que o model muda, só assim para ter uma consistência. (Imagine seu tocador de MP3, onde a informação de uma música está sendo exibida em duas janelas diferentes. Quando você renomeia o título da música em uma janela, a alteração deve aparecer no mesmo instante na outra janela.) Isso é feito através do padrão Observer, onde seu model é o “observado” que notifica, a quem estiver observando, alguma alteração. O observador é a view, que quando notificado, fara re-renderização da janela (e sem intermédio de controller).

Agora, numa aplicação Web, o que existe é um MVC degenerado, porque as telas NÃO são atualizadas quando ocorre alteração do model (se você consultar um registro numa página, um outro usuário faz update nesse registro e você, depois, não fizer nada, então continuará a ver o mesmo dado antigo na tela).

@Rodrigo

Nunca disse para atualizar model sem passar pelo controller. O que a view poderia fazer diretamente é a consulta, CON-SUL-TA, ao model. Ok?

Outra, imagine uma entidade chamada Produto (model). Aí, quando você consulta, muito provavelmente chamará o controller, que é classe ProdutoAction e método consulta(), certo? Pela lógica do framework, a view será direcionada para /WEB-INF/pages/produto/produto-consulta-ok.jsp, que seria mais ou menos assim:

<p>Produto selecionado: ${produto.nome} <br>Por apenas <span class="preco">${produto.preco}</span></p>

Repare, a view conhece o model, sabe que existe um produto e este tem nome e preco como atributos.

Isso todo mundo faz, mas esquecem que esta é a implicação de que a view conhece o model, manipulando-o apenas para a consulta.

Fala Ferreira, obrigado por continuar atento acompanhando o tópico! :smiley:
Muito legal a explicação acima sobre MVC e suas variantes!

[quote=rodrigo.ferreira]Isto é pra web, que uso no dia-a-dia… Quanto à utilização em Swing, creio que seja a mesma coisa, mais não posso afirmar com exata certeza, pois não é a minha especialidade… porém, a sua dúvida presume a conclusão sobre MVC.
[/quote]

Essa ficou em aberto agora hein! Já é mais uma nova pergunta para os programadores Java SE!
E o MVC em Desktop, devemos seguir o mesmo para o modelo WEB?
Acredito eu que sim, só que nesse caso usariamos interfaces entre modelo<->controle E modelo<->visão. Estou certo?

Esses links são bons realmente. O primeiro e o última já os conhecia. O segundo foi novidade!

Realmente agradeço Ferreira sua colaboração, espero que continue acompanhando o tópico!
E para todos que estão lendo, respondendo ou não, agradeço antecipadamente pelo tempo utilizado aqui. :wink:
E espero por mais sugestões, contradições, visões diferentes, críticas, opiniões, etc.

Ah as perguntas que fiz acima continuam em aberto aguardando mais respostas! Não deixem de dar sua opinião! Obrigado.

Fala Leonardo, parabéns por estar aqui acompanhando o tópico!

Numa aplicação desktop, a visão muda assim que o model muda, só assim para ter uma consistência. (Imagine seu tocador de MP3, onde a informação de uma música está sendo exibida em duas janelas diferentes. Quando você renomeia o título da música em uma janela, a alteração deve aparecer no mesmo instante na outra janela.) Isso é feito através do padrão Observer, onde seu model é o “observado” que notifica, a quem estiver observando, alguma alteração. O observador é a view, que quando notificado, fara re-renderização da janela (e sem intermédio de controller).
[/quote]
Corretíssimo! O padrão Observer. É o que diz também grandes personalidades no mundo java sobre MVC Desktop.
Quero até deixar esse link que mostra um exemplo aplicado.
Não quero ser muito detalhista, mas o Observer usa a única herança disponível que temos na classe. Se for analisar bem, o Observer é o “controlador” entre modelo e visões.
Porque então não não implementar um método simples de atualização na visão na qual o controle chamaria toda vez que ele alterasse algo no modelo? (veja imagem em anexo) Quais problemas isso acaba gerando?

Veja como serão chamadas as classes:

Modelo model = new Modelo(); Visao view = new Visao(model); Controle control = new Controle(visão, modelo); Um problema (com ou sem Observer): Se o usuário do MP3 tentar colocar no nome da música caracteres inválidos. Como o usuário vai ficar sabendo disso, digo, como a visão mostrará o erro?

[quote=Leonardo3001]Agora, numa aplicação Web, o que existe é um MVC degenerado, porque as telas NÃO são atualizadas quando ocorre alteração do model (se você consultar um registro numa página, um outro usuário faz update nesse registro e você, depois, não fizer nada, então continuará a ver o mesmo dado antigo na tela).
[/quote]
Interessante é o seguinte: E se agora eu quiser passar minha aplicação Desktop para a WEB? Se eu fizer o desktop com esse “MVC degenerado” talvez eu ganhe um bom tempo, tendo somente que mudar a visão, não acha?

Valew galera estarem contibuindo com o tópico!
Com certeza muitos que estão aprendendo estaram se beneficiando com as opiniões!
Obrigado Leonardo por estar conosco! :wink:
Não deixem de continuar lendo e participando. Obrigado.



Pedro, bom dia! Agora você chegou no ponto certo! :slight_smile:

Diferença principal entre MVC 1 e 2:

“MVC1 it combines the presentation logic with the business logic where as MVC2 it seperates the presentation logic from business logic”

Pronto.

Este “MVC Degenerado” é utilizado, se não por todos, pela grande maioria dos sistemas web feitos em Java; ele é implementado por frameworks como: Struts 1x e 2, JSF (especificação oficial Java EE 5), Webwork, Spring MVC, VRpator etc… e utilizado em praticamente todos os projetos web feitos que em java que você possa usar (bancos, e-commerces, bolsas de valores, seguradoras, setor metalúrgico, de varejo, etc)… e permite o desacoplamento total da visão das outras camadas, logo, você pode facilmente trocar a visão, sem mudar nada no resto; este é o ponto…

Obs: SOA - ESB também utiliza praticamente este mesmo conceito, só que sem a visão (todas as chamadas são centralizadas num controller, e toda a parte de acoplamento é feito nele).

Resumindo: Em aplicações realmente corporativas (Java EE 5 - MVC-2), a visão não sabe nada sobre o modelo, e o modelo não sabe nada sobre a visão, o controle é a “ponte”… você pode utilizar a mesma interface do modelo para aplicações Web, Swing, batch ou até ME… a visão é desacoplada do restante, e isto, pode ter certeza, facilita e muito o trabalho (evitando retrabalho).

No final das contas, você deve utilizar o que se encaixar melhor no seu projeto. O MVC 1 é uma abordagem mais antiga de MVC (quando ainda não existiam muitos sistemas grandes e cheios de componentes), o MVC 2 é uma abordagem mais moderna (baseado no padrão Front Controller - http://java.sun.com/blueprints/corej2eepatterns/Patterns/FrontController.html), para descoplar totalmente as camadas (o que não é possível utilizando o padrão Observer - que gera uma total depedência). MVC-2 é o padrão oficial da especificação JEE 5, implementado pelo framework JSF (http://java.sun.com/javaee/javaserverfaces/)

A abordagem de JEE para JSE é diferente, portanto reitero, não sei exatamente como esta abordagem pode ser aplicada em Swing.

A escolha para qual se encaixa melhor no seu projeto é exclusivamente sua…

Abraço,

pedromuyala

Utilizar o padrão MVC em sistemas que envolvem swing + banco de dados ou web NA MAIORIA das vezes é muito difícil de implementa-lo na integra de forma que fique realmente satisfatório; por isso que causa bastante confusão. Porque vc implementa e no final fica aquela sensação de que está faltando alguma coisa ou o que foi feito não está correto.

Na minha opinião os seguintes aspectos complicam a implementação do MVC nestes sistemas (swing + bdo, web e etc… ).

  1. Eles necessitam da presença de vários outros padrões além do MVC.
  2. Na implementação do MVC existe a tendencia da utilzação do padrão Observer para se chegar na relação entre os 3 pontos (M, V e C) o que pode deixar a aplicação bastante complexa e dificultar muito o entendimento e a manutenção; muito embora alguns recursos tenham sido adicionados pela SUN para ajudar neste sentido.
  3. A busca da reação das ações e a baixa dependencia neste padrão muitas vezes gera fluxos bastante confusos.

O ideal seria adotar um framework para ajudar com este padrão, infelizmente para swing não tem muitos e os poucos que tem sempre tem algumas coisas esquisitas, mas é melhor que nada. Sem utilizar frameworks, geralmente é feita a implementação “parcial” do padrão na tentativa de organizar e facilitar as coisas assumindo que há limites.

flws

[quote=pedromuyala]Corretíssimo! O padrão Observer. É o que diz também grandes personalidades no mundo java sobre MVC Desktop.
Quero até deixar esse link que mostra um exemplo aplicado.
Não quero ser muito detalhista, mas o Observer usa a única herança disponível que temos na classe. Se for analisar bem, o Observer é o “controlador” entre modelo e visões.[/quote]

Não, nem tudo que controla é controlador, pelo menos não para o MVC. O controlador é estritamente para controle de eventos ou de entrada do usuário.

É um simples que acaba saindo caro. Imagine que eu tenha o model M, e eu tenha as views V1, V2 e V3 que a renderizam. Se quem as notificam for o controler C, então seus métodos explicitamente terão que chamar o método de atualização de V1, V2 e V3. Imagine que agora a view V4 também renderizará M, dái você terá que procurar todos os métodos do controler que já manda atualizar as views anteriores para atualizar também a V4. (Pior, e se você esquecer de algum?)

O Observer deixa as coisas meio complicadas a princípio, mas o benefício é que você não polui o Controller com código repetitivo.

Concordo. Quando disse “degenerado”, não quis menosprezar a implementação de MVC pela Web. Todos os frameworks web fazem um MVC “degenerado”, e isso não é nenhum demérito, pois a arquitetura cliente-servidor tem as suas limitações que precisam ser respeitadas.

A view não necessariamente é uma tela para um usuário, pode ser também um XML para consumo externo de outros aplicativos.

Não é. Se a visão não sabe do modelo, como ela se renderiza? Pela adivinhação? O controle sempre repassa o modelo pra view, e a view sempre conhece o model.

Bom dia Leonardo… vamos aumentar um pouco mais o tópico… rsrsrs :slight_smile:

Em JEE 5, utilizando MVC com JSF, por exemplo, a JSP conhece um java bean chamado "Managed Bean" (uma Action no caso do Struts 1x), que fica do lado da visão, e nada tem haver com o modelo; a JSP interage única e exclusivamente com este bean (do lado da visão). Este bean faz o "binding", obtendo todos os dados da requisição e devolvendo os dados para o JSP, automaticamente. Ao solicitar dados do modelo, a JSP chama o ManagedBean, que utiliza geralmente os padrões (Business Delegate, Service Locator e Session Facade), encapsulando a chamada para o modelo real... quando o modelo real responder a chamada, então o Business Delegate devolve os dados formatados para o Backing Bean que devolve os dados para o JSP... é um processo um pouco complexo para ser eficazmente explicado aqui.

Um exemplo básico do tutorial oficial da JEE 5 (http://java.sun.com/javaee/5/docs/tutorial/doc/bnaqq.html) seria:

Onde “myForm.jsp” faz binding com o managed bean “myUi.java” e este sim faz a chamada para um Business Delegate que faz o restante do processo…
O ponto aqui é o seguinte: Todo o acoplamento fica encapsulado no Business Delegate; este é o responsável por chamar o modelo real e caso haja alguma alteração neste modelo, é somente com este componente que você precisará se preocupar.

Leonardo, é óbio que é possível chamar o modelo diretamente da visualização, mas isso não é comumente utilizado por questões já citadas nos tópicos anteriores… Estou citando o padrão utilizado em aplicações web corporativas.

Abraço,

[quote=rodrigo.ferreira]Em JEE 5, utilizando MVC com JSF, por exemplo, a JSP conhece um java bean chamado “Managed Bean” (uma Action no caso do Struts 1x), que fica do lado da visão, e nada tem haver com o modelo; a JSP interage única e exclusivamente com este bean (do lado da visão). Este bean faz o “binding”, obtendo todos os dados da requisição e devolvendo os dados para o JSP, automaticamente. Ao solicitar dados do modelo, a JSP chama o ManagedBean, que utiliza geralmente os padrões (Business Delegate, Service Locator e Session Facade), encapsulando a chamada para o modelo real… quando o modelo real responder a chamada, então o Business Delegate devolve os dados formatados para o Backing Bean que devolve os dados para o JSP… é um processo um pouco complexo para ser eficazmente explicado aqui.

Um exemplo básico do tutorial oficial da JEE 5 (http://java.sun.com/javaee/5/docs/tutorial/doc/bnaqq.html) seria:

Onde “myForm.jsp” faz binding com o managed bean “myUi.java” e este sim faz a chamada para um Business Delegate que faz o restante do processo…
O ponto aqui é o seguinte: Todo o acoplamento fica encapsulado no Business Delegate; este é o responsável por chamar o modelo real e caso haja alguma alteração neste modelo, é somente com este componente que você precisará se preocupar.

Leonardo, é óbio que é possível chamar o modelo diretamente da visualização, mas isso não é comumente utilizado por questões já citadas nos tópicos anteriores… Estou citando o padrão utilizado em aplicações web corporativas.[/quote]

Rodrigo, você mesmo disse: “Ao solicitar dados do modelo, a JSP chama o ManagedBean”, ou seja, o JSP precisa do modelo para renderizar. Não interessa pra view se precisa requisitar o model pro Controller, ou o model é automaticamente injetado nela. O fato é que a view, nos dois casos, conhece o model e, portanto tem dependência dele. E nesse caso, o model ser chamado pela view (não interessa se é direto ou indireto) é bastante comum de ser feito.

O Business Delegate é model, assim como são Service Locator e Service Delegate. Eles têm a função de concentrar alguma regra de negócio ou de acesso, mas não “encapsulam o acoplamento” como você mesmo disse. Coesão e acoplamento são características do sistema como um todo, não dá pra separá-los num módulo do sistema.

Outra, e suas Entities? Elas são parte do model e comumente são retornadas elo Service Delegate. Se houver alguma alteração num getter de uma Entity, as views precisam ser alteradas; o que contradiz sua teoria de que a view é desacoplada do model.

Olá fantomas, boa tarde! Obrigado por estar participando conosco do tópico! :wink:

[quote=fantomas]pedromuyala

Utilizar o padrão MVC em sistemas que envolvem swing + banco de dados ou web NA MAIORIA das vezes é muito difícil de implementa-lo na integra de forma que fique realmente satisfatório; por isso que causa bastante confusão. Porque vc implementa e no final fica aquela sensação de que está faltando alguma coisa ou o que foi feito não está correto.

Na minha opinião os seguintes aspectos complicam a implementação do MVC nestes sistemas (swing + bdo, web e etc… ).

  1. Eles necessitam da presença de vários outros padrões além do MVC.
  2. Na implementação do MVC existe a tendencia da utilzação do padrão Observer para se chegar na relação entre os 3 pontos (M, V e C) o que pode deixar a aplicação bastante complexa e dificultar muito o entendimento e a manutenção; muito embora alguns recursos tenham sido adicionados pela SUN para ajudar neste sentido.
  3. A busca da reação das ações e a baixa dependencia neste padrão muitas vezes gera fluxos bastante confusos.

O ideal seria adotar um framework para ajudar com este padrão, infelizmente para swing não tem muitos e os poucos que tem sempre tem algumas coisas esquisitas, mas é melhor que nada. Sem utilizar frameworks, geralmente é feita a implementação “parcial” do padrão na tentativa de organizar e facilitar as coisas assumindo que há limites.

flws

[/quote]
Exato. Por isso não estou utilizando nenhum framework, justamente por sentir essa sensação de perder o controle durante o desenvolvimento.
Agora você tocou em um ponto interessante sobre o uso de padrões além do MVC. Fora o Observer (Desktop) e pelo que tenho visto também o Singleton e até mesmo o Reflection, algum outro se aplica?
Os fluxos confusos que se refere são os Listener’s, procede? Registrá-los na visão para que as classes internas do controle zejam acionadas!

Abração, obrigado por estar participando! :smiley:
Fico no aguardo pela resposta! Abraço.

Fala Leo, obrigado por continuar aqui discutindo esse assunto, na minha opinião, polemico! kkk.

[quote=Leonardo3001][quote=pedromuyala]Corretíssimo! O padrão Observer. É o que diz também grandes personalidades no mundo java sobre MVC Desktop.
Quero até deixar esse link que mostra um exemplo aplicado.
Não quero ser muito detalhista, mas o Observer usa a única herança disponível que temos na classe. Se for analisar bem, o Observer é o “controlador” entre modelo e visões.[/quote]

Não, nem tudo que controla é controlador, pelo menos não para o MVC. O controlador é estritamente para controle de eventos ou de entrada do usuário.

É um simples que acaba saindo caro. Imagine que eu tenha o model M, e eu tenha as views V1, V2 e V3 que a renderizam. Se quem as notificam for o controler C, então seus métodos explicitamente terão que chamar o método de atualização de V1, V2 e V3. Imagine que agora a view V4 também renderizará M, dái você terá que procurar todos os métodos do controler que já manda atualizar as views anteriores para atualizar também a V4. (Pior, e se você esquecer de algum?)

O Observer deixa as coisas meio complicadas a princípio, mas o benefício é que você não polui o Controller com código repetitivo.
[/quote]
Concordo com tudo isso aí. Acredito sim que realmente utilizando o Observer estaria implementando uma ótima solução para Desktop.
Tem uma forma (claro, um pouco complexa) de implementar usando Reflection (se não for isso que o Observer faz). Colocaria um método de atualização com o mesmo nome em todas as view’s e ao alterar o modelo, o controle por Reflection identifica as classes de visão e chama o método de atualização. Errado? Pode me corrigir se estou falando bobagem!
Pelo menos economizo a herança da classe. :idea:
Um outro detalhe: E se a visão é uma entrada de dados? E eu tiver várias visões para entrar dados. Como o controle vai “controlar” isso até esses dados chegarem na visão?

Obrigadão Léo por estar acompanhando o tópico, agradeço sem palavras! :wink:
Um abração! Não deixe de acompanhar!

Será que não existe um paradigma no MVC entre WEB-SWING?
Ou seja, tenho que fazer dois sistemas mesmo. Um desktop e um web?

Ou posso fazer o sistema desktop no padrão MVC2 citado pelo companheiro Ferreira?
Como ele mesmo deixou em aberto, será que se aplica bem em Desktop?

Não deixe de opinar, criticar, dar sua sugestão, idéia, tudo aquilo que possa benefeiciar o aprendizado de todos aqui do GUJ! :idea:
Com certeza é um assunto polemico não esperava! Mas vai sim beneficiar e ajudar muita gente! :smiley:
Um abraço a todos que acompanham e desprendem do seu tempo aqui respondendo ou simplesmente lendo o tópico! Obrigado.

[quote=pedromuyala]
Concordo com tudo isso aí. Acredito sim que realmente utilizando o Observer estaria implementando uma ótima solução para Desktop.
Tem uma forma (claro, um pouco complexa) de implementar usando Reflection (se não for isso que o Observer faz). Colocaria um método de atualização com o mesmo nome em todas as view’s e ao alterar o modelo, o controle por Reflection identifica as classes de visão e chama o método de atualização. Errado? Pode me corrigir se estou falando bobagem!
Pelo menos economizo a herança da classe. :idea:
Um outro detalhe: E se a visão é uma entrada de dados? E eu tiver várias visões para entrar dados. Como o controle vai “controlar” isso até esses dados chegarem na visão?[/quote]

O uso de Reflection apenas disfarça as dependências, com ou sem ela, o problema seria o mesmo. O padrão Observer é feito sem reflection.

É mais comum haver várias visões para visualizar dados do que para entrar dados. A razão é que formulários costumam aparecer em janelas modais (que bloqueiam a janela mãe) impedindo uma pessoa de visualizar dois formulários de inserção. Mas não havendo modal, poderia ocorrer de uma tela inadvertidamente atualizar uma outra tela que não deveria. Mas isso é exceção (normalmente queremos a propagação de atualização) e podemos tratar caso-a-caso.

Fala Léo!

[quote=Leonardo3001]
O uso de Reflection apenas disfarça as dependências, com ou sem ela, o problema seria o mesmo. O padrão Observer é feito sem reflection.

É mais comum haver várias visões para visualizar dados do que para entrar dados. A razão é que formulários costumam aparecer em janelas modais (que bloqueiam a janela mãe) impedindo uma pessoa de visualizar dois formulários de inserção. Mas não havendo modal, poderia ocorrer de uma tela inadvertidamente atualizar uma outra tela que não deveria. Mas isso é exceção (normalmente queremos a propagação de atualização) e podemos tratar caso-a-caso.[/quote]

Vamos tantar imaginar um sistema… esses sistemas pequenos de gestão, por exemplo, que estão no comércio (padaria, mercados, lojas, etc) que rodam localmente (Desktop).
Poderia estar até ligado a uma rede local (não deixa de ser Desktop). Concorda comigo que esses sistemas fazem forte uso de cadastro, digo formulários? Produto, cliente, pedidos, etc. Então pergunto: MVC se enquadra ao caso, não? Ou melhor usar MVC2? Se futuramente esses sistema precisar estar disponível na Internet?

Estou pegando um exemplo pequeno para que o novo desenvolvedor entenda melhor o conceito. Senão o assunto começa a ficar muito técnico e interesse do iniciante em aprender.

Já escutei algumas pessoas dizerem que a melhor solução é criar um sistema para a Internet, como a princípio não vai estar na Internet, fazer uma simulação de servidor WEB localmente, ou seja, o usuário já inicia no sistema trabalhando com ele em browser localmente e se no futuro pretender disponibilizá-lo na rede mundial nada precisaria ser alterado! Procede?

Ah pessoal, nem tenho mais palavras para agradecer aí o carinho de todos que estão acompanhando o tópico tentando ajudar de todas as maneiras. :roll:
Muito legal essa discussão, tenho certeza que estará beneficiando muita gente, isso é o mais bacana de tudo! Obrigado a todos.
Fico no aguardo por respostas. Quem não opinou, deu sua sugestão e/ou criticou ainda não tenha medo de estar atrasado! Poste no tópico. :wink:

[quote=pedromuyala]Vamos tantar imaginar um sistema… esses sistemas pequenos de gestão, por exemplo, que estão no comércio (padaria, mercados, lojas, etc) que rodam localmente (Desktop).
Poderia estar até ligado a uma rede local (não deixa de ser Desktop). Concorda comigo que esses sistemas fazem forte uso de cadastro, digo formulários? Produto, cliente, pedidos, etc. Então pergunto: MVC se enquadra ao caso, não? Ou melhor usar MVC2? Se futuramente esses sistema precisar estar disponível na Internet? [/quote]

Na minha opinião pode e deve utilizar MVC.

Depende, as vezes utilizar só páginas pode não ser a melhor solução. Sim, se o sistema já for web facilita muito ao disponibilizar na rede, não importando qual seja.

P.S Normalmente quem diz como o sistema deve ser são os requisitos; devemos evitar ao máximo impor idéias mirabolantes.

flws

Olá fantomas, obrigado por estar acompanhando o tópico! :smiley:

É acredito que seja melhor desenvolver um sistema já baseado na web mesmo rodando localmente, seguindo o MVC 2… e esquecer o MVC (aquele do Smalltalk).

Olha tenho três computadores em rede. Digamos que o computador 1 faz o papel de servidor. O computador 2 e 3 rodam o aplicativo que está no computador 1.
Nos computadores 2 e 3 estão com a view de um mesmo produto em aberto. Então o computador 3 altera a quantidade do produto e a sua view é atualizada.
Alguém sabe dizer se o computador 2 (lembrando que o aplicativo que está rodando no computador 1 foi implementado com MVC + Observer) vai atualizar a view para a quantidade correta ou computadores 2 e 3 terão view’s com quantidades diferentes? (assim como ocorreria em uma aplicação WEB)

Agradeço desde já todas as ajudas! São muito bem vindas! :wink:

[quote=pedromuyala]Olha tenho três computadores em rede. Digamos que o computador 1 faz o papel de servidor. O computador 2 e 3 rodam o aplicativo que está no computador 1.
Nos computadores 2 e 3 estão com a view de um mesmo produto em aberto. Então o computador 3 altera a quantidade do produto e a sua view é atualizada.
Alguém sabe dizer se o computador 2 (lembrando que o aplicativo que está rodando no computador 1 foi implementado com MVC + Observer) vai atualizar a view para a quantidade correta ou computadores 2 e 3 terão view’s com quantidades diferentes? (assim como ocorreria em uma aplicação WEB) [/quote]

Como já disse antes, as vezes não dá ou até não é aconselhavel implementar o padrão na integra; mas vamos lá mesmo assim.

Considerando este seu contexto:

Se o sistema for web:

  1. A máquina 2 executa uma atualização.
  2. Na máquinas 3 haverá apenas PÁGINAS renderizadas pelo navegador e seus scripts (javascript), suas atualizações à principio são baseadas em request / response ou através de um objeto que fica de tempos em tempos executando o que muitos chamam de refresh. Ou seja, o que vc está chamando de view não recebe estimulos de uma coisa chamada controller ou algo do tipo.

Como fazer então: Existe um esquena em AJAX que vc pode incluir no script da página para se tornar um receptor da mensagem enviada pelo server quando ouver alguma atualização. Me parece que o framework ZK já tem uma mecanismo chamado pushing que resolve esta questão.

Se o sistema for swing:

  1. A máquina 2 executa uma atualização.
  2. Na máquina 3 haverá apenas os formulários swing (utilizando mvc) conectado ao servidor (máquina 1); tambem não receberá a atualização do servidor sem ter alguma coisa que fique de tempos em tempos executando uma consulta no servidor.

Como fazer então: Vc poderia utilizar um implementação JMS atrelada ao controller dos formulários da estação; quando o servidor fizer uma atualização ele envia uma mensagem para o client e a atualização será efetuada (é claro que isto é implementado por vc nas rotinas que recebem as mensagens).

É isso ai…o sistema sempre sofre influencia do meio em que será executado.

flws

Olá fantomas! Estamos aí!

Então, como deve ter notado, não consigo enxergar o uso do padrão Observer.
Vamos tentar agora um exemplo diferente e que com certeza boa parte do pessoal vai entender:

Imaginem um sistema operacional como o Windows (vou pegar o Windows como exemplo, até porque o Linux é muito mais que um simples exemplo kkkk…). Se você está visualizando uma janela (janela nº1) com várias pastas e tiver uma outra janela (janela nº2) exibindo as mesmas pastas da nº1 e resolver deletar uma pasta da nº1 ou nº2 note que as duas janelas (nº1 e nº2) a pasta deletada também some, ou seja, ambas são atualizadas.

Podemos dizer (óbvio que o Windows nem de longe usa tecnologias boas como Java kkkk… Mais uma brincadeirnha! :D) que é um MVC DESKTOP COM OBSERVER?

Note também que se este mesmo caso estiver acontecendo em computadores diferentes ligados em rede (ou seja janela nº1 em uma estação e janela nº2 em outra estação) a atualização ocorre identica a do exemplo anterior citado.

Isso é MVC na camada de apresentação, ou estou enganado?
Valew pessoal, estou no aguardo por respostas! :wink: Obrigado.

Olhando por fora parece que sim, o problema é que Observer é apenas o nome de um pattern. Como vc pode chegar no mesmo resultado por outros caminhos fica dificil dizer sem analizar o código utilizado.

[quote=pedromuyala] Note também que se este mesmo caso estiver acontecendo em computadores diferentes ligados em rede (ou seja janela nº1 em uma estação e janela nº2 em outra estação) a atualização ocorre identica a do exemplo anterior citado.
Isso é MVC na camada de apresentação, ou estou enganado?
[/quote]

Eu acredito que sim, talvez a maneira com que foi implementado é que não seja como imaginamos.

flws

Pois então, esse comportamento dos exemplos acima parecem ser bem interessante.

A grande dificuldade, acredito eu, não é entender a teoria mas sim a forma de implementação.
Como separar as coisas!

Veja:
Modelo é só os Beans?
Persistencia, os métodos ficam escritos dentro dos Beans?
E controle, só responde ações da visão?
A visão reenderiza o bean do Modelo para mostrá-lo. Mas e se a visão for um formulário? Como os dados vão chegar até o modelo?
Como desacoplo visão do modelo? Com Observer em Desktop. Mas e na WEB?
Encapsulamento: Deve ser usada no Modelo, no Controle e na Visão?
Essas são as dúvidas dos iniciantes… :wink:

Não deixem de participar respondendo essas perguntas básicas.
Sabemos que para grande parte do pessoal são coisas tão simples que ficam até difícil de responder.
Mas por favor, não deixem essas perguntas em aberto. Obrigado pessoal!