Hibernate Annotations + JSF + MySql

stressprogrammer

Ola Pessoal!! Dando continuidade ao post anterior, resolvi dar um update na nossa NewsLetter. No post anterior desenvolvemos usando apenas Hibernate + JSF e tendo o MySql como BD. Hoje veremos um recurso que está “bombando” no mercado sao os Annotations. Realmente vieram para ficar e usar Hibernate puro é bem mais trabalhoso sem falar que ficar criando arquivos .xml para mapeamento com o BD nao é algo tão confortável assim. Então veremos o que annotations pode fazer por nos desenvolvedores. Veremos o básico da tecnologia Annotations nesse post.

Ahh, um ponto importante não vou repetir todo o conteudo do post anterior tais como :criaçao das paginas JSF, do Bean, dos arquivos Hibernate etc. Irei apresentar apenas os arquivos que devem sofrer alterações e o que deve ser acrescentado na aplicação para que a nova tecnologia entre em cena. Se vc perdeu o post anterior, ele está logo abaixo:

Post Recomendado
JSF + Hibernate + MySql no Eclipse

O que é Java Annotations? (abaixo a técnica de reutilização da informação 😉 )
An annotation, in the Java computer programming language, is a special form of syntactic metadata that can be added to Java source code.[1] Classes, methods, variables, parameters and packages may be annotated. Unlike Javadoc tags, Java annotations can be reflective in that they can be embedded in class files generated by the compiler and may be retained by the Java VM to be made retrievable at run-time.

Fonte: http://en.wikipedia.org/wiki/Java_annotation

Downloadhttps://www.hibernate.org/6.html
Antes de começar você precisa ir no site hibernate.org e fazer o download do package Hibernate Annotations a versão que estamos usando aqui é 3.4.0 GA .
Em seguida descompacte o arquivo e copie os arquivos .jars de lib e cole no lib do seu projeto. Na verdade precisamos apenas de dois arquivos .jars: hibernate-annotations.jar e o ejb3-persistence.jar

Desenvolvimento
1. Primeiro passo agora é alterar o Bean. Então abra o seu arquivo bean, que no nosso caso é NewsLetter.java no package br.com.bean. E altere o arquivo conforme o code a seguir:

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table (name="newsletter")
public class NewsLetter {

@Column (name="nome")
String nome;
@Column(name="email")
String email;
@Id
@GeneratedValue
int id;
public String getNome() {
return nome;}
public void setNome(String nome) {
this.nome = nome;	}
public String getEmail() {
return email;}
public void setEmail(String email) {
this.email = email;}
public int getId() {
return id;	}
public void setId(int id) {
this.id = id;	}}

Explicando as anotacoes:
@Entity = é uma entidade que representa uma class bean;
@Table = mapeia com o nome da tabela. Aqui eu coloquei o table para explicar, mas poderia omitir levando em conta que eu teria uma table no meu BD com o mesmo nome da minha class Bean. Ou seja, se nao especificar qual será a tabela do BD, será considerada o nome do Bean. Tenha atenção se você tem tabelas com nomes diferentes em relação ao seu bean;
@Id = tem relação com a chave primaria da sua tabela;
@Column = mapeia com as colunas da sua tabela, segue a mesma regra de table, quando ter colunas com nomes diferentes este campo eh obrigatório, caso contrario non-required ;
2.Precisamos fazer umas mudanças na classe de conexao, entao abra o arquivo ConexaoFactory.java e altere conforme abaixo

package br.com.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;

public class ConexaoFactory {
private static 	final SessionFactory sessionfactory;
private static final ThreadLocal threadlocal = new ThreadLocal();
static{
try{
//agora é Annotations que comanda
sessionfactory = new AnnotationConfiguration()
.configure("hibernate.cfg.xml").buildSessionFactory();
}catch (Throwable e) {
throw new ExceptionInInitializerError(e);
}}
public static Session getInstance(){
Session session = (Session)threadlocal.get();
session = sessionfactory.openSession();
threadlocal.set(session);
return session;
}}

Nessa classe usamos a classe AnnotationConfiguration()para que ele aponte para as anotacoes no arquivo NewsLetter.java atualizado anteriormente com os annotations.

3.Precisamos apenas fazer uma pequena alteração no arquivo de configuração do hibernate que criamos no post anterior o arquivo hibernate.cfg.xml. Lembra que ele tinha uma referencia para o arquivo visitante.hbm.xml que este arquivo tinha como objetivo fazer o mapeamento com o BD? Pois é, ele será descartado a partir de agora, se quiser pode ate deletar do projeto. E deixe o seu arquivo hibernate.cfg.xml conforme o code abaixo:


