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!!!

Os melhores posts de 2010 LpJava

ae! Pessoal,

Em preparativo dos posts para 2011 e das novidades para o próximo ano, resolvi listar os 12 posts mais visitados neste ano. Caso tenha perdido algum, confira quem são eles:

Os posts mais visitados 2010:

  1. Uma simples aplicação Hibernate + JSF + poolConexao

  2. Série NZ: Minha Experiência Intercâmbio – Auckland

  3. SimSCJP Premium

  4. Java Básico + Hibernate JPA + Mysql

  5. Quando ser contratado como PJ?

  6. selectOneMenu JSF com BD

  7. Como ser um Programador Senior Java

  8. JPA com Java Básico MySql

  9. Como melhorar seu estudo? English

  10. Praticando JSF Facelets no Eclipse

  11. Projetos com RedMine

  12. Open Session View – Hibernate Solução

Atingimos o número de 184 posts, desde os técnicos e não técnicos, nesses dois anos de trabalho, iniciado desde março/2008. Este ano foram 55 novos posts( técnicos, carreira, inglês). Espero escrever mais em 2011 😉

Vou ficando por aqui e semana que vem retorno com o ultimo post do ano, sobre metas/plano de carreira e retrospectiva.

Abracos, see ya!

JNDI com Hibernate – Ambiente de Test

Olá Pessoal,

No post de hoje, vou apresentar como usar JNDI dentro do seu arquivo hibernate.cfg.xml dentro de um ambiente de teste. Em outro post falarei como usar em um ambiente de produção e ver que fica mais fácil realizar mudanças nas conexões de modo mais fácil, uma vez que normalmente o ambiente de teste possui configurações levemente diferente do ambiente de produção desde nome do usuário, até o path do BD.

Lets go…

Starting/Nosso Cenário

Eu já falei aqui no blog sobre pool de conexão no TomCat e JNDI, porém não falei como usar o JNDI dentro do Hibernate.

Aqui veremos isso com um framework bem utilizado no mercado que é o Hibernate.

Mas, a pergunta que você pode está fazendo: “Camilo, por que eu usaria isso?”, “Qual a diferença na pratica?”

Como sempre gostei de ser mais pratico e menos teorico, eu também tive essa dúvida rs. Porém, descobrir a grande produvidade quando tive 6 projetos diferentes para Produção e sempre quando tinhamos um release, era fato de esquecer de mudar o hibernate.cfg.xml, para as conexões de produção, fora que toda vez já era um saco, porque tinha que configurar sempre no ambiente de desenvolvimento antes de enviar para prod.

Enfim, na pratica você só vai configurar em um lugar as config de conexão, em um único arquivo e mais nada. E o melhor, quando for pra PRODUÇÃO, veremos que lá temos outro arquivo JNDI só para PROD, que normalmente não tem porque mudar com frequência. E nos desenvolvedores precisamos apenas saber o JNDI correto, e o administrador do Servidor que se vire lá com as configs, do arquivo de conexão em produção. Isso é extremamente importante, trabalhei em um projeto do qual nos desenvolvedores não tinhamos acesso as senhas, pw de produção, somente os administradores, para nos o que importava era apenas o path do JNDI e mais nada. Para quem trabalha fazendo todos os papeis (isso lembra meu tempo de freelance rs) desenvolvedor,administrador, DBA, isso parece ser estranho, mas em projetos grandes que participei na IBM , não é assim que funciona. Desenvolvedor é desenvolvedor,Testador é testador e por ai vai. E em ambiente teste você tem até acesso ao BD, PW etc. Mas, em produção. Not.

Hoje estarei limitado ao ambiente de teste, porque no ambiente de produção há algumas mudanças significativas e quero deixar o post focado à um assunto.

Nosso projeto

Criei um projeto muito simples, pois a funcionalidade está no uso de JNDI com Hibernate em teste. Não passa de um projeto com JSF + Hibernate. Porém,vc pode configurar isso em qualquer projeto com Hibernate para que ele funcione com JNDI.


Primeiro passo:

É configurar o arquivo web.xml do seu projeto com o nome do JNDI que deseja, pode ser o nome do seu cachorro, da sua namorada, o que você quiser.

<resource-ref>

<res-ref-name>jdbc/lpjava</res-ref-name>

<res-type>javax.sql.DataSource</res-type>

<res-auth>Container</res-auth>

</resource-ref>

Segundo passo:

Após ter configurado o web.xml, informando que a conexão para o BD estará naquele path. Vamos configurar o nosso JNDI, com os dados de conexão. Em ambiente de teste, vamos configurar o arquivo context.xml que está na pasta Server do Eclipse. É nele que vai estar as config locais. Insira dentro da tag Context o Resource abaixo:

<Resource auth=“Container”

