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

Olá Bruno, boa tarde!
Obrigado pela indicação mas eu já havia visto a matéria do Eduardo. Até cheguei a dizer em posts anteriores indicando para quem estivesse também interessado para ler! :smiley:

Ainda estou tentando entender o MVC. Ainda tenho muitas dúvidas que, ao meu ver são perguntas simples mas como cada desenvolvedor tem um hábito (um jeito) na qual de familiariza mais acabo ficando perdido nesse meio, infelizmente. Gostaria muito de desenvolver o MVC em uma forma que qualquer desenvolvedor que vier a ler o código entenda sem muitas dificuldades. Meu problema que realmente está me “travando” é o MVC. :frowning: Mas vou tentar formular minha pergunta de uma forma abstrata que fique fácil as pessoas entenderem e poderem colaborar! :slight_smile:

Muito obrigado mesmo por não ter se esquecido do tópico, fico muito contente! :smiley:
[color=red]Um abração Bruno, felicidades.[/color]

É uma pessima pratica usar exceções para tudo… vc pode usar exceções para mensagens de negocio tranquilamente até é mais facil de manipular a app assim… pode ser feito o seguinte: criar somente 1 classe de excecao de negocio onde vc passe a menssagem tipo: cpf invalido, cnpj invalido, qualquer coisa invalida, dai caso for sua exceção de negocio ele a mostra na sua view como uma mensagem normal, e caso for um erro como um Nullpointer, ou uma exceção de banco de dados ele vai para uma pagina de erro… assim é bem mais facil de controlar isto…

Eu vou pela receita que a minha vó me ensinou: Nem oito nem oitenta.

É ruim ter quase nada, também é ruim ter em excesso. O ideal é o caminho do meio, saber medir.

Digo o mesmo para o próprio MVC, ele não é a solução para todos os problemas. Muita coisa é melhor resolvida sem ele, então não tente aprender tudo só trilhando esse caminho. É até bom que esteja travado, tente seguir por outros métodos de fazer a mesma coisa, uma visão diferente pode até te ajudar a entender melhor o que você estava vendo. Basta tempo e paciência.

Olá pessoal, boa noite! :smiley:

Luistiagos, obrigado pela dica da Exception. Também pensei exatamente isso que falou!
Achei legal sobre os exception’s em geral. Como o controle seleciona a visão, caso uma exceção que não conheço ocorra, ele pode solicitar uma nova visão acusando um erro. Muito legal! :idea:
Porém quanto ao uso de uma Exception para tudo força que as informações de erro (menssagens) fiquem fora da visão e aparentemente seria melhor deixar detalhes da visão na visão, ou não?

Acho que o Laturner tem razão quando diz que estou muito “mente fechada” só para MVC. Mas estou estudando o caso do MVP também que o fantomas indicou em um post anterior e até mesmo o uso de frameworks postados bem anteriormente… até porque a teoria do MVC não diz nada sobre validações, banco de dados, exceções… Acredito que essa parte é livre para cada um implementar da forma que achar melhor como no nosso caso real de utilizar exceções para validações.

Assim sendo, tenho uma pergunta bem amadora: Quais as responsabilidades do controle no MVC para Desktop [color=red](não WEB)[/color]? O que ele de fato deverá fazer? :shock:

  • Sabemos que a visão é quem mostra o estado do modelo ao usuário. (ou várias visões)
  • Sabemos que é no modelo que estão os dados a serem exibidos.
  • E o controle??? Essa foi uma pergunta feita no início do tópico que gerou muita discussão. :? Mas com o andar da carroagem a essa altura gostaria de saber de vocês o que entendem nesse momento que é dever do controle? :slight_smile:

Opine, não deixe de opinar, seja veterano no tópico ou um novo leitor! Tem dúvidas, pergunte aqui também, sem se acanhar!
[color=orange][size=16]Obrigado a todos, sem exceções![/size][/color] (kkkk… :thumbup: )