org.gjt.mm.mysql.Driver
jdbc:mysql://localhost/livraria
camilo
bahia
  
org.hibernate.dialect.MySQLDialect

Apenas removemos as tags que apontavam para o arquivo de mapeamento e inserimos a classe bean que possui um annotation mapeamendo o nosso BD.
4.Salve todas as alteracoes, seu projeto deve estar conforme a imagem a seguir:

Note que não temos mais o arquivo visitantes.hbm.xml, como tinhamos no ultimo post.
Agora pode testar o resultado é o mesmo, ou seja, ele deve cadastrar tranquilamente o usuário, porem agora é com annotations e nao mais com hibernate puro.

Vou ficando por aqui e espero que tenham gostado do post. E se vc está começando a estudar o framework aqui pode ser seu ponto de partida ;).
abracos e até o próximo post…

JSF + Hibernate + MySql no Eclipse

stressprogrammer

opa!Pessoal!! Cansado de fazer um CRUD manualmente usando o padrão DAO? É porque você precisa conhecer o Hibernate.
No post de hoje vamos criar uma persistencia de dados usando framework Hibernate no Eclipse tendo o framework JSF como view. Vejam que não é tão complicado assim, o chato é configurar o hibernate no Eclipse, ao contrário do NetBeans que ja traz tudo pre-configurado e não precisa fazer muita coisa para Hibernate funcionar. Mas, como todos nos sabemos que bons programadores,desenvolvedores, etc. não ficam refém das pre-configurações de uma IDE. E isso é uma vantagem do velho e famoso Eclipse, por não contribuir para esse fim, ou seja, você usa o Eclipse por gostar dele e nao por ele fazer as coisas por você ;).
Lets go…

Sobre Aplicação

Bem, a ideia aqui é apresentar a vantagem de usar o framework Hibernate para persistência de dados, entao vamos fazer uma aplicação bem simples e ficaremos mais focado na parte do Hibernate. A nossa aplicação tem a função de gravar o nome de um visitante em um base de dados(MySQL).

Sobre o Hibernate – para não duplicar o que ja tem na net, lá vai a “reutilização da informação” 😉 O que é hibernate?

Download Hibernate – ponto importante, nesse final de semana fiquei tentando colocar a ultima versão do hibernate para funcionar porem nao tive sucesso, com a ultima versão, veio faltando uns .jars e até agora não descobrir o motivo, estou pesquisando e verificando se não é um problema local na hora de descompactar o pacote. Em função disso usei uma versão mais antiga a 3.2.1.ga e no link acima disponibilizei apenas os .jars do hibernate da versao que está sendo utilizado nesse post.

Download Hibernate versão 3.3.2.GA – essa eh a ultima versão que consta no site Hibernate.org neste momento que escrevo o post. Porém, nao estamos usando ela.

Requisitos:
Eclipse Galileo (versão em uso para este post)
JDK 1.5
Hibernate 3.2.1 (versão em uso para este post)
Jboos tools no Eclipse
MySql (vamos considerar que criou o DataBase e Table no BD)
TomCat 5.5/Superior

Alguns problemas:
Para adiantar, identifiquei alguns “problemas” que podem tirar você do sério. Quando você cria um Library no Eclipse e add este ao seu projeto, os arquivos .jars não vão para a pasta lib. E se vc tentar adicionar .jars diretamente ao projeto este também não vai parar no diretorio lib do projeto. Não sei porque o Eclipse não faz isso, desde do dynamic web project há este problema. Em função disso é necessário copiar os .jars do Hibernate para a pasta lib do seu projeto. Abaixo uma imagem dos .jars necessário para que o hibernate funcione. Não esqueça do arquivo .jar do MySql na pasta lib do projeto.

Iniciando

1.crie um projeto JSF PROJECT
2.Agora crie uma página index.jsp com o código a seguir

3.crie uma pagina sucesso.jsp com o código abaixo.

< f:view>

< h:outputText value=“Visitante, cadastrado com sucesso!”/>

< /f:view>

4.Crie uma estrutura conforme abaixo no seu projeto. A seguir vamos apresentar os codes de cada classe, não se preocupe.

5.Agora vamos criar os arquivos de configuração e conexao com o BD via Hibernate. Para isso crie dois arquivos no formato .xml (hibernate.cfg.xml e visitantes.hbm.xml), estes devem estrar dentro de Source. Sua estrutura deve estar conforme abaixo:

Pronto, terminamos a configuração do ambiente de desenvolvimento, agora vamos a parte mais interessante.

Desenvolvimento
1.precisamos criar um Bean para nossa aplicação, então abra o arquivo Visitante.java e deixe conforme o code a seguir:

public class Visitante {
private String nome;
private int id;
public int getId() {
return id;}
public void setId(int id) {
this.id = id;}
public String getNome() {
return nome;}
public void setNome(String nome) {
this.nome = nome;}}

2.Agora vamos criar o controlador JSF para isso abra o arquivo VisitanteControler.java e deixe conforme o code abaixo:

import br.com.bean.Visitante;
import br.com.dao.InterfaceDAO;
import br.com.dao.VisitanteDAO;
//classe controladora JSF
public class VisitanteControler {
private Visitante visitante;
public VisitanteControler() {
visitante  = new Visitante();	}
public Visitante getVisitante() {
return visitante;	}
public void setVisitante(Visitante visitante) {
this.visitante = visitante;}
public String salvar(){
InterfaceDAO visitantedao = new VisitanteDAO();
visitantedao.salvar(visitante);
return "salvar";}}

3.O objetivo agora é configurar e fazer o mapeamento com Hibernate. Para isso atualize o arquivo hibernate.cfg.xml conforme o codigo a seguir:

    <?xml version=“1.0” encoding=“UTF-8”?>

<!DOCTYPE hibernate-configuration PUBLIC

“-//Hibernate/Hibernate Configuration DTD 3.0//EN”

“http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd” >

<!– CONFIGURANDO O HIbernate –>

<hibernate-configuration>

<session-factory>

<property name=“hibernate.connection.driver_class”>org.gjt.mm.mysql.Driver</property>

<property name=“hibernate.connection.url”>jdbc:mysql://localhost/livraria</property>

<property name=“hibernate.connection.username”>camilo</property>

<property name=“hibernate.connection.password”>integrator</property>

<!– USADO PELO HIBERNATE PARA SE COMUNICAR COM O BD –>

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

<mapping resource=“visitantes.hbm.xml”/> <!– pega a tabela –>

</session-factory>

</hibernate-configuration>

 

4.Agora atualize o arquivo visitantes.hbm.xml

< hibernate-mapping>

<!– INFORMANDO O LOCAL DO BEAN E O NOME DA TABELA NO BD –>

<class name=“br.com.bean.Visitante” table=“visitante”>

<!– CHAVE PRIMARIA DA TABELA –>

<id column=“id” name=“id” type=“integer”>

<generator class=“assigned”/>

</id>

<property column=“nome” name=“nome” type=“string”/>

</class>

</hibernate-mapping>

5.Abra o arquivo ConexaoHi.java e insira os codigos a seguir:

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
//classe que conecta ao Hibernate
public class ConexaoHi {
//variavel que armazena os mapeamentos e configuracoes do Hibernate
private static final SessionFactory sessionFactory;
private static final ThreadLocal threadlocal = new ThreadLocal();
static{
try{
sessionFactory = new Configuration()
.configure("hibernate.cfg.xml")
.buildSessionFactory();
/*recebemos a configuracao do arquivo hibernate.cfg.xml que possui
*dados da conexao
* chamamos o metodo buildSessionFactory que retorna um objeto
* session, que estabelece uma sessao de comunicacao com o BD
* atraves de uma conexao JDBC */
}catch (Throwable e) {
throw new ExceptionInInitializerError(e);}
}
/* esse metodo associada cada sessao a um objeto, permitindo que
 * cada sessao abra um processo concorrente  */
public static Session getInstance(){
Session session = (Session) threadlocal.get();
session = sessionFactory.openSession();
threadlocal.set(session);
return session;}}

6.Atualize o arquivo VisitanteDAO.java

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import br.com.bean.Visitante;
import br.com.util.ConexaoHi;
//com hibernate
public class VisitanteDAO implements InterfaceDAO {
private Session session;
//metodo responsavel por salvar os dados no BD
public void salvar(Visitante visitante){
session = ConexaoHi.getInstance();//cria uma sessao
Transaction tx = null; //permite transacoes no BD
try{
tx = session.beginTransaction();
session.save(visitante);//grava no BD
tx.commit();//transacao efetuada
}catch (HibernateException e) {
System.out.println("deu merda aqui");
e.printStackTrace();
//tem o objetivo de desfazer a transcao em caso de erro
tx.rollback();
}finally{
session.close();}}}

7.Seu arquivo InterfaceDAO.java deve estar assim:

import br.com.bean.Visitante;
public interface InterfaceDAO {
public abstract void salvar(Visitante visitante);
}

8.Não podemos esquecer de configurar o arquivo faces-config.xml, para isso deixe conforme o code a seguir :

  visitanteControler
  br.com.controller.VisitanteControler
  session

  /form.jsp

   salvar
   /sucesso.jsp

