JSF – Página: 3 – Blog do Camilo

Validando campos com JSF

olá Pessoal, hoje o post é dedicado para quem está aprendendo JSF e pretende usar os recursos de validação de campo do proprio framework. Perguntas comuns sobre validação: como validar um email? Como validar um campo número? É isso que veremos, claro que mostrarei um pequeno exemplo “motivador”, vai de você criar outras validações para seu formulário. Observe que é algo bem simples e funcional. E para aqueles que estão estudando para antiga SCJP e acham que regex é algo somente para certificação, Vejam nesse post o poder que regex tem. No post tem um link para “testador de expressões regex online”. Muito show, já tem até alguns exemplos prontos tais como: validação de IP, telefone etc.

lets go…

Preparando o ambiente

Certifique-se que você tem os arquivos .jars necessário para rodar JSF. Confira nos posts a seguir quais os arquivos que vc precisa. Sem falar que usar Jboss tools seria uma boa ideia. Para o nosso exemplo usaremos o plugin no Eclipse Jboss tools para suporte à JSF. Também não pode esquecer que nosso application server será o Tomcat, se ainda não instalou/configurou veja no exemplo abaixo.

Desenvolvimento

Com o Jboss tools configurado e Eclipse aberto crie um novo JSF Project.
Em WebContent crie uma página .jsp que redirecione para uma página chamada formulario.jsp. Mas, lembre-se que no seu arquivo index.jsp o code fica assim:
Feito isso, vamos agora codificar nosso formulário em JSF. Para isso crie uma página em jsp com suporte JSF em WebContent chamando de formulario.jsp. Veja abaixo como criar uma página caso tenha esquecido:
Abaixo temos nossa página em JSF. O uso de immediate=true em cada campo é para quando aparecer a mensagem de validação a pagina atual não seja processada, ou seja, ela não vai para a página seguinte enquanto você não atender os requisitos da validação.
Agora crie uma página em .jsp que exiba uma mensagem qualquer. Pois, ela somente será exibida quando as validações da pagina do formulário forem válidas. Nos colocamos nessa página uma mensagem: “Mensagem enviada com sucesso!”
Feito isso, precisamos criar nosso bean e controller. Então crie um package chamado br.com.bean e nele crie uma classe Java chamada de Usuario.java e deixe conforme abaixo:

Agora crie um package br.com.controller e nele crie uma classe chamada Controller. É essa classe que será responsável por controlar nossa aplicação. Ela que diz aonde o usuário vai parar depois de uma determinada ação. Deixe conforme abaixo:
Vá no arquivo face-config.xml e crie um ManageBean para a classe Controller conforme a imagem abaixo:
Agora vamos adicionar as rules para navegação com as pages. Clique em Navigation Rules e a direita add. Veja abaixo como ficou:
Precisamos apenas configurar o Navigation Cases. Veja:
Uma explicação básica: “Quando vinher a uma mensagem chamada ‘sucesso’ da página formulario.jsp, favor de ir para a pagina mensagem.jsp”.
Agora precisamos criar uma classe que vai validar os campos do nosso formulário, que nesse caso será apenas e-mail e idade. Para isso precisamos implementar uma interface JSF que vai nos auxiliar no processo. É a interface Validator. Para isso crie um package br.com.validator e uma classe EmailValidar e informe que essa classe implementa a interface Validator. Veja meu exemplo abaixo:
Agora deixe sua classe conforme abaixo. E para não perder o costume, explicação está nos comentários.
Agora vamos validar o campo idade, onde é permitido apenas digito. Crie a classe IdadeValidar.java e implemente o método Validator.
Feito isso precisamos apenas informar para o nosso face-config.xml que usaremos nosso validador nesta aplicação. Veja como fazer isso:
Faça o mesmo para o validator idade.
Damos um nome ao validador e informamos a classe que tem a validação, o nome é requirido pois é ele que vamos usar no form.
Agora vá na sua página que contém o formulário e deixe os campos email e idade conforme o código abaixo.

Testando Aplicação

Salve as alterações. Se o tomcat estiver rodando, dar um stop e em seguida um start. E veja aplicação rodando. No nosso caso vamos rodar dentro do próprio Eclipse. Para isso a perspectiva que estamos usando é JavaEE depois clique com o botão direito em cima do projeto e vá em Run >> Run as >> Run on Server.

