Named query with entity in JPA
This is an example of how to create a named query with an entity in JPA. The Java Persistence API provides Java developers with an object/relational mapping facility for managing relational data in Java applications. A named query is a predefined query that you create and associate with a container-managed entity. The named queries are stored on the EntityManager
. At run time, you can use the EntityManager
to acquire, configure, and execute a named query. Here we create an entity with a named query and use in with EntityManager
.
The Employee class
The Employee
class is an entity class, annotated with the javax.persistence.Entity
annotation. It has a named query, in the @NamedQuery
annotation, where we set the name of the query and the sql query. It uses the @Id
annotation to define its id property, and the @GeneratedValue
annotation with strategy set to GenerationType.AUTO
so that the id gets auto-generated values. In another property, it uses the @OneToMany
annotation to define a one-to-many relationship to another entity. With the @JoinTable
it creates a join between the two entities, defining the columns to be joined and the name of the join table.
package com.javacodegeeks.snippets.enterprise; import java.util.ArrayList; import java.util.Collection; import java.util.Date; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.JoinTable; import javax.persistence.ManyToOne; import javax.persistence.NamedQuery; import javax.persistence.OneToMany; @Entity @NamedQuery(name="findEmployeeByName", query="SELECT e FROM Employee e " + "WHERE e.name = ?1") public class Employee { @Id @GeneratedValue(strategy=GenerationType.AUTO) private Long id; private String name; private String surname; private String title; private Date created; @OneToMany @JoinTable(name = "EMP_PHONE", joinColumns = @JoinColumn(name = "EMP_ID"), inverseJoinColumns = @JoinColumn(name = "PHONE_ID")) private Collection<Phone> phones; @ManyToOne private Department department; public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSurname() { return surname; } public void setSurname(String surname) { this.surname = surname; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public Date getCreated() { return created; } public void setCreated(Date created) { this.created = created; } public void addPhone(Phone phone) { if (phones==null) { phones = new ArrayList<Phone>(); } if (!phones.contains(phone)) { phones.add(phone); } } public Collection<Phone> getPhones() { return phones; } public Department getDepartment() { return department; } public void setDepartment(Department department) { this.department = department; } @Override public String toString() { return "Employee [id=" + id + ", name=" + name + ", surname=" + surname + ", title=" + title + ", phones=" + phones + "]"; } }
The NamedQueryWithEntityInJPA class
In the NamedQueryWithEntityInJPA class we create we create an EntityManagerFactory
interface to interact with the entity manager factory for MyPeristenceUnit
, that is defined in persistence.xml
file. We create an EntityManager, using the createEntityManager()
API method. Then, we create a new Employee
object. The new object is writen to the database, using the persist(java.lang.Object entity)
API method of EntityManager
. The getTransaction().begin()
and getTransaction().commit()
methods are used before and after the EntityManager
invokes a method so that a transaction begins and ends. The object can be retrieved using the named query, in the createNamedQuery(java.lang.String name)
API method of EntityManager
.
package com.javacodegeeks.snippets.enterprise; import java.util.Date; import java.util.List; import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence.Persistence; import javax.persistence.Query; public class NamedQueryWithEntityInJPA { @SuppressWarnings("unchecked") public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("MyPersistenceUnit"); EntityManager em = emf.createEntityManager(); em.getTransaction().begin(); Employee employee1 = new Employee(); employee1.setName("Jack"); employee1.setSurname("Thomson"); employee1.setTitle("QA Engineer"); employee1.setCreated(new Date()); em.persist(employee1); Employee employee2 = new Employee(); employee2.setName("Mary"); employee2.setSurname("Nickolson"); employee2.setTitle("QA Engineer"); employee2.setCreated(new Date()); em.persist(employee2); em.getTransaction().commit(); em.getTransaction().begin(); Query query = em.createNamedQuery("findEmployeeByName"); query.setParameter(1, "Jack"); List<Employee> employees = (List<Employee>) query.getResultList(); System.out.println("employees " + employees); em.getTransaction().commit(); em.close(); emf.close(); } }
persistence.xml
<persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd" version="2.0"> <persistence-unit name="MyPersistenceUnit" transaction-type="RESOURCE_LOCAL"> <provider>org.hibernate.ejb.HibernatePersistence</provider> <properties> <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" /> <property name="hibernate.hbm2ddl.auto" value="update" /> <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" /> <property name="hibernate.connection.username" value="jcg" /> <property name="hibernate.connection.password" value="jcg" /> <property name="hibernate.connection.url" value="jdbc:mysql://localhost/companydb" /> </properties> </persistence-unit> </persistence>
Output:
employees [Employee [id=1, name=Jack, surname=Thomson, title=QA Engineer, phones=null]]
This was an example of how to create a named query with an entity in JPA.