[BAEL-14315] - Added new module spring-persistence-simple and moved one article

2019-05-10 00:22:34 +05:30
parent d783aba7dc
commit 06047d4280
20 changed files with 1042 additions and 1 deletions
@@ -0,0 +1,157 @@
+package org.baeldung.persistence.service;
+
+import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.lessThan;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.Query;
+import javax.persistence.TypedQuery;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+
+import org.baeldung.config.PersistenceJPAConfig;
+import org.baeldung.persistence.model.Foo;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { PersistenceJPAConfig.class }, loader = AnnotationConfigContextLoader.class)
+@DirtiesContext
+public class FooPaginationPersistenceIntegrationTest {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    @Autowired
+    private FooService fooService;
+
+    @Before
+    public final void before() {
+        final int minimalNumberOfEntities = 25;
+        if (fooService.findAll().size() <= minimalNumberOfEntities) {
+            for (int i = 0; i < minimalNumberOfEntities; i++) {
+                fooService.create(new Foo(randomAlphabetic(6)));
+            }
+        }
+    }
+
+    // tests
+
+    @Test
+    public final void whenContextIsBootstrapped_thenNoExceptions() {
+        //
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public final void givenEntitiesExist_whenRetrievingFirstPage_thenCorrect() {
+        final int pageSize = 10;
+
+        final Query query = entityManager.createQuery("From Foo");
+        configurePagination(query, 1, pageSize);
+
+        // When
+        final List<Foo> fooList = query.getResultList();
+
+        // Then
+        assertThat(fooList, hasSize(pageSize));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public final void givenEntitiesExist_whenRetrievingLastPage_thenCorrect() {
+        final int pageSize = 10;
+        final Query queryTotal = entityManager.createQuery("Select count(f.id) from Foo f");
+        final long countResult = (long) queryTotal.getSingleResult();
+
+        final Query query = entityManager.createQuery("Select f from Foo as f order by f.id");
+        final int lastPage = (int) ((countResult / pageSize) + 1);
+        configurePagination(query, lastPage, pageSize);
+        final List<Foo> fooList = query.getResultList();
+
+        // Then
+        assertThat(fooList, hasSize(lessThan(pageSize + 1)));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public final void givenEntitiesExist_whenRetrievingPage_thenCorrect() {
+        final int pageSize = 10;
+
+        final Query queryIds = entityManager.createQuery("Select f.id from Foo f order by f.name");
+        final List<Integer> fooIds = queryIds.getResultList();
+
+        final Query query = entityManager.createQuery("Select f from Foo as f where f.id in :ids");
+        query.setParameter("ids", fooIds.subList(0, pageSize));
+
+        final List<Foo> fooList = query.getResultList();
+
+        // Then
+        assertThat(fooList, hasSize(pageSize));
+    }
+
+    @Test
+    public final void givenEntitiesExist_whenRetrievingPageViaCriteria_thenCorrect() {
+        final int pageSize = 10;
+        final CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
+        final CriteriaQuery<Foo> criteriaQuery = criteriaBuilder.createQuery(Foo.class);
+        final Root<Foo> from = criteriaQuery.from(Foo.class);
+        final CriteriaQuery<Foo> select = criteriaQuery.select(from);
+        final TypedQuery<Foo> typedQuery = entityManager.createQuery(select);
+        typedQuery.setFirstResult(0);
+        typedQuery.setMaxResults(pageSize);
+        final List<Foo> fooList = typedQuery.getResultList();
+
+        // Then
+        assertThat(fooList, hasSize(pageSize));
+    }
+
+    @Test
+    public final void givenEntitiesExist_whenRetrievingPageViaCriteria_thenNoExceptions() {
+        int pageNumber = 1;
+        final int pageSize = 10;
+        final CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
+
+        final CriteriaQuery<Long> countQuery = criteriaBuilder.createQuery(Long.class);
+        countQuery.select(criteriaBuilder.count(countQuery.from(Foo.class)));
+        final Long count = entityManager.createQuery(countQuery).getSingleResult();
+
+        final CriteriaQuery<Foo> criteriaQuery = criteriaBuilder.createQuery(Foo.class);
+        final Root<Foo> from = criteriaQuery.from(Foo.class);
+        final CriteriaQuery<Foo> select = criteriaQuery.select(from);
+
+        TypedQuery<Foo> typedQuery;
+        while (pageNumber < count.intValue()) {
+            typedQuery = entityManager.createQuery(select);
+            typedQuery.setFirstResult(pageNumber - 1);
+            typedQuery.setMaxResults(pageSize);
+            System.out.println("Current page: " + typedQuery.getResultList());
+            pageNumber += pageSize;
+        }
+
+    }
+
+    // UTIL
+
+    final int determineLastPage(final int pageSize, final long countResult) {
+        return (int) (countResult / pageSize) + 1;
+    }
+
+    final void configurePagination(final Query query, final int pageNumber, final int pageSize) {
+        query.setFirstResult((pageNumber - 1) * pageSize);
+        query.setMaxResults(pageSize);
+    }
+
+}
@@ -0,0 +1,69 @@
+package org.baeldung.persistence.service;
+
+import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
+
+import org.baeldung.config.PersistenceJPAConfig;
+import org.baeldung.persistence.model.Foo;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.dao.DataAccessException;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.dao.InvalidDataAccessApiUsageException;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { PersistenceJPAConfig.class }, loader = AnnotationConfigContextLoader.class)
+@DirtiesContext
+public class FooServicePersistenceIntegrationTest {
+
+    @Autowired
+    private FooService service;
+
+    // tests
+
+    @Test
+    public final void whenContextIsBootstrapped_thenNoExceptions() {
+        //
+    }
+
+    @Test
+    public final void whenEntityIsCreated_thenNoExceptions() {
+        service.create(new Foo(randomAlphabetic(6)));
+    }
+
+    @Test(expected = DataIntegrityViolationException.class)
+    public final void whenInvalidEntityIsCreated_thenDataException() {
+        service.create(new Foo(randomAlphabetic(2048)));
+    }
+
+    @Test(expected = DataIntegrityViolationException.class)
+    public final void whenEntityWithLongNameIsCreated_thenDataException() {
+        service.create(new Foo(randomAlphabetic(2048)));
+    }
+
+    @Test(expected = InvalidDataAccessApiUsageException.class)
+    public final void whenSameEntityIsCreatedTwice_thenDataException() {
+        final Foo entity = new Foo(randomAlphabetic(8));
+        service.create(entity);
+        service.create(entity);
+    }
+
+    @Test(expected = DataAccessException.class)
+    public final void temp_whenInvalidEntityIsCreated_thenDataException() {
+        service.create(new Foo(randomAlphabetic(2048)));
+    }
+
+    @Test
+    public final void whenEntityIsCreated_thenFound() {
+        final Foo fooEntity = new Foo("abc");
+        service.create(fooEntity);
+        final Foo found = service.findOne(fooEntity.getId());
+        Assert.assertNotNull(found);
+    }
+
+}
@@ -0,0 +1,118 @@
+package org.baeldung.persistence.service;
+
+import java.util.List;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.Query;
+import javax.persistence.TypedQuery;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+
+import org.baeldung.config.PersistenceJPAConfig;
+import org.baeldung.persistence.model.Bar;
+import org.baeldung.persistence.model.Foo;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { PersistenceJPAConfig.class }, loader = AnnotationConfigContextLoader.class)
+@DirtiesContext
+@SuppressWarnings("unchecked")
+public class FooServiceSortingIntegrationTest {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    // tests
+
+    @Test
+    public final void whenSortingByOneAttributeDefaultOrder_thenPrintSortedResult() {
+        final String jql = "Select f from Foo as f order by f.id";
+        final Query sortQuery = entityManager.createQuery(jql);
+        final List<Foo> fooList = sortQuery.getResultList();
+        for (final Foo foo : fooList) {
+            System.out.println("Name:" + foo.getName() + "-------Id:" + foo.getId());
+        }
+    }
+
+    @Test
+    public final void whenSortingByOneAttributeSetOrder_thenSortedPrintResult() {
+        final String jql = "Select f from Foo as f order by f.id desc";
+        final Query sortQuery = entityManager.createQuery(jql);
+        final List<Foo> fooList = sortQuery.getResultList();
+        for (final Foo foo : fooList) {
+            System.out.println("Name:" + foo.getName() + "-------Id:" + foo.getId());
+        }
+    }
+
+    @Test
+    public final void whenSortingByTwoAttributes_thenPrintSortedResult() {
+        final String jql = "Select f from Foo as f order by f.name asc, f.id desc";
+        final Query sortQuery = entityManager.createQuery(jql);
+        final List<Foo> fooList = sortQuery.getResultList();
+        for (final Foo foo : fooList) {
+            System.out.println("Name:" + foo.getName() + "-------Id:" + foo.getId());
+        }
+    }
+
+    @Test
+    public final void whenSortingFooByBar_thenBarsSorted() {
+        final String jql = "Select f from Foo as f order by f.name, f.bar.id";
+        final Query barJoinQuery = entityManager.createQuery(jql);
+        final List<Foo> fooList = barJoinQuery.getResultList();
+        for (final Foo foo : fooList) {
+            System.out.println("Name:" + foo.getName());
+            if (foo.getBar() != null) {
+                System.out.print("-------BarId:" + foo.getBar().getId());
+            }
+        }
+    }
+
+    @Test
+    public final void whenSortinfBar_thenPrintBarsSortedWithFoos() {
+        final String jql = "Select b from Bar as b order by b.id";
+        final Query barQuery = entityManager.createQuery(jql);
+        final List<Bar> barList = barQuery.getResultList();
+        for (final Bar bar : barList) {
+            System.out.println("Bar Id:" + bar.getId());
+            for (final Foo foo : bar.getFooList()) {
+                System.out.println("FooName:" + foo.getName());
+            }
+        }
+    }
+
+    @Test
+    public final void whenSortingFooWithCriteria_thenPrintSortedFoos() {
+        final CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
+        final CriteriaQuery<Foo> criteriaQuery = criteriaBuilder.createQuery(Foo.class);
+        final Root<Foo> from = criteriaQuery.from(Foo.class);
+        final CriteriaQuery<Foo> select = criteriaQuery.select(from);
+        criteriaQuery.orderBy(criteriaBuilder.asc(from.get("name")));
+        final TypedQuery<Foo> typedQuery = entityManager.createQuery(select);
+        final List<Foo> fooList = typedQuery.getResultList();
+        for (final Foo foo : fooList) {
+            System.out.println("Name:" + foo.getName() + "--------Id:" + foo.getId());
+        }
+    }
+
+    @Test
+    public final void whenSortingFooWithCriteriaAndMultipleAttributes_thenPrintSortedFoos() {
+        final CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
+        final CriteriaQuery<Foo> criteriaQuery = criteriaBuilder.createQuery(Foo.class);
+        final Root<Foo> from = criteriaQuery.from(Foo.class);
+        final CriteriaQuery<Foo> select = criteriaQuery.select(from);
+        criteriaQuery.orderBy(criteriaBuilder.asc(from.get("name")), criteriaBuilder.desc(from.get("id")));
+        final TypedQuery<Foo> typedQuery = entityManager.createQuery(select);
+        final List<Foo> fooList = typedQuery.getResultList();
+        for (final Foo foo : fooList) {
+            System.out.println("Name:" + foo.getName() + "-------Id:" + foo.getId());
+        }
+    }
+
+}
@@ -0,0 +1,64 @@
+package org.baeldung.persistence.service;
+
+import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
+import static org.junit.Assert.assertNull;
+
+import java.util.List;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.Query;
+
+import org.baeldung.config.PersistenceJPAConfig;
+import org.baeldung.persistence.model.Foo;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { PersistenceJPAConfig.class }, loader = AnnotationConfigContextLoader.class)
+@DirtiesContext
+public class FooServiceSortingWitNullsManualIntegrationTest {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    @Autowired
+    private FooService service;
+
+    // tests
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public final void whenSortingByStringNullLast_thenLastNull() {
+        service.create(new Foo());
+        service.create(new Foo(randomAlphabetic(6)));
+
+        final String jql = "Select f from Foo as f order by f.name desc NULLS LAST";
+        final Query sortQuery = entityManager.createQuery(jql);
+        final List<Foo> fooList = sortQuery.getResultList();
+        assertNull(fooList.get(fooList.toArray().length - 1).getName());
+        for (final Foo foo : fooList) {
+            System.out.println("Name:" + foo.getName());
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public final void whenSortingByStringNullFirst_thenFirstNull() {
+        service.create(new Foo());
+
+        final String jql = "Select f from Foo as f order by f.name desc NULLS FIRST";
+        final Query sortQuery = entityManager.createQuery(jql);
+        final List<Foo> fooList = sortQuery.getResultList();
+        assertNull(fooList.get(0).getName());
+        for (final Foo foo : fooList) {
+            System.out.println("Name:" + foo.getName());
+        }
+    }
+
+}
@@ -0,0 +1,13 @@
+*.class
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+
+# Packaged files #
+*.jar
+*.war
+*.ear