Vou ficando por aqui e espero que tenham gostado do post. Simples e básico.

See you next post! 😀

Lançamento Oficial do Livro JEE com Frameworks

Comprar

ae Pessoal,

Hoje é mais um dia feliz na minha vida, e primeiramente quero agradecer à todos vocês, pela força, atenção, feedbacks que venho recebendo nesses 3 anos de blog e sem eles, acho que não estaria aqui hj fazendo este post e publicando mais este projeto. Pois, meu segundo filhão nasceu, huhuhu \o/. Lindo igual ao pai, por consequencia do destino hehe. Uma das novidades é que além do formato impresso, temos a versão e-book. A seguir fiz um overview,há um post detalhado de pré-lançamento aqui.

Lets go…

Note: Infelizmente, tivemos um problema na linha de produção da gráfica e atrasou a publicação que estava prevista para meados de julho/2011.

Agradecimento

Antes de tudo, preciso agradecer ao melhor amigo o Edson Gonçalves. Amigo este de longas datas, o qual eu tenho grande admiração e respeito. É um dos profissionais mais completos de TI que já pude conhecer, o cara tem um conhecimento cross que é uma coisa de louco(não se limita só a parte técnica). Fora amizade que temos, onde às vezes pego o caminho errado, o verdadeiro amigo aparece e ti fala:”Falei que poderia contar comigo, o caminho é aquele vai em frente”. Esse é o Edson um amigo de verdade.

Outra pessoa que não posso deixar de agradecer é o Daniel de Oliveria (leader-DFJUG) de uma das maiores e respeitável comunidade de Java que temos no Brasil, estou falando do DFJUG. E não poderia deixar de dar minha contribuição (para quem não sabe eu vim da comunidade Java, foi onde tudo começou e hoje retribuir o que recebi é o minimo que posso fazer), adicionado a marca na capa do livro. Obrigado Daniel pelo seu apoio e da comunidade :).

Overview

O livro tem como objetivo de ajudar aqueles profissionais que desejam aprender Java com Frameworks. É comum ao sairmos do “ABC do JEE” (normalmente é JSP/Servlet) sem saber qual framework estudar (Hibernate, JSF, Spring, “Struts”, VRaptor etc). Porém, há um problema que todo iniciante encontra: como aprender os frameworks e saber integrá-los em uma aplicação real? É isso que vamos ver no livro, aprender a usar os frameworks de forma prática e ver um pouco da teoria(se não gosta de teoria não se preocupe, pois veremos o suficiente para poder programar de maneira confortável). Os exemplos são variados, desde Java Application até JEE, a evolução de aprendizado no livro está no formato “baby-step” ajudando assim o leitor leigo no assunto. Uma novidade que alguns vão gostar e outros não, são os exercícios chamados de “Trabalho do dia” que tem como objetivo fazer o leitor desenvolver uma solução, porém há momentos que o leitor vai precisar fazer uma pesquisa na documentação da API, Google ou consultar outros capítulos.Porém, não avisamos isso no livro, então o leitor terá que ter essa percepção. O motivo de ter adotado isso aos exercícios, transmitir um pouco do que vai encontrar no dia-dia como desenvolvedor in company, pois nem sempre teremos um colega do lado para dar o help que precisamos.

Público-Alvo

Programadores Java que tem como objetivo aprender de forma pratica o uso dos frameworks JEE mais requisitado no mercado.

Qual o diferencial?

Meus livros são diferentes, primeiramente pela escrita. Eu gosto muito da informalidade, de ser direto e tentar transmitir a informação da melhor maneira possível, como se eu tivesse ao lado do leitor. Nesse livro há vários diferenciais, um deles é o nosso laboratório on-line onde o leitor poderá fazer download do source, assistir uns vídeos de como colocar aplicação em um servidor de produção JEE(apoio da www.integrator.com.br), exercícios práticos etc.

Quando ler?

Assim, que terminar seus estudos, com Servlet & JSP, vc pode ler, do contrário, não faça o investimento agora e aguarde mais um pouquinho( coloque o livro na prateleira ou remova do seu carrinho de compras : ) ).

Requisitos

