JPA com Java Básico MySql

olá pessoal, nesse post vou apresentar como fazer persistência de dados usando apenas JPA, mas com Java Básico o objetivo é ajudar aqueles que estão dando o primeiro passo com a tecnologia. Não confunda este post com este Java Básico + Hibernate JPA + Mysql são parecidos, mas aqui nos não vamos envolver nada de Hibernate, ou seja, será 100% JPA.

Recomendado: Você vai precisar configurar a JPA no seu projeto Java, portanto veja no post abaixo:

*Basta adicionar ao seu projeto o arquivo .jar referente a JPA do pacote hibernate annotations. Nada mais que isso, confira: Java Básico + Hibernate JPA + Mysql

Outros posts relacionados:

Preparando o ambiente desenvolvimento

  1. crie um Java project no eclipse

  2. E monte conforme a estrutura abaixo:

  3. A classe TesteJPA  deve conter o método main.

  4. Não esqueça de adicionar o .jar ao seu projeto. Se tem dúvida com fazer isso veja nos posts citados acima.

Preparando Banco de Dados

Vamos usar o MySql como BD e vou levar em conta que você já tem o mesmo instalado e configurado. Crie apensa um DataBase e uma table para este. Se quiser seguir o exemplo do post o nosso ficou assim:

DataBase: sistemas Table: Cliente

A tabela cliente possui os seguintes campos como VARCHAR(nome,cidade,sobrenome)e um Integer(id). O id é auto_increment e chave-primaria da tabela.

Desenvolvimento

Explicando as anotações
@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 você não 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 ;

Deixe sua classe Cliente.java conforme abaixo:

package br.com.bean;
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 {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
	private int id;
	private String nome;
	private String cidade;
	private String sobrenome;

	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;
	}
	public String getCidade() {
		return cidade;
	}
	public void setCidade(String cidade) {
		this.cidade = cidade;
	}
	public String getSobrenome() {
		return sobrenome;
	}
	public void setSobrenome(String sobrenome) {
		this.sobrenome = sobrenome;
	} }

A classe ClienteDAO é responsável por implementar o CRUD usando a JPA, vamos ver aqui o salvar, excluir e atualizar. Então atualize seu arquivo ClienteDAO.java conforme abaixo:

package br.com.dao;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import br.com.bean.Cliente;

public class ClienteDAO {

	EntityManagerFactory emf; 

	private EntityManager getEntityManager(){
		return emf.createEntityManager();
	}
	public ClienteDAO() {
	emf = Persistence.createEntityManagerFactory("sistemas");
	}

	public void salvar(Cliente cliente){
		EntityManager em = getEntityManager();
		try{
			em.getTransaction().begin(); //inicia o processo de transacao
			em.persist(cliente);//permite fazer insercoes e atualizacoes no bd
			em.getTransaction().commit();//realizo as alteracoes no banco
		}catch (Exception e) {
			em.getTransaction().rollback();// se rolar uma excecao cancelo acao
			e.printStackTrace();//mostro o percurso de onde veio as excecoes
		}finally{
			em.close();
		}
	}
	public void excluir(Cliente cliente){
		EntityManager em = getEntityManager();

		try{
			em.getTransaction().begin();
			cliente = em.merge(cliente);
			em.remove(cliente);
			em.getTransaction().commit();
		}catch (Exception e) {
			em.getTransaction().rollback();
		}
	}
	public void atualizar(Cliente cliente){
		EntityManager em = getEntityManager();
		try{
			em.getTransaction().begin();
			em.merge(cliente);
			em.getTransaction().commit();
		}catch (Exception e) {
			em.getTransaction().rollback();
		}}
	}
  1. Fazendo a persistência de dados no arquivo persistence.xml. Precisamos passar as informações do BD, user, password etc para o arquivo persistence.xml, assim conseguimos a conexao com o nosso BD. Então atualize o arquivo .xml conforme o code abaixo(tive que dar um espaco entre os <  >  pois o plugin para code não estava reconhecendo com XML):

    org.hibernate.ejb.HibernatePersistence
    < persistence-unit name="sistemas" transaction-type="RESOURCE_LOCAL">
    org.hibernate.ejb.HibernatePersistence
            
    		br.com.bean.Cliente
    
                
                < property name="hibernate.dialect" value="org.hibernate.dialect.MySQLInnoDBDialect" />
                < property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
                < property name="hibernate.connection.url" value="jdbc:mysql://localhost/sistemas" />
                < property name="hibernate.connection.username" value="camilo" />
                < property name="hibernate.connection.password" value="integrator" />
     
                < property name="hibernate.show_sql" value="true" />
                < property name="hibernate.format_sql" value="true" />
                < property name="use_sql_comments" value="true" />
    
            < /properties>
    
        < /persistence-unit>
  2. Atualizando a classe TesteCliente.java. Precisamos ter uma classe para testar o nosso CRUD com JPA. Para isso teremos uma classe java tradicional com o método main. Eu comentei algumas linhas apenas para poder testar outros recursos. Mas, levando em conta que sua table não há nenhuma informação, vamos executar primeiramente a opção salvar.

    package br.com.teste;
    
    import br.com.bean.Cliente;
    import br.com.dao.ClienteDAO;
    
    public class TesteCliente {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		ClienteDAO clidao = new ClienteDAO();
    		Cliente cliente = new Cliente();
    	//	cliente.setCidade("salvador");
    		cliente.setNome("recife");
    		cliente.setSobrenome("neto");
    		//cliente.setId(12);
    		clidao.salvar(cliente);
    		//clidao.excluir(cliente);
    	//cliente.setCidade("Sao Paulo");
    		//cliente.setId(15);
    		//clidao.atualizar(cliente);
    	}
    }