9.Agora atualize os arquivos .jsp, começando pelo form.jsp

Pronto, terminamos o desenvolvimento, chegou a hora de testar…

Testando
1.para testar aplicação clique com o botão direto em cima do projeto e escolha Run As – Run on Server.
2.Aguarde o browser interno do eclipse seja carregado (por padrão será ele). E você verá a seguinte tela:

3.Cadastre um visitante


4.Verificando visitante no BD


Vou ficando por aqui e espero que vocês tenham gostado do post. Um pouco grande, porem bastante produtivo. Vejam a essencia e as vantagens de usar um framework como Hibernate para persistência de dados.
Abracos e até o proximo post…

JSF com JBoss Tools no Eclipse

olá Pessoal,

Hoje vou mostrar como instalar o Jboss Tools para quem desejar usar o framework JavaServerFaces (JSF) no Eclipse por exemplo. Jboss tools não contempla apenas JSF, vc pode desenvolver aplicações usando o framework Struts também. Observe como é bem simples configurar JSF, Struts no Eclipse.

*Nas versões mais recentes do Netbeans(acredito que desde da versão 6.x.x) o JSF já vem configurado na IDE, então o desenvolvedor não precisa se preocupar em montar um ambiente. No Eclipse sabemos que isso não acontece, você desenvolvedor que deve montar no seu Eclipse o ambiente de acordo com as tecnologias que realmente precisa, isso é uma vantagem enorme no ambiente de desenvolvimento.Claro que é possível fazer isso no NetBeans, mas teremos um pouco mais de trabalho.

Lets go…

Antes de entrar no post queria chamar atenção dos alunos que estão na fase do TCC ou que vão entrar nessa fase. Abaixo tem um post bem legal, de um aluno o qual ele relata sobre o projeto de TCC dele, vejam como o TCC influenciou na carreira acadêmica e consequentemente profissional do Junior(até famoso ele ficou, dando palestra e saindo em jornal). Realmente o Junior desenvolveu um excelente trabalho, a seguir o link para o relato e com autorização do autor coloquei na seção de Download do blog a monografia dele para download.

Parabéns!! E realmente é gratificante ver alunos como você, com o objetivo de fazer algo legal assim. Você não fez qualquer TCC para pegar somente o famoso canudo :D. Fica ai mais um exemplo para os alunos que vão entrar ou já estão nessa fase de TCC.

Post Legal:

Como ser contratado pela IBM: veja um post legal da IBM sobre como fazer parte do Team deles.

Sobre Jboss tools

JBoss Tools é um conjunto de plugins para o Eclipse onde pode trabalhar com o servidor de aplicação e frameworks da JBoss, como Hibernate, Seam, jBPM, Drools, Richfaces, dentre outros(JSF,Struts etc).

Para este post: estamos usando o Eclipse Galileo

  1. Faça o download do Eclipse: http://www.eclipse.org/

  2. Faça o download do Jboss Tools de acordo com a versão do Eclipse que está usando: http://www.jboss.org/tools/download

  3. Vídeo de Instalação da ferramenta no Eclipse, veja:


*Se não conseguir visualizar o video acesse este link.

  • este vídeo foi desenvolvido pelo meu amigo e autor Edson Gonçalves e claro, com autorização do mesmo, resolvi publicar aqui no blog, ao invés de ter vários printscreen. Vejam que em questão de minutos você tem o ambiente pronto para desenvolvimento. Jboss tools considero uma excelente ferramenta para desenvolvimento JEE com os frameworks já citados. Enjoy!!

Criando um Projeto JSF no Eclipse com Jboss Tools

  1. Clique File ==> New ==> Project


  2. Vá até o caminho abaixo e escolha JSF Project


  3. Na próxima tela você deve definir o nome do projeto e versão JSF utilizar. Se quiser deixe conforme a imagem a seguir:

  4. Na tela seguinte definimos o servidor de aplicação nesse caso, vou usar o TomCat. Certifique-se de te-lo instalado no seu computador

  5. clique em finish e teremos a imagem a seguir:


  6. Observe que temos toda a estrutura JSF pronta para uso. Observe o famoso arquivo faces-config.xml

Como o objetivo deste post não é mostrar o uso de JSF, e sim apenas sua configuração no Eclipse, não vamos avançar com essa parte aqui, quem sabe no próximo post…

Espero que tenham gostado deste post, agradeço ao amigo Edson, por ter cedido o vídeo. Ah não esquece de voltar em nosso blog.

Ajude nosso blog crescer e vote :

Top30 Brasil - Vote neste site!.