Desenvolvimento em Java com SEO, GWT, JSF ou NOSQL Databases é no Java Com Farinha!

Introdução a Bancos NOSQL e Apache Cassandra

2011-04-02T21:49:00.000-03:00

Olá Pessoal;

Hoje, escrevo este post para falar de uma tecnologia um tanto quanto polêmica ainda, porém que vem tendo crescimento na sua utilização em aplicativos WEB, principalmente com alta escabilidade, estou falando de NoSQL Databases.

NoSQL é uma alternativa aos bancos RDBMS para tentar resolver problemas de escabilidade (para RDBMS pode ser caro ou bastante complexo) e desempenho entre outras caracteristicas. A idéia principal é armazenar dados de uma forma denormalizada, utilizando um padrão chamado key-value, ou seja um valor está sempre associado a uma chave.
Um outro conceito é que cada linha armazenada pode possuir seu próprio esquema, isso facilita a replicação dos dados em vários outros servidores NoSQL.

Empresas como: Facebook, Google, Twitter, Digg, Yahoo utilizam em suas aplicações e são entusiastas de soluções NoSQL.

Eu quero falar especificamente sobre um banco de dados NoSQL que vem crescendo bastante, é o Apache Cassandra que foi desenvolvido primeiramente pelo Facebook que depois entregou o código fonte para a Apache dar continuidade. Escrito em Java e bastante leve, ganhou bastante espaço porque uniu a arquitetura de um banco da Amazon, chamado de Dynamo com o modelo de dados baseado no BigTable do Google e o resultado final ficou bem interessante.

A Estrutura de dados do Apache Cassandra trabalha da seguinte forma:

Keyspaces: Comparando com um banco RDBMS é como se fosse um schema, ou seja, em um keyspace, guardamos todas a estrutura de ColumnFamily da nossa aplicação.
ColumnFamily: Comparado com um banco RDBMS, seria como uma tabela, ou seja irá guardar várias linhas de dados. Cada linha irá possuir uma chave, essa chave serve de identificador da linha e poderá ter colunas ou sub-colunas para guardar suas informações.
Column: Uma coluna é a menor informação possível, é um valor baseado em uma chave. Pode estar associado a um ColumnFamily ou um SuperColumn.
SuperColumn: É um conjunto de colunas, ou seja, para cada linha da ColumnFamily, podemos ter SuperColumns que possuam várias colunas.

Para exemplificar, vou demonstrar a estrutura de uma Livraria usando Apache Cassandra, fica assim:

Nessa estrutura, temos:

Keyspace Livraria: que irá guardar as informações sobre livros e autores.
ColumnFamily Autores: Guarda os dados dos autores, aonde a chave de cada linha é o nome do autor.
Column Email: Coluna que armazena o email para cada autor.
Column Biografia: Coluna que armazena a biografia para cada autor.
ColumnFamily Livros: Guarda os dados dos livros, aonde a chave de cada linha é o nome do livro.
Column ISQN: Coluna que armazena um código qualquer do livro chamado de ISQN.
Column Autor: Coluna que identifica o autor do livro.

E nossa introdução a respeito de bancos NoSQL e Apache Cassandra fica por aqui, o intuito foi dar de fato apenas uma breve introdução, porque existem materiais muito bons na internet falando a respeito disso.

O motivo dessa introdução é que no proxímo post, irei demonstrar a criação de um CRUD em Java com NoSQL e o banco escolhido foi o Apache Cassandra. No CRUD darei continuidade a está introdução para realizar um cadastro de uma livraria.

Até a proxíma.

Fontes:
pt.wikipedia.org/wiki/Apache_Cassandra
blog.caelum.com.br/bancos-de-dados-nao-relacionais-e-o-movimento-nosql/
http://imasters.com.br/artigo/17043/bancodedados/nosql_voce_realmente_sabe_do_que_estamos_falando/

Novidades do Swing no Java 7

2011-03-18T20:40:00.001-03:00

Olá Pessoal;

Enquanto aguardamos anciosamente a espera da versão final do Java 7 (que está prevista para este ano de 2011), e virá com algumas novidades na linguagem.
Mas queria falar sobre as funcionalidades que virão para incrementar o desenvolvimento desktop em Java. Por isso vamos dar uma olhada em algumas das novidades do Swing que estarão presentes na nova versão do Java.

