JSF 2.0: Ajax nativo

Nessa postagem iremos fazer alguns exemplos de utilização da tag <f:ajax /> que é opção nativa para utlizar o ajax na versão 2.0 do JSF.

Bom, vou postando os códigos fonte de cada exemplo e explicando o que cada um faz, ao final posto o bean que utilizei para os testes.
Obs: todos os códigos dos componentes devem estar dentro de um h:form...

Primeiro componente:

Inicialmente eu vou criar um componente, onde eu tenho uma caixinha de texto, e dois botões, um para somar e outro para subtrair um determinado valor da caixinha de texto, assim:

Código:

<h:inputText id="txtNumero" value="#{testeBean.numero}" />
<h:commandButton value="+" actionListener="#{testeBean.somar}">
 <f:ajax render="txtNumero" execute="@this" />
</h:commandButton>
<h:commandButton value="-" actionListener="#{testeBean.subtrair}">
 <f:ajax render="txtNumero" execute="@this" />
</h:commandButton>

Veja que a tag ajax está entre os commandButtons, e usa a propriedade render para renderizar apenas a caixinha de texto, e o execute para executar apenas a ação do commandButton a qual pertence.

Segundo componente:

Este é um dos componentes mais úteis, que é um combo de estados, e quando seleciona o estado, carrega as cidades do estado selecionado.

Código:

<h:selectOneMenu valueChangeListener="#{testeBean.carregarCidades}">
 <f:selectItem itemLabel="Mato Grosso" itemValue="1" />
 <f:selectItem itemLabel="Paraná" itemValue="2" />
 <f:ajax event="change" render="cidades" />
</h:selectOneMenu>

<h:selectOneMenu id="cidades">
 <f:selectItems value="#{testeBean.cidades}" />
</h:selectOneMenu>

Neste código, eu coloquei os estados manualmente (nada impede de ter uma lista de selectItems), a tag f:ajax, utiliza do evento change, e renderiza o combo de cidades, o método valueChangeListener, serve para carregar as cidades conforme o estado selecionado, o codigo do bean pode ser feito completamente diferente, eu fiz dessa forma apenas para mostrar como funciona o evento change do f:ajax.

Terceiro componente:

Este componente é composto de uma caixinha de texto que atualiza um outputText, cada vez que uma letra é digitada.

Código:

<h:inputText value="#{testeBean.palavra}" >
 <f:ajax event="keyup" render="texto"/>
</h:inputText>
<h:outputText id="texto" value=" A palavra é: #{testeBean.palavra}" />

Aqui está mostrando a utilização do evento keyup da tag f:ajax, a cada letra digitada o f:ajax irá renderizar o outputText com o id texto.

Quarto e último componente:

Este é um dos mais simples, apenas mostra como funciona a tag f:ajax em um commandButton, ao clicar no commandButton, é chamado um método que trás a data e hora atual.

Código:

<h:commandButton value="Pegar data e hora" actionListener="#{testeBean.pegarDataHora}" >
 <f:ajax render="dataHora"/>
</h:commandButton>
<h:outputText value="A data e hora é: " />
<h:outputText value="#{testeBean.dataHora}" id="dataHora">
 <f:convertDateTime pattern="dd/MM/yyyy hh:MM:ss" />
</h:outputText>

Em um commandButton, o padrão do evento da tag f:ajax é o click, veja que por isso não especifiquei o event, apenas mando atualizar o meu outputText dataHora.

Agora segue o código do bean, como disse anteriormente, pode ser feito de outra forma, principalmente a parte de carregar as cidades, dessa forma ficou meio estranha, mas é que eu não quis usar o banco de dados nesse exemplo.

TesteBean.java

@Named
@SessionScoped
public class TesteBean implements Serializable {

    private int numero = 0;
    private List<String> cidades;
    private String palavra;
    private Date dataHora;

    public void somar() {
        numero = numero + 1;
    }

    public void subtrair() {
        numero = numero - 1;
    }

    public void carregarCidades(ValueChangeEvent evento) {
        String codigoEstado = evento.getNewValue().toString();
        cidades = new ArrayList<String>();

        if (codigoEstado.equals("1")) {
            cidades.add("Primavera do Leste");
            cidades.add("Cuiabá");
            cidades.add("Santo Antonio do Leste");
        } else if (codigoEstado.equals("2")) {
            cidades.add("Curitiba");
            cidades.add("Palmas");
        }
    }
    
    //gerar getters e setters
}

JPA 2.0: Gerar classes a partir do banco com o Netbeans

Assim como o JPA pode gerar o banco de dados, é possível a partir do banco de dados gerar as classes já com as anotações do JPA!

Nesse exemplo vamos usar o Netbeans 6.9.1, não sei dizer se as outras versões do Netbeans funcionam da mesma forma. Tendo o seguinte banco, vamos gerar as classes automaticamente para ele:

Crie um novo aplicativo web no Netbeans, com o nome de GerarClasses, em pacotes de código fonte crie um pacote com o nome de model, depois disso gere o persistence.xml, caso não saiba como fazer repita o passo 1. Habilitando o JPA dessa postagem lembrando de informar o banco de onde deseja gerar as classes. 

Depois disso, clique com o botão direito em cima do pacote model, aí vai em Outro... selecione a categoria Persistence e depois Classe de entidade do banco de dados. Abrirá a seguinte janela:

Caso não tenha aparecido nenhuma tabela disponível, selecione a "Fonte de dados" e aguarde que as tabelas serão carregadas, depois disso, clique em Adicionar todas, e depois em Próximo...

Aparecerá esta janela:

Nessa não tem o que fazer, basta clicar em Próximo novamente. A próxima janela será para escolher qual é o tipo de associação (Lazy[lento] ou Eager[ancioso]) e o tipo de coleção (List, Set ou Collection). Quanto a associação o padrão é Eager, aí você deve decidir o que é melhor para você, o mesmo serve para o tipo de coleção, segue a janela:

E agora sim é apenas Finalizar. O projeto ficará assim:

Veja que nosso banco tinha 4 tabelas e foram criadas apenas 3 classes, isso aconteceu pois havia alí um relacionamento N-N, que foi resolvido com um @ManyToMany, para mais informações para esta anotação veja aqui.

=)

JSF 2.0: Componentes básicos

O nome da postagem se refere ao JSF 2.0, mas os componentes que serão mostrados também funcionam no JSF 1.2.
Para começar crie um projeto com o nome de ComponentesBasicos, dentro de pacotes de código-fonte crie um pacote com o nome de controle. Nossa base será um TesteBean.java que deverá ser criando dentro do pacote controle. Segue o código:

@Named
@javax.enterprise.context.RequestScoped
public class TesteBean {

    private boolean confirma;
    private String tipoPessoa;
    private List<String> cores;
    private List<String> coresSelecionadasCheckbox;
    private List<String> coresSelecionadasManyMenu;
    private String corSelecionadaOneMenu;

    public TesteBean() {
        cores = new ArrayList<String>();
        cores.add("Amarelo");
        cores.add("Azul");
        cores.add("Preto");
        cores.add("Vermelho");
    }
    
    //Gerar getters e setters
}

Veja que usamos o construtor para inicializar nossa lista de cores.

Para fazer esse exemplo vamos aproveitar a pagina index que é criada juntamente com o projeto. Então vamos começar a conhecer os componentes:
SelectBooleanCheckbox
Como o nome já diz, ele retorna um valor booleano (true ou false).
Exemplo:

Codigo:

<h:selectBooleanCheckbox value="#{testeBean.confirma}" />
<h:outputText value="Deseja receber mais informações desse blog?"/>

SelectOneRadio
Quanto a esse componente, entre as várias opções, apenas uma pode ser selecionada
Exemplo:

Codigo:

<h:selectOneRadio value="#{testeBean.tipoPessoa}">
    <f:selectItem itemLabel="Fisica" itemValue="F" />
   <f:selectItem itemLabel="Juridica" itemValue="J" />
</h:selectOneRadio>

SelectOneMenu
Este componente gera algo mais conhecido como um combobox. Mais detalhes...
Exemplo:

Codigo:

<h:selectOneMenu value="#{testeBean.corSelecionadaOneMenu}" >
    <f:selectItems value="#{testeBean.cores}" />
</h:selectOneMenu>

SelectManyCheckbox
Componente que permite selecionar vários objetos de uma vez só, marcando os checkbox.
Exemplo:

Código:

<h:selectManyCheckbox value="#{testeBean.coresSelecionadasCheckbox}" layout="pageDirection" >
    <f:selectItems value="#{testeBean.cores}" />
</h:selectManyCheckbox>

SelectManyMenu
Componente parecido com o SelectOneMenu, com a diferença que este permite selecionar vários objetos de uma vez, basta usar o CTRL e clicar nos objetos que deseja selecionar.
Exemplo:

Código:

<h:selectManyMenu value="#{testeBean.coresSelecionadasManyMenu}" style="height: 100px"  >
    <f:selectItems value="#{testeBean.cores}" />
</h:selectManyMenu>

Diferença entre usar f:selectItem e f:selectItems
f:selectItem - esta tag serve para definir valores estaticamente, ou seja diretamente na página, ele tem as propriedades itemLabel e itemValue, o primeiro é o que deve mostrar na página e o segundo é o valor que deve ser salvo em algum atributo do bean.
f:selectItems - este é mais claro, como está no plural já dá a entender que receberá uma lista de objetos.

Referência: Exadel - JSF tags

JPA 2.0: Criando tabelas - Parte 3

Dando sequência as postagens sobre JPA 2.0, nessa vamos entender como funciona a anotação @ManyToMany. Esta anotação serve para gerar uma tabela que resolva um relacionamento  N - N entre duas classes. No caso de usar o @ManyToMany, você não vai precisar criar uma classe intermediária que será anotada, pelo contrário, você deverá apenas duas classes, por exemplo, uma Venda.java e uma Produto.java, nesse relacionamento uma venda pode ter N produtos, e um produto pode estar em N vendas. Sendo assim, em Venda teremos uma lista de produtos, e em Produto teremos uma lista de vendas. Então vamos ao código.
Venda.java

@Entity
public class Venda implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long codigo;

    @ManyToMany
    private List<Produto> produtos;

    // gerar os getters e setters
}

Produto.java

@Entity
public class Produto implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long codigo;

    @ManyToMany
    private List<Venda> vendas;

    // gerar os getters e setters
}

O resultado dessas duas classes será:

Isso acontece porque o JPA não sabe qual das classes será a principal, o que pode acontecer é que se caso você insira uma venda com uma lista de produtos, ela irá inserir em VENDA_PRODUTO, e se você inserir um produto com uma lista de vendas, irá inserir em PRODUTO_VENDA, mas como isso não faz sentido no caso de produtos e vendas, na classe Produto.java, altere a anotação @ManyToMany para:

@ManyToMany(mappedBy="produtos")
    private List<Venda> vendas;

O resultado será:

Mas como eu sou chata e não gosto desse estilo de nomenclatura que JPA usa pra gerar as tabelas, veja as colunas da tabela VENDA_PRODUTO: Venda_CODIGO e produtos_CODIGO, tem uma forma de você nomear a tabela e as colunas como quiser, então em Venda.java altere a anotação @ManyToMany para:

@ManyToMany
    @JoinTable(name="VENDA_HAS_PRODUTO",
        joinColumns=@JoinColumn(name="VENDA_CODIGO"),
        inverseJoinColumns=@JoinColumn(name="PRODUTO_CODIGO"))
    private List<Produto> produtos;

Veja que a anotação @JoinTable é a responsável por dar essa possibilidade de nomear a tabela e as colunas, vamos entender ela: a propriedade name se refere ao nome da tabela, a propriedade joinColumns é responsável por nomear a chave primária correspondente a tabela de VENDA, e a inverseJoinColumns renomeia a chave primária de PRODUTO, ficando assim:

Caso seu sistema não queira gerar as tabelas, apenas crie uma classe qualquer que faça a conexão com o banco, isto será suficiente, assim como mostra abaixo:

public class DAO {
    @PersistenceContext(unitName="ManyToManyPU")
    private EntityManager em;
}

Lembrando que o ManyToManyPU é meu persistence-unit que está no meu persistence.xml, veja o que você configurou em seu persistence.

Só mais um detalhe, muitas pessoas tem dúvidas de como será feito a inserção de dados dentro dessa tabela intermediária, isso é mais simples do que imaginam... Em Venda nós não temos uma lista de produtos?? então é bem isso, para inserir uma venda, você deve setar uma lista de produtos nela, e dar um em.merge(venda) ou em.persiste(venda), e ela já insere a venda na tabela de venda, e os relacionamentos dos produtos da lista com a venda na tabela intermediária. 

Para mais informações, veja: ManyToMany (Java EE 6)

 ;)

JPA 2.0: CRUD com EJB 3.1

Segundo a Oracle: 

"Enterprise JavaBeans (EJB) technology is the server-side component architecture for Java Platform, Enterprise Edition (Java EE). EJB technology enables rapid and simplified development of distributed, transactional, secure and portable applications based on Java technology."

Nessa postagem vamos criar um CRUD utilizando EJB como forma de injetar a conexão com o banco de dados. Atualmente está na versão 3.1, para ser utilizada com JEE 6. Eu já usei o EJB 3.0 com o JEE 5, e aquele era um "monstrinho" de pesado! Hoje nem chega ser perceptível o uso dele.

Bom... chega de teorias e vamos ao o que interessa,  crie um projeto com o nome CrudJPA, caso não saiba como iniciar o JPA no projeto, use esse projeto como base (siga os passos até criar o persistence.xml).
Em Pacotes de código-fonte crie os pacotes: model, controle e dao. Dentro do pacote model crie uma classe java com o nome de Cliente.java:

import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="cliente")
public class Cliente implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="codigo")
    private Long codigo;

    @Column(length=100, name="nome")
    private String nome;

    public Long getCodigo() {
        return codigo;
    }

    public void setCodigo(Long codigo) {
        this.codigo = codigo;
    }

    public String getNome() {
        return nome;
    }

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

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (codigo != null ? codigo.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object object) {
        if (!(object instanceof Cliente)) {
            return false;
        }
        Cliente other = (Cliente) object;
        if ((this.codigo == null && other.codigo != null) || (this.codigo != null && !this.codigo.equals(other.codigo))) {
            return false;
        }
        return true;
    }
}

Nosso modelo acima não tem nada de diferente, apenas as anotações do JPA que já foram faladas em postagens anteriores, antes que esqueçamos vamos mapear nossa entidade Cliente, dentro do persistence.xml, o mesmo deverá ficar assim:

<persistence version="2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/persistence" xsi:schemalocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
    <persistence-unit name="TesteJPAPU" transaction-type="JTA">
        <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
        <jta-data-source>5tads</jta-data-source>
        <class>model.Cliente</class>
        <exclude-unlisted-classes>true</exclude-unlisted-classes>
        <properties>
            <property name="eclipselink.ddl-generation" value="create-tables" />
        </properties>
    </persistence-unit>
</persistence>

Agora dentro do pacote dao crie uma classe java com o nome de ClienteDAO.java, com o seguinte código:

package dao;

import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import model.Cliente;

/**
 *
 * @author andii
 */

@Stateless
public class ClienteDAO {

    @PersistenceContext(unitName="TesteJPAPU")
    private EntityManager em;

