Introdução ao GWT

 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!!!

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

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

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

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

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

Dispensa comentários.