É preciso já ter uma certa experiência com Java, Banco de dados, saber como as aplicações JEE funcionam etc. Como o livro é focado em ensinar a usar de forma pratica os frameworks, não podemos perder tempo com toda teoria de JEE, então vamos direto ao assunto.Particularmente não gosto de livros grandes, eles ficam mais caros e o que eu quero é um preço acessível para todos, enfim até os que recebem mesada podem comprar (pelo menos a minha na época que tinha, os livros eram caros demais rs).

Desconto

Se quiser comprar o exemplar com 30% de desconto no site da Editora, basta usar o código a seguir durante a compra: V00014 e se cadastrar como associado.

Concorra Sorteio será 21/08/2011

Faça um RT da mensagem abaixo e sua inscrição, assim terá a chance de receber um exemplar na sua casa autografado(se preferir). Para sorteio usaremos o random.org e o número sorteado será o ganhador e a verificação do RT Lembrando que para aqueles que fizeram mais de um cadastro com o mesmo e-mail, não estará concorrendo ao exemplar.

Lançamento do Livro Guia JEE c/ frameworks @RT: @camilolope #JEE #frameworks.Confira:

Lançamento Oficial do Livro JEE com Frameworks

Após, o resultado entrarei em contato pelo e-mail cadastrado e o ganhador tem até 48 hrs para responder, após o envio do e-mail.Do contrário um novo sorteio será realizado, e o ganhador anterior acabou de perder a chance de receber o livro. : )

Fazer inscrição

Você pode deixar de ganhar se não fizer isso:

cadastrar e não fazer o RT;
fazer o RT e não se cadastrar;

A qtde de RT fica por sua conta, se quiser fazer mais de RT, ficarei feliz :).

Versão do Livro

Paper – R$ 47,20
E-book – R$ 35,40

Eu quero comprar o meu

Onde comprar?

Site da Editora
Saraiva
Cultura
Fnac
Americanas.com
Submarino
e outras que eu não lembro rs

Download

Conseguir com a editora amostra de algumas páginas do livro, confiram aqui

Vou ficando por aqui e espero que tenham gostado do post.

Abracos see ya!!

Relatório Ireport + JasperReport JEE + JSF

olá Pessoal,

No post de hoje, vou apresentar como gerar relatorios de uma base de dados sendo uma aplicação JEE. Em outro post, mostrei como gerar relatorios usando Java Basico com Hibernate, aqui vamos manter a mesma estrutura técnica a diferença apenas que será com foco para JEE. Espero que gostem.
Lets go…

Requisitos

Relatorio Ireport + jasperReport com Hibernate

Starting…

Para gerar relatorios em ambiente JEE, há algumas mudancas a nivel de codigo que sofrem alterações, porem tudo de ireport com BD é mantido.

passo 1

criar o layout no ireport e fazer a conexao com o banco de dados e definir as colunas do relatorio, enfim definir a estrutura do relatorio

passo 2

criar a classe de conexao com banco de dados – Hibernate
Criar o bean

passo 3

cria um package exclusivo para o relatorio e uma classe, por questao de organizacao importar o jrxml para o projeto e para o package do relatorio por medida de seguranca

passo 4

para que o arquivo seja gerado na pagina WEB, eh preciso mudar algumas coisas no metodo responsavel por gerar o relatorio:

FacesContext context = FacesContext.getCurrentInstance();

HttpServletResponse response = (HttpServletResponse) context.getExternalContext().getResponse();

ServletOutputStream responseStream = response.getOutputStream();

InputStream caminho = getClass().getResourceAsStream(“../relatorio/reportblog.jrxml”);

response.setContentType(“application/pdf”);

criar um context e objetos de resposta.
Fazemos um stream do caminho onde esta o jrxml. Quando temos dois pontos antes da barra significa que temosum caminho diferente da classe que gera o relatorio
depois um response que informa o tipo do conteudo para o browser saber qual aplicativo chamar caso ele tenha suporte response.setContentType(“application/pdf”);

Na linha a seguir informamos como sera o nome do arquivo a ser gerado

response.setHeader(“Content-Disposition”,”attachment; filename=\”relatorio.pdf\””);

Abaixo temos o padrao para invocao

JasperReport pathReport = JasperCompileManager.compileReport(caminho);

//relatorio gerado

