Added JPA test for the new 2.1 feature of dynamically adding named

queries.

Author: arjantijms

jpa/dynamic-named-query/pom.xml

@@ -0,0 +1,15 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.javaee7.jpa</groupId>
+        <artifactId>jpa-samples</artifactId>
+        <version>1.0-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    
+    <groupId>org.javaee7.jpa</groupId>
+    <artifactId>dynamic-named-query</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <packaging>war</packaging>
+</project>

jpa/dynamic-named-query/src/main/java/org/javaee7/jpa/dynamicnamedquery/entity/TestEntity.java

@@ -0,0 +1,39 @@
+package org.javaee7.jpa.dynamicnamedquery.entity;
+
+import static javax.persistence.GenerationType.IDENTITY;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+
+/**
+ * A very simple JPA entity that will be used for testing
+ * 
+ * @author Arjan Tijms
+ *
+ */
+@Entity
+public class TestEntity {
+
+    @Id
+    @GeneratedValue(strategy = IDENTITY)
+    private Long id;
+    private String value;
+    
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+    
+}

jpa/dynamic-named-query/src/main/java/org/javaee7/jpa/dynamicnamedquery/entity/TestEntity_.java

@@ -0,0 +1,19 @@
+package org.javaee7.jpa.dynamicnamedquery.entity;
+
+import javax.persistence.metamodel.SingularAttribute;
+import javax.persistence.metamodel.StaticMetamodel;
+
+/**
+ * The meta model of our JPA entity, which we can use to refer to the Entity's attributes
+ * in a type-safe way (if only Java 8 had also introduced attribute/property references...)
+ * 
+ * @author Arjan Tijms
+ *
+ */
+@StaticMetamodel(TestEntity.class)
+public class TestEntity_ {
+    
+    public static volatile SingularAttribute<TestEntity, Long> id;
+    public static volatile SingularAttribute<TestEntity, String> value;
+
+}

jpa/dynamic-named-query/src/main/java/org/javaee7/jpa/dynamicnamedquery/service/QueryRepository.java

@@ -0,0 +1,99 @@
+package org.javaee7.jpa.dynamicnamedquery.service;
+
+import static org.javaee7.jpa.dynamicnamedquery.service.QueryRepository.Queries.TEST_ENTITY_GET_ALL;
+import static org.javaee7.jpa.dynamicnamedquery.service.QueryRepository.Queries.TEST_ENTITY_GET_BY_VALUE;
+
+import javax.annotation.PostConstruct;
+import javax.ejb.Singleton;
+import javax.ejb.Startup;
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.PersistenceContext;
+import javax.persistence.PersistenceUnit;
+import javax.persistence.TypedQuery;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.ParameterExpression;
+import javax.persistence.criteria.Root;
+
+import org.javaee7.jpa.dynamicnamedquery.entity.TestEntity;
+import org.javaee7.jpa.dynamicnamedquery.entity.TestEntity_;
+
+/**
+ * This bean's init method is called when the AS starts and dynamically creates a number of queries
+ * and sets them as named queries on the entity manager factory.
+ * <p>
+ * Dynamically adding named queries is a new feature in Java EE 7.
+ * 
+ * @author Arjan Tijms
+ *
+ */
+@Singleton
+@Startup
+public class QueryRepository {
+
+    public enum Queries {
+        TEST_ENTITY_GET_ALL, TEST_ENTITY_GET_BY_VALUE
+    }
+
+    @PersistenceUnit
+    private EntityManagerFactory entityManagerFactory;
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    @PostConstruct
+    public void init() {
+        
+        // Stores queries that were created via the Criteria API as named queries.
+        
+        // This is the Criteria alternative for the feature where JPQL queries can
+        // be placed in orm.xml files or annotations. (but note that JPQL queries can also
+        // be added here programmatically).
+        
+        entityManagerFactory.addNamedQuery(TEST_ENTITY_GET_ALL.name(), buildGetAll());
+        entityManagerFactory.addNamedQuery(TEST_ENTITY_GET_BY_VALUE.name(), buildGetByValue());
+    }
+
+    /**
+     * Builds a criteria query equal to the JPQL
+     * 
+     * <code>SELECT _testEntity FROM TestEntity _testEntity</code>
+     * 
+     *
+     */
+    private TypedQuery<TestEntity> buildGetAll() {
+        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
+
+        CriteriaQuery<TestEntity> criteriaQuery = criteriaBuilder.createQuery(TestEntity.class);
+        Root<TestEntity> root = criteriaQuery.from(TestEntity.class);
+        
+        criteriaQuery.select(root);
+
+        return entityManager.createQuery(criteriaQuery);
+    }
+    
+    /**
+     * Builds a criteria query equal to the JPQL
+     * 
+     * <code>SELECT _testEntity FROM TestEntity _testEntity WHERE _testEntity.value :value</code>
+     * 
+     *
+     */
+    private TypedQuery<TestEntity> buildGetByValue() {
+        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
+
+        CriteriaQuery<TestEntity> criteriaQuery = criteriaBuilder.createQuery(TestEntity.class);
+        Root<TestEntity> root = criteriaQuery.from(TestEntity.class);
+        ParameterExpression<String> valueParameter = criteriaBuilder.parameter(String.class, TestEntity_.value.getName());
+        
+        criteriaQuery.select(root)
+             .where(
+                 criteriaBuilder.equal(
+                     root.get(TestEntity_.value), valueParameter)
+        );
+
+        return entityManager.createQuery(criteriaQuery);
+    }
+
+}

jpa/dynamic-named-query/src/main/java/org/javaee7/jpa/dynamicnamedquery/service/TestService.java