Não Esqueça:

  • Esteja certo que você deu um start no seu BD.

  • não esqueça dos .jars no seu projeto.

Verificando dados no BD

  1. Acesse seu banco de dados e veja se a informação inserida realmente consta na tabela. Aqui usei uma ferramenta chamada Mysql Query Browser para facilitar o trabalho com o BD. No meu caso eu fiz varias alterações.

Vou ficado por aqui e espero que tenham gostado do post. Para quem está em primeiro contato com a tecnologia pode parecer difícil, estranho ou complicado essa estrutura da JPA, mas pode ter certeza que é mais produtivo no ciclo de desenvolvimento.

Abraços e até o próximo post.

JPA com Jboss

womanjava

olá pessoal, nesse post vou mostrar como criar um JPA Project e seus beneficios através da ferramenta Jboss Tools. Em um dos meus posts eu expliquei como instalar e configurar o Jboss tools no eclipse.

Montar uma estrutura JPA na “mão-grande” é um pouco cansativo e não tão produtivo quando se tem auxilio de uma ferramenta como Jboss tools. Nao estou dizendo que a ferramenta vai programar por você, ela apenas vai fazer a parte operacional não relacionada a programação, e você como bom desenvolvedor vai estar focado na parte lógica do negócio.

Lets go…

Outros posts:

  1. Abra o Eclipse e o seu workspace (uma vez que tenha instalado o plugin Jboss tools)

  2. Clique em New ==> Project

  3. Na lista que aparece vá até o diretório JPA.

  4. Escolha JPA Project, conforme a imagem abaixo:

    japproject

  5. Clique em next e na próxima pagina vamos dar o nome ao projeto e configurar o servidor. Aqui estamos usando o TomCat. Veja na imagem a seguir:

    namejpa

  6. Clique em next duas vezes. Até encontrar a tela a seguir. Agora precisamos configurar JPA e a plataforma. Depois clique em Finish

    jpaeclipse

  7. Pronto! Agora vc ja tem um projeto apto a usar JPA com os .jars adicionados estrutura ja montada pelo Jboss tools. Confira na imagem abaixo:

    jpaestrutura

Se você não conhecia o Jboss tools fica ai um pouquinho como a ferramenta pode ajudar no dia-dia.. 😉

Abraços! See you later…


Follow me: http://twitter.com/camilolope

Java Básico + Hibernate JPA + Mysql