JasperPrint preencher = JasperFillManager.fillReport(pathReport, null,new JRBeanCollectionDataSource(listaUS));

JasperExportManager.exportReportToPdfStream(preencher,responseStream);

responseStream.flush();

responseStream.close();

context.renderResponse();

context.responseComplete();

O resultado

O resultado eh que ao inves de ter um arquivo que é direcionado para um local, ele aparece no browser (firefox, Chrome, IE) do usuario. E o browser decide como vai apresentar esse arquivo. Por exemplo, no FireFox, ele aprende o arquivo no proprio Browser, no Internet Explorer ele abre uma Janela onde o usuario decide se vai abrir ou fazer o download.

JasperViewer

O JasperViewer eh forma de exibir o relatorio em applet, ao inves de usar o browser, pode ser ate mais amigavel que usar o proprio browser, mas deve ser analizado o tempo de carregado disso em producao, basta adiciona a linha abaixo

JasperViewer.viewReport(preencher, false);

E desabilitar as linhas referente ao browser, para que nao seja executada em paralelo

response.setContentType(“application/pdf”);

response.setHeader(“Content-Disposition”,”attachment; filename=\”relatorio.pdf\””);

Vou ficando por aqui, espero que tenham gostado do post.

Abracos, see ya! Have a nice week, guys!

Usando Rendered JSF

olá Pessoal,

Sempre tive dúvidas como ter em um único form do JSF, duas ou mais opções com base em uma condicao XYZ, algo como: o botão alterar/cadastrar só vão aparecer com base na requisição do usuário/cliente. Há varias formas de fazer isso. Mas, em um belo dia, estou navegando na documentação do JSF, e do nada vejo algo interessante sobre o assunto e resolvi testar e deu certo.

Então hoje vou mostrar como não ter dois formulários cadastrar.jsp e alterar.jsp. Será um único formulário (formulario.jsp) e com base no que for solicitado, ele terá um botão cadastrar ou alterar visivel para o usuario.

Lets go…

Starting…

Primeiramente estarei limitando o post à JSF, então configuração de conexão com banco de dados, e outros tópicos relacionado não farão parte. Vou levar em consideração que você tem sua app rodando e quer usar este recurso. Aqui temos o Hibernate como nosso frameworks de persistência.

A seguir tem o projeto que criei para como teste:

A seguir temos o meu face-config.xml

Development

Vamos colocar mão na massa e fazer as devidas configurações.

Passo 1

Alterar as classes de persistência, é o primeiro ponto. Então adicione o método responsável por alterar como o nosso:

public void atualizar(TUsuario tusuario){

begin();

getSession().merge(tusuario);

try{

commit();

}catch (HibernateException e) {

rollback();

}}

O método begin() vem de uma classe generica DAO, minha. Veja:

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.AnnotationConfiguration;

public class DAO {

private static final ThreadLocal<Session> threadlocal = new ThreadLocal<Session>();

private static final SessionFactory sessionfactory = new AnnotationConfiguration()

.configure().buildSessionFactory();

public static Session getSession() {

Session session = (Session) threadlocal.get();

if (session == null) {

session = sessionfactory.openSession();

threadlocal.set(session);

}

return session;

}

public void begin() {

getSession().beginTransaction();

}

public void commit() {

getSession().getTransaction().commit();

}

public void rollback() {

getSession().getTransaction().rollback();

}

public void close() {

getSession().clear();

threadlocal.set(null);

}

Passo 2

Levando em conta que você vai editar o usuário a partir de uma tabela onde exibi todos os usuarios, então você vai precisar inserir na classe de persistencia o seguinte método:

public List listaUsuarios(){

Query query = getSession().createQuery(“from TUsuario tu order by tu.nome asc”);

List<TUsuario> lista = query.list();

return lista;

}

Passo 3

Feito isso va para a classe controladora, aquela de comunicação com o JSF, e insira o seguinte método

public TUsuario getEditorDelete(){

TUsuario tus = (TUsuario) model.getRowData();

return tus;

}

Agora já sabemos, qual linha será editada, observe o que os métodos a seguir fazem:

public String editar(){

TUsuario tu = getEditorDelete();

setTusuario(tu);

return “editarus”;

}

public String editado(){

TUsuarioDAO tusdao = new TUsuarioDAO();

tusdao.atualizar(tusuario);

return “editadous”;

}

O primeiro dele é chamado quando clicamos no link editar, daí ele vai para o formulario.jsp e o segundo método editado() é quando clica no botão submit para fazer a persistencia e alterar o valor daquele objeto.

Passo 4

Agora vamos alterar.jsp nossa pagina formulario.jsp para exibir o botão correto com base na requisição do usuário.

No seu formulário os botões submit deixando desse modo:

<input jsfc=“h:commandButton”

rendered=“#{tUsuarioControler.tusuario.nome==null}” id=“bsalvar”

type=“submit” value=“Salvar” action=“#{tUsuarioControler.salvarUS}” />

<input jsfc=“h:commandButton”

rendered=“#{tUsuarioControler.tusuario.nome!=null}” id=“balterar”

type=“submit” value=“Alterar” action=“#{tUsuarioControler.editado}” />

Conclusão

Observe que apenas adicionamos um atributo que é o rendered onde tem o teste, caso seja null é porque será um novo usuário, porem se for diferente é porque será alterado, nessa condição apenas um dos botões serão exibidos. Vejam uns testes que fiz, ao executar minha aplicação:

Vou ficando por aqui, espero que o post tenha sido útil.Preparei este post tem um tempinho já porém, só agora conseguir publicar, pois a lista é grande :).