@@ -0,0 +1,51 @@
+package org.javaee7.jpa.dynamicnamedquery.service;
+
+import static org.javaee7.jpa.dynamicnamedquery.service.QueryRepository.Queries.TEST_ENTITY_GET_ALL;
+import static org.javaee7.jpa.dynamicnamedquery.service.QueryRepository.Queries.TEST_ENTITY_GET_BY_VALUE;
+
+import java.util.List;
+
+import javax.ejb.Stateless;
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+
+import org.javaee7.jpa.dynamicnamedquery.entity.TestEntity;
+import org.javaee7.jpa.dynamicnamedquery.entity.TestEntity_;
+
+/**
+ * 
+ * @author Arjan Tijms
+ *
+ */
+@Stateless
+public class TestService {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    public void save(TestEntity testEntity) {
+        entityManager.persist(testEntity);
+    }
+
+    /**
+     * Gets a list of all instances of {@link TestEntity} that were persisted
+     * 
+     * @return a list of all instances of {@link TestEntity} that were persisted
+     */
+    public List<TestEntity> getAll() {
+        return entityManager.createNamedQuery(TEST_ENTITY_GET_ALL.name(), TestEntity.class).getResultList();
+    }
+
+    /**
+     * Gets a list of instances of {@link TestEntity} where the <code>value</code> attribute equals
+     * the <code>value</code> parameter of this method.
+     * 
+     * @param value the value by which {@link TestEntity} instances are retrieved.
+     * @return list of {@link TestEntity} instances matching <code>value</code>
+     */
+    public List<TestEntity> getByValue(String value) {
+        return entityManager.createNamedQuery(TEST_ENTITY_GET_BY_VALUE.name(), TestEntity.class)
+                .setParameter(TestEntity_.value.getName(), value).getResultList();
+    }
+
+}

jpa/dynamic-named-query/src/main/java/org/javaee7/jpa/dynamicnamedquery/servlet/Servlet.java

@@ -0,0 +1,41 @@
+package org.javaee7.jpa.dynamicnamedquery.servlet;
+
+import java.io.IOException;
+
+import javax.inject.Inject;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.javaee7.jpa.dynamicnamedquery.entity.TestEntity;
+import org.javaee7.jpa.dynamicnamedquery.service.TestService;
+
+/**
+ * This servlet is not part of the normal test flow, but is an extra artifact to use when deploying the WAR created by this
+ * Maven project standalone.
+ * 
+ * @author Arjan Tijms
+ * 
+ */
+@WebServlet("/servlet")
+public class Servlet extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Inject
+    private TestService testService;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+
+        TestEntity testEntity = new TestEntity();
+        testEntity.setValue("myValue");
+        testService.save(testEntity);
+
+        response.getWriter().write("#Entities after insert = " + testService.getAll().size() + "\n");
+        response.getWriter().write("Value found = " + (testService.getByValue("myValue").size() > 0));
+    }
+
+}

jpa/dynamic-named-query/src/main/resources/META-INF/persistence.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
+    
+    <!-- 
+        This defines the persistence unit from which the entity manager is used in org.javaee7.jpa.dynamicnamedquery.service.TestService
+        
+        Note that this relies on the defaults; in Java EE the transaction type defaults to JTA and the data source defaults to the
+        platform default data source (which is a new feature in Java EE 7)
+    
+    -->
+    
+    <persistence-unit name="testPU" >
+        <properties>
+            <property name="javax.persistence.schema-generation.database.action" value="drop-and-create" />
+        </properties>
+    </persistence-unit>
+</persistence>

jpa/dynamic-named-query/src/main/webapp/index.jsp

@@ -0,0 +1,13 @@
+<%@page contentType="text/html" pageEncoding="UTF-8"%>
+<!DOCTYPE html>
+
+<html>
+    <head>
+        <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+        <title>JPA 2.1 Dynamically adding named queries</title>
+    </head>
+    <body>
+        <h1>JPA 2.1 Dynamically adding named queries</h1>
+        <a href="${pageContext.request.contextPath}/servlet"/>Using dynamically added criteria queries</a>.
+    </body>
+</html>

jpa/dynamic-named-query/src/test/java/org/javaee7/jpa/dynamicnamedquery/DynamicNamedQueryTest.java

@@ -0,0 +1,58 @@
+package org.javaee7.jpa.dynamicnamedquery;
+
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+
+import javax.inject.Inject;
+
+import org.javaee7.jpa.dynamicnamedquery.entity.TestEntity;
+import org.javaee7.jpa.dynamicnamedquery.service.TestService;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.WebArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.xml.sax.SAXException;
+
+/**
+ * This tests that queries which have been dynamically (programmatically) added as named queries
+ * can be executed correctly.
+ * 
+ * @author Arjan Tijms
+ * 
+ */
+@RunWith(Arquillian.class)
+public class DynamicNamedQueryTest {
+
+    @Inject
+    private TestService testService;
+
+    @Deployment
+    public static WebArchive createDeployment() {
+        return ShrinkWrap.create(WebArchive.class).addPackages(true, "org.javaee7.jpa.dynamicnamedquery")
+                .addAsResource("META-INF/persistence.xml");
+    }
+
+    @Test
+    public void testDynamicNamedCriteriaQueries() throws IOException, SAXException {
+
+        // Nothing inserted yet, data base should not contain any entities 
+        // (this tests that a simple query without parameters works as named query created by Criteria)
+        assertTrue(testService.getAll().size() == 0);
+
+        // Insert one entity
+        TestEntity testEntity = new TestEntity();
+        testEntity.setValue("myValue");
+        testService.save(testEntity);
+
+        // The total amount of entities should be 1
+        assertTrue(testService.getAll().size() == 1);
+
+        // The entity with "myValue" should be found
+        // (this tests that a query with a parameter works as named query created by Criteria)
+        assertTrue(testService.getByValue("myValue").size() == 1);
+    }
+
+}