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.