    public boolean gravar(Cliente cliente){
        boolean sucesso = false;
        try {
            em.merge(cliente);
            sucesso = true;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return sucesso;
    }

    public Cliente selecionar(Long codigo){
        Cliente cliente = null;
        try {
            cliente = em.find(Cliente.class, codigo);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return cliente;
    }

    public boolean remover(Cliente cliente){
        boolean sucesso = false;
        try {
            cliente = em.find(Cliente.class, cliente.getCodigo());
            em.remove(cliente);
            sucesso = true;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return sucesso;
    }

    public List<Cliente> listar() {
        List<Cliente> clientes = null;
        try {
            Query query = em.createQuery("Select c from Cliente c");
            clientes = query.getResultList();
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return clientes;
    }
}

Agora vamos entender o que acontece no nosso ClienteDAO:
@Stateless: essa anotação define um bean de sessão sem estado, o que isso quer dizer? Que o nosso dao será criado toda vez que precisarmos dele. Caso precise que esse EJB se mantenha como um escopo de sessão mesmo, aí teria que usar @Stateful... mas não vem ao caso agora.
@PersistenceContext: este é usado para injetar o PU (persistence unit) em um EntityManager, veja que não é necessário instanciar um EntityManagerFactory. Lembre-se que esse TesteJPAPU é o mesmo que foi definido lá no meu persistence-unit do meu persistence.xml.
E quantos aos métodos, perceba nos códigos que não há mais a necessidade de abrir (usando em.getTransaction().begin()) e nem fechar (usando em.close()) a conexão com o banco de dados, ou seja, o EJB será o responsável por fazer isso (isso evita possíveis exception do tipo LazyInitializationException).
Apenas uma observação para o método gravar: veja que não tem o método alterar, isso pois o em.merge(cliente), funciona tanto para persistir um objeto como apenas para alterar, isso funciona assim: caso o JPA identifique que o objeto passado por parâmetro não está sendo gerenciado por ele, isso fará ele gravar um novo objeto, no caso aqui um novo cliente. Já quando você seleciona um cliente com um em.find(...) esse cliente está sendo gerenciado pelo JPA, e se mandar dar um em.merge(cliente) ele vai apenas alterar os dados, e não gravará um novo!

E agora vamos criar um bean dentro do pacote controle, para isso crie uma classe java com o nome de ClienteBean.java, dessa forma:

package controle;

import dao.ClienteDAO;
import java.io.Serializable;
import java.util.List;
import javax.ejb.EJB;
import javax.enterprise.context.SessionScoped;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.inject.Named;
import model.Cliente;

/**
 *
 * @author andii
 */
@Named(value = "clienteBean")
@SessionScoped
public class ClienteBean implements Serializable {

    @EJB
    private ClienteDAO clienteDAO;
    private Cliente cliente = new Cliente();
    private List<Cliente> clientes;

    public void novo(){
        cliente = new Cliente();
    }

    public void gravar() {
        FacesContext context = FacesContext.getCurrentInstance();
        boolean resultado = clienteDAO.gravar(cliente);

        if (resultado) {
            cliente = new Cliente();
            context.addMessage(null, new FacesMessage("Cliente gravado com sucesso"));
        } else {
            context.addMessage(null, new FacesMessage("Falha ao gravar cliente!"));
        }
    }

    public void selecionar(ActionEvent evento) {
        Long codigo = (Long) evento.getComponent().getAttributes().get("codigo");
        cliente = clienteDAO.selecionar(codigo);
    }

    public void remover() {
        FacesContext context = FacesContext.getCurrentInstance();
        boolean resultado = clienteDAO.remover(cliente);

        if (resultado) {
            cliente = new Cliente();
            context.addMessage(null, new FacesMessage("Cliente removido com sucesso"));
        } else {
            context.addMessage(null, new FacesMessage("Falha ao remover cliente!"));
        }
    }

    //Getters e Setters
    public Cliente getCliente() {
        return cliente;
    }

    public void setCliente(Cliente cliente) {
        this.cliente = cliente;
    }

    public List<Cliente> getClientes() {
        clientes = clienteDAO.listar();
        return clientes;
    }

    public void setClientes(List<Cliente> clientes) {
        this.clientes = clientes;
    }
}

A unica diferença nesse bean é o fato do nosso ClienteDAO estar anotado com um @EJB.
@EJB: Essa anotação serve para fazermos a injeção de dependência do nosso EJB, que neste caso é o ClienteDAO, por ele estar sendo injetado, em nenhum momento será necessário instância-lo com um new ClienteDAO();

Agora para finalizar de vez o CRUD, vamos alterar a página index.xhtml(que é criada juntamente com o projeto) e para não ter que criar outras páginas, fiz o CRUD inteiro somente na página index, mas aí é só fazer como desejar, esta deverá ficar assim:

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core">
    <h:head>
        <title>Facelet Title</title>
    </h:head>
    <h:body>
        <h:form id="dadosCliente">
            <fieldset style="width: 350px">
                <legend>Novo cliente</legend>
                <h:commandButton value="Novo" action="#{clienteBean.novo}" />
            </fieldset>
            <fieldset style="width: 350px">
                <legend>Dados do cliente</legend>
                <h:panelGrid columns="4">
                    <h:outputText value="Nome" />
                    <h:inputText value="#{clienteBean.cliente.nome}" />
                    <h:commandButton value="Gravar" action="#{clienteBean.gravar}" />
                    <h:commandButton value="Remover" action="#{clienteBean.remover}" rendered="#{clienteBean.cliente.codigo > 0}" />
                </h:panelGrid>
            </fieldset>
        </h:form>

        <h:form>
            <fieldset style="width: 350px">
                <legend>Clientes</legend>
                <h:dataTable value="#{clienteBean.clientes}" var="cliente" border="1">
                    <h:column>
                        <f:facet name="header"><h:outputText value="CODIGO" /></f:facet>
                        <h:outputText value="#{cliente.codigo}" />
                    </h:column>
                    <h:column>
                        <f:facet name="header"><h:outputText value="NOME" /></f:facet>
                        <h:outputText value="#{cliente.nome}" />
                    </h:column>
                    <h:column>
                        <h:commandButton value="Selecionar" actionListener="#{clienteBean.selecionar}">
                            <f:attribute name="codigo" value="#{cliente.codigo}" />
                            <f:ajax render=":dadosCliente" execute="@this" />
                        </h:commandButton>
                    </h:column>
                </h:dataTable>
            </fieldset>
        </h:form>
    </h:body>
</html>

Inicialmente essa seria a visualização da página index:

Ao clicar no botão Selecionar o cliente será selecionado, e será renderizado um botão de remover, enfim quando selecionado um cliente, a janela fica assim:

Mas como eu falei, essa é apenas uma opção de como pode ser feito nossa visualização, use sua criatividade para deixá-la como achar melhor!

Para mais informações veja a API do Java EE 6, para ver mais sobre o EJB, selecione o pacote javax.ejb. Aqui finalizamos mais uma postagem... fiz ela bem simples, para dar mais foco ao EJB 3.1 com o JPA 2.0. :)

JSF 2.0: Utilização de Facelets

O que é o Facelets?
Segundo a especificação do Java EE 6:

"Facelets is a powerful but lightweight page declaration language that is used to build JavaServer Faces views using HTML style templates and to build component trees." Java EE 6

 Traduzindo... Facelets é uma poderosa e leve linguagem de declaração de página que é usada para construir visualizações  em JSF usando estilos de templates HTML e para construir árvores de componentes, que utiliza da tecnologia XHTML para a criação de páginas web.
O mais interessante e utilizado desta tecnologia é a possibilidade de criar templates para páginas JSF.

Agora vamos fazer alguns exemplos de utilização das 11 tags do Facelets, para isso crie um projeto JEE 6 (Dessa forma), feito isso, vamos começar:

<ui:component > 
Esta tag serve para criar componentes customizados em JSF.

Dentro do WEB-INF crie um diretório chamado componentes. Dentro deste diretório crie um arquivo xhtml com o nome meuComponente.xhtml que será nosso componente, segue o código:

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:ui="http://java.sun.com/jsf/facelets">
    <ui:component>
        <h:form>
            <h:inputText id="#{id}" value="#{value}" required="true" requiredMessage="Este campo obrigatório" />
            <h:message for="#{id}" />
            <h:commandButton value="Enviar" />
        </h:form>
    </ui:component>
</html>

Veja que no código acima usamos a tag ui:component, que define nosso componente, mas apenas isso não é suficiente para fazer ele funcionar, precisamos de um xml para mapear esse componente, então para isso crie um xml dentro do diretório componentes com o nome de facelets.taglib.xml, nele teremos o seguinte código, que explicarei abaixo:

<?xml version="1.0"?>
<!DOCTYPE facelet-taglib PUBLIC "-//Sun Microsystems, Inc.//DTD Facelet Taglib 1.0//EN" "https://facelets.dev.java.net/source/browse/*checkout*/facelets/src/etc/facelet-taglib_1_0.dtd">
<facelet-taglib>
    <namespace>http://javasemcafe.blogspot.com</namespace>
    <tag>
        <tag-name>componenteJSF</tag-name>
        <source>meuComponente.xhtml</source>
    </tag>
</facelet-taglib>

Bom... a tag namespace pode ser preenchida por um link qualquer. A tag tag-name será o nome pelo qual nosso componente será chamado, e a tag source corresponde a localização do nosso componente em xhtml. Além de tudo isso precisamos registrar o xml criado dentro do web.xml que está dentro do WEB-INF, logo após a tag web-app insira o seguinte código:

<context-param>
    <param-name>facelets.LIBRARIES</param-name>
    <param-value>/WEB-INF/componentes/facelets.taglib.xml</param-value>
</context-param>

Agora sim podemos usar nosso componente, para isso, vamos usar a página index.xhtml criada por padrão ao criar o projeto, ela deverá ficar assim:

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:andii="http://javasemcafe.blogspot.com">
    <h:head>
        <title>Facelet Title</title>
    </h:head>
    <h:body>
        <andii:componenteJSF id="meu" />
    </h:body>
</html>

Veja que na tag html foi adicionado o namespace definido no facelets.taglib.xml para assim podermos usar a tag andii:componenteJSF .
Visualmente ele ficará dessa forma:

Bom.. quanto a essa tag do Facelets, acabei nem me aprofundando, apenas aprendi o básico para saber para o que ela servia.

<ui:debug > 
Serve para abrir uma janela de debug quando pressionado as teclas: CTRL + SHIFT + a tecla definida na tag ui:debug, para teste inclua essa tag na página index.xhtml, lembre-se de adicionar na tag html, o namespace para utilização do facelets, ficando dessa forma:

<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:andii="http://javasemcafe.blogspot.com"
      xmlns:ui="http://java.sun.com/jsf/facelets">

E ainda no index.xhtml inclua dentro do h:body, a seguinte tag:

<ui:debug hotkey="K" />

Neste caso estamos usando a letra K para ser nossa hotkey, então para testar, abra no navegador a página  index.jsf, a tag ui:debug não ficará visível, apenas pressione CTRL+SHIFT+K, a seguinte tela deverá aparecer:

<ui:define > , <ui:insert > e  <ui:composition >
Estas são as tags mais utilizadas quando se fala em Facelets, elas são para definir o template das páginas, como isso ocorre? a tag ui:insert "demarca" onde será, por exemplo: o menu, o topo, o corpo do sistema. A ui:define é utilizada nas páginas que desejam utilizar o template, então... um ui:define é correspondente a um ui:insert do template. E por fim, a ui:composition serve para compor páginas que utilizam a tecnologia Facelets. Para testarmos isso vamos criar um template onde terá um menu vertical que ocupará 30% da página, e os outros 70% corresponderão ao corpo da página, para isso crie uma página JSF dentro de Páginas Web, com o nome de template.xhtml, com o código:

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:ui="http://java.sun.com/jsf/facelets"
      xmlns:h="http://java.sun.com/jsf/html">

    <h:head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Facelets Template</title>
        <style type="text/css">
            .styleMenu {
                background-color: yellow;
                width: 30%;
                margin: 0; padding: 0;
                float: left;
            }

            .styleCorpo {
                background-color: red;
                width: 70%;
                float: right;
                text-align: center;
            }
        </style>
    </h:head>
    <h:body>

        <div class="styleMenu">
            <ui:insert name="menu">menu original</ui:insert>
        </div>
        
        <div class="styleCorpo">
            <ui:insert name="corpo">Corpo original do template</ui:insert>
        </div>

    </h:body>
</html>

No código acima veja que na realidade o menu e o corpo são demarcados por estilos de css nas div.
E para testar esse template, crie uma página JSF com o nome de clienteTemplate.xhtml, que corresponderia a qualquer página que utilizaria um template, assim:

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:ui="http://java.sun.com/jsf/facelets">

    <ui:composition template="template.xhtml">

        <ui:define name="corpo">
            isso é do clienteTemplate
        </ui:define>
        
    </ui:composition>
</html>

O resultado será este:

Agora analise o código do clienteTemplate.xhtml e veja que não foi criado um ui:define para o menu, isso aconteceu porque eu não queria que o menu fosse sobrescrito, ou seja, eu quis utilizar o que tinha dentro do template que é o padrão, a menos que você sobrescreva ele terá outro resultado.
DICA: Para quem usa o NetBeans 6.9.1, ele já dá a opção de criar templates pré definidos, como fazer isso? Clique com o botão direito em Páginas Web - Outro... selecione a categoria JavaServer Faces e use Modelo de Facelets para criar o template, aparecerá a seguinte tela:

Nela informe o nome para o template, e selecione o Estilo de layout, para selecionar basta clicar no layout escolhido, e clique em Finalizar...

Já para usar um template, faça os mesmos primeiros passos para criar o template, mas no lugar de escolher Modelo de Facelets, escolha Cliente de modelo de facelets, e aparecerá a seguinte janela:

Nela informe um nome para a página, e lembre-se de selecionar o modelo de template que foi criado, eu geralmente prefiro usar a Marcação de raiz gerada como ui:composition, pelo fato de estar usando Facelets mesmo.

Bom... agora tenha criatividade para criar/editar o template da forma que achar melhor :)

<ui:decorate > 

Esta tem a mesma funcionalidade que a tag ui:composition: serem utilizadas para fazer a composição de páginas que utilizam Facelets, com a diferença de que quando é utilizado a tag ui:composition, o que estiver fora desta, não aparecerá na aplicação, ou seja será ignorada. Já ao usar a ui:decorate, o que for feito fora desta tag será visualizada normalmente, para testarmos isso, na página clienteTemplate.xhtml que foi criada logo acima, depois da tag </ui:composition> e antes da </html>, escreva qualquer coisa, e mande atualizar a visualização, e veja que nada de diferente acontece... pois o que foi escrito fora da ui:composition foi ignorado.
Agora para testar o ui:decorate, nessa mesma página, troque o ui:composition pelo ui:decorate, salve e visualize o resultado, neste caso o que tinha sido escrito fora da tag, aparece normalmente no final da página. A imagem a seguir utiliza a tag ui:decorate:

<ui:include >  e <ui:fragment > 
A tag ui:include serve para incluir páginas dentro de outras páginas assim como o próprio include do PHP, por um exemplo, quando você ver que um código fonte de uma página vai ficar muito extenso, você pode separar ele em uma outra página, para a visualização isso não vai fazer diferença, pois na hora de renderizar ele irá renderizar como uma unica página, a diferença é que para dar manutenção em páginas não muito extensa é mais fácil. Já a tag ui:fragment, não consegui entender muito bem a diferença em usar ela ou o ui:composition, mas pelo o que andei lendo, o pessoal costuma usar ela nas páginas que forem incluídas pelo ui:include, vamos fazer um exemplo usando essa combinação, primeiro crie uma página JSF que será a página a ser incluída, use o nome de fragTeste.xhtml:

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<ui:fragment xmlns="http://www.w3.org/1999/xhtml"
             xmlns:h="http://java.sun.com/jsf/html"
             xmlns:ui="http://java.sun.com/jsf/facelets">

    <h:outputText value="Essa texto é da página fragTeste" />

</ui:fragment>

Agora crie uma página JSF com o nome de include.xhtml:

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:ui="http://java.sun.com/jsf/facelets"
      xmlns:f="http://java.sun.com/jsf/core">
    <h:head>
        <title>Facelet Title</title>
        <f:view contentType="text/html" />
    </h:head>
    <h:body>
        <h:outputText value="Esse texto é da página include!" />
        <br/>
        <ui:include src="fragTeste.xhtml" />
    </h:body>
</html>

O resultado da visualização da página include.xhtml é o seguinte:

Obs: Caso alguém saiba realmente o que a tag ui:fragment faz de diferente, ficaria grata se me informasse.

<ui:remove > e <ui:repeat >
A tag ui:remove serve para remover um código que é inserido dentro dela, ou seja, o que for escrito entre ela não será visualizado (bom... não consigo enxergar a utilização dela na prática), crie uma página JSF com o nome de remove.xhtml :

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:ui="http://java.sun.com/jsf/facelets">
    <h:head>
        <title>Facelet Title</title>
    </h:head>
    <h:body>
        <h:outputText value="Isso aparece na minha pagina remove... pois está fora da tag ui:remove" />
        
        <ui:remove>
            <h:outputText value="Isso não aparece na minha página remove!!" />
        </ui:remove>
    </h:body>
</html>

A visualização será:

Já a tag ui:repeat funciona praticamente como um laço de repetição para ler valores de uma lista de um bean, então... na raiz mesmo de Pacotes de código-fonte, crie uma classe com o nome de ClienteBean.java nessa classe teremos uma lista que será lida pela tag ui:repeat. Segue o conteúdo da classe:

@Named
@javax.enterprise.context.RequestScoped
public class ClienteBean {

    private List<String> clientes;

    public ClienteBean() {
        clientes = new ArrayList<String>();
        clientes.add("Maria");
        clientes.add("Joao");
        clientes.add("Aparecida");
    }

    public List<String> getClientes() {
        return clientes;
    }

    public void setClientes(List<String> clientes) {
        this.clientes = clientes;
    }
}

Agora crie uma nova página JSF, com o nome de repeat.xhtml, segue:

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:ui="http://java.sun.com/jsf/facelets">
    <h:head>
        <title>Facelet Title</title>
    </h:head>
    <h:body>

        <ui:repeat var="cli" value="#{clienteBean.clientes}">
            <h:outputText value="#{cli}" /><br />
        </ui:repeat>
        
    </h:body>
</html>

Veja que essa tag tem seu funcionamento bem parecido com uma h:dataTable, então não tem o que questionar dela. A visualização da mesma:

<ui:param > 
A tag ui:param serve para passar valores para outra página, esse valor pode ser estático ou dinâmico(vindo de um bean), não cheguei a usar essa tag em algum projeto, mas li que o pessoal usa ela bastante para passar o usuário logado de uma página para outra...
Vamos fazer um teste com um valor estático mesmo, primeiro crie uma página JSF, com o nome de recebeParam.xhtml  esta será a página que receberá o parâmetro vindo de uma outra página que irá chamá-la. O parâmetro a ser recebido nesse exemplo será o nome:

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html">
    <h:head>
        <title>Facelet Title</title>
    </h:head>
    <h:body>
        
        <h:outputText value="Esta página estará recebendo um parâmetro vindo de uma outra página:" />
        <br />
        <h:outputText value="Parâmetro recebido: #{nome}" />

    </h:body>
</html>

O parâmetro será capturado usando a EL #{nome}, então na página que chamará ela, precisa ser passado um parâmetro com o name  de nome. Então agora crie uma nova página JSF com o nome de enviaParam.xhtml:

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:ui="http://java.sun.com/jsf/facelets">
    <h:head>
        <title>Facelet Title</title>
    </h:head>
    <h:body>
        <ui:param name="nome" value="andii.brunetta" />

        <h:form>
            <h:commandButton value="Chama a página recebeParam" action="recebeParam" />
        </h:form>
    </h:body>
</html>

Perceba que não é necessário que a tag ui:param esteja dentro do h:form, ou seja, ele não precisa de um form para ser encaminhado para a outra página, o form só está aí por causa do h:commandButton.
Essa é a visualização da página acima:

Ao clicar no botão da página mostrada acima, esta chamará a recebeParam.xhtml, que terá o seguinte resultado:

IMPORTANTE:

Caso você use o Google Chrome (indico usar ele!), ao testar alguns exemplos ele poderá dar um erro, a solução é acrescentar a seguinte tag dentro do h:head da página ou se estiver usando template, será no template mesmo:

<f:view contentType="text/html" />

Para mais informações acesse a documentação do Facelets: Tag Library Documentation - Facelets

Bom até que enfim finalizamos essa postagem... esta ficou bemmmmm extensa, mas está completa com as todas as tags do Facelets! Caso alguém tenha mais informações sobre elas, pode complementar a postagem comentando abaixo! ;)

JPA 2.0: Criando tabelas - Parte 2

Aproveitando o mesmo projeto da postagem da Parte 1: Este aqui vamos montar nossas classes para criar a seguinte estrutura do banco de dados:

Para isso vamos usar as seguintes anotações que tratam as cardinalidades:

@OneToOne

@OneToMany

@ManyToOne

e tem a @ManyToMany que ficará para uma próxima postagem!

No pacote model vamos criar as classes: Endereco.java, Categoria.java, Dependente.java e alterar a Cliente.java.

Começando...

Endereco.java

@Entity
@Table(name = "endereco")
public class Endereco implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "codigo", nullable = false)
    private Integer codigo;

    @Column(name = "rua")
    private String rua;

    @Column(name = "cidade")
    private String cidade;

    @Column(name = "estado")
    private String estado;

    @OneToOne(mappedBy="endereco", fetch=FetchType.LAZY)
    private Cliente cliente;

    //Getters e Setters
    //equals e hashCode

}