JLayer: O JLayer iniciou do projeto JXLayer (mais os dois seguem caminhos independentes), que serve para desenhar camadas sobre os seus componentes visuais. O que eu achei legal é que você pode registrar eventos em que o JLayer esteja interessado e repintar a camada como você bem entender quando o evento for disparado. Um exemplo disso seria você adicionar um desenho na tela toda a vez que o mouse se mova por exemplo. Alguns exemplos visuais do JLayer:

Criação de Janelas e desenhos translucidos: Essa é uma funcionalidade que estará disponivel no Java 7 que é para deixar suas janelas translucidas, ou seja, aquele efeito de transparência, você poderá definir o grau de transparência e também o gradiente que deseja e "tha-ram", veja como sua janela pode ficar:

The Nimbus Look & Feel: Outra novidade é que será adicionado mais um Look & Feel, o Nimbus que estará disponivel também no javax.swing a partir da versão 7. Uma tela com esse look & Feel fica assim:

Outra novidade anunciada será uma maior facilidade em trabalhar com a mistura de componentes tanto AWT e Swing em uma mesma tela.

Estou aguardando a versão final do Java 7, enquanto isso, "brincamos" com as versões betas.

Fonte do conteudo citado aqui está em: http://download.java.net/jdk7/docs/technotes/guides/swing/7.0/index.html

Abraços e até a proxíma.

Algumas formas de melhorar o tempo de compilação do GWT

2011-03-15T21:21:00.001-03:00

Olá Pessoal;

Nest post, estou aqui para dizer que nem tudo é maravilha ao se utilizar o GWT. Como o GWT compila o código Java, gerando código Javascript otimizado para cada browser, pode ser que algum módulo tenha um tempo de compilação nada performático.

Trabalho em uma aplicação que tem em torno de 300 módulos GWT e alguns demoram quase 10 minutos para serem compilados (Por erros de design patterns) , imagina se quanto tempo demora a compilação do projeto.

Por isso, disponibilizo para vocês esse link em que o autor se preocupa em demonstrar a importância e dicas para melhorar o tempo de compilação do seu módulo.

link: http://supplychaintechnology.wordpress.com/2010/06/04/gwt_compile_times/

Uma outra dica (que eu acho muito importante) é diminuir os "permutations", ou seja quando o GWT compila um módulo ele compila para cada browser e cada locale, por exemplo, se o seu módulo for compilado para 5 browsers e 10 locales diferentes, irá gerar 50 "permutations" e consequentemente uma demora a mais na compilação.

A dica é definir os browsers que realmente serão utilizados pela aplicação (se for uma aplicação disponivel para web esqueça) e definir o locales de sua aplicação (se sua aplicação é mult-linguagem).

As dicas para diminuir os permutations: http://bazoud.free.fr/post/2008/07/31/Can-I-speed-up-the-GWT-compiler/

Fica a Dica

Abraços

Criando seu primeiro aplicativo com GWT e Netbeans

2011-03-15T20:43:00.001-03:00

Pessoal;

Dando continuidade ao artigo sobre introdução ao GWT, e conforme prometido, vou demonstrar como criar um aplicativo GWT usando o Netbeans (No proximo post vou mostrar como criar no Eclipse xD).

Para habilitar o suporte do GWT no netbeans, será necessário a instalação do plugin GWT4NB, que você pode fazer o download a partir do site do projeto: https://gwt4nb.dev.java.net/, a partir dai é só instalar o plugin que irá aparecer a opção de utilizar o Google Web Toolkit nos projetos web.

Com o plugin instalado, vamos começar a desenvolver o nosso primeiro aplicativo GWT, o primeiro passo é criar um novo projeto WEB, como mostra na imagem:

A partir dai, é só configurar o nome do projeto, selecionar qual o servidor será instalado, e na ultima etapa, selecionar o plugin do Google Web Toolkit, como mostra na imagem:

Nesse passo, nos precisamos informar o diretório de instalação do GWT, se não estiver instalado, você pode fazer o download em http://code.google.com/intl/pt-BR/webtoolkit/ ou clicar em "You can download the GWT SDK here" na tela de configuração.

