Prestação de contas

advice.jpgEste post é uma continuação do meu penúltimo texto, o quase-tapa-na-cara “Não culpem o Swing!”. Irei escrever um pouco a respeito do que venho fazendo para tentar evitar que a terrível profecia se concretize.

Bom… resumindo um pouco, essa minha “contribuição” nada mais é do que um projeto Open Source que comecei a desenvolver para entregar como trabalho de conclusão de curso para a faculdade. Aliás, era para ser só isso: um trabalho de conclusão de curso. Entretanto, com o decorrer do projeto eu fui percebendo o quanto algo semelhante ao que eu estava desenvolvendo podia ser útil.

Obviamente, não existe e nem existirá um único framework adaptável a qualquer situação, seja para web, desktop ou qualquer outra coisa. Dessa forma, devo frisar que ele foi construído com o objetivo de simplificar algumas tarefas que eu considero chatas e repetitivas, além de tentar definir uma forma “padrão” de se estruturar uma aplicação.

Portanto, se você tiver qualquer sugestão ou crítica em relação ao que lhe for apresentado aqui, fique a vontade para comentar e deixar sua opinião! Talvez esse tipo de contribuição seja até mais importante do que criar um novo projeto, pois você ajuda a melhorar projetos já existentes com sugestões bem fundamentadas.

Apresentações

Quem já acompanha este blog há algum tempo - desde o Stupid’s Thoughts para ser mais exato - já sabe que eu estou falando do Surf. Tive a idéia de criá-lo depois de achar no site do mestre informações sobre um padrão de projeto até então desconhecido por mim: o Model View Presenter.

Fiquei tão empolgado com o que tinha acabado de ler, mas tão empolgado, que cheguei a pensar que havia encontrado, ao mesmo tempo, o ponto G e a resposta definitiva que explica como surgiu a Vida no Universo. No entanto, conforme eu ia adicionando features ao framework eu comecei a perceber que a coisa toda vai além de criar uma mera implementação de um padrão de projeto. Estamos falando em ajudar os desenvolvedores… não importa se o framework implementa um padrão de projeto X ou Y. O que realmente importa é o quanto ele pode facilitar a nossa vida.

Provavelmente devo ser o único, mas, se eu precisar escolher um framework dentre vários e me deparar com uma descrição tipo…

O framework XXXXX é um framework MVC para…

… eu simplesmente fecho e vou para o próximo da lista. Não me importo se é um framework MVC ou PQP, pelo menos, não mais. Eu só quero saber como ele pode me ajudar a sair do trabalho mais cedo (não devido à uma demissão, mas sim a um aumento de produtividade :D )

Então, fica a minha humilde dica: se você está disposto a criar um framework, não caia na besteira de criar uma implementação pura de um padrão de projeto, pensando que o padrão por si só justifica sua criação. Obviamente você precisará utilizar padrões de projeto no código do seu framework para deixar mais fácil de estendê-lo ou de corrigir bugs, mas a sua preocupação principal deve ser atacar aquilo que causa problemas ao desenvolvedor.

Voltando ao assunto, o Surf só tem uma release, que fiz por obrigação, já que ele estava em um estágio digamos, embrionário. A próxima release oficial será feita provavelmente em abril, cuja versão será 0.2.5, devido ao grande número de bugs resolvidos e novos recursos que foram adicionados. Tá certo, ainda falta muito, mas, com as coisas melhorando e começando a dar algum resultado, eu me sinto muito mais à vontade para mostrar o que foi desenvolvido até então. Assim, você poderá me dar uma dica, avisando se o projeto é uma perda de tempo ou se ele tem algum valor prático.

Enquanto a nova release não sai, você pode acessar o código através do servidor SVN, que contém, além do código do framework, três aplicações simples de demonstração que tentam mostrar alguns dos principais recursos oferecidos pelo Surf.

Primeiros passos

Criaremos agora uma aplicação bem simples, no estilo hello world, onde você poderá ver alguns dos recursos do Surf em funcionamento. Claro que isso não é tudo o que o Surf pode fazer, mas, por questões de espaço, este post dará a você apenas “um gostinho”. Caso queira saber mais sobre o assunto, deixe um comentário com a dúvida/pergunta que eu tentarei responder o mais breve possível.