name=“jdbc/lpjava”

driverClassName=“com.mysql.jdbc.Driver”

maxActive=“20” maxIdle=“10” maxWait=“-1”

type=“javax.sql.DataSource”

url=“jdbc:mysql://localhost/apptestes”

password=“lpjava”

username=“camilolopes”

validationQuery=“SELECT 1”

testOnBorrow=“true”

testWhileIdle=“true”

timeBetweenEvictionRunsMillis=“10000”

minEvictableIdleTimeMillis=“60000” />

Observe que informamos o nome do JNDI, que este tem referencia.

Terceiro passo:

Feito isso, vamos informar ao Hibernate que ele vai usar uma conexão JNDI, para o Hibernate o que importa é o path, se amanha você muda a senha de conexão vai precisar alterar apenas o arquivo context.xml que está na pasta Server dentro do Eclipse, lembrando que isso em ambiente de teste. Abaixo como ficou meu arquivo hibernate.cfg.xml

<hibernate-configuration>

<session-factory name=“hibernate/SessionFactory”>

<property name=“hibernate.connection.datasource”>java:/comp/env/jdbc/lpjava</property>

<property name=“hibernate.current_session_context_class”>thread</property>

<property name=“hibernate.transaction.factory_class”>org.hibernate.transaction.JDBCTransactionFactory</property>

<property name=“hibernate.dialect”>org.hibernate.dialect.MySQL5InnoDBDialect</property>

<property name=“hibernate.jdbc.batch_size”>0</property>

<mapping class=“br.com.camilolopes.bean.TUsuario”/>

</session-factory>

</hibernate-configuration>

Quem usa o Hibernate ou está começando vai ver que não temos mais a property para o password ou user, uma vez que há uma referencia para um path, onde este tem referencia para um arquivo (context.xml) onde está de fato nossa conexão.

Finalizando

Teste sua aplicação, mande executar e faça uma persistencia, porem não deixe de verificar se já deu um start no banco de dados, se todos os .jars referente ao Hibernate estão no projeto e no caso do Eclipse olhe se está fisicamente na pasta lib do projeto.

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

Abracos, see ya guys!!! 🙂

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

  1. Ter o BD e tabelas criadas

  2. criar a estrutura do projeto JSF Project

  3. Adicionar as bibliotecas dos frameworks

  4. criar o bean e fazer os annotations (não queira usar xml )

  5. criar o JNDI META-INF/context.xml

  6. criar o pool de conexao com o JNDI em web.xml (Resources)

  7. 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

  8. criar o DAO Generico com Hibernate no package dao

  9. Criar a classeDAO para fazer a persistencia no BD

  10. criar o managebean e controlador para JSF

  11. iniciar a construção do front end com JSF.

  12. Implementar o SpringSecurity (optional)

  13. 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. 🙂

Importando Projeto JSF Eclipse

Olá pessoal,

No post de hoje, vou mostrar como importar um projeto JSF para o Eclipse. Parece algo simples, mas no Eclipse as vezes as coisas mais simples, é onde tem mais problemas. Sempre quando preciso fazer algo básico no Eclipse, fico surpreso com os problemas que surgem e dai preciso pesquisar pra ver se alguém já sofreu com algo. Mas, o de hoje fui brincado com Jboss tools eu achei a opção..

lets go…

Importando JSF Project Eclipse

A situação de importar um projeto para o Eclipse pode acontecer por vários motivos. A forma padrão que é bem comum a tentativa é ir no menu File >> Import e escolher a opção a abaixo:

importjsfprojecteclipse

Porém, ao escolhe a opção acima, você ainda vai precisar configurar algumas coisas para o X sair do projeto e conseguir executar e vezes isso se torna um pesadelo, pois nem sempre o projeto volta a executar, ou não reconhece o servidor de aplicação. Enfim eu tive vários probleminhas chatos, ao importar por dessa forma. E daí veio o formato de importação do Jboss tools que permite já pegar um projeto especifico JSF e fazer as devidas configurações de forma automática Basta escolher a seguinte opção:

importjsfprojectother

Clique em next e localize o web.xml do projeto, depois clique em next, verifique como será os folders e o servidor de application configurado, em seguida clique em finish. se ficar com o X, vai em properties do projeto clicando com o botão direito e veja a versão do Project Facet. Normalmente é Java 5 para JDK 1.5. Certifique-se que os .jars dos frameworks foram adicionados ao projeto, tais como: JSF, Hibernate, Toplink etc.

Um dos problemas que eu tive com a importação padrão é que as vezes, ele bagunçava meu arquivo web.xml e duplicava umas linhas de code era horrível, e daí meu projeto para de funcionar e tinha que fix na mão, ou pegando de outro projeto.

Espero que tenham gostado do post. See you next post guys!!