see you next post!!!

Uma simples aplicação Hibernate + JSF + poolConexao

olá Pessoal,

Bem, hoje resolvi fazer um post, do qual eu já tive problemas e acredito que alguém já passou ou passa por isso. Vc nunca ficou perdido nos passos de como desenvolver uma nova aplicação usando um conjunto de frameworks? Tipo, por onde começar? Quando você faz isso com frequência não tem como esquecer, mas não é a realidade, nem todo dia estamos criando novas aplicações e alguns processos base, “dão branco”. Eu sofria com isso, quando precisava iniciar uma nova app do zero. Claro que hoje temos ferramentas que nos ajuda. Mas, vamos esquecer essas ferramentas de auxilio e pensar em um ambiente que não temos ela disponível.

O objetivo deste post, é documentar tópicos para que você possa montar uma pequena estrutura para o ambiente de produção e ao mesmo tempo ir reelembrando aquilo que seu cerebro deixou no “pool” dele. Usarei o Hibernate + JSF tendo o pool de conexão implementado.

note: Claro em projetos reais e grandes não fazemos isso, para não perder tempo e tb não é nada legal. Porém, se você está começando agora a fazer aplicações sem muita experiência, procure sempre lembrar a funcionalidade de cada framework dentro do projeto e quando eles aparecem no desenvolvimento isto é tão importante qto saber usar cada um deles.

Lets go…

note: vou considerar os passos abaixo para um ambiente de produção, pois em testes raramente temos problemas. Um deles é o open session view que só descobrir ele quando subir minha app.

Steps

Ter o BD e tabelas criadas
criar a estrutura do projeto JSF Project
Adicionar as bibliotecas dos frameworks
criar o bean e fazer os annotations (não queira usar xml )
criar o JNDI META-INF/context.xml
criar o pool de conexao com o JNDI em web.xml (Resources)
atualizar o hibernate.cfg.xml com o JNDI/Pool de conexão.

current_session_context_class: thread

connection.datasource: java:com/env/jdbc/nomejndi

transaction.factory_class:org.hibernate.transaction.JDBCTransactionFactory

jdbc.batch_size:0
criar o DAO Generico com Hibernate no package dao
Criar a classeDAO para fazer a persistencia no BD
criar o managebean e controlador para JSF
iniciar a construção do front end com JSF.
Implementar o SpringSecurity (optional)
Implementar o Filter para evitar o open session view

Claro que nesses passos há temos apenas os pontos chaves que acabam reativando o conhecimento que está la no “pool de string” do seu cerebro.

Visite a nossa as categorias abaixo no blog que boa parte dos assuntos listados nos passos estão nas respectivas categorias:

https://blog.camilolopes.com.br/category/hibernate/

https://blog.camilolopes.com.br/category/java/

https://blog.camilolopes.com.br/category/javaee/

https://blog.camilolopes.com.br/category/jpa/

https://blog.camilolopes.com.br/category/jsf/

Abracos, see you next post. 🙂