Também definimos o caminho para nosso primeiro modulo, no caso eu preenchi: com.javacomfarinha.gwt.login.Login (Login será o nome do nosso primeiro modulo GWT).

Pronto, o netbeans irá criar o nosso projeto com a seguinte estrutura:

Com isso, temos criado o nosso primeiro modulo GWT criado pelo Netbeans, agora vou explicar o que são esses arquivos:

Cada modulo GWT, possui essa estrutura, na raiz do pacote do projeto, possui um arquivo gwt.xml com o nome do modulo que e guardam as configurações do modulo, o mais importante para você sobre esse arquivo é que nele nós definimos, quando esse modulo for iniciado, qual tela (que é um EntryPoint no GWT) que será carregada e quais outros modulos criados no seu projeto serão utilizados nesse modulo. Também podemos definir várias outras configurações, mais veremos isto em outros posts.

Todo modulo GWT também tem essa pacote "client", neste pacote temos todas as classes a respeito da criação das telas/componentes visuais e TODAS as classes que estiverem nesse pacote serão compilados para um código JavaScript.

A Classe LoginEntryPoint é a classe que foi gerada pelo plugin irá exibir nossos componentes na tela do browser, essa classe implementa a interface do GWT chamada EntryPoint. Uma classe EntryPoint será exibida para o usuário quando o modulo for carregado, pois o modulo irá chamar o metodo onModuleLoad que é definido nessa interface, no exemplo gerado pelo plugin, ficou assim:

Nesse exemplo, está sendo adicionado uma label e um botão direto a pagina WEB que irá chamar esse modulo GWT.

O Plugin também criou uma pagina HTML (welcomeGWT.xml) que será responsavel por chamar esse modulo GWT, o código HTML fica assim:

