Métodos de Validação em JSF – Parte V

 

Criando um componente de validação personalizado

 

Quando a validação não esta amarrada a lógica de negócio da aplicação, mas nenhum dos validadores padrão do JSF não é o suficiente.

 

Vamos implementar um componente personalizado de validação, para isso precisaremos de uma classe que implemente a interface Validator e possua um método chamado validate, único método definido pela interface.

 

void validate(FacesContext context, UIComponent componente,Object value)

 

Quando uma validação falha, devemos gerar uma FacesMessage que descreva o erro, construa uma ValidadorException e apresente-a:

 

if (vlPgto < vlMinimo) {

                  FacesMessage message = new FacesMessage(

                             "Pagamento abaixo do valor minimo aceitável:"

                             + " (R$"

                                         + vlMinimo + ").");

                  throw new ValidatorException(message);

            }

      }

 

Crie um pacote chamado fatura.model e nele crie a classe FaturaBean conforme mostrado a seguir:

 

package fatura.model;

 

public class FaturaBean {

     

      private String clienteNome; 

      private double valorPagto;

     

 

      public String getClienteNome() {

            return (clienteNome);

      }

      public void setClienteNome(String nome) {

            this.clienteNome = nome;

      }

 

      public double getValorPagto() {

            return (valorPagto);

      }

 

      public void setValorPagto(double valorPg) {

            this.valorPagto = valorPg;

      }    

      public String efetuarPagto() {

            return ("success");

      }

 

}

 

A classe FaturaBean tem dois atributos definidos como private e seus métodos de acesso (getters e setters) além do método efetuarPagto() que retorna uma string.

 

package fatura.control;

 

import javax.faces.application.FacesMessage;

import javax.faces.component.UIComponent;

import javax.faces.context.FacesContext;

import javax.faces.validator.Validator;

import javax.faces.validator.ValidatorException;

 

public class Validacao implements Validator {

 

      @Override //comente essa linha se estive usando jdk 1.4

      public void validate(FacesContext context, UIComponent componente,Object value)

      throws ValidatorException {

     

      //Em uma situação real estes campos deveriam estar definidos como privados

      double vlPgto = ((Double) value).doubleValue();

      double vlMinimo = vlMinimoPgto();

     

      if (vlPgto < vlMinimo) {

                  FacesMessage message = new FacesMessage(

                             "Pagamento abaixo do valor minimo aceitável:"

                             + " (R$"

                                         + vlMinimo + ").");

                  throw new ValidatorException(message);

            }

      }

 

      public double vlMinimoPgto() {

            /** Em uma situação real este valor retornado seria

             * originado de uma consulta ao banco de dados

            */

            return (10.00);

      }

 

}

 

Além disso, precisaremos de uma classe auxiliar ao validator para que através dela o validador seja reconhecido, nesse momento ela instancia a classe Validacao.

 

Crie em fatura.control a classe TagValidacao:

 

package fatura.control;

 

import javax.faces.validator.Validator;

import javax.faces.webapp.ValidatorTag;

import javax.servlet.jsp.JspException;

 

@SuppressWarnings("serial") //comente essa linha se estive usando jdk 1.4

public class TagValidacao extends ValidatorTag {

     

      public TagValidacao() {

            super();

            setId("Validacao");

      }

     