Cliente.java

@Entity
@Table(name = "cliente")
public class Cliente implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "codigo", nullable = false)
    private Integer codigo;

    @Column(name = "nome")
    private String nome;

    @Column(name = "data_nascimento")
    @Temporal(TemporalType.DATE)
    private Date dataNascimento;

    @Column(name = "limite")
    private Double limite;

    @OneToOne(fetch=FetchType.LAZY)
    @JoinColumn(name = "endereco_codigo", nullable = false)
    private Endereco endereco;

    @OneToMany(mappedBy = "cliente", fetch = FetchType.LAZY)
    private List< Dependente > dependenteList;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "categoria_codigo", nullable = false)
    private Categoria categoria;
   
    //getters e setters
    //equals e hashCode
}

Categoria.java

@Entity
@Table(name = "categoria")
public class Categoria implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "codigo", nullable = false)
    private Integer codigo;

    @Column(name = "nome")
    private String nome;

    @OneToMany(mappedBy = "categoria", fetch = FetchType.LAZY)
    private List< Cliente > clienteList;

    //getters e setters
    //equals e hashCode
}

Dependente.java

@Entity
@Table(name = "dependente")
public class Dependente implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "codigo", nullable = false)
    private Integer codigo;

    @Column(name = "nome")
    private String nome;

    @Column(name = "cpf")
    private String cpf;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "cliente_codigo", nullable = false)
    private Cliente cliente;

    //getters e setters
    //equals e hashCode
}