Através da Tag Meta (utilizado nas versões 1.3 e anteriores do GWT e da chamada ao script nocache.js com o nome do módulo, será invocado o modulo Login do GWT.

Agora é só compilar o projeto que o plugin Gwt4Nb irá realizar a compilação do modulo GWT criado, rodar o projeto e chamar a página welcomeGWT.html o resultado final fica assim:

Quando você clica no botão o Label se exibe ou se esconde.

Pronto, um simples e bem abstrato exemplo está funcionando, vou ficar por aqui para deixar vocês criarem os seus primeiros "Hello World" e no proximo post vou continuar com esse mesmo exemplo para criar um exemplo de Login e Senha usando GWT.

Valeu Pessoal

Dica Java - Como remover elementos nulo de uma coleção

2010-07-20T21:31:00.003-03:00

Olá Pessoal;

Essa é uma dica que recebi de um amigo meu do trabalho, o Josivan (cara faz mestrado na UTFPR e também faz a revisão de vários livros técnicos) e achei interessante disponibilizar para todos que acessam o blog.

Já deparei algumas vezes com códigos para remover elementos nulo em uma lista por exemplo que fica mais ou menos assim:

Porém isso pode ser realizado com uma forma que economiza linhas de código além de manter um código mais limpo, e cumprindo o objetivo de remover os elementos nulos da coleção em apenas uma linha, o código fica assim:

É algo simples e bem cotidiano para um desenvolvedor Java.

Você tem alguma forma mais pratica? envie nos comentários!

Abraços e Até a proxíma!

Introdução ao GWT

2010-07-18T14:12:00.000-03:00

Pessoal, como tenho bastante interesse em falar sobre o GWT e suas vantagens no Blog, vou começar com esse post falando um pouco sobre o que é o GWT e um pouco do que ele pode fazer, assim mais para frente nós podemos ir avançado sobre o assunto falando sobre componentes e criando GUI avançadas de forma bem pratica. Espero que gostem!

O que é GWT

O Google Web Toolkit é um framework para o desenvolvimento de interfaces ricas com Java. É algo drasticamente diferente desenvolver aplicados web, bem diferente de como usamos com JSP/JSF/Struts... Etc. Pois a idéia principal do GWT é escrever o código de nossas interfaces WEB em código Java, esse código será compilado para um código Javascript já otimizado pelo compilador e funcional para os navegadores utilizados no mercado (IE, Firefox, Safari, Opera ...etc) .

Isso facilita e agiliza bastante o desenvolvimento de aplicativos WEB, pois não precisamos ficar escrevendo Javascript que tenha suporte em todos os navegadores e podemos usufruir de todas as funcionalidades presentes no Javascript e da reutilização de componentes de uma forma bem pratica, podemos utilizar também ferramentas de testes para verificar se uma interface está cumprindo o que prometeu.

Possui também um mecanismo de comunicação com o código cliente e servidor assíncrono, chamado de RPC (Remote Procedure Call) que pode trabalhar com vários protocolos como JSON ou XML é bem parecido com um código RMI de forma bem mais simples, que na pratica a pagina web gerada se comunica com o servidor utilizando o AJAX de forma transparente.

Você conferir a própria pagina do GWT, que está em Português e pode ajudar bastante: http://code.google.com/intl/pt-BR/webtoolkit/overview.html.

Casos de aplicativos que usam o GWT

Você pode ver alguns exemplos de aplicativos que foram feitos em GWT nesse link http://gwtgallery.appspot.com/

Alguns pontos positivos

Possui todos os componentes HTML como botões, input text, checkbox e alguns outros compoonentes como Tree, Menu e também já existem bastantes bibliotecas com vários recursos e componentes interessantes (mais para frente falo sobre eles).

Possui recursos de internacionalização

Suporte a analise de documentos XML.

Possui suporte a todos os tipos primitivos (byte, char, short, int) e suas classes wrappers (Byte, Char, Short, Integer), a única exceção é o long que é convertido para o tipo Double no javascript e por isso é recomendado a usar Int ao invés de long.

Pode se trabalhar diretamente com exceções, checadas e não checadas, as existentes na API do Java e também pode se criar novas exceções.
Plugin para as IDE´s do mercado como Eclipse, Netbeans, IntelliJ, você pode debugar, compilar, criar novos Widgtes de forma pratica e rápida em seu ambiente de desenvolvimento preferido.

Alguns pontos negativos

Como nem tudo é um mar de rosas, também possui algumas desvantagens:

Se estiver pensando em desenvolver um pagina WEB com foco em SEO, não use o GWT, pois o código gerado não é nenhum pouco entendível para os buscadores, pois trabalha com Javascript, existem algumas formas que pode ajudar mais irá perder bastante com relação a uma pagina com HTML bem semântico.
O processo de compilação do GWT ainda não é o mais performático, dependendo de como sua aplicação foi desenhada, a compilação pode ficar lenta.
O tamanho da aplicação (seu arquivo de distribuição .war ou .ear), é maior do que comparado com um aplicativo que utiliza JSF ou qualquer framework baseado em tag´s.

Por enquanto é isso, nos próximos posts vou demonstrar na pratica todo esse bla-bla-bla que foi dito ai em cima criando um exemplo simples utilizando o Netbeans e o Eclipse.

Abraços e até a próxima.

O Java Com Farinha Voltou!!!

2010-07-10T21:10:00.001-03:00

Pessoal;

É com grande prazer que quero comunicar que irei voltar a atualizar o Blog! Isso mesmo o Java Com Farinha está de volta, a pedidos de muitos (não são tantos assim ... rsrs).

E voltará melhor do que nunca, já que agora vamos abordar alguns posts interessantes a respeito do desenvolvimento Java & Afins.

Alguns dos temas que iremos abordar nos próximos postos são:

Java Com SEO - Isso mesmo, o Java também é bom para o SEO, vamos mostrar alguns artigos para ajudar no desenvolvimento de sites com Java e também pensando na otimização para os mecanismos de buscas.

GWT - Quem diria, eu que era contra a esse tal de Google Web Toolkit, fui rendido a ele. A produtividade para desenvolvimento de aplicativos WEB utilizando AJAX escrito em código Java com o Google Web Toolkit é muito interessante, e o resultado final é muito legal também, mais para frente vamos falar sobre isso.

JSF - O "queridinho" dos desenvolvedores Java para WEB não poderia ser esquecido. Vamos falar de algumas coisas legais como a sua novoa versão (2.0) e algumas coisas interessantes. Aguardem!

NOSQL Databases - Caraca!!! um assunto polêmico (pelo menos no meu trabalho e com pessoas que converso). Vamos falar também um pouco desse novo paradigma de banco de dados, no qual eu acho muito interessante e tem um futuro muito promissor, irei mostrar alguns dos principais bancos NOSQL utilizados hoje em dia e exemplos com clientes Java (é claro).

Espero que gostem, enquanto os novos posts não chegam, você pode responder a minha enquete (No canto direito) - Você usa ou já usou GWT?

É Isso pessoal, fico por aqui e ja na próxima semana irei começar os posts!

Abraços e até a próxima!

Java 6 - Criando uma aplicação na SystemTray

2007-05-09T20:03:00.000-03:00

Olá, continuando com a sequência "O que o Java 6 trouxe de novo" irei falar um pouquinho de uma importante nova funcionalidade adicionada na nova versão do Java, O SystemTray.
O SystemTray é para deixar os programas em um icone que fica na bandeja do sistema operacional (aquela do lado do relógio), o Java na versão 6 trouxe isso nativo na JDK, nas versões anteriores isso era feito utilizando a biblioteca JDIC.

E para ilustar vou dar um exemplo de como criar uma aplicação na bandeja, como várias pessoas me pediram isso, está ai, é bem simples:

import java.awt.Image;
import java.awt.MenuItem;
import java.awt.MenuShortcut;
import java.awt.PopupMenu;
import java.awt.SystemTray;
import java.awt.Toolkit;
import java.awt.TrayIcon;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ImageIcon;
import javax.swing.JOptionPane;

/**
*
* @author Emmanuel Silva
*/
public class TestTray {

/** Creates a new instance of SisTray */
public TestTray() {
createSystemTray();
}

public static void main(String[] args) {
new TestTray();
}

private void createSystemTray() {

//criando a classe que gerencia a bandeja
SystemTray tray = SystemTray.getSystemTray();
if(!tray.isSupported()) {
System.err.println("Não é possível rodar a aplicação");
System.exit(0);
}

//icone que será exibido na bandeja
Image icon = Toolkit.getDefaultToolkit().createImage( getClass().getResource("informacao.gif").getPath());

PopupMenu menu = new PopupMenu();

//item para sair
MenuItem itemSair = new MenuItem("Sair");
itemSair.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
});
menu.add(itemSair);

//item para uma opção qualquer
MenuItem itemOption = new MenuItem("Opção");
itemOption.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(null, "E ai gostou?");
}
});
menu.add(itemOption);

