JPA Using NetBeans and MySQL

In this article you will learn how to quickly get started with JPA. I will be using NetBeans and MySQL database to store data using JPA. If you have MySQL running, all you have to do is follow the steps below.

First let’s create a database that we will be using later on. From the command line you can just run the following command. Note, I will be using “JPA” as the name of my database for this tutorial.

create database JPA;

Now we are ready to fire up NetBeans and get started. Once NetBeans is loaded, created a new “Java Application” project and give it a name. In my case I named it “JPA”. Go ahead and delete the generated java class file, we will create our own.

[[{"type":"media","view_mode":"media_large","fid":"158","attributes":{"alt":"","class":"media-image","height":"331","width":"480"}}]]

[[{"type":"media","view_mode":"media_large","fid":"159","attributes":{"alt":"","class":"media-image","height":"331","width":"480"}}]]

Now, right click on the (in my case) “JPA” package, select new, other, persistence, Entity Class as shown in the picture below.

[[{"type":"media","view_mode":"media_large","fid":"161","attributes":{"alt":"","class":"media-image","height":"299","width":"480"}}]]

Give new entity class a name, in my case I left it as the default name the IDE provided “NewEntity”. Click next and from database connection select “new database connection” and look for MySQL as shown in the picture below.

[[{"type":"media","view_mode":"media_large","fid":"162","attributes":{"alt":"","class":"media-image","height":"358","width":"480"}}]]

Click next, and a configuration window should show up for setting up the connection to the MySQL database. In my case the database is running on a remote server but I have HeidiSQL connected through SSH tunnel on local port 3307. So I used the following configurations.

package jpa;

import java.io.Serializable;
import java.util.Objects;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class NewEntity implements Serializable {
  private static final long serialVersionUID = 1L;
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO) private Long id;
  @Column(length = 100)
  private String name;

  public String getName() {
   return name;
  } 
  public void setName(String name) { 
    this.name = name; 
  } 
  public Long getId() { 
    return id; 
  }
  public void setId(Long id) { 
    this.id = id; 
  } 

  @Override public int hashCode() {
    int hash = 7; 
    hash = 59 * hash + Objects.hashCode(this.id); 
    hash = 59 * hash + Objects.hashCode(this.name); 
    return hash; 
  } 
  @Override public boolean equals(Object obj) {
    if (obj == null) {
     return false; 
    } 
    if (getClass() != obj.getClass()) { 
      return false; 
    } 
  final NewEntity other = (NewEntity) obj;
    if (!Objects.equals(this.id, other.id)) { 
      return false; 
    } 
    if (!Objects.equals(this.name, other.name)) {
     return false;
    } 
    return true; 
  } 
  @Override public String toString() {
    return "jpa.NewEntity[ id=" + id + " ]"; 
  } 
}

package jpa;
 
import java.io.Serializable;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import jpa.exceptions.NonexistentEntityException;
 
public class NewEntityJpaController implements Serializable {
 
public NewEntityJpaController(EntityManagerFactory emf) {
this.emf = emf;
}
private EntityManagerFactory emf = null;
 
public EntityManager getEntityManager() {
return emf.createEntityManager();
}
 
public void create(NewEntity newEntity) {
EntityManager em = null;
try {
em = getEntityManager();
em.getTransaction().begin();
em.persist(newEntity);
em.getTransaction().commit();
} finally {
if (em != null) {
em.close();
}
}
}
 
public void edit(NewEntity newEntity) throws NonexistentEntityException, Exception {
EntityManager em = null;
try {
em = getEntityManager();
em.getTransaction().begin();
newEntity = em.merge(newEntity);
em.getTransaction().commit();
} catch (Exception ex) {
String msg = ex.getLocalizedMessage();
if (msg == null || msg.length() == 0) {
Long id = newEntity.getId();
if (findNewEntity(id) == null) {
throw new NonexistentEntityException("The newEntity with id " + id + " no longer exists.");
}
}
throw ex;
} finally {
if (em != null) {
em.close();
}
}
}
 
public void destroy(Long id) throws NonexistentEntityException {
EntityManager em = null;
try {
em = getEntityManager();
em.getTransaction().begin();
NewEntity newEntity;
try {
newEntity = em.getReference(NewEntity.class, id);
newEntity.getId();
} catch (EntityNotFoundException enfe) {
throw new NonexistentEntityException("The newEntity with id " + id + " no longer exists.", enfe);
}
em.remove(newEntity);
em.getTransaction().commit();
} finally {
if (em != null) {
em.close();
}
}
}
 
public List<NewEntity> findNewEntityEntities() {
return findNewEntityEntities(true, -1, -1);
}
 
public List<NewEntity> (int maxResults, int firstResult) {
return findNewEntityEntities(false, maxResults, firstResult);
}
 
private List<NewEntity> (boolean all, int maxResults, int firstResult) {
EntityManager em = getEntityManager();
try {
CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
cq.select(cq.from(NewEntity.class));
Query q = em.createQuery(cq);
if (!all) {
q.setMaxResults(maxResults);
q.setFirstResult(firstResult);
}
return q.getResultList();
} finally {
em.close();
}
}
 
public NewEntity findNewEntity(Long id) {
EntityManager em = getEntityManager();
try {
return em.find(NewEntity.class, id);
} finally {
em.close();
}
}
 
public int getNewEntityCount() {
EntityManager em = getEntityManager();
try {
CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
Root<NewEntity> rt = cq.from(NewEntity.class);
cq.select(em.getCriteriaBuilder().count(rt));
Query q = em.createQuery(cq);
return ((Long) q.getSingleResult()).intValue();
} finally {
em.close();
}
}
}

In this class we will create our entityManagerFactory and set a name to the column we created with the @Column annotation in NewEntity.java class. Here is the code:

package App;
 
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import jpa.NewEntity;
import jpa.NewEntityJpaController;
 
public class Application {
public static void main (String args[]) {
EntityManagerFactory objFactory = Persistence.createEntityManagerFactory("JPAPU");
EntityManager manager = objFactory.createEntityManager();
NewEntity record = new NewEntity();
NewEntityJpaController jpa = new NewEntityJpaController(objFactory);
List<NewEntity> list = jpa.findNewEntityEntities();
 
record.setName("Test");
 
jpa.create(record);
 
for (NewEntity l : list) {
System.out.println("Cod.: "+l.getId()+"\nName.: "+l.getName());
 }
}
}

Make sure the persistence-unit name from the persistence.xml file is what you are using in line 12. EntityManagerFactory objFactory = Persistence.createEntityManagerFactory("JPAPU");

Here is how it looks in persistence.xml:  <persistence-unit name="JPAPU" transaction-type="RESOURCE_LOCAL">

Now you are ready to run the project and see that it created a table NewEntity in JPA database and a column “name” with the word “test” in it or whatever you have put in the code. Here is a screenshot of my database after I ran the code.