e por fim como ficou nosso persistence.xml:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
  <persistence-unit name="TesteJPAPU" transaction-type="JTA">
    <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
    <jta-data-source>5tads</jta-data-source>
    <class>model.Cliente</class>
    <class>model.Endereco</class>
    <class>model.Categoria</class>
    <class>model.Dependente</class>
    <exclude-unlisted-classes>true</exclude-unlisted-classes>
    <properties>
      <property name="eclipselink.ddl-generation" value="drop-and-create-tables"/>
    </properties>
  </persistence-unit>
</persistence>

É isso aí! :)

JavaEE 6: Bean Validation 1.0

A especificação do JEE 6, criou uma validação padrão para os JavaBeans, que foi o Bean Validation 1.0. O que isso faz? bom.. a partir de anotações na classe de modelo, você consegue validar campos numéricos, definir se datas informadas serão obrigatoriamente maiores ou menores que a data atual, se o campo pode ser vazio ou não, assim ao dar o submit no form ele já valida esses campos, não precisando submeter os valores e verificar um a um no bean antes de fazer qualquer operação, outro detalhe interessante dessas anotações é que todas elas tem a propriedade message que é recebido pela tag <h:message> do JSF... para facilitar vou dizer o que cada anotação faz, e depois mostrar um exemplo com todas as anotações, vamos lá:

@AssertFalse: Obriga que valores booleanos sejam falsos;

@AssertTrue: Obriga que valores booleanos sejam verdadeiros;

@DecimalMax: Os valores decimais devem ser menores ou iguais ao definido na propriedade value;

@DecimalMin: Os valores decimais devem ser maiores ou iguais ao definido na propriedade value;

@Digits: Define o intervalo de um decimal, a propriedade integer diz respeito a quantidade de números inteiros, e a fraction define quantas casas após a vírgula;

@Future: Anotação para datas futuras, a data deve ser uma data futura, maior que a data atual;

@Max: Anotação para inteiros, define que o valor seja inferior ou igual ao valor definido no value;

@Min: Anotação para inteiros, define que o valor seja superior ou igual ao valor definido no value;

@NotNull: O valor para o campo que recebe essa anotação não pode ser nulo;

@Null: O valor para o campo que recebe essa anotação pode ser nulo;

@Past: Anotação para datas passadas, a data deve ser uma data passada ou a data atual;

@Pattern: O valor desse campo deve corresponder à expressão regular definida na propriedade regexp;

@Size: Esta anotação pode ser usada para String, Collection ou arrays. Caso seja String, esta deverá ter a quantidade mínima de caracteres definidas na propriedade min e a quantidade máxima definida com o max. No caso de Collection/array é avaliado a quantidade mínima e máxima de elementos. Obs: pode ser usado a propriedade min ou max separadas, ou seja, pode-se definir apenas que seja validado a quantidade mínima de alguma coisa ou apenas a quantidade máxima.

