1409243945064

Análise e Desenvolvimento de Sistemas
Disciplina: Programação Web II
Prof.(a): Veronice de Freitas
Aula: 03 – JSF com PRIMERACES e Hibernate
Semestre: 6°
Aula Atividade
Objetivo: introdução ao desenvolvimento web Java usando framework.
Orientações:
Caro aluno,
Inicialmente faça download e instale os softwares preparando o ambiente para criar os
projetos JSF no início do texto da atividade coloquei uma tabela contendo os links para
download (no material de apoio (logo após a tabela) contém vários tutoriais que auxiliam
na instalação e configuração do ambiente).
Na unidade 01 do livro da disciplina “Programação Web II” também contém orientações
para instalar os programas (se você ainda não teve contato com as ferramentas, siga o
padrão utilizado na disciplina eclipse e tomCat).
Em relação ao gabarito dos projetos:
Obs: deixei as primeiras atividades com o gabarito para facilitar a analise dos códigos. Em
relação aos exemplos de projetos (02, 03, 04) veja as descrições passo a passo nos
artigos referenciados nas atividades (também estão nas seções aprofundando
conhecimento dos capítulos 02, 03, 04 e 05 do livro da disciplina programação Web II (os
arquivos do projeto também estarão disponíveis no endereço:
https://www.dropbox.com/sh/ozxlcn9925dn0qf/AACrdllTeNnQPo6hdYywsMfda) se ainda não
teve contato com desenvolvimento Web em Java, siga as orientações para preparar o
ambiente de desenvolvimento usando o Eclipse e TomCat.
Sobre a impressão da atividade:
Obs: imprima somente as páginas das atividades.
Organização do texto
1 - PREPARANDO O AMBIENTE ...................................................................................................... 2
2 PROGRAMAÇÃO WEB EM JAVA (CONTINUAÇÃO) ................................................................ 3
2.1 - Necessidades de uma aplicação web ............................................................................................. 3
2.2 Como o Java EE pode ajudar? ......................................................................................................... 5
2.3 Servidor de Aplicação Java EE ........................................................................................................ 5
3 - Atividade .......................................................................................................................................... 7
4 - Material de apoio ............................................................................................................................ 20
UNOPAR VIRTUAL (página: 1)

1 - PREPARANDO O AMBIENTE
Para desenvolver uma aplicação web em Java, será necessário as
ferramentas abaixo.
Tabela – Sotwares
Software Disponível em
SDK Java 1.7 http://www.oracle.com/technetwork/java/javase/downloads/index.ht
ml
Eclipse Juno http://www.eclipse.org/downloads/packages/release/juno/sr1
Tomcat http://tomcat.apache.org/download-70.cgi
MySQL 5.5 http://dev.mysql.com/downloads/
Obs: orientações para instalação (unidade 04)
JSF 2.1 http://javaserverfaces.java.net/
Hibernate 3.5 http://www.hibernate.org/)
Primefaces 3.3.1 http://www.primefaces.org/downloads.html
OUTRAS OPÇÕES
Netbeans 7.2 (http://netbeans.org/community/releases/72/
Glassfish 3.2 Já vem embutido no Netbeans versão JEE
Observação: poderá usar como forma alternativa para o Eclipse o NetBeans e para o
Tomcat o Glassfish, que já contém embutido a versão JEE).
Material de apoio:
• Programação Java para a Web
https://www.novatec.com.br/livros/javaparaweb/capitulo9788575222386.pdf
• Tutorial de instalação do Java 7 no Windows 7.
http://www.activeinfo.com.br/tutos/tutorial_instalacao_java_windows.pdf
• Tutorial Tomcat - Instalação e Configuração Básica.
http://www.mhavila.com.br/topicos/java/tomcat.html
• Tutorial – Configurando o Eclipse ...
http://ges.dc.ufscar.br/graduacao/tutorial_criacao_projeto_web_eclipse.pdf
• Curso de Java básico para iniciantes usando Eclipse:
http://www.java.marcric.com/pages/004-instalandoeclipse.html
No capitulo 01 do livro “Programação Web II” contém orientações para
preparar o ambiente.

2 PROGRAMAÇÃO WEB EM JAVA (CONTINUAÇÃO)
2.1 - Necessidades de uma aplicação web
HTTP
Os usuários de uma aplicação web utilizam navegadores (browsers) para interagir com
essa aplicação.
A comunicação entre navegadores e uma aplicação web é realizada através de requisições
e respostas definidas pelo protocolo HTTP. Dessa forma, os desenvolvedores de aplicação
web devem estar preparados para trabalhar com o protocolo HTTP.
Acesso simultâneo
Além disso, na grande maioria dos casos, as aplicações web devem ser acessadas por
diversos usuários ao mesmo tempo. Consequentemente, os desenvolvedores web devem
criar ou utilizar algum mecanismo eficiente que permita esse tipo de acesso.
Conteúdo dinâmico
As páginas de uma aplicação web devem ser geradas dinamicamente. Por exemplo,
quando um usuário de uma aplicação de email acessa a sua caixa de entrada, ele deseja
ver todos os emails enviados até aquele momento. A página contendo a lista de emails
deve ser gerada novamente toda vez que essa página for requisitada. Consequentemente,
os desenvolvedores web devem criar ou utilizar algum mecanismo eficiente que permita
que o conteúdo das páginas das aplicações web seja gerado dinamicamente.
Figura 01: Necessidades de uma aplicação web
Fonte: k19

Solução
Resolver os três problemas apresentados tomaria boa parte do tempo de desenvolvimento,
além de exigir conhecimentos técnicos extremamente específicos por parte dos
desenvolvedores. Para facilitar o desenvolvimento de aplicações web, a plataforma Java
oferece uma solução genérica que pode ser utilizada para desenvolver aplicações web.
Figura 02 Web Container
Fonte: k19
Web Container
web container
Uma aplicação web Java deve ser implantada em um Web Container para obter os
recursos fundamentais que ela necessita.
Um Web Container é responsável:
• Pelo envio e recebimento de mensagens HTTP.
• Por permitir que as aplicações sejam acessadas simultaneamente por vários
usuários de uma maneira eficiente.
• Por permitir que as páginas de uma aplicação web sejam geradas dinamicamente.
Dois Web Containers mais conhecidos do mercado são Tomcat e Jetty. Também pode
utilizar um servidor de aplicação Java EE como o JBoss, Glassfish ouWebSphere, pois
eles possuem um Web Container internamente.
Para saber mais
Desenvolvimento Web com JSF 2 e JPA 2
http://www.k19.com.br/downloads/apostilas/java/k19-k12-desenvolvimento-web-com-jsf2-
e-jpa2
Orientação a Objetos em Java
http://www.k19.com.br/downloads/apostilas/java/k19-k11-orientacao-a-objetos-em-java

2.2 Como o Java EE pode ajudar?
As aplicações Web de hoje em dia já possuem regras de negócio bastante complicadas.
Codificar essas muitas regras já representam um grande trabalho. Além dessas regras,
conhecidas como requisitos funcionais de uma aplicação existem outros requisitos que
precisam ser atingidos através da nossa infraestrutura: persistência em banco de dados,
transação, acesso remoto, web services, gerenciamento de threads, gerenciamento de
conexões HTTP, cache de objetos, gerenciamento da sessão web, balanceamento de
carga, entre outros. São chamados de requisitos não-funcionais. Se fosse o responsável
por escrever código para tratar esses outros requisitos, teria muito mais trabalho a fazer.
Tendo isso em vista, a Sun criou uma série de especificações que, quando implementadas,
podem ser usadas por desenvolvedores para tirar proveito e reutilizar toda essa
infraestrutura já pronta fonte: CAELUM).
Algumas APIS especificadas no Java EE
• JavaServer Pages (JSP), Java Servlets, Java Server Faces (JSF) (trabalhar para
a Web)
• Enterprise Javabeans Components (EJB) e Java Persistence API (JPA). (objetos
distribuídos, clusters, acesso remoto a objetos etc)
• Java API for XML Web Services (JAX-WS), Java API for XML Binding (JAX-B)
(trabalhar com arquivos xml e webservices)
• Java Autenthication and Authorization Service (JAAS) (API padrão do Java para
segurança)
• Java Transaction API (JTA) (controle de transação no contêiner)
• Java Message Service (JMS) (troca de mensagens assíncronas)
• Java Naming and Directory Interface (JNDI) (espaço de nomes e objetos)
• Java Management Extensions (JMX) (administração da sua aplicação e
estatísticas sobre a mesma)
2.3 Servidor de Aplicação Java EE
É o nome dado a um servidor que implementa as especificações do Java EE. Existem
diversos servidores de aplicação famosos compatíveis com a especificação Java EE. O
JBoss é um dos líderes do mercado e tem a vantagem de ser gratuito e open source.
Alguns softwares implementam apenas uma parte dessas especificações do Java EE,
como o Apache Tomcat, que só implementa JSP e Servlets (como dissemos, duas das
principais especificações), portanto não é totalmente correto chamá-lo de servidor de
aplicação. A partir do Java EE 6, existe o termo “application server web profile”, para poder
se referencia a servidores que não oferecem tudo, mas um grupo menor de especificações,
consideradas essenciais para o desenvolvimento web fonte: CAELUM.
Alguns servidores de aplicação conhecidos no mercado:
• RedHat, JBoss Application Server, gratuito;
• Sun (Oracle), GlassFish, gratuito;

• Apache, Apache Geronimo, gratuito;
• Oracle/BEA, WebLogic Application Server;
• IBM, IBM Websphere Application Server;
• Sun (Oracle), Sun Java System Application Server (baseado no GlassFish);
• SAP, SAP Application Serve.
Servlet Container
O Java EE possui várias especificações, entre elas, algumas específicas para lidar com o
desenvolvimento de uma aplicação Web:
• JSP
• Servlets
• JSTL
• JSF
Um Servlet Container é um servidor que suporta essas funcionalidades, mas não
necessariamente o Java EE completo. É indicado a quem não precisa de tudo do Java EE
e está interessado apenas na parte web (boa parte das aplicações de médio porte se
encaixa nessa categoria).
Há alguns Servlet Containers famosos no mercado. O mais famoso é o Apache Tomcat,
mas há outros como o Jetty
Para saber mais
Apostila Java Web
http://www.flashcafe.com.br/wp-content/uploads/2012/04/Apostila-Java-Web-
Primefaces.pdf

3 - Atividade
Atividade 01:
Analise a figura abaixo e responda o procedimento usado para que o valor definido na
classe Java ExemploBean seja alterado através da interface com o usuário.
Exemplo: package bean
package bean;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
@ManagedBean
@RequestScoped
public class ExemploBean {
private int numero = 20;
public int getNumero() {
return numero;
}
public void setNumero(int numero) {
this.numero = numero;
}
}
Exemplo: view
?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
titleExemplo JSF/title
/h:head
h:body
Valor: #{exemploBean.numero}
h:form
Resposta:
Através uma classe Bean (com uso da
anotação @ManagedBean) que possibilita
intermediar a comunicação com o formulário
através de uma Linguagem de Expressão (em
inglês, Expression Language ou EL).
#{exemploBean.numero}
Atributo privado
inicializado com o
valor 20
Métodos públicos
get e set para o
atributo numero
Métodos públicos
get e set para o
atributo numero
Expressão EL
(Expression
Language)

h:inputText value = #{exemploBean.numero}/
h:commandButton value=Altera/
/h:form
/h:body
/html
Atividade 02:
1. Crie um formulário para cadastro de clientes com pelo menos três campos.
2. Qual a diferença dos componentes que iniciam com p: ... e h: ... utilizados no código.
Resposta: item 01
?xml version=1.0 encoding=ISO-8859-1 ?
!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:p=http://primefaces.org/ui
h:head
titleFormulário/title
/h:head
h:body
p:fieldset legend=Meu Cadastro toggleable=true
h:form
h:outputText value=Nome: /
p:inputText id=nome value=#{beanCliente.cliente.nome} /
h:outputText value=Observações: /
p:inputTextarea value=#{beanCliente.cliente.obervacao} /
Botão de ação

h:outputText value=Data cadastro: /
p:calendar value=#{beanCliente.cliente.dataCadastro} /
h:outputText value=Telefone: /
p:inputMask mask=(999)9999-9999 value=#{beanCliente.cliente.telefone} /
h:outputText value=CPF: /
p:inputMask mask=999.999.999-99 value=#{beanCliente.cliente.CPF} /
h:outputText value=Descrição: /
p:keyboard layout=qwertyBasic value=#{beanCliente.cliente.descricao} /
h:outputText value=Senha: /
p:keyboard password=true keypadOnly=true value=#{beanCliente.cliente.senha} /
h:commandButton value=Salvar action=#{beanCliente.salvar} /
/h:form
/p:fieldset
/h:body
/html
Resposta: item 02
p: ... - componentes – primefaces necessário o namespace xmlns:p=http://primefaces.org/ui
h: ... - componentes – JSF necessário o namespace (xmlns:h=http://java.sun.com/jsf/html
ATIVIDADE 03:
Crie uma classe (POJO) com os atributos do formulário (crie também os métodos gets e sets para
cada atributo).
Resposta:
package modelo;
import java.util.Date;
public class Cliente {
private String CPF;
private String nome;
private String descricao;
private String telefone;
private String obervacao;
private Date dataCadastro;
private String senha;
public String getCPF() {
return CPF;
}
public void setCPF(String cPF) {
CPF = cPF;
}

public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getDescricao() {
return descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public String getTelefone() {
return telefone;
}
public void setTelefone(String telefone) {
this.telefone = telefone;
}
public String getObervacao() {
return obervacao;
}
public void setObervacao(String obervacao) {
this.obervacao = obervacao;
}
public Date getDataCadastro() {
return dataCadastro;
}
public void setDataCadastro(Date dataCadastro) {
this.dataCadastro = dataCadastro;
}
public String getSenha() {
return senha;
}
public void setSenha(String senha) {
this.senha = senha;
}
}
Atividade 04:
Crie uma classe “bean” para intermediar a comunicação entre a página JSF (atividade 02) e o modelo
(atividade 03). Nessa classe crie também o método salvar (nesse método imprima os dados enviados
pelo formulário para que seja apresentado no console).
package bean;
import javax.faces.bean.SessionScoped;
import modelo.Cliente;
@ManagedBean(name = beanCliente)
@SessionScoped
public class ClienteBean {
Cliente cliente = new Cliente();
import classe Cliente
(atividade 03)
Nome para o ManagedBean (nesse caso o
nome será beanCliente nomeado através do
name (se omitir o name o nome do bean será o
nome da classe com a inicial em minúsculo)

Apresenta no console os valores
dos atributos da classe modelo
(atividade 03) através dos métodos
get (públicos) de cada atributo.
public String salvar(){
// ------ teste - visualiza no console --------------
System.out.println(cliente.getNome());
System.out.println(cliente.getCPF());
System.out.println(cliente.getDescricao());
System.out.println(cliente.getTelefone());
System.out.println(cliente.getObervacao());
System.out.println(cliente.getDataCadastro());
System.out.println(cliente.getSenha());
return sucesso;
}
public Cliente getCliente() {
return cliente;
}
public void setCliente(Cliente cliente) {
this.cliente = cliente;
}
}
ATIVIDADE 05
1) Qual a função da anotação @ManagedBean(name = beanCliente) no código
01?
Resposta:
A classe ClienteBean representa um managed bean, isso significa dizer que eu é possível
vincular (binding) seus atributos ou métodos com componentes da páginas JSF. Essa
característica que torna o JSF uma framework orientado a componentes e a eventos. O
que caracteriza a classe como sendo um bean gerenciado é a
anotação @ManagedBean definida logo acima a definição da classe. Essa é nova forma
de se declarar Managed Bean na nova especificação JSF (JSF2)
Obs: se omitir o uso do name o nome do bean será o nome da classe (ClienteBean) com a
inicial e minúsculo (clienteBean).
2) Qual a função da anotação @SessionScoped no código 01?
Resposta:
Outra anotação usada logo abaixo da anotação @ManagedBean é a
anotação @SessionScoped. Essa anotação informa que o escopo do bean gerenciado é
de sessão, ou seja, enquanto durar minha sessão eu vou ter um objeto da
classe ClienteBean na sessão da minha aplicação. Análogo ao escopo de sessão existe o
escopo de request referenciado pela anotação @RequestScoped onde um novo objeto é
criado a cada requisição realizada pelo usuario.

O escopo nada mais é do que o tempo de vida e morte do seu objeto, ou seja, quando ele
será criado e destruído. Dentre esses escopos estão os apresentados na tabela 01:
Tabela 01: Tempo de vida da classe
Escopo Descrição
@ApplicationScoped Apenas uma instância da classe em toda a aplicação. Todos
os usuários acessam a mesma instância.
@SessionScoped Existe uma instância para cada usuário.
@RequestScoped Existe uma instância pelo tempo de duração da requisição
feita pelo usuário.
@NoneScoped Cada vez que houver uma chamada a uma propriedade ou
método da classe Bean será criada uma nova instância
@ViewScoped Armazena a instância da classe Bean na página exibida.
Enquanto esta estiver sendo manipulada, a mesma instância
da classe Bean estará disponível.
@CustomScoped(value=“
#{meuMap}”)
Armazena a instância da classe Bean em um java.util.Map
declarado.
Fonte: http://blog.fimes.edu.br/fernando/files/2012/05/JavaServer-Faces-%E2%80%93-JSF.pdf
3) Qual a relação entre a linha de código import modelo.Cliente e a linha de código
Resposta:
import modelo - importa da classe Cliente
Cliente cliente = new Cliente(); cria um objeto Cliente da classe Cliente
Código 01:
import modelo.Cliente;
@ManagedBean(name = beanCliente)
@SessionScoped
public class ClienteBean {
//...
}
Código 02:
h:form
h:outputText value=Nome: /
p:inputText id=nome value=#{beanCliente.cliente.nome} /
h:outputText value=Observações: /
p:inputTextarea value=#{beanCliente.cliente.obervacao} /
h:commandButton value=Salvar action=#{beanCliente.salvar} /
/form
O escopo padrão do JSF 2.0 é o request (anotação
@RequestScoped). Os beans gerenciáveis do
tipo request podem ter a anotação de escopo omitida.
Porém, para uma melhor legibilidade do
código, é recomendável não omitir a anotação de escopo.
http://www.venturus.org.br/wp-content/
themes/newera/artigo/anotacoes-navegacao-
JSF.pdf

ATIVIDADE 06: (projeto seção aprofundando conhecimento – autor Thiago Marques)
1) Analise os três códigos a seguir:
a) Como foi possível cadastrar os dados no formulário e apresentar de forma tabular logo
Import da
abaixo do formulário?
Segue os blocos de código:
package controllers;
//imports omitidos
import models.Pessoa;
@ManagedBean
@ViewScoped
public class PessoaMB implements Serializable {
private Pessoa pessoa = new Pessoa();
private ListPessoa pessoaLista = new ArrayListPessoa();
/** Creates a new instance of PessoaMB */
public PessoaMB() {
}
/**Getters e Setters */
public Pessoa getPessoa() {
return pessoa;
}
public void setPessoa(Pessoa pessoa) {
this.pessoa = pessoa;
}
public ListPessoa getPessoaLista() {
return pessoaLista;
}
public void setPessoaLista(ListPessoa pessoaLista) {
this.pessoaLista = pessoaLista;
}
public void salvarPessoa() {
//adicionando pessoas a lista
pessoaLista.add(pessoa);
//instanciado uma nova para ser cadastrada
pessoa = new Pessoa();
}
}
classe Pessoa
Cria uma instância da classe
Pessoa (objeto pessoa)
através desse objeto é
possível armazenar
informações nos atributos
privados através dos métodos
públicos gets e sets.
objeto pessoaLista (armazena na memória
as informações do objeto pessoa)
imagine todas as informações do objeto
pessoa sendo armazenado em uma linha
de uma matriz heterogênea (são atributos
de vários tipos).
Método chamado ao clicar no botão
Salvar no formulário de cadastro de
clientes.
Armazena as informações do
cadastro que estão no objeto pessoa
em pessoaLista que é um objeto
instrânciado através de:
ArrayListPessoa();