TrayIcon trayIcon = new TrayIcon(icon, "Tooltip", menu);

try {
//adiciona na bandeja do sistema
tray.add(trayIcon);

//exibindo um "tooltip" para o tray
trayIcon.displayMessage("SystemTray Demo", "Você gostou do SystemTray nativo do java?", TrayIcon.MessageType.INFO);
} catch(Exception ex) {
ex.printStackTrace();
}
}

}

O resultado dessa classe é:

Ao clicar com o botão direito em cima do icone:

Bom, espero que gostem;

Até a proxíma!

Java 6

2007-05-08T20:15:00.000-03:00

Irei em alguns artigos mostrar o que o Java na versão 6 trouxe de novo para os desenvolvedores java, hoje queria começar com a classe Desktop, essa classe era pertencente a biblioteca chamada JDIC, que realmente era uma biblioteca muito boa e acabou sendo incorporada dentro do JDK.

Features que essa biblioteca trouxe para o Java 6, com um exemplo de como utiliza-la:

java.awt.Desktop desktop = java.awt.Desktop.getDesktop();
if(!desktop.isDesktopSupported()) {
System.err.println("Desktop não é suportado.");
System.exit(0);
}

Suporte para abrir o navegador padrão do sistema operacional

desktop.browse(new URI("http://www.javacomfarinha.blogspot.com"));

Abrir arquivos para edição com programas padrões do sistema operacional

desktop.edit(new File("C:\\DV.txt"));

Abrir o programa de leitor de correio padrão do sistema operacional para enviar e-mails

desktop.mail(new URI("mailto:emmanuel.silva@gmail.com"));

Ele pode abrir um arquivo para visualização

desktop.open(new File("C:\\compilador_java.pdf"));

Ele pode enviar arquivos para a impressão

desktop.print(new File("C:\\compilador_java.pdf"));