O que será mostrado foi compilado em um projeto do NetBeans e disponibilizado para download. Caso queira acompanhar o “tutorial” a seguir, utilize os JARs situados no diretório lib e siga as instruções normalmente. Se você apenas quer rodar o projeto, basta abrí-lo no NetBeans e apertar F6. Devo lembrar que, se o NetBeans acusar problemas ao localizar os JARs, você deve indicar os arquivos do diretório lib para que seja possível compilar e rodar o exemplo.

Ok.. abra o NetBeans e crie um projeto Java SE. Crie também um JFrame chamado MyFrame. Desenhe o formulário de acordo com o layout abaixo:

surf_intro_01.png

Nomeie os JTextField na seguinte ordem: nome, idade, email. Sete o nome do botão para mostrarDados. Vá até o código-fonte do frame e gere métodos get para os componentes nome, idade, email e mostrarDados, através da opção Refactor - Encapsulate Fields… .

Antes de prosseguirmos, devemos adicionar os JARs do Surf (e dependências), que são: log4j, ognl, e surf-framework. Conforme já foi dito, eles se encontram na pasta lib do projeto.

Volte ao código-fonte do frame e insira as anotações nos métodos get, conforme a listagem que segue:

  1.  
  2. public class MyFrame extends JFrame {
  3.  
  4.    // …
  5.  
  6.    @Bind
  7.    public javax.swing.JTextField getNome() {
  8.        return nome;
  9.    }
  10.    
  11.    @Bind
  12.    public javax.swing.JTextField getEmail() {
  13.        return email;
  14.    }
  15.    
  16.    @Bind
  17.    public javax.swing.JTextField getIdade() {
  18.        return idade;
  19.    }
  20.    
  21.    @Interaction
  22.    public javax.swing.JButton getMostrarDados() {
  23.        return mostrarDados;
  24.    }
  25.  
  26.    // …
  27. }
  28.  

Prosseguindo, crie o bean Pessoa, no mesmo pacote do frame:

  1.  
  2. package helloworld;
  3.  
  4. public class Pessoa {
  5.    
  6.     private String nome;
  7.     private int idade;
  8.     private String email;
  9.    
  10.     public String getNome() {
  11.         return nome;
  12.     }
  13.    
  14.     public void setNome(String nome) {
  15.         this.nome = nome;
  16.     }
  17.    
  18.     public int getIdade() {
  19.         return idade;
  20.     }
  21.    
  22.     public void setIdade(int idade) {
  23.         this.idade = idade;
  24.     }
  25.    
  26.     public String getEmail() {
  27.         return email;
  28.     }
  29.    
  30.     public void setEmail(String email) {
  31.         this.email = email;
  32.     }
  33.    
  34.     public String toString() {
  35.         return "Nome: " + nome + " - idade: " + idade + " - email: " + email;
  36.     }
  37. }
  38.  

Certo, já criamos a view e o model. Agora precisamos criar a classe que irá coordenar a lógica da aplicação: o presenter. Crie a classe MyPresenter, no mesmo pacote que as outras duas classes:

  1.  
  2. package helloworld;
  3.  
  4. import net.sf.surfframework.annotation.presenter.Model;
  5. import net.sf.surfframework.annotation.presenter.Presenter;
  6. import net.sf.surfframework.annotation.view.View;
  7. import net.sf.surfframework.mvp.presenter.AbstractPresenter;
  8.  
  9. @Presenter("myPresenter")
  10. @View(MyFrame.class)
  11. public class MyPresenter extends AbstractPresenter {
  12.    
  13.     private Pessoa pessoa;
  14.    
  15.     public void mostrarDados() {
  16.        
  17.         getDataTransferer().updateModel();
  18.         System.out.println("Dados da pessoa: " + pessoa);
  19.     }
  20.    
  21.     @Model
  22.     public Pessoa getPessoa() {
  23.         return pessoa;
  24.     }
  25.    
  26.     public void setPessoa(Pessoa pessoa) {
  27.         this.pessoa = pessoa;
  28.     }
  29. }
  30.  