Na view foi utilizado um componente h:dataTable ... que apresenta os dados armazenados no
objeto pessoaLista indicados no código anterior.
h:dataTable id=tablePessoa value=#{pessoaMB.pessoaLista} var=p title=Pessoas Cadastradas border=1
rows=10
h:column
f:facet name=header
h:outputText value=NOME /
/f:facet
h:outputText value=#{p.nome}/
/h:column
h:column
f:facet name=header
h:outputText value=ENDEREÇO /
/f:facet
h:outputText value=#{p.endereco}/
/h:column
h:column
f:facet name=header
h:outputText value=NÚMERO /
/f:facet
h:outputText value=#{p.numero}/
/h:column
h:column
f:facet name=header
h:outputText value=TELEFONE /
/f:facet
h:outputText value=#{p.telefone}/
/h:column
h:column
Nome do
ManagedBean
classe PessoaMB var=”p” variável para
acesso aos atributos da
lista.

f:facet name=header
h:outputText value=CIDADE /
/f:facet
h:outputText value=#{p.cidade}/
/h:column
/h:dataTable
b) Qual a relação dos códigos com a arquitetura MVC?
Através dos três códigos é possível ter uma visão dos benefícios da arquitetura MVC onde
A view contém somente códigos relacionados a interface, os dados representados na classe
Pessoa e o controle representado na classe PessoaMB (que facilita a organização e
Manutenção do projeto).
Interface: view
Código 01: modelo
package models;
public class Pessoa {
private String nome;
private String endereco;
private String numero;
private String telefone;
private String cidade;
public String getCidade() {
return cidade;
}

public void setCidade(String cidade) {
this.cidade = cidade;
}
public String getEndereco() {
return endereco;
}
public void setEndereco(String endereco) {
this.endereco = endereco;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getNumero() {
return numero;
}
public void setNumero(String numero) {
this.numero = numero;
}
public String getTelefone() {
return telefone;
}
public void setTelefone(String telefone) {
this.telefone = telefone;
}
}
Código 02: controller
package controllers;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.faces.bean.ViewScoped;
import models.Pessoa;
@ManagedBean
@ViewScoped
public class PessoaMB implements Serializable {
private Pessoa pessoa = new Pessoa();
private ListPessoa pessoaLista = new ArrayListPessoa();

/** Creates a new instance of PessoaMB */
public PessoaMB() {
}
/**Getters e Setters */
public Pessoa getPessoa() {
return pessoa;
}
public void setPessoa(Pessoa pessoa) {
this.pessoa = pessoa;
}
public ListPessoa getPessoaLista() {
return pessoaLista;
}
public void setPessoaLista(ListPessoa pessoaLista) {
this.pessoaLista = pessoaLista;
}
public void salvarPessoa() {
//adicionando pessoas a lista
pessoaLista.add(pessoa);
//instanciado uma nova para ser cadastrada
pessoa = new Pessoa();
}
}
Código 03: formulário (view)
?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:f=http://java.sun.com/jsf/core
h:head
titleCadastro/title
/h:head
h:body
h:form
h:panelGrid columns=3

h:outputLabel value=Nome:/
h:inputText id=nome value=#{pessoaMB.pessoa.nome} size=20 required=true
requiredMessage=Campo Obrigatório/
h:message for=nome /
h:outputLabel value=Endereço:/
h:inputText id=end value=#{pessoaMB.pessoa.endereco} size=20 required=true
h:message for=end /
h:outputLabel value=Número:/
h:inputText id=nro value=#{pessoaMB.pessoa.numero} size=20 /
h:message for=nro /
h:outputLabel value=Telefone:/
h:inputText id=tel value=#{pessoaMB.pessoa.telefone} size=20 /
h:message for=tel /
h:outputLabel value=Cidade:/
h:inputText id=mun value=#{pessoaMB.pessoa.cidade} size=20 required=true
h:message for=mun /
h:commandButton id=btnE value=Enviar type=submit
action=#{pessoaMB.salvarPessoa}/
h:commandButton id=btnL value=Limpar type=reset/
/h:panelGrid
/h:form
h:panelGrid
h:dataTable id=tablePessoa value=#{pessoaMB.pessoaLista} var=p title=Pessoas
Cadastradas border=1 rows=10
h:column
f:facet name=header
h:outputText value=NOME /
/f:facet
h:outputText value=#{p.nome}/
/h:column
h:column
Bloco –
componente
h:dataTable
,,,

f:facet name=header
h:outputText value=ENDEREÇO /
/f:facet
h:outputText value=#{p.endereco}/
/h:column
h:column
f:facet name=header
h:outputText value=NÚMERO /
/f:facet
h:outputText value=#{p.numero}/
/h:column
h:column
f:facet name=header
h:outputText value=TELEFONE /
/f:facet
h:outputText value=#{p.telefone}/
/h:column
h:column
f:facet name=header
h:outputText value=CIDADE /
/f:facet
h:outputText value=#{p.cidade}/
/h:column
/h:dataTable
/h:panelGrid
/h:body
/html

4 - Material de apoio
ACTIVEINFO. Tutorial de instalação do Java 7 no Windows 7.
http://www.activeinfo.com.br/tutos/tutorial_instalacao_java_windows.pdf
ADRIELCAFE. Hibernate: tipos de dados e dialetos suportados. 2013
http://adrielcafe.com/cafelog/hibernate/46-hibernate-tipos-de-dados-e-dialetos-suportados
ALGAWORKS. DWJSF desenvolvimento web com javaserver faces.
http://www.algaworks.com/downloads/apostilas/algaworks-dwjsf-desenvolvimento-web-com-
javaserver-faces-2a-edicao.pdf
BRUNETTA, Andii. JSF 2.0: Componentes PrimeFaces 2.2.1 - Parte 1. 2011
http://javasemcafe.blogspot.com.br/2011/05/jsf-20-componentes-primefaces-221-parte.html
BRUNETTA, Andii. JSF 2.0: Template em Facelets com Layout do PrimeFaces 3.0.
http://javasemcafe.blogspot.com.br/2012/03/jsf-20-template-em-facelets-com-layout.html.
CAELUM Ensino e Inovação. JSF – Lidando com o estado da view.
http://blog.caelum.com.br/jsf-lidando-com-o-estado-da-view
CAELUM. Introdução ao JSF e Primefaces.
http://www.caelum.com.br/apostila-java-testes-jsf-web-services-design-patterns/introducao-ao-
jsf-e-primefaces/#7-6-introducao-ao-jsf-com-mojarra-e-primefaces
DOMENECH, Edson. Desenvolvimento de um sistema Web com JavaServer Faces e
PrimeFaces (Parte I)
http://domenechbr.blogspot.com.br/ 2012/08/desenvolvimento-de-um-sistema-web-com.
html
FLASHCAGE. Apostila Java Web
http://www.flashcafe.com.br/wp-content/uploads/2012/04/Apostila-Java-Web-Primefaces.pdf
GONÇALVES, Edson. Desenvolvimento de Aplicações Web com IDE 5.5. Rio de
Janeiro: Editora Ciência Moderna. 2007.
GONÇALVES, Edson. Dominando Java Server Faces e Facelets utilizando Spring 2.5,
Hibernate e JPA. http://www.flashcafe.com.br/wp-content/uploads/2012/04/dominando-jsf-e-
facelets-utilizando-spring-2.5-hibernate-e-jpa.pdf
GONÇALVES, Edson. JavaServer Faces 2.0 na Prática – Parte 3
http://www.edsongoncalves.com.br/2010/02/21/javaserver-faces-2-0-na-pratica-parte-3/
K19. Desenvolvimento Web com JSF 2 e JPA 2
http://www.k19.com.br/downloads/apostilas/java/k19-k12-desenvolvimento-web-com-jsf2-e-jpa2
K19. Orientação a Objetos em Java
http://www.k19.com.br/downloads/apostilas/java/k19-k11-orientacao-a-objetos-em-java

KING, Gavin. et al. Documentação de Referência Hibernate. 2010.
http://docs.jboss.org/hibernate/core/3.5/reference/pt-BR/pdf/hibernate_reference.pdf
PROCACI, THIAGO. Internacionalização de mensagens com JSF – Exemplo prático.
http://thiagoprocaci.blogspot.com/2009/07/internacionalizacao-de-mensagens-com.html
UNIVERSIDADEJAVA. Introdução ao JavaServer Faces 2.0.
http://www.universidadejava.com.br/docs/introducaoaojavaserverfaces20
UNIVERSIDADEJAVA. Criando uma tela de login. Disponível em
http://www.universidadejava.com.br/docs/criandoumateladeloginutilizandoojsf20
UNIVERSIDADEJAVA. Criando uma tela de login.
http://www.universidadejava.com.br/docs/jsf20-bibliotecadetagshtml
USANDO hibernate: conceitos e consultas.2012.
http://www.facom.ufu.br/~bacala/DAW/06%20-%20Usando%20Hibernate.pdf
VENTURINI, Danilo; MARCHI, Késsia Rita da Costa. Desenvolvimento web utilizando
primefaces. 2013.
http://web.unipar.br/~seinpar/artigos/Danilo-Venturini.pdf
VINICIUS, Samuel. Conheça o ciclo de vida do JSF. Disponível
http://imasters.com.br/linguagens/java/conheca-o-ciclo-fe-vida-do-jsf
WORKBENCH. MYSQL WORKBENCH.
http://www.mysql.com/products/workbench
ZANOTTI, Emerson. Aula 7: conversão e validação. 2012.
http://www.codigosfontes.com.br/jsf-conversao-e-validacao/
Observações:
Caro Aluno,
Peça para o tutor de sala enviar suas dúvidas pelo Chat Atividade para que o professor
possa esclarecê-las.

1409243945064

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (18)

En vedette

En vedette (10)

Similaire à 1409243945064

Similaire à 1409243945064 (20)

Plus de Fábio Junior

Plus de Fábio Junior (15)

1409243945064