Por hoje é só, nos proximos artigos sobre o Java 6 irei falar um pouco sobre como criar aplicação que ficam no Tray (Do lado do relogio), Trabalhar um pouco com Threads no Swing utilizando a classe SwingWorker.

Netbeans 6 M9

2007-05-04T19:57:00.000-03:00

Pessoal;

A versão 6 do Netbeans está começando a mostrar as caras do eles tinham imaginado para essa nova versão da IDE.
Eles adicionaram muitas novidades, o suporte a desenvolvimento de telas swing com o matisse está muito bom, o Editor foi totalmente reformulando, está muito mais agil trabalhar com ele, mas a novidade que eu gostaria de destacar é:

Javascript Editor

Muito bom, pois sentia falta de uma boa IDE para desenvolver javascript, questões como exibir erros, refactoring, code completion, o Netbeans 6 tras tudo isso ai:

Lembrando que ainda está em versão de desenvolvimento.

Mais para quem quiser baixar é só seguir o link http://bits.nbextras.org/download/6.0/m9/

E para quem quer ver todas as features inclusas: http://wiki.netbeans.org/wiki/view/NewAndNoteWorthyMilestone9

Annotations

2007-05-03T22:50:00.000-03:00

Olá, hoje vou falar um pouquinho das Annotations, que está disponibilizado desde a versão 5.0 do Java.

Annotation são meta-informações que guardam informações de dados dentro do proprio código-fonte, isso é muito util em frameworks por exemplo, porque não precisamos ter mais bilhões de arquivos xml guardando configurações e isso pode estar dentro do código, ficando mais facil e rapido de configurar o framework.

Bom para ilustrar melhor as annotations e o seu uso resolvi fazer um exemplo de validação de java beans utilizando elas.

Para começar, o código da Annotation:

/*
* Validation.java
*
* Created on 5 de Abril de 2007, 21:55
*
*/

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
* Annotation para validar campos em beans.
* @author Emmanuel Silva
*/

@Retention(RetentionPolicy.RUNTIME)
@Target(value=ElementType.FIELD)
public @interface Validation {

 /**
  * Tipo da validação guardada em um Enum que será realizada, por padrão será
  * checagem de not null
  **/
 ValidationType type() default ValidationType.NOT_NULL;

 /**
  * Se a validação for do tipo max_length, aqui eu guardo o tamanho maximo
  **/
 int maxlength() default 0;

}

Proximo passo é a criação do Enum que define os tipos de validações que serão validadas:

/**
*
* @author Emmanuel Silva
*/
public enum ValidationType {

MAX_LENGTH,

NOT_NULL;
}

Agora, temos o nosso Java Bean que será validado, repare que as annotations são chamadas através de um @ e porque a Annotation é para field ela está em cima dos atributos:

/**
*
* @author Emmanuel Silva
*/
public class PessoaBean {

  @Validation()
  private String nome;
  private String login;
  @Validation(type=ValidationType.MAX_LENGTH, maxlength=6)
  private String senha;

  /** Creates a new instance of PessoaBean */
  public PessoaBean() {
  }

  public String getNome() {
      return nome;
  }

  public void setNome(String nome) {
      this.nome = nome;
  }

  public String getLogin() {
      return login;
  }

  public void setLogin(String login) {
      this.login = login;
  }

  public String getSenha() {
      return senha;
  }

  public void setSenha(String senha) {
      this.senha = senha;
  }
}

Agora temos a classe responsavel por validar os Java Beans, essa classe utiliza de um recurso muito poderoso presente no Java chamado Reflection, o reflection serve para que através de código Java eu consiga manipular uma classe como: Listar seus atributos, ler/modificar seus valores, entre outras coisas:

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
*
* @author Emmanuel Silva
*/
public class ValidatorUtil {
 
   private Object obj;
 
   public void validate(Object obj) {
       this.obj = obj;
       Class classe = obj.getClass();
       Field[] fields = classe.getDeclaredFields();
     
       for(Field field : fields) {
           if(field.isAnnotationPresent(Validation.class)) {
               Validation validation = field.getAnnotation(Validation.class);
               validateField(validation, field);
           }
       }
   }
 