Está quase pronto! Para fazer a aplicação rodar, abra a classe Main e a modifique de acordo com a listagem:

  1.  
  2. package helloworld;
  3.  
  4. import net.sf.surfframework.annotation.parser.AnnotationPresenterConfigFactory;
  5. import net.sf.surfframework.configuration.SurfConfig;
  6. import net.sf.surfframework.configuration.xml.XMLSurfConfig;
  7. import net.sf.surfframework.mvp.presenter.DefaultPresenterFactory;
  8.  
  9. public class Main {
  10.    
  11.     public static void main(String[] args) {
  12.        
  13.         SurfConfig config = new XMLSurfConfig();
  14.        
  15.         config.addPresenterMapping(
  16.                 new AnnotationPresenterConfigFactory(config)
  17.                 .getMapping(MyPresenter.class)
  18.                 );
  19.        
  20.         new DefaultPresenterFactory(config)
  21.             .createPresenter("myPresenter").showView(true);
  22.     }
  23. }
  24.  

Pronto. Rode a aplicação, preencha o formulário (com dados válidos, claro!) e pressione o botão:

surf_intro_02.png

Agora, vá até a classe Pessoa e mude o tipo de int para Byte:

  1.  
  2. public class Pessoa {
  3.  
  4.     private String nome;
  5.     private Byte idade;
  6.     private String email;
  7.  
  8.     // …
  9.  
  10.     public Byte getIdade() {
  11.         return idade;
  12.     }
  13.  
  14.     public void setIdade(Byte idade) {
  15.         this.idade = idade;
  16.     }
  17.    
  18.     // …
  19. }
  20.  

Rode a aplicação e veja que ela ainda funciona. Achou pouco? Então vamos fazer algo mais ousado: troque o JTextField idade por um JSpinner e modifique a assinatura do método get:

  1.  
  2. public class MyFrame extends JFrame {
  3.  
  4.     // …
  5.  
  6.     @Bind
  7.     public javax.swing.JSpinner getIdade() {
  8.         return idade;
  9.     }
  10.  
  11.     // …
  12. }
  13.  

Rode a aplicação e veja que ela ainda funciona!

surf_intro_03.png

Só com o que foi mostrado nesse post já dá pra economizar uma boa graninha que seria gasta em calmantes, fliperamas ou coloque_seu_método_para_desestressar_aqui :P

Concluindo

Gostaria que você respondesse às perguntas abaixo, analisando o que foi mostrado:

  • Você precisou criar um listener?
  • Você usou as temíveis classes internas anônimas com o código do listener socado lá dentro?
  • Você precisou passar e converter dados manualmente entre a view e o model?
  • Você precisou alterar os programas quando mudamos a idade de int para Byte e quando trocamos de componente (exceto os métodos set/get)?
  • Suas classes view e model precisaram implementar classes do framework?

Não, não, não, não e NÃO! Repare em como o código ficou: a view se comporta somente como uma view, o model se comporta somente como um model e o presenter se comporta somente como um presenter (coordenando a aplicação). Tudo tem o seu devido lugar.

Deixando um pouco o Surf de lado… o que eu quero passar é que devemos colocar idéias em prática. Dá trabalho? Opa se dá. Mas compensa, uma vez que você começa a colher os resultados daquela semente que você plantou lá no comecinho.

Não importa se você é um iniciante ou um mestre. Aproveite esta oportunidade obter novos conhecimentos ou colocá-los à prova em uma tarefa realmente desafiadora. Isso é bom, considerando que nossa capacidade de resolver problemas costuma se reduzir uma vez que só fazemos cadastros! PS: O link para o site do Rails foi uma brincadeira ;)

Momento de reflexão

go_surf.jpgVocê se lembra da imagem que coloquei no início deste post? Imagine que você tenha uma praia e tal placa esteja cravada na areia, bem à vista. Isso é frustrante, para não dizer coisa pior. Agora, já que a praia é sua (e supondo que você saiba como se livrar dos tubarões :P), que tal suar um pouco a camisa e trabalhar para que as pessoas, em vez de acabarem topando com aquela placa horrível, se deparessem com a cena ilustrada pela imagem ao lado?!

Wow… bem melhor, não? Por razões óbvias, sua praia será muito mais freqüentada, você será um cara famoso e as mulheres o acharão o máximo.

E, melhor que isso, você se achará o máximo! Pense nisso.

Tags: , , , , ,
26 de fevereiro de 2007 | programação