olá Pessoal,
Recebi alguns emails pedindo para criar um post mais puro com Hibernate + JPA, ou seja, sem o uso de JSF. Atendendo aos pedidos, montei um post bem simples, onde vamos criar a nossa velha classe Java com o método main e armazenar as informações em um BD (MySql) tendo o Hibernate como framework de persitencia. Entao se você deseja dar os primeiros passos usando os frameworks: Hibernate + JPA para persistencia de dados nao deixe de ler o post a seguir.
Lets go..
Outros posts.
– JSF + Hibernate + MySql no Eclipse
– Hibernate Annotations + JSF + MySql
– Busca com Hibernate Annotation + JSF
Atenção: Não apresentarei como criar um DB ou configurar o Hibernate no Eclipse. Qualquer dúvida consulte um dos posts acima. Vou considerar que você já tem um ambiente de desenvolvimento pronto para entrar em ação.
Dados do DataBase:

  • Crie um DataBase (usarei uma chamada livraria)
  • crie uma tabela (usarei uma tabela com o nome camilo )
  • Dados da tabela: id(auto_increment), nome(varchar), cidade(varchar)
  • Preparação do projeto
    1.Crie um o Java Project no Eclipse com o nome que achar conveniente.
    2.Agora crie uma estrutura de packages conforme a imagem a seguir

    3.Adicione os arquivos .jars do mysql, hibernate + JPA ao projeto. Clique com o botão direito no projeto escolha Properties e depois clique em JavaBuild. Na tela que aparece clique em Add external jars. (Caso nao tenha uma Library para os .jars )

    Desenvolvimento/Teste
    1.Agora crie uma classe Java com nome de Pessoa no package br.com.bean.

    package br.com.bean;
    /*se os arquivos .jars nao estiver no projeto
     * nao será possivel encontrar os imports
     */
    import javax.persistence.Entity;
    import javax.persistence.Id;
    import javax.persistence.Table;
    @Entity
    @Table(name="camilo")
    public class Pessoa {
    	
    	private String nome; 
    	private String cidade; 
    	@Id
    	int id;
    	public String getNome() {
    		return nome;
    	}
    	public void setNome(String nome) {
    		this.nome = nome;
    	}
    	public String getCidade() {
    		return cidade;
    	}
    	public void setCidade(String cidade) {
    		this.cidade = cidade;
    	}
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	
    }

    2.Crie uma classe ConexaoHibert.java no package br.com.conexao

    private static final SessionFactory sessionFactory;
    	private static final ThreadLocal threadLocal = 
    		new ThreadLocal();
    	/* observe o que temos de importante 
    	 * nesse bloco static, o arquivo
    	 * que possui os dados de conexao com 
    	 * o banco de dados hibernateconfig.xml 
    	 */
    	static{
    		try{
    			sessionFactory = new  AnnotationConfiguration().
    			configure("hibernateconfig.xml")
    			.buildSessionFactory();
    		
    		}catch (Throwable e) {
    			throw new ExceptionInInitializerError(e);
    		}
    	}
    	//retorna uma sessao de comunicacao com o BD
    	public static Session getInstance(){
    		Session session = (Session) threadLocal.get();
    		session = sessionFactory.openSession();
    		threadLocal.set(session);
    		return session;
    	} 

    3.Crie uma class PessoaDAO no package br.com.hibernatedao

    package br.com.hibernatedao;
    
    import org.hibernate.Session;
    import org.hibernate.Transaction;
    
    import br.com.bean.Pessoa;
    import br.com.conexao.ConexaoHibert;
    
    public class PessoaDAO {
    	private Session session;
    	
    	public void Salvar(Pessoa p){
    		//obtem uma sessao
    		session = ConexaoHibert.getInstance();
    		Transaction tx = null; //permite transacao com o BD 
    		
    		try{
    			tx = session.beginTransaction();
    			session.save(p);
    			tx.commit();//faz a transacao
    		}catch (Exception e) {
    			e.printStackTrace();
    			//cancela a transcao em caso de falha
    			tx.rollback();
    		}finally{
    			session.close();
    		}}}
    

    4.Agora crie uma arquivo .xml em source conforme o code abaixo:

    
    
    
     
      org.gjt.mm.mysql.Driver
    
      jdbc:mysql://localhost/livraria
    
      camilo
      integrator
      
     
    
    

    Fique atento aos nomes usado na class Pessoa.java para fazer anotação. Veja que eu tenho o nome da tabela no BD diferente do nome da minha class Java (fiz de proposito). Então somos obrigado a definir o name da tabela, caso contrario a JPA vai considerar o nome da classe.
    5.Agora crie uma classe no package br.com.teste com o nome de PessoaTest.java.

    package br.com.teste;
    
    import br.com.bean.Pessoa;
    import br.com.hibernatedao.PessoaDAO;
    
    public class PessoaTest {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		Pessoa p = new Pessoa(); 
    		p.setNome("mel"); 
    		p.setCidade("Salvador");
    		PessoaDAO pdao = new PessoaDAO(); 
    			pdao.Salvar(p);	}}
    

    6.Salve e execute a classe PessoaTest.java e verifique se os dados foram inseridos no BD.

    Pronto!Bem simples não? E menos cansativo que usar o velho padrão DAO. Espero que tenham gostado do post. Abracos e até o proximo post…


    Follow me: http://twitter.com/camilolope

    Busca com Hibernate Annotation + JSF

    olá Pessoal,
    Neste post resolvi, apresentar um recurso bem simples que temos no hibernate usando a linguagem HQL. Tendo como exemplo aplicação construida no post anterior: Hibernate+ Annotations, iremos apenas neste post criar 2 paginas JavaServerFaces – JSF, e alterar alguns arquivos .java para implementar um sistema de busca no sistema. A ideia aqui é mostrar a facilidade que o framework possibilita, sem falar que nao precisa modificar quase nada do que ja foi construido, apenas adicionar os novos recursos.
    Lets go…

    Requisitos:
    É necessário ter implementado os posts abaixo, sobre hibernate. Aqui vamos apenas dar continuidade aplicação ja desenvolvida.
    JSF + Hibernate + MySql no Eclipse
    Hibernate Annotations + JSF + MySql

    Desenvolvendo

    1. Primeiro passo é atualizar a class NewsDAO.java inserindo o metodo que será responsavel por fazer a busca no BD.

    //realiza a pesquisa no BD
    public List consultar(String letter){
    session = ConexaoFactory.getInstance();
    /*para entender o HQL o from abaixo será seu bean
     *  o l eh como se fosse o ? que temos o sql usando
     *o PreparedStatement apos o where temos o campo 
     *de pesquisa que eh a coluna na tabela
     *  paraemtro da query para pesquisa do hibernate
     */
    
    Query query = session.createQuery("from NewsLetter l where 
    l.nome like :letter");
    List list = query.setString("letter", "%"+letter+"%").list();
    return list;}
    

    2.Agora vamos criar o metodo responsável por obter os dados no BD e armazenar esses dados em um DataModel, para facilitar a busca. Para isso temos que alterar nossa classe controladora NewsControler.java

    /*metodo que armazena o retorno da pesquisa em
    * DataTable,de acordo o retorno do metodo 
    * de pesquisa  */
    public DataModel getBuscar(){
    NewsDAO newsdao = new NewsDAO();
    /* chamando o metodo de pesquisa 
     * e passando o valor da campo digitado
     */
    model = new ListDataModel(newsdao.consultar(keynome));
    return model; }
    

    3.Agora criaremos as paginas JSF, a primeira tem o campo de busca, a segunda traz o resultado da busca.

    
    
    
    
    
    
    
    
    
    
    
    

    4.Página JSF que exibi o resultado da busca exibirpesquisa.jsp(nao esqueça de importar os tagslib para o JSF.

    ….
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    			
    
    

    Atualizando faces-config.xml

    Deixe seu arquivo faces-config.xml conforme abaixo.

    
      newsControler
      br.com.controler.NewsControler
    
      session
     
     
      news
      /news.jsp
      
       salvar
       /sucesso.jsp
      
     
     
      buscar
      /buscar.jsp
      
       pesquisar
       /exibipesquisa.jsp
      
     
    
    

    Testando

    Agora vamos testar a nossa busca, abaixo temos a imagem do nosso BD com alguns newsletter cadastrados, assim podemos nos certificar que a busca trouxe o elemento correto.

    Abraço a todos e espero que tenham gostado do post!. Até o próximo pessoal!!

    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…