Adding Hibernate 5 Project (#1129)

* Changes in assert statement * Adding Hibernate 5 Project * Adding Hibernate 5 Project
2017-02-26 12:56:52 -06:00
parent 325466a782
commit 7f20437cb0
91 changed files with 4520 additions and 0 deletions
@@ -0,0 +1,13 @@
+*.class
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+
+# Packaged files #
+*.jar
+*.war
+*.ear
@@ -0,0 +1,239 @@
+<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>
+    <groupId>com.baeldung</groupId>
+    <artifactId>spring-hibernate5</artifactId>
+    <version>0.1-SNAPSHOT</version>
+
+    <name>spring-hibernate5</name>
+
+    <dependencies>
+
+        <!-- Spring -->
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+            <version>${org.springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-aspects</artifactId>
+            <version>${org.springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-core</artifactId>
+            <version>${org.springframework.security.version}</version>
+        </dependency>
+
+        <!-- persistence -->
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-orm</artifactId>
+            <version>${org.springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-jpa</artifactId>
+            <version>${org.springframework.data.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-core</artifactId>
+            <version>${hibernate.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-envers</artifactId>
+            <version>${hibernate-envers.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.transaction</groupId>
+            <artifactId>jta</artifactId>
+            <version>${jta.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>${mysql-connector-java.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tomcat</groupId>
+            <artifactId>tomcat-dbcp</artifactId>
+            <version>${tomcat-dbcp.version}</version>
+        </dependency>
+
+        <!-- validation -->
+
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-validator</artifactId>
+            <version>${hibernate-validator.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.el</groupId>
+            <artifactId>javax.el-api</artifactId>
+            <version>${javax.el-api.version}</version>
+        </dependency>
+
+        <!-- utils -->
+
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
+
+        <!-- test scoped -->
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <version>${org.springframework.version}</version>
+            <scope>test</scope>
+        </dependency>
+        
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-test</artifactId>
+            <version>${org.springframework.security.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest-core</artifactId>
+            <version>${org.hamcrest.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit-dep</artifactId>
+            <version>4.11</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest-library</artifactId>
+            <version>${org.hamcrest.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>${mockito.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.hsqldb</groupId>
+            <artifactId>hsqldb</artifactId>
+            <version>${hsqldb.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <finalName>spring-hibernate5</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+
+        <plugins>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${maven-surefire-plugin.version}</version>
+                <configuration>
+                    <excludes>
+                         <exclude>**/*IntegrationTest.java</exclude>
+                    </excludes>
+                    <systemPropertyVariables>
+                        <!-- <provPersistenceTarget>h2</provPersistenceTarget> -->
+                    </systemPropertyVariables>
+                </configuration>
+            </plugin>
+
+        </plugins>
+
+    </build>
+
+    <properties>
+        <!-- Spring -->
+        <org.springframework.version>4.3.5.RELEASE</org.springframework.version>
+	    <org.springframework.security.version>4.2.1.RELEASE</org.springframework.security.version>
+	    <org.springframework.data.version>1.10.6.RELEASE</org.springframework.data.version>
+        
+        <!-- persistence -->
+        <hibernate.version>5.2.8.Final</hibernate.version>
+        <hibernate-envers.version>${hibernate.version}</hibernate-envers.version>
+        <mysql-connector-java.version>6.0.5</mysql-connector-java.version>
+        <tomcat-dbcp.version>8.5.11</tomcat-dbcp.version>
+        <jta.version>1.1</jta.version>
+        <hsqldb.version>2.3.4</hsqldb.version>
+
+        <!-- logging -->
+        <org.slf4j.version>1.7.21</org.slf4j.version>
+        <logback.version>1.1.7</logback.version>
+        
+        <!-- various -->
+        <hibernate-validator.version>5.4.0.Final</hibernate-validator.version>
+        <javax.el-api.version>2.2.5</javax.el-api.version>
+
+        <!-- util -->
+        <guava.version>21.0</guava.version>
+        <commons-lang3.version>3.5</commons-lang3.version>
+
+        <!-- testing -->
+        <org.hamcrest.version>1.3</org.hamcrest.version>
+        <junit.version>4.12</junit.version>
+        <mockito.version>2.6.8</mockito.version>
+
+        <httpcore.version>4.4.1</httpcore.version>
+        <httpclient.version>4.5</httpclient.version>
+
+        <rest-assured.version>2.9.0</rest-assured.version>
+
+        <!-- maven plugins -->
+        <maven-compiler-plugin.version>3.6.0</maven-compiler-plugin.version>
+        <maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version>
+        <maven-resources-plugin.version>2.7</maven-resources-plugin.version>
+        <cargo-maven2-plugin.version>1.6.1</cargo-maven2-plugin.version>
+
+    </properties>
+
+</project>
@@ -0,0 +1,81 @@
+package com.baeldung.hibernate.criteria.model;
+
+import java.io.Serializable;
+
+public class Item implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+    private Integer itemId;
+    private String itemName;
+    private String itemDescription;
+    private Integer itemPrice;
+
+    // constructors
+    public Item() {
+
+    }
+
+    public Item(final Integer itemId, final String itemName, final String itemDescription) {
+        super();
+        this.itemId = itemId;
+        this.itemName = itemName;
+        this.itemDescription = itemDescription;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((itemId == null) ? 0 : itemId.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(final Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        final Item other = (Item) obj;
+        if (itemId == null) {
+            if (other.itemId != null)
+                return false;
+        } else if (!itemId.equals(other.itemId))
+            return false;
+        return true;
+    }
+
+    public Integer getItemId() {
+        return itemId;
+    }
+
+    public void setItemId(final Integer itemId) {
+        this.itemId = itemId;
+    }
+
+    public String getItemName() {
+        return itemName;
+    }
+
+    public void setItemName(final String itemName) {
+        this.itemName = itemName;
+    }
+
+    public String getItemDescription() {
+        return itemDescription;
+    }
+
+    public Integer getItemPrice() {
+        return itemPrice;
+    }
+
+    public void setItemPrice(final Integer itemPrice) {
+        this.itemPrice = itemPrice;
+    }
+
+    public void setItemDescription(final String itemDescription) {
+        this.itemDescription = itemDescription;
+    }
+}
@@ -0,0 +1,17 @@
+package com.baeldung.hibernate.criteria.util;
+
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.cfg.Configuration;
+
+public class HibernateUtil {
+
+    public static Session getHibernateSession() {
+
+        final SessionFactory sf = new Configuration().configure("criteria.cfg.xml").buildSessionFactory();
+
+        final Session session = sf.openSession();
+        return session;
+    }
+
+}
@@ -0,0 +1,284 @@
+/**
+ * ApplicationViewer is the class that starts the application
+ * First it creates the session object and then creates the
+ * criteria query.
+ *
+ *  @author  Sandeep Kumar
+ *  @version 1.0
+ *  @since   01/13/2017
+ */
+
+package com.baeldung.hibernate.criteria.view;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.persistence.Tuple;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Order;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
+
+import org.hibernate.Session;
+import org.hibernate.Transaction;
+
+import com.baeldung.hibernate.criteria.model.Item;
+import com.baeldung.hibernate.criteria.util.HibernateUtil;
+
+public class ApplicationView {
+
+    public ApplicationView() {
+
+    }
+
+    @SuppressWarnings("unchecked")
+    public boolean checkIfCriteriaTimeLower() {
+        final Session session = HibernateUtil.getHibernateSession();
+        CriteriaBuilder builder = session.getCriteriaBuilder();
+        CriteriaQuery<Item> criteriaItem = builder.createQuery(Item.class);
+        Root<Item> rootItem = criteriaItem.from(Item.class);
+        Transaction tx = null;
+
+        // calculate the time taken by criteria
+        final long startTimeCriteria = System.nanoTime();
+        criteriaItem.select(rootItem).where(builder.like(rootItem.get("itemName"), "%item One%"));
+        final List<Item> results = session.createQuery(criteriaItem).getResultList();
+        final long endTimeCriteria = System.nanoTime();
+        final long durationCriteria = (endTimeCriteria - startTimeCriteria) / 1000;
+
+        // calculate the time taken by HQL
+        final long startTimeHQL = System.nanoTime();
+        tx = session.beginTransaction();
+        final List<Item> items = session.createQuery("FROM Item where itemName like '%item One%'").getResultList();
+        final long endTimeHQL = System.nanoTime();
+        final long durationHQL = (endTimeHQL - startTimeHQL) / 1000;
+
+        if (durationCriteria > durationHQL) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    // To get items having price more than 1000
+    public String[] greaterThanCriteria() {
+        final Session session = HibernateUtil.getHibernateSession();
+        CriteriaBuilder builder = session.getCriteriaBuilder();
+        CriteriaQuery<Item> criteriaItem = builder.createQuery(Item.class);
+        Root<Item> rootItem = criteriaItem.from(Item.class);
+        criteriaItem.select(rootItem).where(builder.greaterThan(rootItem.get("itemPrice"), 1000));
+        final List<Item> greaterThanItemsList = session.createQuery(criteriaItem).getResultList();
+        final String greaterThanItems[] = new String[greaterThanItemsList.size()];
+        for (int i = 0; i < greaterThanItemsList.size(); i++) {
+            greaterThanItems[i] = greaterThanItemsList.get(i).getItemName();
+        }
+        session.close();
+        return greaterThanItems;
+    }
+
+    // To get items having price less than 1000
+    public String[] lessThanCriteria() {
+        final Session session = HibernateUtil.getHibernateSession();
+        CriteriaBuilder builder = session.getCriteriaBuilder();
+        CriteriaQuery<Item> criteriaItem = builder.createQuery(Item.class);
+        Root<Item> rootItem = criteriaItem.from(Item.class);
+        criteriaItem.select(rootItem).where(builder.lessThan(rootItem.get("itemPrice"), 1000));
+        final List<Item> lessThanItemsList = session.createQuery(criteriaItem).getResultList();
+        final String lessThanItems[] = new String[lessThanItemsList.size()];
+        for (int i = 0; i < lessThanItemsList.size(); i++) {
+            lessThanItems[i] = lessThanItemsList.get(i).getItemName();
+        }
+        session.close();
+        return lessThanItems;
+    }
+
+    // To get items whose Name start with Chair
+    public String[] likeCriteria() {
+        final Session session = HibernateUtil.getHibernateSession();
+
+        CriteriaBuilder builder = session.getCriteriaBuilder();
+        CriteriaQuery<Item> criteriaItem = builder.createQuery(Item.class);
+        Root<Item> rootItem = criteriaItem.from(Item.class);
+        criteriaItem.select(rootItem).where(builder.like(rootItem.get("itemName"), "%chair%"));
+        final List<Item> likeItemsList = session.createQuery(criteriaItem).getResultList();
+        final String likeItems[] = new String[likeItemsList.size()];
+        for (int i = 0; i < likeItemsList.size(); i++) {
+            likeItems[i] = likeItemsList.get(i).getItemName();
+        }
+        session.close();
+        return likeItems;
+    }
+
+    // Case sensitive search
+    public String[] likeCaseCriteria() {
+        final Session session = HibernateUtil.getHibernateSession();
+        CriteriaBuilder builder = session.getCriteriaBuilder();
+        CriteriaQuery<Item> criteriaItem = builder.createQuery(Item.class);
+        Root<Item> rootItem = criteriaItem.from(Item.class);
+        criteriaItem.select(rootItem).where(builder.like(rootItem.get("itemName"), "%Chair%"));
+        final List<Item> ilikeItemsList = session.createQuery(criteriaItem).getResultList();
+        final String ilikeItems[] = new String[ilikeItemsList.size()];
+        for (int i = 0; i < ilikeItemsList.size(); i++) {
+            ilikeItems[i] = ilikeItemsList.get(i).getItemName();
+        }
+        session.close();
+        return ilikeItems;
+    }
+
+    // To get records having itemPrice in between 100 and 200
+    public String[] betweenCriteria() {
+        final Session session = HibernateUtil.getHibernateSession();
+        CriteriaBuilder builder = session.getCriteriaBuilder();
+        CriteriaQuery<Item> criteriaItem = builder.createQuery(Item.class);
+        Root<Item> rootItem = criteriaItem.from(Item.class);
+        // To get items having price more than 1000
+        criteriaItem.select(rootItem).where(builder.between(rootItem.get("itemPrice"), 100, 200));
+        final List<Item> betweenItemsList = session.createQuery(criteriaItem).getResultList();
+        final String betweenItems[] = new String[betweenItemsList.size()];
+        for (int i = 0; i < betweenItemsList.size(); i++) {
+            betweenItems[i] = betweenItemsList.get(i).getItemName();
+        }
+        session.close();
+        return betweenItems;
+    }
+
+    // To check if the given property is null
+    public String[] nullCriteria() {
+        final Session session = HibernateUtil.getHibernateSession();
+        CriteriaBuilder builder = session.getCriteriaBuilder();
+        CriteriaQuery<Item> criteriaItem = builder.createQuery(Item.class);
+        Root<Item> rootItem = criteriaItem.from(Item.class);
+        criteriaItem.select(rootItem).where(builder.isNull(rootItem.get("itemDescription")));
+        final List<Item> nullItemsList = session.createQuery(criteriaItem).getResultList();
+        final String nullDescItems[] = new String[nullItemsList.size()];
+        for (int i = 0; i < nullItemsList.size(); i++) {
+            nullDescItems[i] = nullItemsList.get(i).getItemName();
+        }
+        session.close();
+        return nullDescItems;
+    }
+
+    // To check if the given property is not null
+    public String[] notNullCriteria() {
+        final Session session = HibernateUtil.getHibernateSession();
+        CriteriaBuilder builder = session.getCriteriaBuilder();
+        CriteriaQuery<Item> criteriaItem = builder.createQuery(Item.class);
+        Root<Item> rootItem = criteriaItem.from(Item.class);
+        criteriaItem.select(rootItem).where(builder.isNotNull(rootItem.get("itemDescription")));
+        final List<Item> notNullItemsList = session.createQuery(criteriaItem).getResultList();
+        final String notNullDescItems[] = new String[notNullItemsList.size()];
+        for (int i = 0; i < notNullItemsList.size(); i++) {
+            notNullDescItems[i] = notNullItemsList.get(i).getItemName();
+        }
+        session.close();
+        return notNullDescItems;
+    }
+
+    // Adding more than one expression in one cr
+    public String[] twoCriteria() {
+        final Session session = HibernateUtil.getHibernateSession();
+        CriteriaBuilder builder = session.getCriteriaBuilder();
+        CriteriaQuery<Item> criteriaItem = builder.createQuery(Item.class);
+        Root<Item> rootItem = criteriaItem.from(Item.class);
+        criteriaItem.select(rootItem).where(builder.isNull(rootItem.get("itemDescription")))
+                .where(builder.like(rootItem.get("itemName"), "chair%"));
+        final List<Item> notNullItemsList = session.createQuery(criteriaItem).getResultList();
+        final String notNullDescItems[] = new String[notNullItemsList.size()];
+        for (int i = 0; i < notNullItemsList.size(); i++) {
+            notNullDescItems[i] = notNullItemsList.get(i).getItemName();
+        }
+        session.close();
+        return notNullDescItems;
+    }
+
+    // To get items matching with the above defined conditions joined
+    // with Logical AND
+    public String[] andLogicalCriteria() {
+        List<Predicate> predicates = new ArrayList<Predicate>();
+        final Session session = HibernateUtil.getHibernateSession();
+        CriteriaBuilder builder = session.getCriteriaBuilder();
+        CriteriaQuery<Item> criteriaItem = builder.createQuery(Item.class);
+        Root<Item> rootItem = criteriaItem.from(Item.class);
+        predicates.add(builder.greaterThan(rootItem.get("itemPrice"), 1000));
+        predicates.add(builder.like(rootItem.get("itemName"), "Chair%"));
+        Predicate andPredicate = builder.and(predicates.toArray(new Predicate[] {}));
+        criteriaItem.select(rootItem).where(andPredicate);
+        final List<Item> andItemsList = session.createQuery(criteriaItem).getResultList();
+        final String andItems[] = new String[andItemsList.size()];
+        for (int i = 0; i < andItemsList.size(); i++) {
+            andItems[i] = andItemsList.get(i).getItemName();
+        }
+        session.close();
+        return andItems;
+    }
+
+    // To get items matching with the above defined conditions joined
+    // with Logical OR
+    public String[] orLogicalCriteria() {
+        List<Predicate> predicates = new ArrayList<Predicate>();
+        final Session session = HibernateUtil.getHibernateSession();
+        CriteriaBuilder builder = session.getCriteriaBuilder();
+        CriteriaQuery<Item> criteriaItem = builder.createQuery(Item.class);
+        Root<Item> rootItem = criteriaItem.from(Item.class);
+        predicates.add(builder.greaterThan(rootItem.get("itemPrice"), 1000));
+        predicates.add(builder.like(rootItem.get("itemName"), "Chair%"));
+        Predicate orPredicate = builder.or(predicates.toArray(new Predicate[] {}));
+        criteriaItem.select(rootItem).where(orPredicate);
+        final List<Item> orItemsList = session.createQuery(criteriaItem).getResultList();
+        final String orItems[] = new String[orItemsList.size()];
+        for (int i = 0; i < orItemsList.size(); i++) {
+            orItems[i] = orItemsList.get(i).getItemName();
+        }
+        session.close();
+        return orItems;
+    }
+
+    // Sorting example
+    public String[] sortingCriteria() {
+        List<Order> listOrders = new ArrayList<Order>();
+        final Session session = HibernateUtil.getHibernateSession();
+        CriteriaBuilder builder = session.getCriteriaBuilder();
+        CriteriaQuery<Item> criteriaItem = builder.createQuery(Item.class);
+        Root<Item> rootItem = criteriaItem.from(Item.class);
+        listOrders.add(builder.asc(rootItem.get("itemName")));
+        listOrders.add(builder.desc(rootItem.get("itemPrice")));
+        criteriaItem.orderBy(listOrders.toArray(new Order[] {}));
+        final List<Item> sortedItemsList = session.createQuery(criteriaItem).getResultList();
+        final String sortedItems[] = new String[sortedItemsList.size()];
+        for (int i = 0; i < sortedItemsList.size(); i++) {
+            sortedItems[i] = sortedItemsList.get(i).getItemName();
+        }
+        session.close();
+        return sortedItems;
+    }
+
+    // Set projections Row Count
+    public Long[] projectionRowCount() {
+        final Session session = HibernateUtil.getHibernateSession();
+        CriteriaBuilder builder = session.getCriteriaBuilder();
+        CriteriaQuery<Tuple> criteriaItem = builder.createQuery(Tuple.class);
+        Root<Item> rootItem = criteriaItem.from(Item.class);
+        criteriaItem.multiselect(builder.count(rootItem));
+        final List<Tuple> itemProjected = session.createQuery(criteriaItem).getResultList();
+        final Long projectedRowCount[] = new Long[1];
+        projectedRowCount[0] = (long) itemProjected.get(0).get(0);
+        session.close();
+        return projectedRowCount;
+    }
+
+    // Set projections average of itemPrice
+    public Double[] projectionAverage() {
+        final Session session = HibernateUtil.getHibernateSession();
+        CriteriaBuilder builder = session.getCriteriaBuilder();
+        CriteriaQuery<Tuple> criteriaItem = builder.createQuery(Tuple.class);
+        Root<Item> rootItem = criteriaItem.from(Item.class);
+        criteriaItem.multiselect(builder.avg(rootItem.get("itemPrice")));
+        final List<Tuple> itemProjected = session.createQuery(criteriaItem).getResultList();
+        Double avgItemPrice[] = new Double[1];
+        avgItemPrice[0] = Double.valueOf(itemProjected.get(0).get(0).toString());
+        session.close();
+        return avgItemPrice;
+    }
+
+}
@@ -0,0 +1,58 @@
+package com.baeldung.hibernate.fetching.model;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.sql.Date;
+
+@Entity
+@Table(name = "USER_ORDER")
+public class OrderDetail implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue
+    @Column(name = "ORDER_ID")
+    private Long orderId;
+
+    public OrderDetail() {
+    }
+
+    public OrderDetail(Date orderDate, String orderDesc) {
+        super();
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((orderId == null) ? 0 : orderId.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        OrderDetail other = (OrderDetail) obj;
+        if (orderId == null) {
+            if (other.orderId != null)
+                return false;
+        } else if (!orderId.equals(other.orderId))
+            return false;
+
+        return true;
+    }
+
+    public Long getOrderId() {
+        return orderId;
+    }
+
+    public void setOrderId(Long orderId) {
+        this.orderId = orderId;
+    }
+}
@@ -0,0 +1,71 @@
+package com.baeldung.hibernate.fetching.model;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.Set;
+
+@Entity
+@Table(name = "USER")
+public class UserEager implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue
+    @Column(name = "USER_ID")
+    private Long userId;
+
+    @OneToMany(fetch = FetchType.EAGER, mappedBy = "user")
+    private Set<OrderDetail> orderDetail = new HashSet<OrderDetail>();
+
+    public UserEager() {
+    }
+
+    public UserEager(final Long userId) {
+        super();
+        this.userId = userId;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((userId == null) ? 0 : userId.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(final Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        final UserEager other = (UserEager) obj;
+        if (userId == null) {
+            if (other.userId != null)
+                return false;
+        } else if (!userId.equals(other.userId))
+            return false;
+        return true;
+    }
+
+    public Long getUserId() {
+        return userId;
+    }
+
+    public void setUserId(final Long userId) {
+        this.userId = userId;
+    }
+
+    public Set<OrderDetail> getOrderDetail() {
+        return orderDetail;
+    }
+
+    public void setOrderDetail(Set<OrderDetail> orderDetail) {
+        this.orderDetail = orderDetail;
+    }
+
+}
@@ -0,0 +1,71 @@
+package com.baeldung.hibernate.fetching.model;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.Set;
+
+@Entity
+@Table(name = "USER")
+public class UserLazy implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue
+    @Column(name = "USER_ID")
+    private Long userId;
+
+    @OneToMany(fetch = FetchType.LAZY, mappedBy = "user")
+    private Set<OrderDetail> orderDetail = new HashSet<OrderDetail>();
+
+    public UserLazy() {
+    }
+
+    public UserLazy(final Long userId) {
+        super();
+        this.userId = userId;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((userId == null) ? 0 : userId.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(final Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        final UserLazy other = (UserLazy) obj;
+        if (userId == null) {
+            if (other.userId != null)
+                return false;
+        } else if (!userId.equals(other.userId))
+            return false;
+        return true;
+    }
+
+    public Long getUserId() {
+        return userId;
+    }
+
+    public void setUserId(final Long userId) {
+        this.userId = userId;
+    }
+
+    public Set<OrderDetail> getOrderDetail() {
+        return orderDetail;
+    }
+
+    public void setOrderDetail(Set<OrderDetail> orderDetail) {
+        this.orderDetail = orderDetail;
+    }
+
+}
@@ -0,0 +1,28 @@
+package com.baeldung.hibernate.fetching.util;
+
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.cfg.Configuration;
+
+public class HibernateUtil {
+
+    public static Session getHibernateSession(String fetchMethod) {
+        // two config files are there
+        // one with lazy loading enabled
+        // another lazy = false
+        SessionFactory sf;
+        if ("lazy".equals(fetchMethod)) {
+            sf = new Configuration().configure("fetchingLazy.cfg.xml").buildSessionFactory();
+        } else {
+            sf = new Configuration().configure("fetching.cfg.xml").buildSessionFactory();
+        }
+
+        // fetching.cfg.xml is used for this example
+        return sf.openSession();
+    }
+
+    public static Session getHibernateSession() {
+        return new Configuration().configure("fetching.cfg.xml").buildSessionFactory().openSession();
+    }
+
+}
@@ -0,0 +1,68 @@
+package com.baeldung.hibernate.fetching.view;
+
+import com.baeldung.hibernate.fetching.model.OrderDetail;
+import com.baeldung.hibernate.fetching.model.UserEager;
+import com.baeldung.hibernate.fetching.model.UserLazy;
+import com.baeldung.hibernate.fetching.util.HibernateUtil;
+import org.hibernate.Session;
+import org.hibernate.Transaction;
+
+import java.util.List;
+import java.util.Set;
+
+public class FetchingAppView {
+
+    public FetchingAppView() {
+
+    }
+
+    // lazily loaded
+    public Set<OrderDetail> lazyLoaded() {
+        final Session sessionLazy = HibernateUtil.getHibernateSession("lazy");
+        List<UserLazy> users = sessionLazy.createQuery("From UserLazy").getResultList();
+        UserLazy userLazyLoaded = users.get(3);
+        // since data is lazyloaded so data won't be initialized
+        return (userLazyLoaded.getOrderDetail());
+    }
+
+    // eagerly loaded
+    public Set<OrderDetail> eagerLoaded() {
+        final Session sessionEager = HibernateUtil.getHibernateSession();
+        // data should be loaded in the following line
+        // also note the queries generated
+        List<UserEager> user = sessionEager.createQuery("From UserEager").getResultList();
+        UserEager userEagerLoaded = user.get(3);
+        return userEagerLoaded.getOrderDetail();
+    }
+
+    // creates test data
+    // call this method to create the data in the database
+    public void createTestData() {
+
+        final Session session = HibernateUtil.getHibernateSession("lazy");
+        Transaction tx = session.beginTransaction();
+        final UserLazy user1 = new UserLazy();
+        final UserLazy user2 = new UserLazy();
+        final UserLazy user3 = new UserLazy();
+
+        session.save(user1);
+        session.save(user2);
+        session.save(user3);
+
+        final OrderDetail order1 = new OrderDetail();
+        final OrderDetail order2 = new OrderDetail();
+        final OrderDetail order3 = new OrderDetail();
+        final OrderDetail order4 = new OrderDetail();
+        final OrderDetail order5 = new OrderDetail();
+
+        session.saveOrUpdate(order1);
+        session.saveOrUpdate(order2);
+        session.saveOrUpdate(order3);
+        session.saveOrUpdate(order4);
+        session.saveOrUpdate(order5);
+
+        tx.commit();
+        session.close();
+
+    }
+}
@@ -0,0 +1,8 @@
+package com.baeldung.persistence.dao;
+
+import com.baeldung.persistence.dao.common.IAuditOperations;
+import com.baeldung.persistence.model.Bar;
+
+public interface IBarAuditableDao extends IBarDao, IAuditOperations<Bar> {
+    //
+}
@@ -0,0 +1,10 @@
+package com.baeldung.persistence.dao;
+
+import java.io.Serializable;
+
+import com.baeldung.persistence.model.Bar;
+import org.springframework.data.repository.CrudRepository;
+
+public interface IBarCrudRepository extends CrudRepository<Bar, Serializable> {
+    //
+}
@@ -0,0 +1,8 @@
+package com.baeldung.persistence.dao;
+
+import com.baeldung.persistence.dao.common.IOperations;
+import com.baeldung.persistence.model.Bar;
+
+public interface IBarDao extends IOperations<Bar> {
+    //
+}
@@ -0,0 +1,8 @@
+package com.baeldung.persistence.dao;
+
+import com.baeldung.persistence.model.Child;
+import com.baeldung.persistence.dao.common.IOperations;
+
+public interface IChildDao extends IOperations<Child> {
+    //
+}
@@ -0,0 +1,8 @@
+package com.baeldung.persistence.dao;
+
+import com.baeldung.persistence.dao.common.IAuditOperations;
+import com.baeldung.persistence.model.Foo;
+
+public interface IFooAuditableDao extends IFooDao, IAuditOperations<Foo> {
+    //
+}
@@ -0,0 +1,8 @@
+package com.baeldung.persistence.dao;
+
+import com.baeldung.persistence.model.Foo;
+import com.baeldung.persistence.dao.common.IOperations;
+
+public interface IFooDao extends IOperations<Foo> {
+    //
+}
@@ -0,0 +1,8 @@
+package com.baeldung.persistence.dao;
+
+import com.baeldung.persistence.model.Parent;
+import com.baeldung.persistence.dao.common.IOperations;
+
+public interface IParentDao extends IOperations<Parent> {
+    //
+}
@@ -0,0 +1,14 @@
+package com.baeldung.persistence.dao.common;
+
+import java.io.Serializable;
+
+import com.google.common.base.Preconditions;
+
+public abstract class AbstractDao<T extends Serializable> implements IOperations<T> {
+
+    protected Class<T> clazz;
+
+    protected final void setClazz(final Class<T> clazzToSet) {
+        clazz = Preconditions.checkNotNull(clazzToSet);
+    }
+}
@@ -0,0 +1,37 @@
+package com.baeldung.persistence.dao.common;
+
+import java.io.Serializable;
+import java.util.List;
+
+import org.hibernate.envers.AuditReader;
+import org.hibernate.envers.AuditReaderFactory;
+import org.hibernate.envers.query.AuditQuery;
+
+@SuppressWarnings("unchecked")
+public class AbstractHibernateAuditableDao<T extends Serializable> extends AbstractHibernateDao<T> implements IAuditOperations<T> {
+
+    @Override
+    public List<T> getEntitiesAtRevision(final Number revision) {
+        final AuditReader auditReader = AuditReaderFactory.get(getCurrentSession());
+        final AuditQuery query = auditReader.createQuery().forEntitiesAtRevision(clazz, revision);
+        final List<T> resultList = query.getResultList();
+        return resultList;
+    }
+
+    @Override
+    public List<T> getEntitiesModifiedAtRevision(final Number revision) {
+        final AuditReader auditReader = AuditReaderFactory.get(getCurrentSession());
+        final AuditQuery query = auditReader.createQuery().forEntitiesModifiedAtRevision(clazz, revision);
+        final List<T> resultList = query.getResultList();
+        return resultList;
+    }
+
+    @Override
+    public List<T> getRevisions() {
+        final AuditReader auditReader = AuditReaderFactory.get(getCurrentSession());
+        final AuditQuery query = auditReader.createQuery().forRevisionsOfEntity(clazz, true, true);
+        final List<T> resultList = query.getResultList();
+        return resultList;
+    }
+
+}
@@ -0,0 +1,59 @@
+package com.baeldung.persistence.dao.common;
+
+import java.io.Serializable;
+import java.util.List;
+
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import com.google.common.base.Preconditions;
+
+@SuppressWarnings("unchecked")
+public abstract class AbstractHibernateDao<T extends Serializable> extends AbstractDao<T> implements IOperations<T> {
+
+    @Autowired
+    protected SessionFactory sessionFactory;
+
+    // API
+
+    @Override
+    public T findOne(final long id) {
+        return (T) getCurrentSession().get(clazz, id);
+    }
+
+    @Override
+    public List<T> findAll() {
+        return getCurrentSession().createQuery("from " + clazz.getName()).getResultList();
+    }
+
+    @Override
+    public void create(final T entity) {
+        Preconditions.checkNotNull(entity);
+        getCurrentSession().saveOrUpdate(entity);
+    }
+
+    @Override
+    public T update(final T entity) {
+        Preconditions.checkNotNull(entity);
+        return (T) getCurrentSession().merge(entity);
+    }
+
+    @Override
+    public void delete(final T entity) {
+        Preconditions.checkNotNull(entity);
+        getCurrentSession().delete(entity);
+    }
+
+    @Override
+    public void deleteById(final long entityId) {
+        final T entity = findOne(entityId);
+        Preconditions.checkState(entity != null);
+        delete(entity);
+    }
+
+    protected Session getCurrentSession() {
+        return sessionFactory.getCurrentSession();
+    }
+
+}
@@ -0,0 +1,56 @@
+package com.baeldung.persistence.dao.common;
+
+import java.io.Serializable;
+import java.util.List;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.TypedQuery;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+
+public class AbstractJpaDao<T extends Serializable> extends AbstractDao<T> implements IOperations<T> {
+
+    @PersistenceContext
+    private EntityManager em;
+
+    // API
+
+    @Override
+    public T findOne(final long id) {
+        return em.find(clazz, Long.valueOf(id).intValue());
+    }
+
+    @Override
+    public List<T> findAll() {
+        final CriteriaBuilder cb = em.getCriteriaBuilder();
+        final CriteriaQuery<T> cq = cb.createQuery(clazz);
+        final Root<T> rootEntry = cq.from(clazz);
+        final CriteriaQuery<T> all = cq.select(rootEntry);
+        final TypedQuery<T> allQuery = em.createQuery(all);
+        return allQuery.getResultList();
+    }
+
+    @Override
+    public void create(final T entity) {
+        em.persist(entity);
+    }
+
+    @Override
+    public T update(final T entity) {
+        em.merge(entity);
+        return entity;
+    }
+
+    @Override
+    public void delete(final T entity) {
+        em.remove(entity);
+    }
+
+    @Override
+    public void deleteById(final long entityId) {
+        delete(findOne(entityId));
+    }
+
+}
@@ -0,0 +1,13 @@
+package com.baeldung.persistence.dao.common;
+
+import java.io.Serializable;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.context.annotation.Scope;
+import org.springframework.stereotype.Repository;
+
+@Repository
+@Scope(BeanDefinition.SCOPE_PROTOTYPE)
+public class GenericHibernateDao<T extends Serializable> extends AbstractHibernateDao<T> implements IGenericDao<T> {
+    //
+}
@@ -0,0 +1,14 @@
+package com.baeldung.persistence.dao.common;
+
+import java.io.Serializable;
+import java.util.List;
+
+public interface IAuditOperations<T extends Serializable> {
+
+    List<T> getEntitiesAtRevision(Number revision);
+
+    List<T> getEntitiesModifiedAtRevision(Number revision);
+
+    List<T> getRevisions();
+
+}
@@ -0,0 +1,7 @@
+package com.baeldung.persistence.dao.common;
+
+import java.io.Serializable;
+
+public interface IGenericDao<T extends Serializable> extends IOperations<T> {
+    //
+}
@@ -0,0 +1,20 @@
+package com.baeldung.persistence.dao.common;
+
+import java.io.Serializable;
+import java.util.List;
+
+public interface IOperations<T extends Serializable> {
+
+    T findOne(final long id);
+
+    List<T> findAll();
+
+    void create(final T entity);
+
+    T update(final T entity);
+
+    void delete(final T entity);
+
+    void deleteById(final long entityId);
+
+}
@@ -0,0 +1,28 @@
+package com.baeldung.persistence.dao.impl;
+
+import java.util.List;
+
+import com.baeldung.persistence.dao.IBarAuditableDao;
+import com.baeldung.persistence.dao.common.AbstractHibernateAuditableDao;
+import com.baeldung.persistence.model.Bar;
+
+public class BarAuditableDao extends AbstractHibernateAuditableDao<Bar> implements IBarAuditableDao {
+
+    public BarAuditableDao() {
+        super();
+
+        setClazz(Bar.class);
+    }
+
+    // API
+
+    @Override
+    public List<Bar> getRevisions() {
+        final List<Bar> resultList = super.getRevisions();
+        for (final Bar bar : resultList) {
+            bar.getFooSet().size(); // force FooSet initialization
+        }
+        return resultList;
+    }
+
+}
@@ -0,0 +1,19 @@
+package com.baeldung.persistence.dao.impl;
+
+import com.baeldung.persistence.dao.common.AbstractHibernateDao;
+import com.baeldung.persistence.dao.IBarDao;
+import com.baeldung.persistence.model.Bar;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class BarDao extends AbstractHibernateDao<Bar> implements IBarDao {
+
+    public BarDao() {
+        super();
+
+        setClazz(Bar.class);
+    }
+
+    // API
+
+}
@@ -0,0 +1,19 @@
+package com.baeldung.persistence.dao.impl;
+
+import com.baeldung.persistence.dao.IBarDao;
+import com.baeldung.persistence.dao.common.AbstractJpaDao;
+import com.baeldung.persistence.model.Bar;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class BarJpaDao extends AbstractJpaDao<Bar> implements IBarDao {
+
+    public BarJpaDao() {
+        super();
+
+        setClazz(Bar.class);
+    }
+
+    // API
+
+}
@@ -0,0 +1,19 @@
+package com.baeldung.persistence.dao.impl;
+
+import com.baeldung.persistence.dao.common.AbstractHibernateDao;
+import com.baeldung.persistence.model.Child;
+import com.baeldung.persistence.dao.IChildDao;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class ChildDao extends AbstractHibernateDao<Child> implements IChildDao {
+
+    public ChildDao() {
+        super();
+
+        setClazz(Child.class);
+    }
+
+    // API
+
+}
@@ -0,0 +1,17 @@
+package com.baeldung.persistence.dao.impl;
+
+import com.baeldung.persistence.dao.common.AbstractHibernateAuditableDao;
+import com.baeldung.persistence.model.Foo;
+import com.baeldung.persistence.dao.IFooAuditableDao;
+
+public class FooAuditableDao extends AbstractHibernateAuditableDao<Foo> implements IFooAuditableDao {
+
+    public FooAuditableDao() {
+        super();
+
+        setClazz(Foo.class);
+    }
+
+    // API
+
+}
--- a/Show More
+++ b/Show More