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.

9 comentários em “JPA com Java Básico MySql”

    1. olá! Rafael,
      Nao existe IDE preferida, existe aquela que é melhor para desenvolver de acordo com o projeto. veja aqui
      O “br.com” questao de padrão apenas, poderia ser qualquer outra coisa.

      abracos,

  1. Olá, o meu remove esta dando erro. esta igual ao seu porém não remove nada i sim aparece um erro.

    java.lang.NullPointerException
    at org.eclipse.persistence.internal.jpa.EntityManagerImpl.getActivePersistenceContext(EntityManagerImpl.java:1571)
    at org.eclipse.persistence.internal.jpa.transaction.EntityTransactionImpl.begin(EntityTransactionImpl.java:49)
    at br.com.integrator.dao.DaoGeneric.remove(DaoGeneric.java:44)
    at br.com.integrator.teste.TesteDaJPA.main(TesteDaJPA.java:29)

    1. ola salatiel,

      eu olhei o codigo da aplicacao aqui e ta normal, nao tem nada diferente, a excecao acima é conceitos basicos do java, dar uma olhadinha com cautela no seu codigo. principalmente no seu dao.
      abracos

  2. So um recado, a sua classe ClienteDAO nao implementa o padrao Data Access Object. De DAO so o nome mesmo! O que aconteceria se ao inves de acessar banco de dados com JPA eu precisa-se ler arquivos XML? ou texto? Ou qualquer outra API? Ou passar a buscar e cadastrar clientes em uma aplicacao externa (quem sabe invocando webservices)?

    O re-trabalho seria grande!

    Digo isso, pois ja vi esse engano mesmo em aplicacoes ditas “profissionais”! Onde do padrao DAO, restou apenas o “nome”!

    []’s

    1. Olá Valter,

      obrigado por comentar. Seu comentário realmente é válido. Mas, o objetivo do post não é apresentar boas práticas com DAO. E sim apresentar usar JPA de maneira simples e prática.Claro que no dia-dia o ideal é que teu DAO seja genérico.Mas, o fato de eu não ter o meu DAO genérico não quer dizer que não tenho um DAO. O ponto chave e que na minha opinião que fere o conceito do DAO é quando ele passa ter lógica de negócio, ai sim é um fator forte. De novo tê-lo generico seria o ideal, mas o fato dele não ser generico não quer dizer que o conceito de DAO não foi implementado.

      abracos

Deixe um comentário

O seu endereço de e-mail não será publicado.