   private void validateField(Validation v, Field field) {
       field.setAccessible(true);
       if(v.type() == ValidationType.NOT_NULL) {
           boolean result = checkNotNull(field);
           if(!result) {
               System.out.println("Campo " + field.getName() + " nao foi preenchido corretamente.");
           }
       }
     
       if(v.type() == ValidationType.MAX_LENGTH) {
           boolean result = checkMaxLength(field, v.maxlength());
           if(!result) {
               System.out.println("Quantidade de caracteres permitido para o campo " + field.getName() + " é de "+ v.maxlength() +".");
           }
       }
   }
 
 
   private boolean checkNotNull(Field field) {
       try {
           if(field.get(this.obj) == null)
               return false;
            else
               return true;
       } catch(Exception ex) {
           return false;
       }
   }
 
   private boolean checkMaxLength(Field field, int max) {
       try {
           if(field.get(this.obj) != null && field.get(this.obj).toString().length() > max)
               return false;
           else
               return true;
       } catch(Exception ex) {
           return false;
       }
   }
 
}

Por final, criei uma classe para testar as validações, criando 2 instancias do Java Bean "PessoaBean", uma instancia está com os dados incorretos e a outra instancia está com os dados corretos, assim que a instancia que estiver incorreta passar pelo validador será impressa os seus erros:

/**
*
* @author Emmanuel Silva
*/
public class Main {
  
   /** Creates a new instance of Main */
   public Main() {
      
       System.out.println("Validando primeira pessoa");
       //pessoa com cadastro invalido
       PessoaBean pessoa = new PessoaBean();
       pessoa.setLogin("login");
       pessoa.setSenha("1234567");
      
       ValidatorUtil valida = new ValidatorUtil();
       valida.validate(pessoa);
      
       //pessoa com cadastro correto
       System.out.println("");
       System.out.println("");
       System.out.println("Validando segunda pessoa");
       PessoaBean pessoaCorreta = new PessoaBean();
       pessoaCorreta.setNome("Emmanuel Silva");
       pessoaCorreta.setLogin("login");
       pessoaCorreta.setSenha("123456");
       valida.validate(pessoaCorreta);
   }
  
   /**
    * @param args the command line arguments
    */
   public static void main(String[] args) {
       new Main();
   }
  
}

Bom pessoal, acho que é isso espero que tenham gostado do material.

Até a proxíma!

IPhone

2007-05-02T12:53:00.000-03:00

Dispensa comentários.

Procurando um exemplo de código java?

2007-03-07T21:22:00.000-03:00

Esse site tem uma lista de exemplos de códigos em Java, é bem interessante pois você pode buscar por pacotes, e tem exemplos de "quase tudo" que a gente precisa, salvou a minha vida algumas vezes.

Link

Componentes JSF com Ajax

2007-03-07T20:33:00.000-03:00

Descobri um framework chamado JMaki para trabalhar com componentes JSF como:

data table ordenada
calendario
editor html
Galeria de imagens
chat
Entre vários

Ele usa a notação JSON para interagir com seus componentes, simplesmente um show, e o melhor tem um plugin sensacional para o Netbeans.

Nesse link você pode encontrar uma demonstração dos componentes trabalhando com o Netbeans 5.5.

A pagina do projeto esta aqui.

Drag and Drop com Javascript

2007-03-07T20:29:00.000-03:00

Achei esse artigo que ensina como fazer componentes que tenham um efeito drag and drop na web, muito interessante, vale a pena conferir isso, nesse novo mundo da "web 2.0" não podemos ficar para traz.

Link com artigo.

Debugando javascript

2007-02-27T23:34:00.000-03:00

Para quem precisa debugar javascript e não aguenta mais ficar dando "alert" para saber o valor das suas variaveis, pois é criaram uma extensão ao firefox que acreditem se quiser debuga javascript entre outras coisas, poderia dizer que é um canivete suiço. Para baixar é só seguir o link: https://addons.mozilla.org/firefox/1843/

Até que enfim!

2007-02-27T22:57:00.000-03:00

Realizando o desejo de muitas pessoas estou criando o meu blog, vou tentar compartilhar o meu aprendizado com a plataforma Java, usabilidade, web-semântica e também um pouquinho de javascript (que todos odeiam mais eu gosto muito), espero que gostem.