      protected Validator createValidator() throws JspException{

            return new Validacao();     

...

Métodos de Validação em JSF - Parte IV

 

Validação Explícita Automática

A Validação Explícita Automática é útil quando você não quer deixar a validação de campos atada a lógica de negócio de uma aplicação e situações em que o que você precisa apenas é chegar um determinado tipo de dados, o valor mínimo ou máximo de um campo ou a quantidade de caracteres.

 

A implementação é muito parecida com a Validação Explícita Simples, exceto por:

 

Faz-se uso das tags <f:validadeLength/>, <f:validateDoubleRange/> e <f:validateLongRange/> do Java Server Faces.

Ex:

 

<h:inputText value="#{ApostaBean2.nome}"

 id="nome">

<f:validateLength minimum="5" maximum="16"/>

</h:inputText></TD>

 

O que significa que o campo nome deve ter no mínimo 5 e no máximo 16 caracteres.

 

web.xml

 

Não será necessário alterar o arquivo web.xml caso você tenha lido a terceira parte deste artigo, mas listarei ele novamente para quem não viu o artigo anterior, importante lembrar para quem ainda não tem experiência em desenvolvimento web, os arquivos web.xml e faces-config.xml devem ser criados na pasta WEB-INF do seu projeto.

 

<?xml version="1.0"?>   

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"

         version="2.4">

    

  <servlet>

     <servlet-name>Faces Servlet</servlet-name>

     <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>

     <load-on-startup>1</load-on-startup>

  </servlet>

  <servlet-mapping>

     <servlet-name>Faces Servlet</servlet-name>

     <url-pattern>*.faces</url-pattern>

  </servlet-mapping> 

  <welcome-file-list>

     <welcome-file>index.jsp</welcome-file>

     <welcome-file>index.html</welcome-file>

  </welcome-file-list>

</web-app>

 

Não será necessário alterar a classe ApostaBean2.java  localizada no  pacote br.nitewing.claudio.validacoes., ainda assim listarei ela para quem não leu a parte 3 deste artigo, sendo possível assim testar o exemplo sem depender do anterior.

 

package br.nitewing.claudio.validacoes;

 

public class ApostaBean2 {

 

  private String nome;

  private String cavalo;

  private double valorAposta;

  private int quantJogos;

 

  public String getNome() { return(nome); }

  public void setNome(String nome) {

    this.nome = nome;

  }

 

  public String getCavalo() { return(cavalo); }

  public void setCavalo(String cavalo) {

    this.cavalo = cavalo;

  }

 

  public double getValorAposta() { return(valorAposta); }

  public void setValorAposta(double valoraposta) {

    this.valorAposta = valoraposta;

  }

 

  public int getQuantJogos() { return(quantJogos); }

  public void setQuantJogos(int quantjogos) {

    this.quantJogos = quantjogos;

  }

  public String apostar() {

    return("sucesso");

  }

}

 

O Método apostar() devolve a String sucesso que faz com que o usuário seja redirecionado para a pagina de confirmação caso não exista erro no preenchimento dos campos do form.

 

No arquivo faces-config.xml adicionaremos uma nova <navigation-rule> conforme mostrado com destaque no código abaixo.

 

<?xml version='1.0' encoding='UTF-8'?>

<!DOCTYPE faces-config PUBLIC

  "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN"

  "http://java.sun.com/dtd/web-facesconfig_1_1.dtd">

 

<faces-config>

  <managed-bean>

    <managed-bean-name>apostaBean2</managed-bean-name>

    <managed-bean-class>br.nitewing.claudio.validacoes.ApostaBean2

</managed-bean-class>

    <managed-bean-scope>request</managed-bean-scope>

  </managed-bean>

 

  <navigation-rule>

    <from-view-id>/aposta1.jsp</from-view-id>

    <navigation-case>

      <from-outcome>sucesso</from-outcome>

      <to-view-id>/WEB-INF/resultados/mostrarAposta1.jsp</to-view-id>

    </navigation-case>

  </navigation-rule>

 

  <navigation-rule>

    <from-view-id>/aposta2.jsp</from-view-id>

    <navigation-case>

      <from-outcome>sucesso</from-outcome>

      <to-view-id>/WEB-INF/resultados/mostrarAposta2.jsp</to-view-id>

    </navigation-case>

  </navigation-rule>   

 

</faces-config>

 

Altere o arquivo index.jsp para chamar desta vez aposta2.faces.

 

<% response.sendRedirect("aposta2.faces"); %>

 

 

aposta2.jsp

 

<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>

<f:view>

     

      <HTML>

      <HEAD>

      <TITLE></TITLE>

      <style type="text/css">

.RED {

      font-weight: bold;

...

Métodos de validação em JSF - Parte III

 

Validação Explícita

A Validação Explícita vem para evitar que ocorram os problemas existentes na validação manual onde a checagem dos campos é todo feita nas classes de negócio, tendo em vista que  casa seja mudada alguma regra de validação o desenvolvedor é forçado mexer no codigo fonte da aplicação e recompilar as classes.

 

Na Validação Explícita e na Validação Explícita Automática fazemos uso de validadores fornecidos pelo Java Server Faces ou simplesmente JSF como irei me referir de agora adiante.

 

Para implementar a Validação Explícita é necessário seguir os seguinte passos:

 

Definir as propriedades do bean com os tipos adequados. Ex: int/Integer, long/Long, double/Double, boolean/Boolean, etc.

 

Usar os campos id e required nas tags <h:inputtext> dos forms para que com isso todo campo que estiver vazio existente no momento da submissão de um form dispare uma mensagem de erro.

 

Deve usar a tag <h:message> para exibir as mensagens de erro. A tag <h:message>  aceita o  atributo styleClass para que possamos fazer uso de Folhas de Estilo (CSS).

 

Você pode e deve adicionar na tag  h:commandButton o atributo immediate para desviar da validação, é necessário desviar da validação pois a sua ou ausência ou caso esteja definido como false fará com que a pagina atual seja exibida novamente, o atributo immediate  é muito util quando a aplicação tem um botão logout, validação de senha ou cancelar operação.

 

Agora vamos a um exemplo completo:

 

web.xml

 

<?xml version="1.0"?>   

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"

         version="2.4">

  <!-- Configuracao Faces Servlet -->

  <servlet>

     <servlet-name>Faces Servlet</servlet-name>

     <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>

     <load-on-startup>1</load-on-startup>

  </servlet>

  <!-- Mapeando o Faces Servlet para a extensao *.faces -->

  <servlet-mapping>

     <servlet-name>Faces Servlet</servlet-name>

     <url-pattern>*.faces</url-pattern>

  </servlet-mapping>

 

  <!-- Welcome files -->

  <welcome-file-list>

     <welcome-file>index.jsp</welcome-file>

     <welcome-file>index.html</welcome-file>

  </welcome-file-list>

</web-app>

 

Crie o pacote: br.nitewing.claudio.validacoes e nele crie o arquivo ApostaBean2.java.

 

package br.nitewing.claudio.validacoes;

 

public class ApostaBean2 {

 

  private String nome;

  private String cavalo;

  private double valorAposta;

  private int quantJogos;

 

// Metodos Getters e Setters

 

  public String getNome()

  { return(nome); }

  public void setNome(String nome) {

    this.nome = nome;

  }

 

  public String getCavalo()

  { return(cavalo); }

  public void setCavalo(String cavalo) {

    this.cavalo = cavalo;

  }

 

  public double getValorAposta()

  { return(valorAposta); }

  public void setValorAposta(double valoraposta) {

    this.valorAposta = valoraposta;

  }

 

  public int getQuantJogos()

  { return(quantJogos); }

  public void setQuantJogos(int quantjogos) {

    this.quantJogos = quantjogos;

  }

 

  public String apostar() {

    return("sucesso");

  }

}

 

O Método apostar() devolve a String sucesso que faz com que o usuário seja redirecionado para a pagina de confirmação caso não exista erro no preenchimento dos campos do form.

 

Em seguida vemos o código do Faces-config.xml aonde configuramos ApostaBean utlizando as tags : <managed-bean-name> e <managed-bean-class> que  são atributos da tag <managed-bean>.

 

<?xml version='1.0' encoding='UTF-8'?>

<!DOCTYPE faces-config PUBLIC

  "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN"

  "http://java.sun.com/dtd/web-facesconfig_1_1.dtd">

 

<faces-config>

  <managed-bean>

    <managed-bean-name>apostaBean2</managed-bean-name>

    <managed-bean-class>br.nitewing.claudio.validacoes.ApostaBean2

</managed-bean-class>

    <managed-bean-scope>request</managed-bean-scope>

  </managed-bean>

 

  <navigation-rule>

    <from-view-id>/aposta1.jsp</from-view-id>

    <navigation-case>

      <from-outcome>sucesso</from-outcome>

      <to-view-id>/WEB-INF/resultados/mostrarAposta1.jsp</to-view-id>

    </navigation-case>

  </navigation-rule>

</faces-config>

 

No arquivo aposta1.jsp abaixo temos um form que servirá para entradas de dados digitado pelos apostadores.

 

aposta1.jsp

 

<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>

<f:view>

      <HTML>

      <HEAD>

      <TITLE>Apostas</TITLE>

      <style type=

...

Conhecendo as Classes Wrappers, Autoboxing e Auto-unboxing (Introdução)

 

Neste artigo falaremos sobre o uso de classes Wrappers , e dos recursos do java 5 de Autoboxing e Auto-unboxing.

 

 

Tabela de Tipos primitivos e Classes Wrappers

 

Tipo primitivo

Classe Wrapper

Subclasse

...

Formatando números com Numberformat

 

A classe  NumberFormat, faz parte do pacote java.text e permite formatar números conforme a localização geográfica em que você se encontra, realizando a distinção entre o sinal de ponto,milhar e de  decimal,  também identifica a posição do sinal do número e identifica o prefixo que indica a moeda em caso de valores monetários.

 

A Classe NumberFormat possui três mêtodos para formatar números, valores monetários e percentuais. Para fazer uso dela é necessário importa-la.

 

ex:

import java.text.NumberFormat;

 

Os principais métodos do NumberFormat são:

 

getNumberInstance()

Retorna a instância de um objeto com base no formato da localidade padrão. É utilizado para numeros

 

getCurrencyInstance()

Usado para formatar moedas

 

getIntegerInstance()

Usado para formatar números ignorando casas decimais

 

getPercentInstance()

Usado para formatar frações pro exemplo 0,15 é formatado e mostrado como 15%

 

Exemplo:

 

import java.text.NumberFormat;

 

public class Formata {

 

      public static void main(String[] args) {

           

            System.out.println(NumberFormat.getCurrencyInstance().format(12345678.90));

            // imprimirá R$ 12.345.678,90          

      }

}

 

Agora um exemplo para uma situação em que se há muitos números a serem formatados.

 

import java.text.NumberFormat;

 

public class Formata2 {

 

      public static void main(String[] args) {

            double n[]={523.34, 54344.23 ,95845.223 ,1084.895};

           

            NumberFormat z = NumberFormat.getCurrencyInstance();

           

            for (int a = 0; a < n.length; a++) {

                  if(a != 0)

                        System.out.print(", ");

                        System.out.print(z.format(n[a]));

            }

            System.out.println();

            /*

            Imprime:

            R$ 523,34, R$ 54.344,23, R$ 95.845,22, R$ 1.084,90

            */

      }    

}

 

Ainda é possível criar uma formatação personlizada utilizando o objeto DecimalFormat.

 

por exemplo:

 

import java.text.DecimalFormat;

 

public class Formata {

     

      public static void main(String[] args) {

           

            double valor = 2000.0;

            double vezes = 3.0;

            double prestacao = valor/vezes;

     

            DecimalFormat df = new DecimalFormat("0.##");

            String dx = df.format(prestacao);

           

            System.out.print(dx);

           

      }

      // sera impresso : 666,67

}

 

Algumas strings de formatação que podem ser utilizadas com o Decimal Format

 

Marcara de formatação

Formato impresso

Descrição

...

Java Server Faces: Métodos de Validação – Parte 2

 

Continuando com nosso artigo sobre métodos de validação em JSF, vamos ver um exemplo de Validação Manual.

 

 

Figura-1

 

O código de nosso aplicativo  esta comentado, é um aplicativo bem simples que simula um aplicação de venda de Títulos de aplicação, ela não é um exemplo real, mas o seu objetivo é você entender como se ocorre a validação manual.

 

Primeiro crie um projeto web em sua IDE preferida, e vamos criar dois arquivos com extensão .jsp, chame o primeiro de index.jsp e o segundo de cap1,jsp como na Figura-1 mostrada anteriormente.

 

É importante lembrar que como estou usando eclipse, com os plugins Sysdeo para Tomcat, e Amateras HTML e Amateras Faces IDE, estrutura do projeto pode parecer estranha para usuários do WTP ou ainda para usuários do Netbeans, mas isso não chega a ser um problema, pois o exemplo funcionara se você tiver os  jars  do myfaces na sua aplicação no classpath da sua aplicação como mostrada  na Figura-2, não usamos o Tomahawk em nossa aplicação mas o plugin Amateras Faces adiciona tambem coloca ele na aplicação por padrão, no Eclipse você pode baixar o eclipse 1.1.5 que é a versão utiliza em nosso artigo ou uma mais nova, e colocar na pasta lib de sua aplicação,  caso esteja usando o eclipse com Exadel, Lomboz ou algum outro plugin é só pedir para adicionar JSF capabilities, já no Netbeans você pode escolher um projeto web e marcar o frame java server faces quando estiver criando um projeto web pois o código aqui apresentando é totalmente compatível com a especificação da Sun e não usamos componentes do Tomahawk.

 

 

Figura-2

 

código do index.jsp

 

<%@page pageEncoding="UTF-8" contentType="text/html; charset=UTF-8" %>

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>

<title>Validação Manual</title>

</head>

<body>

<h1>Metódos de Validação</h1>

<a "cap1.jsf"> Validação Manual</a><br>

</body>

</html>

 

Agora crie o arquivo cap1.jsp:

 

<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>

<%@page pageEncoding="UTF-8" contentType="text/html; charset=UTF-8" %>

<f:view>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">

<HTML>

<HEAD>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>

<TITLE>Exemplo de Validação Manual</TITLE>

 

<LINK REL="STYLESHEET"

      "./css/styles.css"

      TYPE="text/css">

</HEAD>

<BODY>

<CENTER>

<h1>Capitalização NossaCap</h1>

 

<h:form>

  <h:outputText value="#{capBean1.errorMessages}"

                escape="false"/>

  <TABLE width="350px">

  <TR>

    <TD>Nome Titular:

    </TD>

    <td align="right"><h:inputText value="#{capBean1.userID}"/></td>

    </TR>

 

    <TD>Valor Aplicado(R$):

    </TD>

    <td align="right"><h:inputText value="#{capBean1.bidAmount}"/></td>

    </TR>

  <TR>

    <TD>Vigência do Titulo:

    </TD>

    <td align="right"><h:inputText value="#{capBean1.bidDuration}"/></td>

    </TR>

  <TR><Td colspan="2" align="right">

      <h:commandButton value="Confirmar!"

                       action="#{capBean1.doCap}"/></Td></TR>  </TABLE>

</h:form>

</CENTER></BODY></HTML>

</f:view>

 

Agora vamos criar o Backbean CapBean1 que será responsável pela validação de campos submetidos pelo usuário.

 

CapBean.java

 

package validacoes;

//Essa classe faz parte do pacote validacoes

 

import java.util.ArrayList;

 

public class CapBean1 {

  private String userID = "";

  private String bidAmount;

  private double numericBidAmount = 0;

  private String bidDuration;

  private int numericBidDuration = 0;

/* As mensagens de erro serão armazenadas em um ArrayList

 * Observe que o nosso código é adaptado para o Java 5

 * podendo ser rodado sobre um JVM 1.4 com algumas adaptações

 * no código.

 */

  private ArrayList<String> errorMessages = new ArrayList<String>();

 

  // Agora definiremos o metódos get e Set do Managed Bean CapBean1.java

 

  public String getUserID() { return(userID); }

 

  public void setUserID(String userID) {

    this.userID = userID.trim();

  }

 

  public String getBidAmount() { return(bidAmount); }

 

  public void setBidAmount(String bidAmount) {

    this.bidAmount = bidAmount;

    /* é feita a conversão da String recebida e armazenada no objeto

     numericBidAmout que é do tipo double

     */

    try {

      numericBidAmount = Double.parseDouble(bidAmount);

    } catch(NumberFormatException nfe) {}

  }

 

  public double getNumericBidAmount() {

    return(numericBidAmount);

  }

 

  public String getBidDuration() { return(bidDuration); }

 

  public void setBidDuration(String bidDuration) {

    this.bidDuration = bidDuration;

...

Java Server Faces: Métodos de Validação (Introdução)

 

Eu poderia iniciar logo falando sobre os métodos de validação do Java Server Faces (JSF) mas acho interessante responder ou pelo menos tentar esclarecer um pouco questões da orientação objeto e da  tecnologia Java Beans antes de colocarmos a mão na massa.

 

O que são JavaBeans  ?

JavaBeans são classes javas que seguem algumas convenções :

l  Devem possuir um construtor sem parâmetros , você pode satisfazer esse requerimento,  omitindo todos os métodos construtores de sua classe ou definindo o construtor sem a passagem de parâmetros.

l  Não podem possuir variáveis(campos)  públicos, em resumo não pode haver acesso direto ao campos, ao invés disso deve ser feito uso de métodos assessores.

l  A Persistência de dados deve ser feita através de métodos Getters e Setters, ou seja se a classe possuir um método getNome ela retornara uma String pois provavelmente o campo definido na classe sera do tipo String, em caso de valores do tipo Boleanos, é o utilizado a sintaxe isXxx  invés de getXxx.

 

ex:

Ao invés de declararmos:

 

      public double speed;

 

Devemos usar:

 

      // Declaramos o atributo speed como privado

      private double speed;

 

 

      // Método Get que irá retornar o valor do atributo speed

      public double getSpeed()

      {

      return speed);

      }    

 

      // Metódo set que irá armazenar em speed

      public void setSpeed(double newSpeed)

       {

      speed = newSpeed;

      }

 

Para informações sobre beans é aconselhável uma visita a : http://java.sun.com/beans/docs/

 

E o que são Construtores ?

Um método construtor é chamado sobre um objeto no momento em que este é criado, ao contrário de outros métodos ele não pode ser chamado diretamente, eles servem para definir valores iniciais para variáveis(atributos) de instância, eles sempre têm o mesmo nome da classe que fazem parte, não tem nenhum tipo de retorno, não fazem uso da instrução return.

 

ex:

      class Carro {

      // Atributos(varíaveis)

      String marca

      int ano

      //Método construtor

      Carro(String m, int a){

...

JSF – Usando arquivos de propriedades(Resource Bundle) para internacionalização de aplicativos

 

Este artigo tem como objetivo mostrar o uso de arquivos .properties (os Resources Bundles), eles servem pra inúmeras coisas, mas nesse artigo iremos dar um enfoque maior em seu uso para internacionalização de aplicações em JSF.

 

index.jsp

<%@page contentType="text/html"%>

<%@page pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

   "http://www.w3.org/TR/html4/loose.dtd">

<html>

    <head>

        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

        <title>JSF - Usando Properties Files</title>

    </head>

    <body>

    <h1>JSF - Usando Properties Files</h1>

    <br/>

    <li><a "./simples.jsf">Exemplo Mensagens Simples</a></li>

    <li><a "./parametros.jsf">Exemplo Mensagens Parametrizadas</a></li>

    <li><a "./parametros.jsf">Internacionalização</a></li>

</body>

</html>

 

simples.jsp

<%@page contentType="text/html"%>

<%@page pageEncoding="UTF-8"%>

<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>

<%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>

    <head>

        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

        <title>Mensagens Simples</title>

    </head>

    <body>

        <f:view>

            <h1>JSF - Usando Properties Files</h1>

            <f:loadBundle basename="recursos.mensagens" var="msgs"/>

            <h2><h:outputText value="#{msgs.title}"/></h2>

            <BR>

            <h:outputText value="#{msgs.text}"/>

            <P>

            <h:form>

                <table border="0" cellspacing="2" cellpadding="2">

                    <tbody>

                        <tr>

                            <td> <h:outputText value="#{msgs.firstNamePrompt}"/>:</td>

                            <td><h:inputText /></td>

                        </tr>

                        <tr>

                            <td><h:outputText value="#{msgs.lastNamePrompt}"/>:</td>

                            <td> <h:inputText /></td>

                        </tr>

                        <tr>

                            <td><h:outputText value="#{msgs.emailAddressPrompt}"/>:</td>

                            <td><h:inputText /></td>

                        </tr>

                        <tr>

                            <td><h:commandButton

                                value="#{msgs.buttonLabel}"/></td>

                            <td></td>

                        </tr>

                    </tbody>

                </table>               

            </h:form>

        </f:view>

    </body>

</html>

 

Altere o contéudo do arquivo web.xml acrescentando as seguintes linhas:

 

<servlet>

        <servlet-name>Faces Servlet</servlet-name>

        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>

        <load-on-startup>1</load-on-startup>

        </servlet>

    <servlet-mapping>

        <servlet-name>Faces Servlet</servlet-name>

        <url-pattern>*.jsf</url-pattern>

 </servlet-mapping>

<welcome-file-list>

      <welcome-file>

            index.jsp

        </welcome-file>

</welcome-file-list>

 

Agora vamos criar um pacote chamado recursos e dentro do pacote recursos vamos criar um arquivo com extensão .properties, vamos chama-lo de mensagens.properties.

 

E nele adicionaremos o seguinte conteúdo:

 

title=Inscrição para Workshop

text=Por favor insira o seu nome e sobrenome e email.

firstNamePrompt=Nome

...

Navegação Estática e Dinâmica com JSF - Parte II

 

No artigo anterior começamos a utilizar Java Server Faces, mas não chegamos a usar nenhuma classe java, o nosso próximo exemplo utiliza um Action Controller, mas em artigos futuros usaremos exemplos mais realistas, por enquanto vamos dar continuidade o que começamos no artigo anterior.

 

 

Figura 1

 

A Figura1 mostra o funcionamento de nossa aplicação:

 

Atualize seu faces-config.xml com o conteúdo abaixo:

 

<?xml version="1.0"?>

<!DOCTYPE faces-config PUBLIC "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN" "http://java.sun.com/dtd/web-facesconfig_1_1.dtd">

<faces-config>

<navigation-rule>

                        <from-view-id>/registrar1.jsp</from-view-id>

            <navigation-case>

                        <from-outcome>registrar</from-outcome>

                        <to-view-id>/WEB-INF/respostas/resultado1.jsp</to-view-id>

            </navigation-case>

</navigation-rule>

<navigation-rule>

            <from-view-id>/registrar2.jsp</from-view-id>

<navigation-case>

            <from-outcome>aceito</from-outcome>

            <to-view-id>/WEB-INF/respostas/aceito.jsp</to-view-id>

</navigation-case>

<navigation-case>

            <from-outcome>rejeitado</from-outcome>

            <to-view-id>/WEB-INF/respostas/rejeitado.jsp</to-view-id>

</navigation-case>

</navigation-rule>

            <managed-bean>

                        <managed-bean-name>PlanoSaudeController</managed-bean-name>

                        <managed-bean-class>navegacao.PlanoSaudeController</managed-bean-class>

                        <managed-bean-scope>request</managed-bean-scope>

            </managed-bean>

</faces-config>

 

Atualize também o arquivo web.xml:

 

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"

    version="2.4">

  <display-name>MyFaces Application</display-name>

  <!-- servlet -->

  <servlet>

    <servlet-name>FacesServlet</servlet-name>

    <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>

    <load-on-startup>1</load-on-startup>

  </servlet>

  <!-- servlet-mapping -->

   <servlet-mapping>

    <servlet-name>FacesServlet</servlet-name>

    <url-pattern>*.faces</url-pattern>

  </servlet-mapping>

  <!-- The Usual Welcome File List -->

    <welcome-file-list>

      <welcome-file>index.jsp</welcome-file>

    </welcome-file-list>

   

<security-constraint>

<display-name>

Bloqueio  a acesso direto as paginas JSP.

</display-name>

<web-resource-collection>

<web-resource-name>Raw-JSF-JSP-Pages</web-resource-name>

<!-- Add url-pattern for EACH raw JSP page -->

<url-pattern>/welcome.jsp</url-pattern>

<url-pattern>/registrar1.jsp</url-pattern>

<url-pattern>/registrar2.jsp</url-pattern>

</web-resource-collection>

<auth-constraint>

<description>Sem regras, Apenas bloqueio  acesso direto</description>

</auth-constraint>

</security-constraint>

</web-app>

 

Crie o arquivo registrar2.jsp:

 

<%@ page contentType="text/html; charset=UTF-8" %>

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>

<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

<html>

            <head>

                        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>

                        <title>Plano de Saude JM</title>

            </head>

...

Navegação estática e dinâmica com JSF – Parte I

 

JSF(ou Java Server Faces) é uma tecnologia que incorpora características de um framework MVC para WEB e também as de um modelo de interfaces gráficas baseado em eventos. Por basear-se no padrão de projeto MVC, uma de suas melhores vantagens é a clara separação entre a visualização e regras de negócio (modelo).

 

O controller é composto pelo FacesServlet por arquivos de configuração e por um conjunto de manipuladores de ações e observadores de eventos.

 

O FacesServlet é responsável por receber requisições da WEB, redirecioná-las para o modelo e então remeter uma resposta

 

Os arquivos de configuração são responsáveis por realizar associações e mapeamentos de ações e pela definição de regras de navegação.

 

Os manipuladores de eventos são responsáveis por receber os dados vindos da camada de visualização, acessar o modelo, e então devolver o resultado para o FacesServlet

 

O modelo representa os objetos de negócio e executa uma lógica de negócio ao receber os dados vindos da camada de visualização.

 

A visualização é composta por component trees (hierarquia de componentes UI), tornando possível unir um componente ao outro para formar interfaces mais complexas.

 

Após essa breve introdução do que é o Java Server Faces, vamos agora criar um exemplo bem simples com pra demonstrar o uso do mesmo.

 

Aplicação de exemplo esta dividida em duas partes e embora não seja uma aplicação real, o exemplo permite ter uma noção de alguns recursos do  JSF, outros serão explorados em outros tutoriais.

 

Nessa primeira etapa veremos um exemplo de navegação estática com JSF:

 

Nossa aplicação será composta de dois formulários, o segundo formulário que ao ser submetido, terá um Bean  é instanciado e um método action controller  invocado, retornando então uma condição que resultara em uma resposta que será mostrada ao usuário.

 

 

 

Primeiro vamos configurar o arquivo faces-config.xml

 

<?xml version="1.0"?>

<!DOCTYPE faces-config PUBLIC "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN" "http://java.sun.com/dtd/web-facesconfig_1_1.dtd">

 

<faces-config>

<navigation-rule>

            <from-view-id>/registrar1.jsp</from-view-id>

      <navigation-case>

            <from-outcome>registrar</from-outcome>

            <to-view-id>/WEB-INF/respostas/resultado1.jsp</to-view-id>

      </navigation-case>

</navigation-rule>

</faces-config>

 

Agora crie um arquivo .jsp de nome index.jsp:

 

<%@ page language="java" contentType="text/html; charset=UTF-8"

    pageEncoding="UTF-8"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

 

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>Registrar</title>

</head>

<body>

<a "registrar1.faces">Registrar1 - Exemplo de Navegação Estática</a><br>

<a "registrar2.faces">Registrar2 - Exemplo de Navegação Dinâmica</a>

</body>

</html>

 

registrar1.jsp

 

<%@ page contentType="text/html; charset=UTF-8" %>

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>

<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

 

<html>

      <head>

            <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>

            <title></title>

...

Desenvolvendo um cadastro simples com Struts

 

Embora o Struts 2 ofereça uma quantidade enorme de recursos, muitas empresas ainda usam o Struts 1.2.x ou 1.3.x, neste artigo veremos um exemplo bem simples de Struts, bem básico mesmo.

 

Agora iremos criar um arquivo index.jsp ao qual teremos links para os exemplos que nós veremos em nossas próximos artigos.

 

<html>

    <head>

        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

        <title>Exemplos com Struts</title>

    </head>

    <body>

    <div align="center">

    <h1>Indice de Exemplos<br> com Struts 1.2.x</h1>

   

    <ol>

        <li><a "Registro1.jsp">Exemplo 1</a></li>

        <li>Exemplo2</li>

    </ol> 

    </div>

    </body>   

</html>

 

Edite o arquivo web.xml  para se parecer com o mostrado abaixo:

 

<?xml version="1.0" encoding="UTF-8"?>

<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

    <servlet>

        <servlet-name>action</servlet-name>

        <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>

        <init-param>

            <param-name>config</param-name>

            <param-value>/WEB-INF/struts-config.xml</param-value>

        </init-param>

        <init-param>

            <param-name>debug</param-name>

            <param-value>2</param-value>

        </init-param>

        <init-param>

            <param-name>detail</param-name>

            <param-value>2</param-value>

        </init-param>

        <load-on-startup>2</load-on-startup>

        </servlet>

    <servlet-mapping>

        <servlet-name>action</servlet-name>

        <url-pattern>*.do</url-pattern>

    </servlet-mapping>

    <session-config>

        <session-timeout>

            30

        </session-timeout>

    </session-config>

    <welcome-file-list>

      <welcome-file>index.jsp</welcome-file>

        </welcome-file-list>

    </web-app>

 

Em strutsaula/web crie o arquivo Registro1.jsp :

 

<html>

...

Como usar coleções - Parte V – Final

 

Estamos chegando ao final de nossa série de artigos sobre Coleções do Java. Nessa última parte falaremos um pouco sobre Map.

 

Usando Mapas

Mapas (também chamados de arrays associativos) de objetos são mais uma das formas de organizarmos coleções de objetos, apesar de se parecerem com arrays de objetos, seus índices não precisam necessariamente ser valores inteiros positivos seqüênciais, por isso podem ser instâncias de uma classe qualquer, simplificando: Mapas são conjuntos de pares de objetos, sendo um chamado chave e o outro, valor.

 

Mapas permitem valores iguais, porém, não permitem chaves repetidas, é importante lembrar que chaves diferentes podem ser ou estarem associadas a valores iguais.

 

No Java as interfaces e classes que implementam Mapas não herdam da interface Collection, mas mesmo assim é possível de forma separada acessar e manipular chaves e valores de mapas como se estes fossem coleções.

 

Os métodos que podem ser aplicados a um mapa são definidos pela interface Map, esses métodos são implementados por duas classes HashMap e TreeMap.

 

 

Figura 1 – Exemplo de HashMap

 

A seguir um exemplo do uso de Map:

Crie o arquivo DIPs.java.

// Importando as bibliotecas necessárias

import java.io.IOException;

import java.util.*;

import java.io.BufferedReader;

import java.io.InputStreamReader;

/**

 *

 * @author claudio

 */

public class DIPs {

    public DIPs() {

      //Metdp construtor

    }

...

Utilizando recursos do Java para formatação de datas

 

Para formatarmos elementos de uma data é necessário o uso do DateFormat, podemos com ela definir  a forma como queremos que seja exibido uma determinada data, por exemplo: “dia/mês/ano” ou “ano-mês-dia”, podemos também converter uma data para texto e vice versa independente da posição geográfica, Internamente DateFormat o número de milissegundos decorridos desde 01/01/1900.

 

A Classe DateFormat não traz métodos adequados para conversão para texto, mas isso pode ser sanado com o uso de SimpleDateFormat.

 

Veja exemplos abaixo:

 

package javaapplication1;

 

import java.text.DateFormat;

import java.util.Date;

 

/**

 * @author claudios

 */

public class Main {

 

    /**

     * @param args the command line arguments

     */

    public static void main(String[] args) {

        // Imprime a data no formato Padrão

        System.out.println(DateFormat.getDateInstance().format(new Date()));                     

    }

}

 

package javaapplication1;

 

import java.text.DateFormat;

import java.util.Date;

 

/**

 * @author claudios

 */

public class Main {

 

    /**

     * @param args the command line arguments

     */

    public static void main(String[] args) {

         // Imprime a data no formato curto

        System.out.println(DateFormat.getDateInstance(DateFormat.SHORT).format(new Date()));

  

       

    }

 

}

 

package javaapplication1;

 

import java.text.DateFormat;

import java.util.Date;

 

/**

 * @author claudios

 */

public class Main {

 

    /**

     * @param args the command line arguments

     */

    public static void main(String[] args) {

        // Imprime a data no formato medio

        System.out.println(DateFormat.getDateInstance(DateFormat.MEDIUM).format(new Date()));       

    }

 

}

 

package javaapplication1;

 

import java.text.DateFormat;

import java.util.Date;

 

/**

 * @author claudios

 */

public class Main {

 

    /**

     * @param args the command line arguments

     */

    public static void main(String[] args) {

        // Imprime  a data no formato longo

        System.out.println(DateFormat.getDateInstance(DateFormat.LONG).format(new Date()));

    }

 

}

 

package javaapplication1;

 

import java.text.DateFormat;

import java.util.Date;

 

/**

 * @author claudios

 */

public class Main {

 

    /**

     * @param args the command line arguments

     */

    public static void main(String[] args) {

        // Imprime a data no formato completo

        System.out.println(DateFormat.getDateInstance(DateFormat.FULL).format(new Date()));

    }

 

}

 

O Resultado deveram se parecer com os que são mostrados abaixo :

 

         * 31/05/2007

         * 31/05/07

         * 31/05/2007

         * 31 de Maio de 2007

         * Quinta-feira, 31 de Maio de 2007

 

Formatação Personalizada

A classe SimpleDateFormat possibilita que você possa fornecer uma String de formatação para  data/hora com letras que tem signifados especiais como mostra a Tabela-1.

 

Símbolo

Significado

Exemplo

...

Quando usar Coleções - Parte III

 

Antes de começarmos a falar sobre Iterators, vamos relembrar o conceito de Lista de Objetos.

 

Listas de Objetos são coleções onde elementos repetidos podem ocorrer e onde os elementos têm posições definidas, para simplificar, podemos afirmar que listas são como arrays com características adicionais, sendo que destas a que mais merece destaque é a capacidade de seu tamanho a ser modificado de acordo com a necessidade.

 

Já havia sido comentado no artigo anterior que a interface List declara métodos que podem ser usados para manipular listas e também sobre a existência de duas classes que implementam a interface List: ArrayList e LinkedList. Também comparamos as vantagens e desvantagens destas duas classes.

 

Após essa recapitulação vamos agora falar sobre Iterators.

 

Iterators

Quando usar Iterators ?

 

Há ocasiões (e não são poucas) em que precisamos que nosso programa percorra um a um os elementos que estão dentro de um objeto de coleção.

 

Uma boa solução para resolver essa situação é criar uma variável que varra o conjunto de elementos, montar um índice variando do primeiro elemento até o último.

 

Com isso em vez de escrever:

 

import java.util.ArrayList;

 

public class Lista3 {  

      public static void main(String[] args) {

            ArrayList lista2 = new ArrayList();

            lista2.add("Dinardo");

            lista2.add("Rosa");

            lista2.add("Rafa");

            lista2.add("Anderson");

            lista2.add("Alex");         

            for (int i = 0; i < lista2.size(); i++) {

                  System.out.println(lista2.get(i));

            }

      }

}

 

Com o uso de iterators  o código ficaria assim:

 

package javaapplication1teste;

 

import java.util.ArrayList;

import java.util.Iterator;

 

public class Lista3 {  

      public static void main(String[] args) {

            ArrayList lista2 = new ArrayList();

            lista2.add("Dinardo");

            lista2.add("Rosa");

...

Quando usar Collections - Parte II

 

No Artigo anterior eu prometia que iríamos explorar o grupo List, mas, antes de começar a falar sobre Listas de Objetos, é importante que se saiba quais são os principais métodos da Classe Collection e da interface Map.

 

Os Principais métodos da Classe Collection

Add(Object objeto) - Adiciona a coleção a um determinado objeto

 

addAll(Collection outraCollection) – Adiciona todos elementos de outra coleção.

 

clear() - Limpa todos os elementos de uma coleção.

 

contains(Object objeto) – Retorna true se o objeto já fizer parte da coleção.

 

containsAll(Collection outraCollection) – Retorna true caso todos os elementos de outra coleção estiverem presentes em determinada coleção.

 

hashcode() - Retorna o hashcode do objeto.

 

iterator() - Retorna o objeto de iteração com os elementos desta coleção.

 

remove(Object objeto) – Remove o objeto da coleção

 

removeAll(Collection outraCollection) – Remove todos os elementos que pertençam  à coleção corrente e á outra coleção determinada.

 

retainAll(Collection outraCollection) – Remove todos os elementos que não façam parte da coleção corrente e da outra coleção.

 

Size() - Retorna   a quantidade elementos existentes na coleção.

 

toArray() - Retorna  uma matriz de objetos(Object[]) dos elementos que estão contidos na coleção.

 

toArray([]matriz) – Retorna uma matriz do fornecido e, se a a matriz contiver a quantidade de elementos suficiente, passa a ser utilizada para armazenamento.

 

Os principais métodos da interface Map

clear() - Limpa todos os elementos do mapa.

 

containsKeys(Object Key) – Verifica se a chave faz parte do mapa.

 

containsValue(Object value) – Verifica se o valor faz parte do mapa.

 

EntrySet() - Retorna um conjunto do tipo (Set) contendo as chaves do mapa.

 

get(Object key)  - Retorna o valor baseado em uma chave.

 

put(Object Key,Object value) – Coloca a chave com base em valor.

 

putAll(Map outroMapa) – Coloca todos os elementos de outroMapa no mapa corrente.

 

remove(Object key) – Remove o elemento com a chave fornecida.

 

Size() - Retorna   a quantidade de elementos existentes no mapa.

 

Value() - Retorna uma coleção com os elementos do mapa.

 

As coleções estão dividas em três grandes grupos: List, Set e Map

Falaremos primeiro sobre o grupo List (Lista de Objetos)

 

A Finalidade do grupo List é gerenciar um grupo de elementos em sequência, muito semelhante a uma matriz, porem com a diferença de que, quando usamos uma classe do grupo List, a quantidade de elementos são modificadas dinamicamente.

 

Listas de Objetos são coleções onde os elementos podem se repetidos podem ocorrer e onde todos tem uma posição definida, a implementação de listas em java é muito semelhante a de Conjuntos (veremos nos próximos artigos).

 

Novo Java existe a interface List, esta declara quais metódos podem ser utilizados pelas classes ArrayList e LinkedList para manipular listas, essas classes possuem mecanismos distintos para representação interna dos objetos da Lista.

 

Na Figura1 e Figura 2 ilustramos o funcionamento das classes: ArrayList e LinkedList:

 

Figura 1

Figura 2

 

ArrayList implementa internamente uma lista como um array e tem um performance melhor, porém não é eficiente em situações que envolvam a inserção e deleção de elementos na lista. Enquanto que com o LinkedList ocorre justamento o inverso, sendo mas lenta para acesso sequencial a elementos da lista.

 

 Veja o código abaixo:

 

public class Lista {

 

      public static void main (String args[]) {

            String pessoas[] = new String[4];

            pessoas[0] = "Dinardo";

            pessoas[1] = "Rosa";

            pessoas[2] = "Rafael";

            pessoas[3] = "Alex";

            for(int i=0; i < pessoas.length

...

Quando usar Java Collections - Parte I

 

Em primeiro lugar o que é uma coleção?

 

Em Programação orientada a objetos, é comum trabalharmos não apenas com um objeto, mas sim com um conjunto deles. Com base nisso fica clara que uma collection é um objeto que agrupa múltiplos elementos (variáveis primitivas ou objetos) dentro de uma única unidade, devido a isso uma coleção também pode ser denominada como um container.

 

Ok, mas isso serve para que?

 

Coleções são usadas para armazenar, recuperar e manipular dados, assim como facilitar a transmissão de dados de um método para outro.

 

Tem um exemplo disso?

 

Geralmente coleções representam itens de dados que formam no geral um grupo.

 

Ex: Uma agenda telefônica contém uma coleção de números e nomes de telefones.

 

Antes do Java 1.2 existiam (ainda existem :-)) as seguintes classes:

·         Vector

·         Stack

·         Hashtable

·         Array

·         BitSet

 

A partir do Java 1.2 foi introduzido o Java Collections Frameworks, uma arquitetura unificada para fornecer uma manipulação mais eficiente de coleções de objetos, através de interfaces, algoritmos e implementações. Essas classes e interfaces estão localizadas no pacote java.util.

 

Collections disponibiliza componentes reutilizáveis, tais como:

·         Listas

·

...

Criando um Systray Multiplataforma com Java 6.0

 

Neste artigo iremos explorar alguns dos recursos das classes SystemTray e TrayIcon do Java 6 para com isso criarmos uma System Tray multiplataforma, para usarmos em nossas aplicações desktop, as classes SystemTray e TrayIcon fazem parte do pacote java.awt e juntas possibilitam a criação de um Tray com recursos tais como : imagens, popups,menus,submenus e itens de notificações.

 

No código descrito nesse artigo nós abordamos a maioria dos recursos dessas classes, para não ficar muito extenso, o código esta todo comentado.

 

A Figura 01 apresenta a aparência de nosso Tray.

 

Figura 01. Tray em execução.

 

//Importando as bibliotecas necessárias

import java.awt.AWTException;

import java.awt.CheckboxMenuItem;

import java.awt.Image;

import java.awt.MenuItem;

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 java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import javax.swing.JOptionPane;

 

public class Main {

   

    public static void main(String[] args) {

       

    final TrayIcon trayIcon; // declarando uma constante do tipo TrayIcon

 

    // Aqui vamos testar se o recurso é suportado

    if (SystemTray.isSupported()) {

   

    //declarando uma variavel  do tipo SystemTray

    SystemTray tray = SystemTray.getSystemTray();

   

    //declarando uma variavel  do tipo Image que contera a imagem tray.gif

    Image image = Toolkit.getDefaultToolkit().getImage("tray.gif");

   

   

     //Criamos um listener para escutar os eventos de mouse

      

    MouseListener mouseListener = new MouseListener() {

               

        public void mouseClicked(MouseEvent e) {

            

        }

 

        public void mouseEntered(MouseEvent e) {

           

        }

 

        public void mouseExited(MouseEvent e) {

           

        }

 

        public void mousePressed(MouseEvent e) {           

           

        //Toda vez que for clicado imprime uma mensagem na tela

            System.out.println("Tray Icon - O Mouse foi pressionado!");                       

        }

 

        public void mouseReleased(MouseEvent e) {

           

        }

    };

 

    // Criamos um ActionListener para a ação de encerramento do programa.

    ActionListener exitListener = new ActionListener() {

...

Criando Digramas de Classe usando o plugin Amateras UML no Eclipse

 

O Amateras UML é um plugin open source, regido pela Eclipse Public License -v 1.0, simples e leve que exige apenas ter o GEF instalado. Ele gera Diagramas de Classe, Casos de Uso e Diagramas de Seqüência. Os diagramas criados podem ser impressos ou ainda salvos no formato de imagem .jpeg e exportados para código fonte  java.

 

Figura 01 – Tela inicial do Programa

 

O Amateras pode ser baixado em:

 

http://amateras.sourceforge.jp/cgi-bin/fswiki_en/wiki.cgi?page=AmaterasUML

 

Instalando o plugin Amateras UML

A Instalação do plugin é bastante simples basta descompactar o arquivo AmaterasUML.x.x.x.zip no diretório plugins do Eclipse, entretanto é importante avisar que o Amateras UML deve ser baixado e instalado o GEF disponível em : http://www.eclipse.org/gef .

 

Criando um Diagrama de Classes

A primeira coisa a se fazer é criar um projeto java no Eclipse.

 

File >> New >> Java Project

 

Vamos dar a ele o nome de “transportadora”.

 

Em seguida vamos criar uma pasta no nosso projeto.

 

File >> new  >> Folder

 

Chame essa pasta de “Diagrama” ou qualquer outro nome que desejar.

 

Em seguida clique na pasta Diagrama e com o botão direito do mouse escolha:

 

New >> Other >> Amateras UML >> Class Diagram

 

Salve como: Exemplo.cld

 

Para criar a nossa primeira classe, a classe Cliente, clique na opção entity e escolha o item Class. Clicando nele e clicando na área cinza, será criada uma classe de nome class1, um duplo clique no nome da classe permite que ela seja renomeada.

 

Antes de inserirmos os atributos e métodos, clique com o botão do mouse sobre a classe e escolha opção Open Property View, com isso teremos disponível para nós uma barra de propriedades.

 

Para inserir os atributos na classe clicamos novamente da classe Cliente e escolhemos o item Add Atribute, para adicionar um método clicamos na opção Add Operation.

 

Vamos Criar duas classes, de acordo com a Figura 2:

 

...

Criando interfaces Swing com o GuiGeanie 1.0

 

A criação de interfaces para aplicações desktop em java costumam ser trabalhosas, para muitos pouco produtiva, apesar de IDE’s  com recursos  poderosos como o Netbeans, JBuilder, JDeveloper ou mesmo o plugin VE do Eclipse, há uma parcela de usuários iniciantes que nem sempre tem um equipamento a altura de idéias tão cheias de recursos, pensando em gerar alguma produtividade, consumindo muito pouco recurso de sistema existem softwares como o GuiGenie(www.guigenie.cjb.net) e o Cafeteira do Brasileiro Fernando Anselmo.

 

O GuiGenie possibilita a criação de componentes Swing de forma simples, gera um código comentado, um preview de como a tela ficará e salva a classe como um arquivo .java, além de fornecer a possibilidade de salvar o projeto criado nele.

 

Para usar o GuiGenie o primeiro a coisa é baixa-lo no endereço : www.guigenie.cjb.net

 

Existe uma versão multiplataforma e um instalador pra Windows.

 

Se você baixou a versão multiplataforma descompacte o arquivo e entre na pasta desejada, você poderá acessar o programa dando um duplo click no arquivo .jar do GuiGenie  se estiver no Windows ou via prompt do DOS ou Terminal do Linux utilizando um comando :

 

java –jar GuiGenie.jar

 

E será mostrada a seguinte tela conforme a Figura 1.

 

...