Nem uma ídéia? :idea:
A pergunta está mal formulada? :?

Não respondi pq nunca trabalhei com Desktop. Umas perguntas retóricas:

Que diferença você vê entre Desktop e Web? Qual a diferença da View Web da View Desktop? Qual a diferença do Controller Web do Controller Desktop? Há diferenças entre Model Web e Model Desktop?

Também sou um aluno aqui :slight_smile:

Boa tarde Bruno!
Vou responder aquilo que sei, pois WEB sou muito ruim. Mas vamos lá:

Desktop não precisa usar servlet’s como controlador. Porém para mim no Desktop o controlador só é uma “ponte” para visão e modelo se comunicarem.
Não faz validações, não trata eventos da visão… Não faz nada a não ser criar uma instancia do modelo para poder alterá-lo ou passar dados da visão para ele. E dependendo do que for solicitado na visão, pode trocar a visão ou alterar a visão sem fazer nada no modelo.

Desktop usa Swing/AWT.

Não existe, a não ser usar servlet.

Não existe, ao meu ver, é o mesmo.

Valew Bruno! :smiley:

Uma situação:

Você tem uma aplicação desktop, e você move o model para um servidor remoto, numa máquina diferente. Não querendo que a cara da aplicação mude, você mantém a mesma view. Neste caso tem que mudar somente o Controller, considerando que eles mantém a mesma interface e tratamento de eventos da view?

Bruno, olá!

[quote=Bruno Laturner]Uma situação:

Você tem uma aplicação desktop, e você move o model para um servidor remoto, numa máquina diferente. Não querendo que a cara da aplicação mude, você mantém a mesma view. Neste caso tem que mudar somente o Controller, considerando que eles mantém a mesma interface e tratamento de eventos da view?[/quote]

:arrow: Então Bruno até aí entendi a situação! Só uma coisa que fiquei na dúvida: A visão deve ter uma interface e o controle um implements dessa interface da visão?

Na verdade, a pergunta é a seguinte:

A visão conhece o modelo para se reenderizar;
O modelo é o domínio do sistema. Não conhece ninguém.
O controle recebe eventos da visão e altera o modelo. É aí que surge a dúvida: Quando diz: “O controle recebe eventos da visão” significa que quando eu clicar em um botão da visão ela chamará um método do controle?

Ex:
Botão adicionar da visão chama controle.adicionar(par1, par2, par3);
Botão remover da visão chama controle.remover();

Aguardo pela resposta! :smiley:
Quero deixar um abraço para o Bruno que tem me ajudado bastante aqui no fórum! :wink:

[quote=pedromuyala]Na verdade, a pergunta é a seguinte:

A visão conhece o modelo para se reenderizar;
O modelo é o domínio do sistema. Não conhece ninguém.
O controle recebe eventos da visão e altera o modelo. É aí que surge a dúvida: Quando diz: “O controle recebe eventos da visão” significa que quando eu clicar em um botão da visão ela chamará um método do controle?

Ex:
Botão adicionar da visão chama controle.adicionar(par1, par2, par3);
Botão remover da visão chama controle.remover();

Aguardo pela resposta! :smiley:
Quero deixar um abraço para o Bruno que tem me ajudado bastante aqui no fórum! :wink:[/quote]

Oi Pedro,

Deixa eu intrometer um pouco… hehe…

Na verdade é o contrário, pelo menos como eu entendo - me corrigam se estiver errado - , é responsabilidade do controle avisar a visão quando alguma coisa mudar

Para entender melhor dê uma lida no pattern observer que vai te esclarecer bem

t+

Olá André, obrigdo por estar atento ao tópico! :smiley:

Então o Observer avisa as visões sobre a mudança do modelo para que elas sejam reenderizada.
Até aí 100%. Porém, o controle recebe os eventos emitidos pela visão. Aí que eu quero entender que eventos são esses?
Ou seja, essa ligação dos eventos da visão com o controle é feita assim:

   import javax.swing.*;
   import java.awt.event.*;

    public class View extends JPanel {
    
      private ClienteControl controller = null;
      private JButton btnExecute;
      private JTextField nome;   
      private JTextField cpf;   
      private JLabel lblCad; 
   
       public View(ClienteControl controller) {
         this.controller = controller;
         this.initialize();
      }
   
       private void initialize() {
         nome = new JTextField(10);   
         add(nome);   
         cpf = new JTextField(10);   
         add(cpf);   
         btnExecute = new JButton("Cadastrar");   
         btnExecute.addActionListener(
                new ActionListener() {
                   public void actionPerformed(ActionEvent e) {		     
                     View.this.cadastrar();
                  }
               });
         add(btnExecute);   
         lblCad = new JLabel();   
         add(lblCad);   
      }
   
       private void cadastrar() {
         try {
            this.controller.cadastrar(nome.getText(), cpf.getText());
            lblCad.setText("Cadastro realizado com sucesso");
         }
             catch (CadastroDeClienteException e) {
               lblCad.setText(e.getMessage());
            } 
      }  
   }
   public class ClienteControl {       
           
      private Cliente cli = null;       
       
       ClienteControl(Cliente cli) {       
         this.cli = cli;       
      }     
       
       public void cadastrar(String nome, String cpf) throws CadastroDeClienteException {
          // ALTERA O MODELO!
      }
   }

Fico no aguardo pela resposta! Obrigado André e a todos que estão acompanhando!

Na verdade a pergunta é: Os eventos que o controle recebe da visão também usam Observer?

Ninguém arrisca responder essa última pergunta?

Utilizar o Observer é UMA das maneiras de se implementar o MVC, muitos não são favoráveis ao uso dele por adicionar complexidade e dificultar o debug da aplicação.

Nos seus exemplos não foi utilizado este padrão, ou seja, foi adotada uma outra abordagem (sem o uso do observer).

Resumindo…tenho a impressão que a idéia do observer está fazendo o assunto mudar um pouco a direção, confirma?

E respondendo sua pergunta: sim, já que o padrão faz com que as 3 partes fiquem de certa forma associadas.

flws

Boa tarde fantomas, desculpa não responder antes!

[quote=fantomas]Utilizar o Observer é UMA das maneiras de se implementar o MVC, muitos não são favoráveis ao uso dele por adicionar complexidade e dificultar o debug da aplicação.

Nos seus exemplos não foi utilizado este padrão, ou seja, foi adotada uma outra abordagem (sem o uso do observer).

Resumindo…tenho a impressão que a idéia do observer está fazendo o assunto mudar um pouco a direção, confirma?

E respondendo sua pergunta: sim, já que o padrão faz com que as 3 partes fiquem de certa forma associadas.

flws
[/quote]

Então realmente fizemos sem o uso do Observer e que na minha opinião ficou muito bom!
Está bem definido o que é visão, controle e modelo. A aplicação da propagação de Exception do modelo até a visão nas validações e erros também ficou muito legal, super bacana e muito fácil de entender.

Porém se eu tiver várias visões, como elas se atualizarão com uma mudança no modelo?

E percebo que existe um acoplamento fortíssimo entre as 3 partes. Por isso pensei no uso do Observer afim de libertar as partes para que fiquem flexíveis.
Na verdade, se for olhar o esquema da comunicação entre as partes, repare que o modelo avisa a visão sobre mudanças sem se associar diretamente a visão e o mesmo ocorre com a visão avisando o controle sobre mudanças feitas (Ex: botões clicados). Outra coisa que reparei é que o “controle é quem recebe o objeto visão e objeto modelo” e a “visão recebe o objeto modelo” (associação direta).