TESTE:

Vamos ao projeto de teste: no NetBeans crie uma  Aplicação Web com o nome de BeanValidation.

Dentro do pacotes de código-fonte, crie os pacotes model e controle, agora no model crie uma classe java com o nome de Objeto.java com o seguinte código:

public class Objeto {

    @AssertFalse(message="Este campo precisa ser falso")
    private boolean isFalso;

    @AssertTrue(message="Este campo precisa ser verdadeiro")
    private boolean isVerdadeiro;

    @NotNull(message="Data não pode ser nula")
    @Future(message="Data precisa ser maior que a data atual")
    private Date eventoFuturo;

    @Past(message="Data precisa ser menor ou igual que a data atual")
    private Date dataNascimento;

    @Max(value=100, message="Quantidade Max: não pode ultrapassar 100 unidades")
    private int quantidadeMax;

    @Min(value=10, message="Quantidade Min: não pode ser abaixo de 10 unidades")
    private int quantidadeMin;

    @DecimalMax(value="30.00", message="Desconto Max: precisa ser abaixo de 30.00")
    private BigDecimal descontoMaximo;

    @DecimalMin(value="1.50", message="Juro Min: precisa ser acima de 1.50")
    private BigDecimal juroMinimo;

    @Digits(integer=3, fraction=2, message="Preço: apenas centenas e 2 casas após o ponto")
    private BigDecimal preco;

    @Null(message="Apelido: campo pode ser nulo")//Utilizar em combos
    private String apelido;

    @Pattern(regexp = "\\(\\d{3}\\)\\d{4}-\\d{4}", message="Telefone: preencha no formato (XXX)XXXX-XXXX")
    private String telefone;

    @NotNull
    @Size(min = 2, max = 200, message="Descrição: tamanho mínimo de 2 e máximo de 200")
    private String descricao;

    //getters e setters
}

Obs: todas as anotações são importadas do pacote javax.validation.constraints. 
Agora no pacote controle crie uma nova classe java para ser nosso bean de comunicação com o JSF, com o nome de ObjetoBean.java, segue o código:

@Named
@RequestScoped
public class ObjetoBean {

    private Objeto objeto = new Objeto();

    public String salvar(){
        return "sucesso";
    }

    public Objeto getObjeto() {
        return objeto;
    }

    public void setObjeto(Objeto objeto) {
        this.objeto = objeto;
    }
}

Agora reaproveitanto a página index.xhtml que é criada juntamente com o projeto, vamos montar nosso form com todos os campos a serem validados, segue o código que deve estar dentro do < h:body >:

<h:body>
    <h:form>
        <h:panelgrid columns="3">
            <h:outputtext value="Check False" />
            <h:selectbooleancheckbox id="checkFalse" value="#{objetoBean.objeto.isFalso}" />
            <h:message for="checkFalse" />

            <h:outputtext value="Check True" />
            <h:selectbooleancheckbox id="checkTrue" value="#{objetoBean.objeto.isVerdadeiro}" />
            <h:message for="checkTrue" />

            <h:outputtext value="Evento Futuro:" />
            <h:inputtext id="eventoFuturo" value="#{objetoBean.objeto.eventoFuturo}" />
                <f:convertdatetime pattern="dd/MM/yyyy" />
            </h:inputtext>
            <h:message for="eventoFuturo" />

            <h:outputtext value="Data Nascimento:" />
            <h:inputtext id="dataNascimento" value="#{objetoBean.objeto.dataNascimento}" />
                <f:convertdatetime pattern="dd/MM/yyyy" />
            </h:inputtext>
            <h:message for="dataNascimento" />

            <h:outputtext value="Quantidade Max:" />
            <h:inputtext id="qtdMax" value="#{objetoBean.objeto.quantidadeMax}" />
            <h:message for="qtdMax" />

            <h:outputtext value="Quantidade Min:" />
            <h:inputtext id="qtdMin" value="#{objetoBean.objeto.quantidadeMin}" />
            <h:message for="qtdMin" />

            <h:outputtext value="Desconto Max:" />
            <h:inputtext id="descontoMax" value="#{objetoBean.objeto.descontoMaximo}" />
            <h:message for="descontoMax" />

            <h:outputtext value="Juro Min:" />
            <h:inputtext id="juroMin" value="#{objetoBean.objeto.juroMinimo}" />
            <h:message for="juroMin" />

            <h:outputtext value="Preço:" />
            <h:inputtext id="preco" value="#{objetoBean.objeto.preco}" />
            <h:message for="preco" />

            <h:outputtext value="Telefone:" />
            <h:inputtext id="telefone" value="#{objetoBean.objeto.telefone}" />
            <h:message for="telefone" />

            <h:outputtext value="Descrição:" />
            <h:inputtext id="descricao" value="#{objetoBean.objeto.descricao}" />
            <h:message for="descricao" />

        </h:panelgrid>
        <h:commandbutton action="#{objetoBean.salvar}" value="Testar" />
    </h:form>
</h:body>

E crie uma página JSF com o nome de sucesso.xhtml que será para onde seremos redirecionados quando todos os campos validados estejam corretos. Código:

<h:body>
    <h:form>
        Valores informados com sucesso!
        <h:commandButton value="Testar novamente" action="index" />
    </h:form>
</h:body>

Segue abaixo a imagem da página index, com os valores fora dos limites estipulados nas anotações:

E agora a janela com os valores corretos, que passam pela validação:

Eu particularmente achei muito util essas anotações, já que não sou muito adepta de testar valores nos métodos do bean. :)