Lembro que a primeira postagem do código-exemplo que postei tinha a visão completamente desacoplada do controle (a visão podia receber qualquer tipo de controlador). Porém o controlador fazia uma “ponte” entre visão e modelo na hora de atualizar a visão, o que sabemos não ser correto! Aí então surgiu a idéia de aplicar o observer para que a visão se atualize com o estado do modelo, as Exception’s para o caso de problemas de validação e erros e a visão transmitindo ao controle somente eventos sem conhecer nada sobre ele (o controle recebe a visão e se registra nela - acho que é assim que se fala).

Entenderam a idéia? Acredito que assim teriamos uma implementação bem flexivel, ou seja, posso alterar a visão (V) sem alterar nada no resto (C,M) que é o ponto chave aí da questão. Já o modelo não tem jeito se for alterado a visão e o controle vão sofrer impacto (isso digo no caso de mudar os métodos existentes na interface do modelo).

Tem lógica o que estou falando ou estou “dirigindo completamente embriagado sem direção alguma”? ( SE BEBER NÃO DIRIJA! :wink: )

Um abraço a todos do GUJ é um prazer estar aqui com todos vocês trocando essas idéias. :wink:
Um abração aí para fantomas, Bruno Laturner e o André Fonseca que evoluiram muito o tópico!
Obrigado fico no aguardo pelas respostas!

O que vc está falando tem sentido sim.

A questão é a seguinte: Tem que ver o quanto vc está disposto a “pagar” para chegar no objetivo almejado.

  1. O que foi feito até agora é uma abstração que timidamente se aproxima da definição do padrão MVC. Porem oferece menos complexidade e maior controle sobre o fluxo dos eventos.

  2. O Observer é um elemento intermediador que oferece maior independencia fazendo com que os resultados fiquem praticamente iguais aos da proposta dos padrão MVC. Porem a complexidade aumenta bastante e o controle do fluxo dos eventos fica também mais dificil (claro que isto está diretamente ligado as condições técnicas de quem está desenvolvendo, logo para alguns pode ser até simples de operar).

Na internet tem vários exemplos que aplicam o Observer para implementar o MVC http://csis.pace.edu/~bergin/mvc/mvcgui.html dá uma olhada e vc perceberá melhor o que estou dizendo.

P.S Tente aplicar o Observer no exemplo para vc ver como é que fica.

Resumindo…o treco é como quase tudo, uma questão de escolha.

flws

Bom dia fantomas!

Vou tentar implementar sim escolhendo a opção 2 para tentar manter a visão associada indiretamente com o controle e tentar manter o modelo associado indiretamente com a visão. Não vou usar o padrão java.util.Observer (igual ao do exemplo do termômetro do link) e sim o Source e Listener. Concordo quanto a complexidade, realmente vai complicar, mas acredito que será útil e importante esse desacoplamento futuramente.

Obigado vou estudar e qualquer coisa volto a postar :wink:

Boa noite pessoal, estou de volta! :lol:
Passei um tempo afastado mas estamos aí! :expressionless:

Tenho uma pergunta bem simples, ainda dentro do MVC (DESKTOP)!

Já aprendi os seguintes passos:

  • Para a visão reenderizar o modelo devo implementar o pattern Observer;
  • A função do controle é de alterar o estado do modelo e/ou a visão para que esta seja apresentada de forma apropriada;
  • O controle somente recebe eventos para tomar a atitude correta na hora de alterar o modelo (somente eventos);

Pergunta: Mas para o controle receber um evento ele deve estar preparado para isso, ou seja, ele deve ser um observador (listener) de eventos que ocorrem na visão?

Obrigado galera! Um abração para todos, fico no aguardo pelas respostas! :thumbup:

Olha só pessoal, para servir como auxilio no entendimento da pergunta anterior a imagem abaixo representa bem a situação:

Veja que na linha “notificação de atualização” o pattern Observer é ao meu ver a melhor solução do problema.
Mas e na “User Gestures” uso Observer também?

Obrigado pessoal estou no aguardo! :smiley: