Merge branch 'master' of https://github.com/JonCook/tutorials

persistence-modules/spring-hibernate-5/.gitignore

@@ -0,0 +1,13 @@
+*.class
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+
+# Packaged files #
+*.jar
+*.war
+*.ear

persistence-modules/spring-hibernate-5/README.md

@@ -0,0 +1,14 @@
+## Hibernate 5 with Spring
+
+This module contains articles about Hibernate 5 with Spring.
+
+### Relevant articles
+
+- [Hibernate Many to Many Annotation Tutorial](http://www.baeldung.com/hibernate-many-to-many)
+- [Programmatic Transactions in the Spring TestContext Framework](http://www.baeldung.com/spring-test-programmatic-transactions)
+- [JPA Criteria Queries](http://www.baeldung.com/hibernate-criteria-queries)
+- [Introduction to Hibernate Search](http://www.baeldung.com/hibernate-search)
+- [@DynamicUpdate with Spring Data JPA](https://www.baeldung.com/spring-data-jpa-dynamicupdate)
+- [Hibernate Second-Level Cache](http://www.baeldung.com/hibernate-second-level-cache)
+- [Deleting Objects with Hibernate](http://www.baeldung.com/delete-with-hibernate)
+- [Spring, Hibernate and a JNDI Datasource](http://www.baeldung.com/spring-persistence-jpa-jndi-datasource)

persistence-modules/spring-hibernate-5/pom.xml

@@ -0,0 +1,157 @@
+<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-hibernate-5</artifactId>
+    <version>0.1-SNAPSHOT</version>
+    <name>spring-hibernate-5</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../</relativePath>
+    </parent>
+
+    <dependencies>
+
+        <!-- Spring -->
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+            <version>${org.springframework.version}</version>
+            <exclusions>
+                <exclusion>
+                    <artifactId>commons-logging</artifactId>
+                    <groupId>commons-logging</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-aspects</artifactId>
+            <version>${org.springframework.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-ehcache</artifactId>
+            <version>${hibernate.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.transaction</groupId>
+            <artifactId>jta</artifactId>
+            <version>${jta.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-search-orm</artifactId>
+            <version>${hibernatesearch.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tomcat</groupId>
+            <artifactId>tomcat-dbcp</artifactId>
+            <version>${tomcat-dbcp.version}</version>
+        </dependency>
+
+        <!-- validation -->
+
+        <!-- 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>org.springframework.security</groupId>
+            <artifactId>spring-security-test</artifactId>
+            <version>${org.springframework.security.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.hsqldb</groupId>
+            <artifactId>hsqldb</artifactId>
+            <version>${hsqldb.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>${mysql-connector-java.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <version>${h2.version}</version>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <finalName>spring-hibernate-5</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+    </build>
+
+    <properties>
+        <!-- Spring -->
+        <org.springframework.version>5.0.2.RELEASE</org.springframework.version>
+        <org.springframework.data.version>1.10.6.RELEASE</org.springframework.data.version>
+        <org.springframework.security.version>4.2.1.RELEASE</org.springframework.security.version>
+
+        <!-- persistence -->
+        <hibernate.version>5.2.10.Final</hibernate.version>
+        <hibernatesearch.version>5.8.2.Final</hibernatesearch.version>
+        <mysql-connector-java.version>8.0.7-dmr</mysql-connector-java.version>
+        <tomcat-dbcp.version>9.0.0.M26</tomcat-dbcp.version>
+        <jta.version>1.1</jta.version>
+        <hsqldb.version>2.3.4</hsqldb.version>
+
+        <!-- util -->
+        <guava.version>21.0</guava.version>
+
+    </properties>
+
+</project>

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/bootstrap/BarHibernateDAO.java

@@ -0,0 +1,39 @@
+package com.baeldung.hibernate.bootstrap;
+
+import com.baeldung.hibernate.bootstrap.model.TestEntity;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+public abstract class BarHibernateDAO {
+
+    @Autowired
+    private SessionFactory sessionFactory;
+
+    public TestEntity findEntity(int id) {
+
+        return getCurrentSession().find(TestEntity.class, 1);
+    }
+
+    public void createEntity(TestEntity entity) {
+
+        getCurrentSession().save(entity);
+    }
+
+    public void createEntity(int id, String newDescription) {
+
+        TestEntity entity = findEntity(id);
+        entity.setDescription(newDescription);
+        getCurrentSession().save(entity);
+    }
+
+    public void deleteEntity(int id) {
+
+        TestEntity entity = findEntity(id);
+        getCurrentSession().delete(entity);
+    }
+
+    protected Session getCurrentSession() {
+        return sessionFactory.getCurrentSession();
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/bootstrap/HibernateConf.java

@@ -0,0 +1,61 @@
+package com.baeldung.hibernate.bootstrap;
+
+import com.google.common.base.Preconditions;
+import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.core.env.Environment;
+import org.springframework.orm.hibernate5.HibernateTransactionManager;
+import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import javax.sql.DataSource;
+import java.util.Properties;
+
+@Configuration
+@EnableTransactionManagement
+@PropertySource({ "classpath:persistence-h2.properties" })
+public class HibernateConf {
+
+    @Autowired
+    private Environment env;
+
+    @Bean
+    public LocalSessionFactoryBean sessionFactory() {
+        final LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
+        sessionFactory.setDataSource(dataSource());
+        sessionFactory.setPackagesToScan(new String[] { "com.baeldung.hibernate.bootstrap.model" });
+        sessionFactory.setHibernateProperties(hibernateProperties());
+
+        return sessionFactory;
+    }
+
+    @Bean
+    public DataSource dataSource() {
+        final BasicDataSource dataSource = new BasicDataSource();
+        dataSource.setDriverClassName(Preconditions.checkNotNull(env.getProperty("jdbc.driverClassName")));
+        dataSource.setUrl(Preconditions.checkNotNull(env.getProperty("jdbc.url")));
+        dataSource.setUsername(Preconditions.checkNotNull(env.getProperty("jdbc.user")));
+        dataSource.setPassword(Preconditions.checkNotNull(env.getProperty("jdbc.pass")));
+
+        return dataSource;
+    }
+
+    @Bean
+    public PlatformTransactionManager hibernateTransactionManager() {
+        final HibernateTransactionManager transactionManager = new HibernateTransactionManager();
+        transactionManager.setSessionFactory(sessionFactory().getObject());
+        return transactionManager;
+    }
+
+    private final Properties hibernateProperties() {
+        final Properties hibernateProperties = new Properties();
+        hibernateProperties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
+        hibernateProperties.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
+
+        return hibernateProperties;
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/bootstrap/HibernateXMLConf.java

@@ -0,0 +1,24 @@
+package com.baeldung.hibernate.bootstrap;
+
+import com.google.common.base.Preconditions;
+import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.ImportResource;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.core.env.Environment;
+import org.springframework.orm.hibernate5.HibernateTransactionManager;
+import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import javax.sql.DataSource;
+import java.util.Properties;
+
+@Configuration
+@EnableTransactionManagement
+@ImportResource({ "classpath:hibernate5Configuration.xml" })
+public class HibernateXMLConf {
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/bootstrap/model/TestEntity.java

@@ -0,0 +1,29 @@
+package com.baeldung.hibernate.bootstrap.model;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+
+@Entity
+public class TestEntity {
+
+    private int id;
+
+    private String description;
+
+    @Id
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/cache/dao/AbstractJpaDAO.java

@@ -0,0 +1,46 @@
+package com.baeldung.hibernate.cache.dao;
+
+import java.io.Serializable;
+import java.util.List;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+
+public abstract class AbstractJpaDAO<T extends Serializable> {
+
+    private Class<T> clazz;
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    public final void setClazz(final Class<T> clazzToSet) {
+        this.clazz = clazzToSet;
+    }
+
+    public T findOne(final long id) {
+        return entityManager.find(clazz, id);
+    }
+
+    @SuppressWarnings("unchecked")
+    public List<T> findAll() {
+        return entityManager.createQuery("from " + clazz.getName()).getResultList();
+    }
+
+    public void create(final T entity) {
+        entityManager.persist(entity);
+    }
+
+    public T update(final T entity) {
+        return entityManager.merge(entity);
+    }
+
+    public void delete(final T entity) {
+        entityManager.remove(entity);
+    }
+
+    public void deleteById(final long entityId) {
+        final T entity = findOne(entityId);
+        delete(entity);
+    }
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/cache/dao/FooDao.java

@@ -0,0 +1,17 @@
+package com.baeldung.hibernate.cache.dao;
+
+import com.baeldung.hibernate.cache.model.Foo;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class FooDao extends AbstractJpaDAO<Foo> implements IFooDao {
+
+    public FooDao() {
+        super();
+
+        setClazz(Foo.class);
+    }
+
+    // API
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/cache/dao/IFooDao.java

@@ -0,0 +1,21 @@
+package com.baeldung.hibernate.cache.dao;
+
+import java.util.List;
+
+import com.baeldung.hibernate.cache.model.Foo;
+
+public interface IFooDao {
+
+    Foo findOne(long id);
+
+    List<Foo> findAll();
+
+    void create(Foo entity);
+
+    Foo update(Foo entity);
+
+    void delete(Foo entity);
+
+    void deleteById(long entityId);
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/cache/model/Bar.java

@@ -0,0 +1,102 @@
+package com.baeldung.hibernate.cache.model;
+
+import java.io.Serializable;
+import java.util.List;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.OneToMany;
+import javax.persistence.OrderBy;
+
+@Entity
+public class Bar implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private long id;
+
+    @Column(nullable = false)
+    private String name;
+
+    @OneToMany(mappedBy = "bar", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
+    @OrderBy("name ASC")
+    List<Foo> fooList;
+
+    public Bar() {
+        super();
+    }
+
+    public Bar(final String name) {
+        super();
+
+        this.name = name;
+    }
+
+    // API
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(final long id) {
+
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+
+    public List<Foo> getFooList() {
+        return fooList;
+    }
+
+    public void setFooList(final List<Foo> fooList) {
+        this.fooList = fooList;
+    }
+
+    //
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((name == null) ? 0 : name.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 Bar other = (Bar) obj;
+        if (name == null) {
+            if (other.name != null)
+                return false;
+        } else if (!name.equals(other.name))
+            return false;
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder builder = new StringBuilder();
+        builder.append("Bar [name=").append(name).append("]");
+        return builder.toString();
+    }
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/cache/model/Foo.java

@@ -0,0 +1,92 @@
+package com.baeldung.hibernate.cache.model;
+
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import javax.persistence.*;
+import java.io.Serializable;
+
+@Entity
+@Cacheable
+@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class Foo implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    public Foo() {
+        super();
+    }
+
+    public Foo(final String name) {
+        super();
+
+        this.name = name;
+    }
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    @Column(name = "ID")
+    private Long id;
+    @Column(name = "NAME")
+    private String name;
+
+    @ManyToOne(targetEntity = Bar.class, fetch = FetchType.EAGER)
+    @JoinColumn(name = "BAR_ID")
+    private Bar bar;
+
+    public Bar getBar() {
+        return bar;
+    }
+
+    public void setBar(final Bar bar) {
+        this.bar = bar;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(final Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((name == null) ? 0 : name.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 Foo other = (Foo) obj;
+        if (name == null) {
+            if (other.name != null)
+                return false;
+        } else if (!name.equals(other.name))
+            return false;
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder builder = new StringBuilder();
+        builder.append("Foo [name=").append(name).append("]");
+        return builder.toString();
+    }
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/cache/service/FooService.java

@@ -0,0 +1,37 @@
+package com.baeldung.hibernate.cache.service;
+
+import java.util.List;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.baeldung.hibernate.cache.dao.IFooDao;
+import com.baeldung.hibernate.cache.model.Foo;
+
+@Service
+@Transactional
+public class FooService {
+
+    @Autowired
+    private IFooDao dao;
+
+    public FooService() {
+        super();
+    }
+
+    // API
+
+    public void create(final Foo entity) {
+        dao.create(entity);
+    }
+
+    public Foo findOne(final long id) {
+        return dao.findOne(id);
+    }
+
+    public List<Foo> findAll() {
+        return dao.findAll();
+    }
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/criteria/model/Item.java

@@ -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;
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/criteria/util/HibernateUtil.java

@@ -0,0 +1,19 @@
+package com.baeldung.hibernate.criteria.util;
+
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.cfg.Configuration;
+
+public class HibernateUtil {
+
+    @SuppressWarnings("deprecation")
+    public static Session getHibernateSession() {
+
+        final SessionFactory sf = new Configuration().configure("criteria.cfg.xml").buildSessionFactory();
+
+        // factory = new Configuration().configure().buildSessionFactory();
+        final Session session = sf.openSession();
+        return session;
+    }
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/criteria/view/ApplicationView.java

@@ -0,0 +1,335 @@
+/**
+ * ApplicationViewer is the class that starts the application
+ * First it creates the session object and then creates the
+ * criteria query.
+ *
+ *  @author  Pritam Banerjee
+ *  @version 1.0
+ *  @since   07/20/2016
+ */
+
+package com.baeldung.hibernate.criteria.view;
+
+import java.util.List;
+
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
+
+import org.hibernate.Session;
+import org.hibernate.query.Query;
+
+import com.baeldung.hibernate.criteria.model.Item;
+import com.baeldung.hibernate.criteria.util.HibernateUtil;
+
+public class ApplicationView {
+
+    // default Constructor
+    public ApplicationView() {
+
+    }
+
+    public boolean checkIfCriteriaTimeLower() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final CriteriaBuilder cb = session.getCriteriaBuilder();
+        final CriteriaQuery<Item> cr = cb.createQuery(Item.class);
+        final Root<Item> root = cr.from(Item.class);
+
+        // calculate the time taken by criteria
+        final long startTimeCriteria = System.nanoTime();
+        cr.select(root)
+            .where(cb.like(root.get("itemName"), "%item One%"));
+        // .add(Restrictions.like("itemName", "%item One%"));
+        Query<Item> query = session.createQuery(cr);
+
+        final List<Item> results = query.getResultList();
+        final long endTimeCriteria = System.nanoTime();
+        final long durationCriteria = (endTimeCriteria - startTimeCriteria) / 1000;
+
+        // calculate the time taken by HQL
+        final long startTimeHQL = System.nanoTime();
+        session.beginTransaction();
+        final List<Item> items = session.createQuery("FROM Item where itemName like '%item One%'")
+            .list();
+        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();
+        final CriteriaBuilder cb = session.getCriteriaBuilder();
+        final CriteriaQuery<Item> cr = cb.createQuery(Item.class);
+        final Root<Item> root = cr.from(Item.class);
+        cr.select(root)
+            .where(cb.gt(root.get("itemPrice"), 1000));
+        // cr.add(Restrictions.gt("itemPrice", 1000));
+        Query<Item> query = session.createQuery(cr);
+        final List<Item> greaterThanItemsList = query.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();
+        final CriteriaBuilder cb = session.getCriteriaBuilder();
+        final CriteriaQuery<Item> cr = cb.createQuery(Item.class);
+        final Root<Item> root = cr.from(Item.class);
+        cr.select(root)
+            .where(cb.lt(root.get("itemPrice"), 1000));
+        // cr.add(Restrictions.lt("itemPrice", 1000));
+        Query<Item> query = session.createQuery(cr);
+        final List<Item> lessThanItemsList = query.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();
+        final CriteriaBuilder cb = session.getCriteriaBuilder();
+        final CriteriaQuery<Item> cr = cb.createQuery(Item.class);
+        final Root<Item> root = cr.from(Item.class);
+        cr.select(root)
+            .where(cb.like(root.get("itemName"), "%chair%"));
+        // cr.add(Restrictions.like("itemName", "%chair%"));
+        Query<Item> query = session.createQuery(cr);
+        final List<Item> likeItemsList = query.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();
+        final CriteriaBuilder cb = session.getCriteriaBuilder();
+        final CriteriaQuery<Item> cr = cb.createQuery(Item.class);
+        final Root<Item> root = cr.from(Item.class);
+        cr.select(root)
+            .where(cb.like(cb.lower(root.get("itemName")), "%chair%"));
+        // cr.add(Restrictions.ilike("itemName", "%Chair%"));
+        Query<Item> query = session.createQuery(cr);
+        final List<Item> ilikeItemsList = query.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();
+        final CriteriaBuilder cb = session.getCriteriaBuilder();
+        final CriteriaQuery<Item> cr = cb.createQuery(Item.class);
+        final Root<Item> root = cr.from(Item.class);
+        cr.select(root)
+            .where(cb.between(root.get("itemPrice"), 100, 200));
+        // cr.add(Restrictions.between("itemPrice", 100, 200));
+        Query<Item> query = session.createQuery(cr);
+        final List<Item> betweenItemsList = query.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();
+        final CriteriaBuilder cb = session.getCriteriaBuilder();
+        final CriteriaQuery<Item> cr = cb.createQuery(Item.class);
+        final Root<Item> root = cr.from(Item.class);
+        cr.select(root)
+            .where(cb.isNull(root.get("itemDescription")));
+        // cr.add(Restrictions.isNull("itemDescription"));
+        Query<Item> query = session.createQuery(cr);
+        final List<Item> nullItemsList = query.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();
+        final CriteriaBuilder cb = session.getCriteriaBuilder();
+        final CriteriaQuery<Item> cr = cb.createQuery(Item.class);
+        final Root<Item> root = cr.from(Item.class);
+        cr.select(root)
+            .where(cb.isNotNull(root.get("itemDescription")));
+        // cr.add(Restrictions.isNotNull("itemDescription"));
+        Query<Item> query = session.createQuery(cr);
+        final List<Item> notNullItemsList = query.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();
+        final CriteriaBuilder cb = session.getCriteriaBuilder();
+        final CriteriaQuery<Item> cr = cb.createQuery(Item.class);
+        final Root<Item> root = cr.from(Item.class);
+        Predicate[] predicates = new Predicate[2];
+        predicates[0] = cb.isNull(root.get("itemDescription"));
+        predicates[1] = cb.like(root.get("itemName"), "chair%");
+        cr.select(root)
+            .where(predicates);
+        // cr.add(Restrictions.isNull("itemDescription"));
+        // cr.add(Restrictions.like("itemName", "chair%"));
+        Query<Item> query = session.createQuery(cr);
+        final List<Item> notNullItemsList = query.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() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final CriteriaBuilder cb = session.getCriteriaBuilder();
+        final CriteriaQuery<Item> cr = cb.createQuery(Item.class);
+        final Root<Item> root = cr.from(Item.class);
+        Predicate greaterThanPrice = cb.gt(root.get("itemPrice"), 1000);
+        Predicate chairItems = cb.like(root.get("itemName"), "Chair%");
+        cr.select(root)
+            .where(cb.and(greaterThanPrice, chairItems));
+        // final Criterion greaterThanPrice = Restrictions.gt("itemPrice", 1000);
+        // final Criterion chairItems = Restrictions.like("itemName", "Chair%");
+        // final LogicalExpression andExample = Restrictions.and(greaterThanPrice, chairItems);
+        // cr.add(andExample);
+        Query<Item> query = session.createQuery(cr);
+        final List<Item> andItemsList = query.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() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final CriteriaBuilder cb = session.getCriteriaBuilder();
+        final CriteriaQuery<Item> cr = cb.createQuery(Item.class);
+        final Root<Item> root = cr.from(Item.class);
+        Predicate greaterThanPrice = cb.gt(root.get("itemPrice"), 1000);
+        Predicate chairItems = cb.like(root.get("itemName"), "Chair%");
+        cr.select(root)
+            .where(cb.or(greaterThanPrice, chairItems));
+        Query<Item> query = session.createQuery(cr);
+        final List<Item> orItemsList = query.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() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final CriteriaBuilder cb = session.getCriteriaBuilder();
+        final CriteriaQuery<Item> cr = cb.createQuery(Item.class);
+        final Root<Item> root = cr.from(Item.class);
+        cr.select(root);
+        cr.orderBy(cb.asc(root.get("itemName")), cb.desc(root.get("itemPrice")));
+        // cr.addOrder(Order.asc("itemName"));
+        // cr.addOrder(Order.desc("itemPrice")).list();
+        Query<Item> query = session.createQuery(cr);
+        final List<Item> sortedItemsList = query.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();
+        final CriteriaBuilder cb = session.getCriteriaBuilder();
+        final CriteriaQuery<Long> cr = cb.createQuery(Long.class);
+        final Root<Item> root = cr.from(Item.class);
+        cr.select(cb.count(root));
+        Query<Long> query = session.createQuery(cr);
+        final List<Long> itemProjected = query.getResultList();
+        // session.createCriteria(Item.class).setProjection(Projections.rowCount()).list();
+        final Long projectedRowCount[] = new Long[itemProjected.size()];
+        for (int i = 0; i < itemProjected.size(); i++) {
+            projectedRowCount[i] = itemProjected.get(i);
+        }
+        session.close();
+        return projectedRowCount;
+    }
+
+    // Set projections average of itemPrice
+    public Double[] projectionAverage() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final CriteriaBuilder cb = session.getCriteriaBuilder();
+        final CriteriaQuery<Double> cr = cb.createQuery(Double.class);
+        final Root<Item> root = cr.from(Item.class);
+        cr.select(cb.avg(root.get("itemPrice")));
+        Query<Double> query = session.createQuery(cr);
+        final List avgItemPriceList = query.getResultList();
+        // session.createCriteria(Item.class).setProjection(Projections.projectionList().add(Projections.avg("itemPrice"))).list();
+
+        final Double avgItemPrice[] = new Double[avgItemPriceList.size()];
+        for (int i = 0; i < avgItemPriceList.size(); i++) {
+            avgItemPrice[i] = (Double) avgItemPriceList.get(i);
+        }
+        session.close();
+        return avgItemPrice;
+    }
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/dynamicupdate/AccountRepository.java

@@ -0,0 +1,11 @@
+package com.baeldung.hibernate.dynamicupdate;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import com.baeldung.hibernate.dynamicupdate.model.Account;
+
+@Repository
+public interface AccountRepository extends JpaRepository<Account, Integer> {
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/dynamicupdate/DynamicUpdateConfig.java

@@ -0,0 +1,80 @@
+package com.baeldung.hibernate.dynamicupdate;
+
+import java.util.Properties;
+
+import javax.persistence.EntityManagerFactory;
+import javax.sql.DataSource;
+
+import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.core.env.Environment;
+import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.JpaVendorAdapter;
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import com.google.common.base.Preconditions;
+
+@EnableTransactionManagement
+@Configuration
+@PropertySource({ "classpath:persistence-h2.properties" })
+@EnableJpaRepositories(basePackages = { "com.baeldung.hibernate.dynamicupdate" })
+@ComponentScan({ "com.baeldung.hibernate.dynamicupdate" })
+public class DynamicUpdateConfig {
+
+    @Autowired
+    private Environment env;
+
+    @Bean
+    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
+        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
+        em.setDataSource(dataSource());
+        em.setPackagesToScan(new String[] { "com.baeldung.hibernate.dynamicupdate.model" });
+
+        JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
+        em.setJpaVendorAdapter(vendorAdapter);
+        em.setJpaProperties(additionalProperties());
+
+        return em;
+    }
+
+    @Bean
+    public DataSource dataSource() {
+        final BasicDataSource dataSource = new BasicDataSource();
+        dataSource.setDriverClassName(Preconditions.checkNotNull(env.getProperty("jdbc.driverClassName")));
+        dataSource.setUrl(Preconditions.checkNotNull(env.getProperty("jdbc.url")));
+        dataSource.setUsername(env.getProperty("jdbc.user"));
+        dataSource.setPassword(env.getProperty("jdbc.pass"));
+
+        return dataSource;
+    }
+
+    @Bean
+    public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
+        JpaTransactionManager transactionManager = new JpaTransactionManager();
+        transactionManager.setEntityManagerFactory(emf);
+
+        return transactionManager;
+    }
+
+    @Bean
+    public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
+        return new PersistenceExceptionTranslationPostProcessor();
+    }
+
+    Properties additionalProperties() {
+        Properties properties = new Properties();
+        properties.setProperty("hibernate.hbm2ddl.auto", Preconditions.checkNotNull(env.getProperty("hibernate.hbm2ddl.auto")));
+        properties.setProperty("hibernate.dialect", Preconditions.checkNotNull(env.getProperty("hibernate.dialect")));
+        properties.setProperty("hibernate.show_sql", "true");
+        return properties;
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/dynamicupdate/model/Account.java

@@ -0,0 +1,97 @@
+package com.baeldung.hibernate.dynamicupdate.model;
+
+import java.text.MessageFormat;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+
+import org.hibernate.annotations.DynamicUpdate;
+
+@Entity
+@DynamicUpdate
+public class Account {
+
+    @Id
+    private int id;
+
+    @Column
+    private String name;
+
+    @Column
+    private String type;
+
+    @Column
+    private boolean active;
+
+    public Account() {
+    }
+
+    public Account(int id, String name, String type, boolean active) {
+        super();
+        this.id = id;
+        this.name = name;
+        this.type = type;
+        this.active = active;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public boolean isActive() {
+        return active;
+    }
+
+    public void setActive(boolean active) {
+        this.active = active;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + id;
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        Account other = (Account) obj;
+        if (id != other.id)
+            return false;
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return MessageFormat.format("id:{0}, name:{1}, active:{2}, type:{3}", id, name, active, type);
+    }
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/immutable/entities/Event.java

@@ -0,0 +1,58 @@
+package com.baeldung.hibernate.immutable.entities;
+
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
+import org.hibernate.annotations.Immutable;
+
+import javax.persistence.*;
+import java.util.Set;
+
+@Entity
+@Immutable
+@Table(name = "events")
+public class Event {
+
+    @Id
+    @Column(name = "event_id")
+    private Long id;
+
+    @Column(name = "title")
+    private String title;
+
+    @ElementCollection
+    @Immutable
+    private Set<String> guestList;
+
+    public Event() {}
+
+    public Event(Long id, String title, Set<String> guestList) {
+        this.id = id;
+        this.title = title;
+        this.guestList = guestList;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    @Cascade({ CascadeType.SAVE_UPDATE, CascadeType.DELETE })
+    public Set<String> getGuestList() {
+        return guestList;
+    }
+
+    public void setGuestList(Set<String> guestList) {
+        this.guestList = guestList;
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/immutable/entities/EventGeneratedId.java

@@ -0,0 +1,55 @@
+package com.baeldung.hibernate.immutable.entities;
+
+import org.hibernate.annotations.GenericGenerator;
+import org.hibernate.annotations.Immutable;
+
+import javax.persistence.*;
+
+@Entity
+@Immutable
+@Table(name = "events_generated")
+public class EventGeneratedId {
+
+    @Id
+    @Column(name = "event_generated_id")
+    @GeneratedValue(generator = "increment")
+    @GenericGenerator(name = "increment", strategy = "increment")
+    private Long id;
+
+    @Column(name = "name")
+    private String name;
+    @Column(name = "description")
+    private String description;
+
+    public EventGeneratedId() {
+    }
+
+    public EventGeneratedId(String name, String description) {
+        this.name = name;
+        this.description = description;
+    }
+
+    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 getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/immutable/util/HibernateUtil.java

@@ -0,0 +1,31 @@
+package com.baeldung.hibernate.immutable.util;
+
+import com.baeldung.hibernate.immutable.entities.Event;
+import com.baeldung.hibernate.immutable.entities.EventGeneratedId;
+import org.hibernate.SessionFactory;
+import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
+import org.hibernate.cfg.Configuration;
+import org.hibernate.service.ServiceRegistry;
+
+public class HibernateUtil {
+    private static final SessionFactory sessionFactory = buildSessionFactory();
+
+    private static SessionFactory buildSessionFactory() {
+        try {
+            // Create a session factory from immutable.cfg.xml
+            Configuration configuration = new Configuration();
+            configuration.addAnnotatedClass(Event.class);
+            configuration.addAnnotatedClass(EventGeneratedId.class);
+            configuration.configure("immutable.cfg.xml");
+            ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
+            return configuration.buildSessionFactory(serviceRegistry);
+        } catch (Throwable ex) {
+            System.out.println("Initial SessionFactory creation failed." + ex);
+            throw new ExceptionInInitializerError(ex);
+        }
+    }
+
+    public static SessionFactory getSessionFactory() {
+        return sessionFactory;
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/manytomany/model/Employee.java

@@ -0,0 +1,88 @@
+package com.baeldung.hibernate.manytomany.model;
+
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Column;
+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.ManyToMany;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "Employee")
+public class Employee implements Serializable {
+    @Id
+    @Column(name = "employee_id")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long employeeId;
+
+    @Column(name = "first_name")
+    private String firstName;
+
+    @Column(name = "last_name")
+    private String lastName;
+
+    @ManyToMany(cascade = { CascadeType.ALL })
+    @JoinTable(
+      name = "Employee_Project", 
+      joinColumns = { @JoinColumn(name = "employee_id") }, 
+      inverseJoinColumns = { @JoinColumn(name = "project_id") }
+    )
+    Set<Project> projects = new HashSet<Project>();
+   
+
+    public Employee() {
+       super();
+    }
+
+    public Employee(String firstName, String lastName) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+    
+    public Employee(String firstName, String lastName, Set<Project> projects) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.projects = projects;
+    }
+    
+
+    public Long getEmployeeId() {
+        return employeeId;
+    }
+
+    public void setEmployeeId(Long employeeId) {
+        this.employeeId = employeeId;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    public Set<Project> getProjects() {
+        return projects;
+    }
+
+    public void setProjects(Set<Project> projects) {
+        this.projects = projects;
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/manytomany/model/Project.java

@@ -0,0 +1,61 @@
+package com.baeldung.hibernate.manytomany.model;
+
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.Set;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.ManyToMany;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "Project")
+public class Project implements Serializable {
+
+    @Id
+    @Column(name = "project_id")
+    @GeneratedValue
+    private Long projectId;
+
+    @Column(name = "title")
+    private String title;
+
+    @ManyToMany(mappedBy = "projects")
+    private Set<Employee> employees = new HashSet<Employee>();
+    
+    public Project() {
+        super();
+    }
+
+    public Project(String title) {
+        this.title = title;
+    }
+
+    public Long getProjectId() {
+        return projectId;
+    }
+
+    public void setProjectId(Long projectId) {
+        this.projectId = projectId;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public Set<Employee> getEmployees() {
+        return employees;
+    }
+
+    public void setEmployees(Set<Employee> employees) {
+        this.employees = employees;
+    }
+    
+    
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernate/manytomany/util/HibernateUtil.java

@@ -0,0 +1,41 @@
+package com.baeldung.hibernate.manytomany.util;
+
+import org.hibernate.SessionFactory;
+import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
+import org.hibernate.cfg.Configuration;
+import org.hibernate.service.ServiceRegistry;
+import com.baeldung.hibernate.manytomany.model.Employee;
+import com.baeldung.hibernate.manytomany.model.Project;
+
+public class HibernateUtil {
+    private static SessionFactory sessionFactory;
+
+    private static SessionFactory buildSessionFactory() {
+        try {
+            // Create the SessionFactory from hibernate-annotation.cfg.xml
+            Configuration configuration = new Configuration();
+            configuration.addAnnotatedClass(Employee.class);
+            configuration.addAnnotatedClass(Project.class);
+            configuration.configure("manytomany.cfg.xml");
+            System.out.println("Hibernate Annotation Configuration loaded");
+
+            ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties())
+                .build();
+            System.out.println("Hibernate Annotation serviceRegistry created");
+
+            SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
+
+            return sessionFactory;
+        } catch (Throwable ex) {
+            System.err.println("Initial SessionFactory creation failed." + ex);
+            ex.printStackTrace();
+            throw new ExceptionInInitializerError(ex);
+        }
+    }
+
+    public static SessionFactory getSessionFactory() {
+        if (sessionFactory == null)
+            sessionFactory = buildSessionFactory();
+        return sessionFactory;
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernatesearch/HibernateSearchConfig.java

@@ -0,0 +1,78 @@
+package com.baeldung.hibernatesearch;
+
+import com.google.common.base.Preconditions;
+import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.core.env.Environment;
+import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.jdbc.datasource.DriverManagerDataSource;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.JpaVendorAdapter;
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import javax.persistence.EntityManagerFactory;
+import javax.sql.DataSource;
+import java.util.Properties;
+
+@EnableTransactionManagement
+@Configuration
+@PropertySource({ "classpath:persistence-h2.properties" })
+@EnableJpaRepositories(basePackages = { "com.baeldung.hibernatesearch" })
+@ComponentScan({ "com.baeldung.hibernatesearch" })
+public class HibernateSearchConfig {
+
+    @Autowired
+    private Environment env;
+
+    @Bean
+    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
+        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
+        em.setDataSource(dataSource());
+        em.setPackagesToScan(new String[] { "com.baeldung.hibernatesearch.model" });
+
+        JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
+        em.setJpaVendorAdapter(vendorAdapter);
+        em.setJpaProperties(additionalProperties());
+
+        return em;
+    }
+
+    @Bean
+    public DataSource dataSource() {
+        final BasicDataSource dataSource = new BasicDataSource();
+        dataSource.setDriverClassName(Preconditions.checkNotNull(env.getProperty("jdbc.driverClassName")));
+        dataSource.setUrl(Preconditions.checkNotNull(env.getProperty("jdbc.url")));
+        dataSource.setUsername(env.getProperty("jdbc.user"));
+        dataSource.setPassword(env.getProperty("jdbc.pass"));
+
+        return dataSource;
+    }
+
+    @Bean
+    public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
+        JpaTransactionManager transactionManager = new JpaTransactionManager();
+        transactionManager.setEntityManagerFactory(emf);
+
+        return transactionManager;
+    }
+
+    @Bean
+    public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
+        return new PersistenceExceptionTranslationPostProcessor();
+    }
+
+    Properties additionalProperties() {
+        Properties properties = new Properties();
+        properties.setProperty("hibernate.hbm2ddl.auto", Preconditions.checkNotNull(env.getProperty("hibernate.hbm2ddl.auto")));
+        properties.setProperty("hibernate.dialect", Preconditions.checkNotNull(env.getProperty("hibernate.dialect")));
+        return properties;
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernatesearch/ProductSearchDao.java

@@ -0,0 +1,195 @@
+package com.baeldung.hibernatesearch;
+
+import com.baeldung.hibernatesearch.model.Product;
+import org.apache.lucene.search.Query;
+import org.hibernate.search.engine.ProjectionConstants;
+import org.hibernate.search.jpa.FullTextEntityManager;
+import org.hibernate.search.jpa.FullTextQuery;
+import org.hibernate.search.jpa.Search;
+import org.hibernate.search.query.dsl.QueryBuilder;
+import org.springframework.stereotype.Repository;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import java.util.List;
+
+@Repository
+public class ProductSearchDao {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    public List<Product> searchProductNameByKeywordQuery(String text) {
+
+        Query keywordQuery = getQueryBuilder()
+            .keyword()
+            .onField("productName")
+            .matching(text)
+            .createQuery();
+
+        List<Product> results = getJpaQuery(keywordQuery).getResultList();
+
+        return results;
+    }
+
+    public List<Product> searchProductNameByFuzzyQuery(String text) {
+
+        Query fuzzyQuery = getQueryBuilder()
+            .keyword()
+            .fuzzy()
+            .withEditDistanceUpTo(2)
+            .withPrefixLength(0)
+            .onField("productName")
+            .matching(text)
+            .createQuery();
+
+        List<Product> results = getJpaQuery(fuzzyQuery).getResultList();
+
+        return results;
+    }
+
+    public List<Product> searchProductNameByWildcardQuery(String text) {
+
+        Query wildcardQuery = getQueryBuilder()
+            .keyword()
+            .wildcard()
+            .onField("productName")
+            .matching(text)
+            .createQuery();
+
+        List<Product> results = getJpaQuery(wildcardQuery).getResultList();
+
+        return results;
+    }
+
+    public List<Product> searchProductDescriptionByPhraseQuery(String text) {
+
+        Query phraseQuery = getQueryBuilder()
+            .phrase()
+            .withSlop(1)
+            .onField("description")
+            .sentence(text)
+            .createQuery();
+
+        List<Product> results = getJpaQuery(phraseQuery).getResultList();
+
+        return results;
+    }
+
+    public List<Product> searchProductNameAndDescriptionBySimpleQueryStringQuery(String text) {
+
+        Query simpleQueryStringQuery = getQueryBuilder()
+            .simpleQueryString()
+            .onFields("productName", "description")
+            .matching(text)
+            .createQuery();
+
+        List<Product> results = getJpaQuery(simpleQueryStringQuery).getResultList();
+
+        return results;
+    }
+
+    public List<Product> searchProductNameByRangeQuery(int low, int high) {
+
+        Query rangeQuery = getQueryBuilder()
+            .range()
+            .onField("memory")
+            .from(low)
+            .to(high)
+            .createQuery();
+
+        List<Product> results = getJpaQuery(rangeQuery).getResultList();
+
+        return results;
+    }
+
+    public List<Object[]> searchProductNameByMoreLikeThisQuery(Product entity) {
+
+        Query moreLikeThisQuery = getQueryBuilder()
+            .moreLikeThis()
+            .comparingField("productName")
+            .toEntity(entity)
+            .createQuery();
+
+        List<Object[]> results = getJpaQuery(moreLikeThisQuery).setProjection(ProjectionConstants.THIS, ProjectionConstants.SCORE)
+            .getResultList();
+
+        return results;
+    }
+
+    public List<Product> searchProductNameAndDescriptionByKeywordQuery(String text) {
+
+        Query keywordQuery = getQueryBuilder()
+            .keyword()
+            .onFields("productName", "description")
+            .matching(text)
+            .createQuery();
+
+        List<Product> results = getJpaQuery(keywordQuery).getResultList();
+
+        return results;
+    }
+
+    public List<Object[]> searchProductNameAndDescriptionByMoreLikeThisQuery(Product entity) {
+
+        Query moreLikeThisQuery = getQueryBuilder()
+            .moreLikeThis()
+            .comparingField("productName")
+            .toEntity(entity)
+            .createQuery();
+
+        List<Object[]> results = getJpaQuery(moreLikeThisQuery).setProjection(ProjectionConstants.THIS, ProjectionConstants.SCORE)
+            .getResultList();
+
+        return results;
+    }
+
+    public List<Product> searchProductNameAndDescriptionByCombinedQuery(String manufactorer, int memoryLow, int memoryTop, String extraFeature, String exclude) {
+
+        Query combinedQuery = getQueryBuilder()
+            .bool()
+            .must(getQueryBuilder().keyword()
+                .onField("productName")
+                .matching(manufactorer)
+                .createQuery())
+            .must(getQueryBuilder()
+                .range()
+                .onField("memory")
+                .from(memoryLow)
+                .to(memoryTop)
+                .createQuery())
+            .should(getQueryBuilder()
+                .phrase()
+                .onField("description")
+                .sentence(extraFeature)
+                .createQuery())
+            .must(getQueryBuilder()
+                .keyword()
+                .onField("productName")
+                .matching(exclude)
+                .createQuery())
+            .not()
+            .createQuery();
+
+        List<Product> results = getJpaQuery(combinedQuery).getResultList();
+
+        return results;
+    }
+
+    private FullTextQuery getJpaQuery(org.apache.lucene.search.Query luceneQuery) {
+
+        FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
+
+        return fullTextEntityManager.createFullTextQuery(luceneQuery, Product.class);
+    }
+
+    private QueryBuilder getQueryBuilder() {
+
+        FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
+
+        return fullTextEntityManager.getSearchFactory()
+            .buildQueryBuilder()
+            .forEntity(Product.class)
+            .get();
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/hibernatesearch/model/Product.java

@@ -0,0 +1,94 @@
+package com.baeldung.hibernatesearch.model;
+
+import org.hibernate.search.annotations.*;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Entity
+@Indexed
+@Table(name = "product")
+public class Product {
+
+    @Id
+    private int id;
+
+    @Field(termVector = TermVector.YES)
+    private String productName;
+
+    @Field(termVector = TermVector.YES)
+    private String description;
+
+    @Field
+    private int memory;
+
+    public Product(int id, String productName, int memory, String description) {
+        this.id = id;
+        this.productName = productName;
+        this.memory = memory;
+        this.description = description;
+    }
+
+    public Product() {
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (!(o instanceof Product))
+            return false;
+
+        Product product = (Product) o;
+
+        if (id != product.id)
+            return false;
+        if (memory != product.memory)
+            return false;
+        if (!productName.equals(product.productName))
+            return false;
+        return description.equals(product.description);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = id;
+        result = 31 * result + productName.hashCode();
+        result = 31 * result + memory;
+        result = 31 * result + description.hashCode();
+        return result;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getProductName() {
+        return productName;
+    }
+
+    public void setProductName(String productName) {
+        this.productName = productName;
+    }
+
+    public int getMemory() {
+        return memory;
+    }
+
+    public void setMemory(int memory) {
+        this.memory = memory;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/manytomany/spring/PersistenceConfig.java

@@ -0,0 +1,70 @@
+package com.baeldung.manytomany.spring;
+
+import java.util.Properties;
+import javax.sql.DataSource;
+import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.core.env.Environment;
+import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
+import org.springframework.orm.hibernate5.HibernateTransactionManager;
+import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+
+
+@Configuration
+@EnableTransactionManagement
+@PropertySource({ "classpath:persistence-h2.properties" })
+@ComponentScan({ "com.baeldung.hibernate.manytomany" })
+public class PersistenceConfig {
+
+    @Autowired
+    private Environment env;
+    
+    @Bean
+    public LocalSessionFactoryBean sessionFactory() {
+        final LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
+        sessionFactory.setDataSource(restDataSource());
+        sessionFactory.setPackagesToScan(new String[] { "com.baeldung.hibernate.manytomany" });
+        sessionFactory.setHibernateProperties(hibernateProperties());
+
+        return sessionFactory;
+    }
+    
+    @Bean
+    public DataSource restDataSource() {
+        final BasicDataSource dataSource = new BasicDataSource();
+        dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName"));
+        dataSource.setUrl(env.getProperty("jdbc.url"));
+        dataSource.setUsername(env.getProperty("jdbc.user"));
+        dataSource.setPassword(env.getProperty("jdbc.pass"));
+
+        return dataSource;
+    }
+    
+    @Bean
+    public PlatformTransactionManager hibernateTransactionManager() {
+        final HibernateTransactionManager transactionManager = new HibernateTransactionManager();
+        transactionManager.setSessionFactory(sessionFactory().getObject());
+        return transactionManager;
+    }
+    
+    @Bean
+    public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
+        return new PersistenceExceptionTranslationPostProcessor();
+    }
+    
+    private final Properties hibernateProperties() {
+        final Properties hibernateProperties = new Properties();
+        hibernateProperties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
+        hibernateProperties.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
+        hibernateProperties.setProperty("hibernate.show_sql", "true");
+     
+        return hibernateProperties;
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/persistence/dao/IFooDao.java

@@ -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> {
+    //
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/persistence/dao/common/AbstractDao.java

@@ -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);
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/persistence/dao/common/AbstractHibernateDao.java

@@ -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();
+    }
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/persistence/dao/common/IOperations.java

@@ -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);
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/persistence/dao/impl/FooHibernateDao.java

@@ -0,0 +1,19 @@
+package com.baeldung.persistence.dao.impl;
+
+import com.baeldung.persistence.dao.common.AbstractHibernateDao;
+import com.baeldung.persistence.dao.IFooDao;
+import com.baeldung.persistence.model.Foo;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class FooHibernateDao extends AbstractHibernateDao<Foo> implements IFooDao {
+
+    public FooHibernateDao() {
+        super();
+
+        setClazz(Foo.class);
+    }
+
+    // API
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/persistence/manytomany/dao/IEmployeeDao.java

@@ -0,0 +1,8 @@
+package com.baeldung.persistence.manytomany.dao;
+
+import com.baeldung.hibernate.manytomany.model.Employee;
+import com.baeldung.persistence.dao.common.IOperations;
+
+public interface IEmployeeDao extends IOperations<Employee>{
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/persistence/manytomany/dao/IProjectDao.java

@@ -0,0 +1,8 @@
+package com.baeldung.persistence.manytomany.dao;
+
+import com.baeldung.hibernate.manytomany.model.Project;
+import com.baeldung.persistence.dao.common.IOperations;
+
+public interface IProjectDao extends IOperations<Project>{
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/persistence/manytomany/dao/impl/EmployeeDao.java

@@ -0,0 +1,16 @@
+package com.baeldung.persistence.manytomany.dao.impl;
+
+import org.springframework.stereotype.Repository;
+import com.baeldung.hibernate.manytomany.model.Employee;
+import com.baeldung.persistence.dao.common.AbstractHibernateDao;
+import com.baeldung.persistence.manytomany.dao.IEmployeeDao;
+
+@Repository
+public class EmployeeDao extends AbstractHibernateDao<Employee> implements IEmployeeDao {
+
+    public EmployeeDao() {
+        super();
+
+        setClazz(Employee.class);
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/persistence/manytomany/dao/impl/ProjectDao.java

@@ -0,0 +1,17 @@
+package com.baeldung.persistence.manytomany.dao.impl;
+
+import org.springframework.stereotype.Repository;
+import com.baeldung.hibernate.manytomany.model.Project;
+import com.baeldung.persistence.dao.common.AbstractHibernateDao;
+import com.baeldung.persistence.manytomany.dao.IProjectDao;
+
+
+@Repository
+public class ProjectDao extends AbstractHibernateDao<Project> implements IProjectDao {
+
+    public ProjectDao() {
+        super();
+
+        setClazz(Project.class);
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/persistence/model/Foo.java

@@ -0,0 +1,73 @@
+package com.baeldung.persistence.model;
+
+import javax.persistence.*;
+import java.io.Serializable;
+
+@Entity
+public class Foo implements Serializable {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    @Column(name = "id")
+    private long id;
+
+    @Column(name = "name")
+    private String name;
+
+    public Foo() {
+        super();
+    }
+
+    public Foo(final String name) {
+        super();
+        this.name = name;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(final long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((name == null) ? 0 : name.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 Foo other = (Foo) obj;
+        if (name == null) {
+            if (other.name != null)
+                return false;
+        } else if (!name.equals(other.name))
+            return false;
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder builder = new StringBuilder();
+        builder.append("Foo [name=").append(name).append("]");
+        return builder.toString();
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/spring/PersistenceConfig.java

@@ -0,0 +1,82 @@
+package com.baeldung.spring;
+
+import com.baeldung.persistence.dao.IFooDao;
+import com.baeldung.persistence.dao.impl.FooHibernateDao;
+import com.google.common.base.Preconditions;
+import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.core.env.Environment;
+import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
+import org.springframework.orm.hibernate5.HibernateTransactionManager;
+import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import javax.sql.DataSource;
+import java.util.Properties;
+
+@Configuration
+@EnableTransactionManagement
+@PropertySource({ "classpath:persistence-h2.properties" })
+@ComponentScan({ "com.baeldung.persistence" })
+public class PersistenceConfig {
+
+    @Autowired
+    private Environment env;
+
+    @Bean
+    public LocalSessionFactoryBean sessionFactory() {
+        final LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
+        sessionFactory.setDataSource(dataSource());
+        sessionFactory.setPackagesToScan(new String[] { "com.baeldung.persistence.model" });
+        sessionFactory.setHibernateProperties(hibernateProperties());
+
+        return sessionFactory;
+    }
+
+    @Bean
+    public DataSource dataSource() {
+        final BasicDataSource dataSource = new BasicDataSource();
+        dataSource.setDriverClassName(Preconditions.checkNotNull(env.getProperty("jdbc.driverClassName")));
+        dataSource.setUrl(Preconditions.checkNotNull(env.getProperty("jdbc.url")));
+        dataSource.setUsername(Preconditions.checkNotNull(env.getProperty("jdbc.user")));
+        dataSource.setPassword(Preconditions.checkNotNull(env.getProperty("jdbc.pass")));
+
+        return dataSource;
+    }
+
+    @Bean
+    public PlatformTransactionManager hibernateTransactionManager() {
+        final HibernateTransactionManager transactionManager = new HibernateTransactionManager();
+        transactionManager.setSessionFactory(sessionFactory().getObject());
+        return transactionManager;
+    }
+
+    @Bean
+    public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
+        return new PersistenceExceptionTranslationPostProcessor();
+    }
+
+    @Bean
+    public IFooDao fooHibernateDao() {
+        return new FooHibernateDao();
+    }
+
+    private final Properties hibernateProperties() {
+        final Properties hibernateProperties = new Properties();
+        hibernateProperties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
+        hibernateProperties.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
+
+        hibernateProperties.setProperty("hibernate.show_sql", "true");
+
+        // Envers properties
+        hibernateProperties.setProperty("org.hibernate.envers.audit_table_suffix", env.getProperty("envers.audit_table_suffix"));
+
+        return hibernateProperties;
+    }
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/spring/PersistenceJNDIConfig.java

@@ -0,0 +1,66 @@
+package com.baeldung.spring;
+
+import java.util.Properties;
+
+import javax.naming.NamingException;
+import javax.persistence.EntityManagerFactory;
+import javax.sql.DataSource;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.core.env.Environment;
+import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.jndi.JndiTemplate;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+@Configuration
+@EnableTransactionManagement
+@PropertySource("classpath:persistence-jndi.properties")
+@ComponentScan("com.baeldung.hibernate.cache")
+@EnableJpaRepositories(basePackages = "com.baeldung.hibernate.cache.dao")
+public class PersistenceJNDIConfig {
+
+    @Autowired
+    private Environment env;
+
+    @Bean
+    public LocalContainerEntityManagerFactoryBean entityManagerFactory() throws NamingException {
+        final LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
+        em.setDataSource(dataSource());
+        em.setPackagesToScan("com.baeldung.hibernate.cache.model");
+        em.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
+        em.setJpaProperties(additionalProperties());
+        return em;
+    }
+
+    @Bean
+    public DataSource dataSource() throws NamingException {
+        return (DataSource) new JndiTemplate().lookup(env.getProperty("jdbc.url"));
+    }
+
+    @Bean
+    public PlatformTransactionManager transactionManager(final EntityManagerFactory emf) {
+        return new JpaTransactionManager(emf);
+    }
+
+    @Bean
+    public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
+        return new PersistenceExceptionTranslationPostProcessor();
+    }
+
+    final Properties additionalProperties() {
+        final Properties hibernateProperties = new Properties();
+        hibernateProperties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
+        hibernateProperties.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
+        hibernateProperties.setProperty("hibernate.cache.use_second_level_cache", "false");
+        return hibernateProperties;
+    }
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/spring/PersistenceJPAConfigL2Cache.java

@@ -0,0 +1,89 @@
+package com.baeldung.spring;
+
+import com.google.common.base.Preconditions;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.core.env.Environment;
+import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.jdbc.datasource.DriverManagerDataSource;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import javax.persistence.EntityManagerFactory;
+import javax.sql.DataSource;
+import java.util.Properties;
+
+@Configuration
+@EnableTransactionManagement
+@PropertySource({ "classpath:persistence-h2.properties" })
+@ComponentScan({ "com.baeldung.hibernate.cache" })
+@EnableJpaRepositories(basePackages = { "com.baeldung.hibernate.cache.dao"})
+public class PersistenceJPAConfigL2Cache {
+
+    @Autowired
+    private Environment env;
+
+    public PersistenceJPAConfigL2Cache() {
+        super();
+    }
+
+    // beans
+
+    @Bean
+    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
+        final LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
+        em.setDataSource(dataSource());
+        em.setPackagesToScan(getPackagesToScan());
+
+        final HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
+        em.setJpaVendorAdapter(vendorAdapter);
+        em.setJpaProperties(additionalProperties());
+
+        return em;
+    }
+
+    protected String[] getPackagesToScan() {
+        return new String[] { "com.baeldung.hibernate.cache.model" };
+    }
+
+    @Bean
+    public DataSource dataSource() {
+        final DriverManagerDataSource dataSource = new DriverManagerDataSource();
+        dataSource.setDriverClassName(Preconditions.checkNotNull(env.getProperty("jdbc.driverClassName")));
+        dataSource.setUrl(Preconditions.checkNotNull(env.getProperty("jdbc.url")));
+        dataSource.setUsername(Preconditions.checkNotNull(env.getProperty("jdbc.user")));
+
+        return dataSource;
+    }
+
+    @Bean
+    public PlatformTransactionManager transactionManager(final EntityManagerFactory emf) {
+        final JpaTransactionManager transactionManager = new JpaTransactionManager();
+        transactionManager.setEntityManagerFactory(emf);
+        return transactionManager;
+    }
+
+    @Bean
+    public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
+        return new PersistenceExceptionTranslationPostProcessor();
+    }
+
+    final Properties additionalProperties() {
+        final Properties hibernateProperties = new Properties();
+        hibernateProperties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
+        hibernateProperties.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
+        hibernateProperties.setProperty("hibernate.cache.use_second_level_cache", env.getProperty("hibernate.cache.use_second_level_cache"));
+        hibernateProperties.setProperty("hibernate.cache.use_query_cache", env.getProperty("hibernate.cache.use_query_cache"));
+        hibernateProperties.setProperty("hibernate.cache.region.factory_class", env.getProperty("hibernate.cache.region.factory_class"));
+        hibernateProperties.setProperty("hibernate.show_sql", env.getProperty("hibernate.show_sql"));
+        return hibernateProperties;
+    }
+
+}

persistence-modules/spring-hibernate-5/src/main/java/com/baeldung/spring/PersistenceXmlConfig.java

@@ -0,0 +1,14 @@
+package com.baeldung.spring;
+
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.ImportResource;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+@Configuration
+@EnableTransactionManagement
+@ComponentScan({ "com.baeldung.persistence.dao", "com.baeldung.persistence.service" })
+@ImportResource({ "classpath:hibernate5Config.xml" })
+public class PersistenceXmlConfig {
+
+}

persistence-modules/spring-hibernate-5/src/main/resources/hibernate5Config.xml

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
+    xsi:schemaLocation="
+      http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
+      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd"
+>
+
+    <context:property-placeholder location="classpath:persistence-mysql.properties"/>
+
+    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
+        <property name="dataSource" ref="dataSource"/>
+        <property name="packagesToScan" value="com.baeldung.persistence.model"/>
+        <property name="hibernateProperties">
+            <props>
+                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
+                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
+            </props>
+        </property>
+    </bean>
+
+    <bean id="dataSource" class="org.apache.tomcat.dbcp.dbcp2.BasicDataSource">
+        <property name="driverClassName" value="${jdbc.driverClassName}"/>
+        <property name="url" value="${jdbc.url}"/>
+        <property name="username" value="${jdbc.eventGeneratedId}"/>
+        <property name="password" value="${jdbc.pass}"/>
+    </bean>
+
+    <bean id="txManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
+        <property name="sessionFactory" ref="sessionFactory"/>
+    </bean>
+
+    <bean id="persistenceExceptionTranslationPostProcessor" class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>
+
+</beans>

persistence-modules/spring-hibernate-5/src/main/resources/hibernate5Configuration.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
+    xsi:schemaLocation="
+      http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
+
+    <context:property-placeholder location="classpath:persistence-h2.properties"/>
+
+    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
+        <property name="dataSource" ref="dataSource"/>
+        <property name="packagesToScan" value="com.baeldung.hibernate.bootstrap.model"/>
+        <property name="hibernateProperties">
+            <props>
+                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
+                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
+            </props>
+        </property>
+    </bean>
+
+    <bean id="dataSource" class="org.apache.tomcat.dbcp.dbcp2.BasicDataSource">
+        <property name="driverClassName" value="${jdbc.driverClassName}"/>
+        <property name="url" value="${jdbc.url}"/>
+        <property name="username" value="${jdbc.user}"/>
+        <property name="password" value="${jdbc.pass}"/>
+    </bean>
+
+    <bean id="txManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
+        <property name="sessionFactory" ref="sessionFactory"/>
+    </bean>
+</beans>

persistence-modules/spring-hibernate-5/src/main/resources/immutable.cfg.xml

@@ -0,0 +1,32 @@
+<?xml version='1.0' encoding='utf-8'?>
+<!DOCTYPE hibernate-configuration PUBLIC
+        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
+
+<hibernate-configuration>
+
+    <session-factory>
+
+        <!-- Database connection settings -->
+        <property name="connection.driver_class">org.hsqldb.jdbcDriver</property>
+        <property name="connection.url">jdbc:hsqldb:mem:test</property>
+        <property name="connection.username">sa</property>
+        <property name="connection.password"></property>
+
+        <!-- JDBC connection pool (use the built-in) -->
+        <property name="connection.pool_size">1</property>
+
+        <!-- SQL dialect -->
+        <property name="dialect">org.hibernate.dialect.HSQLDialect</property>
+
+        <!-- Enable Hibernate's automatic session context management -->
+        <property name="current_session_context_class">thread</property>
+
+        <!-- Echo all executed SQL to stdout -->
+        <property name="show_sql">true</property>
+
+        <!-- Drop and re-create the database schema on startup -->
+        <property name="hbm2ddl.auto">update</property>
+    </session-factory>
+
+</hibernate-configuration>

persistence-modules/spring-hibernate-5/src/main/resources/import.sql

@@ -0,0 +1,31 @@
+insert into item (item_id, item_name, item_desc, item_price)     
+values(1,'item One', 'test 1', 35.12);
+
+insert into item (item_id, item_name, item_desc, item_price)     
+values(2,'Pogo stick', 'Pogo stick', 466.12);
+insert into item (item_id, item_name, item_desc, item_price)     
+values(3,'Raft', 'Raft', 345.12);
+
+insert into item (item_id, item_name, item_desc, item_price)     
+values(4,'Skate Board', 'Skating', 135.71);
+
+insert into item (item_id, item_name, item_desc, item_price)     
+values(5,'Umbrella', 'Umbrella for Rain', 619.25);
+
+insert into item (item_id, item_name, item_desc, item_price)     
+values(6,'Glue', 'Glue for home', 432.73);
+
+insert into item (item_id, item_name, item_desc, item_price)     
+values(7,'Paint', 'Paint for Room', 1311.40);
+
+insert into item (item_id, item_name, item_desc, item_price)     
+values(8,'Red paint', 'Red paint for room', 1135.71);
+
+insert into item (item_id, item_name, item_desc, item_price)     
+values(9,'Household Chairs', 'Chairs for house', 25.71);
+
+insert into item (item_id, item_name, item_desc, item_price)     
+values(10,'Office Chairs', 'Chairs for office', 395.98);
+
+insert into item (item_id, item_name, item_desc, item_price)     
+values(11,'Outdoor Chairs', 'Chairs for outdoor activities', 1234.36);

persistence-modules/spring-hibernate-5/src/main/resources/logback.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>web - %date [%thread] %-5level %logger{36} - %message%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <logger name="org.springframework" level="WARN" />
+    <logger name="org.springframework.transaction" level="WARN" />
+
+    <!-- in order to debug some marshalling issues, this needs to be TRACE -->
+    <logger name="org.springframework.web.servlet.mvc" level="WARN" />
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

persistence-modules/spring-hibernate-5/src/main/resources/manytomany.cfg.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE hibernate-configuration PUBLIC
+		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+		"http://hibernate.org/dtd/hibernate-configuration-3.0.dtd">
+<hibernate-configuration>
+    <session-factory>
+        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
+        <property name="hibernate.connection.password">tutorialmy5ql</property>
+        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/spring_hibernate_many_to_many</property>
+        <property name="hibernate.connection.username">tutorialuser</property>
+        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
+        <property name="hibernate.current_session_context_class">thread</property>
+        <property name="hibernate.show_sql">true</property>
+    </session-factory>
+</hibernate-configuration>

persistence-modules/spring-hibernate-5/src/main/resources/persistence-h2.properties

@@ -0,0 +1,21 @@
+# jdbc.X
+jdbc.driverClassName=org.h2.Driver
+jdbc.url=jdbc:h2:mem:db;DB_CLOSE_DELAY=-1
+jdbc.eventGeneratedId=sa
+jdbc.user=sa
+jdbc.pass=
+
+# hibernate.X
+hibernate.dialect=org.hibernate.dialect.H2Dialect
+hibernate.show_sql=false
+hibernate.hbm2ddl.auto=create-drop
+hibernate.cache.use_second_level_cache=true
+hibernate.cache.use_query_cache=true
+hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory
+
+# hibernate.search.X
+hibernate.search.default.directory_provider = filesystem
+hibernate.search.default.indexBase = /data/index/default
+
+# envers.X
+envers.audit_table_suffix=_audit_log

persistence-modules/spring-hibernate-5/src/main/resources/persistence-jndi.properties

@@ -0,0 +1,8 @@
+# jdbc.X
+jdbc.url=java:comp/env/jdbc/BaeldungDatabase
+
+# hibernate.X
+hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
+hibernate.show_sql=false
+#hibernate.hbm2ddl.auto=create
+hibernate.hbm2ddl.auto=update

persistence-modules/spring-hibernate-5/src/main/resources/persistence-mysql.properties

@@ -0,0 +1,13 @@
+# jdbc.X
+jdbc.driverClassName=com.mysql.cj.jdbc.Driver
+jdbc.url=jdbc:mysql://localhost:3306/spring_hibernate5_01?createDatabaseIfNotExist=true
+jdbc.eventGeneratedId=tutorialuser
+jdbc.pass=tutorialmy5ql
+
+# hibernate.X
+hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
+hibernate.show_sql=false
+hibernate.hbm2ddl.auto=create-drop
+
+# envers.X
+envers.audit_table_suffix=_audit_log

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/hibernate/bootstrap/HibernateBootstrapIntegrationTest.java

@@ -0,0 +1,185 @@
+package com.baeldung.hibernate.bootstrap;
+
+import com.baeldung.hibernate.bootstrap.model.TestEntity;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.junit.Assert;
+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.Commit;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+import org.springframework.test.context.transaction.TestTransaction;
+import org.springframework.transaction.annotation.Transactional;
+
+import static junit.framework.TestCase.assertFalse;
+import static junit.framework.TestCase.assertTrue;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { HibernateConf.class })
+@Transactional
+public class HibernateBootstrapIntegrationTest {
+
+    @Autowired
+    private SessionFactory sessionFactory;
+
+    @Test
+    public void whenBootstrapHibernateSession_thenNoException() {
+
+        Session session = sessionFactory.getCurrentSession();
+
+        TestEntity newEntity = new TestEntity();
+        newEntity.setId(1);
+        session.save(newEntity);
+
+        TestEntity searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNotNull(searchEntity);
+    }
+
+    @Test
+    public void whenProgrammaticTransactionCommit_thenEntityIsInDatabase() {
+        assertTrue(TestTransaction.isActive());
+
+        //Save an entity and commit.
+        Session session = sessionFactory.getCurrentSession();
+
+        TestEntity newEntity = new TestEntity();
+        newEntity.setId(1);
+        session.save(newEntity);
+
+        TestEntity searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNotNull(searchEntity);
+        assertTrue(TestTransaction.isFlaggedForRollback());
+
+        TestTransaction.flagForCommit();
+        TestTransaction.end();
+
+        assertFalse(TestTransaction.isFlaggedForRollback());
+        assertFalse(TestTransaction.isActive());
+
+        //Check that the entity is still there in a new transaction,
+        //then delete it, but don't commit.
+        TestTransaction.start();
+
+        assertTrue(TestTransaction.isFlaggedForRollback());
+        assertTrue(TestTransaction.isActive());
+
+        session = sessionFactory.getCurrentSession();
+        searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNotNull(searchEntity);
+
+        session.delete(searchEntity);
+        session.flush();
+
+        TestTransaction.end();
+
+        assertFalse(TestTransaction.isActive());
+
+        //Check that the entity is still there in a new transaction,
+        //then delete it and commit.
+        TestTransaction.start();
+
+        session = sessionFactory.getCurrentSession();
+        searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNotNull(searchEntity);
+
+        session.delete(searchEntity);
+        session.flush();
+
+        assertTrue(TestTransaction.isActive());
+
+        TestTransaction.flagForCommit();
+        TestTransaction.end();
+
+        assertFalse(TestTransaction.isActive());
+
+        //Check that the entity is no longer there in a new transaction.
+        TestTransaction.start();
+
+        assertTrue(TestTransaction.isActive());
+
+        session = sessionFactory.getCurrentSession();
+        searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNull(searchEntity);
+    }
+
+    @Test
+    @Commit
+    public void givenTransactionCommitDefault_whenProgrammaticTransactionCommit_thenEntityIsInDatabase() {
+        assertTrue(TestTransaction.isActive());
+
+        //Save an entity and commit.
+        Session session = sessionFactory.getCurrentSession();
+
+        TestEntity newEntity = new TestEntity();
+        newEntity.setId(1);
+        session.save(newEntity);
+
+        TestEntity searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNotNull(searchEntity);
+        assertFalse(TestTransaction.isFlaggedForRollback());
+
+        TestTransaction.end();
+
+        assertFalse(TestTransaction.isFlaggedForRollback());
+        assertFalse(TestTransaction.isActive());
+
+        //Check that the entity is still there in a new transaction,
+        //then delete it, but don't commit.
+        TestTransaction.start();
+
+        assertFalse(TestTransaction.isFlaggedForRollback());
+        assertTrue(TestTransaction.isActive());
+
+        session = sessionFactory.getCurrentSession();
+        searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNotNull(searchEntity);
+
+        session.delete(searchEntity);
+        session.flush();
+
+        TestTransaction.flagForRollback();
+        TestTransaction.end();
+
+        assertFalse(TestTransaction.isActive());
+
+        //Check that the entity is still there in a new transaction,
+        //then delete it and commit.
+        TestTransaction.start();
+
+        session = sessionFactory.getCurrentSession();
+        searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNotNull(searchEntity);
+
+        session.delete(searchEntity);
+        session.flush();
+
+        assertTrue(TestTransaction.isActive());
+
+        TestTransaction.end();
+
+        assertFalse(TestTransaction.isActive());
+
+        //Check that the entity is no longer there in a new transaction.
+        TestTransaction.start();
+
+        assertTrue(TestTransaction.isActive());
+
+        session = sessionFactory.getCurrentSession();
+        searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNull(searchEntity);
+    }
+
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/hibernate/bootstrap/HibernateXMLBootstrapIntegrationTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.hibernate.bootstrap;
+
+import com.baeldung.hibernate.bootstrap.model.TestEntity;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.transaction.annotation.Transactional;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { HibernateXMLConf.class })
+@Transactional
+public class HibernateXMLBootstrapIntegrationTest {
+
+    @Autowired
+    private SessionFactory sessionFactory;
+
+    @Test
+    public void whenBootstrapHibernateSession_thenNoException() {
+
+        Session session = sessionFactory.getCurrentSession();
+
+        TestEntity newEntity = new TestEntity();
+        newEntity.setId(1);
+        session.save(newEntity);
+
+        TestEntity searchEntity = session.find(TestEntity.class, 1);
+
+        Assert.assertNotNull(searchEntity);
+    }
+
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/hibernate/criteria/HibernateCriteriaIntegrationTest.java

@@ -0,0 +1,236 @@
+package com.baeldung.hibernate.criteria;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+import java.util.List;
+
+import org.hibernate.Session;
+import org.hibernate.Transaction;
+import org.junit.Test;
+
+import com.baeldung.hibernate.criteria.model.Item;
+import com.baeldung.hibernate.criteria.util.HibernateUtil;
+import com.baeldung.hibernate.criteria.view.ApplicationView;
+
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaDelete;
+import javax.persistence.criteria.CriteriaUpdate;
+import javax.persistence.criteria.Root;
+
+public class HibernateCriteriaIntegrationTest {
+
+    final private ApplicationView av = new ApplicationView();
+
+    @Test
+    public void testPerformanceOfCriteria() {
+        assertFalse(av.checkIfCriteriaTimeLower());
+    }
+
+    @Test
+    public void testLikeCriteriaQuery() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final List<Item> expectedLikeList = session.createQuery("From Item where itemName like '%chair%'").list();
+        final String expectedLikeItems[] = new String[expectedLikeList.size()];
+        for (int i = 0; i < expectedLikeList.size(); i++) {
+            expectedLikeItems[i] = expectedLikeList.get(i).getItemName();
+        }
+        session.close();
+        assertArrayEquals(expectedLikeItems, av.likeCriteria());
+    }
+
+    @Test
+    public void testILikeCriteriaQuery() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final List<Item> expectedChairCaseList = session.createQuery("From Item where itemName like '%Chair%'").list();
+        final String expectedChairCaseItems[] = new String[expectedChairCaseList.size()];
+        for (int i = 0; i < expectedChairCaseList.size(); i++) {
+            expectedChairCaseItems[i] = expectedChairCaseList.get(i).getItemName();
+        }
+        session.close();
+        assertArrayEquals(expectedChairCaseItems, av.likeCaseCriteria());
+    }
+
+    @Test
+    public void testNullCriteriaQuery() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final List<Item> expectedIsNullDescItemsList = session.createQuery("From Item where itemDescription is null").list();
+        final String expectedIsNullDescItems[] = new String[expectedIsNullDescItemsList.size()];
+        for (int i = 0; i < expectedIsNullDescItemsList.size(); i++) {
+            expectedIsNullDescItems[i] = expectedIsNullDescItemsList.get(i).getItemName();
+        }
+        session.close();
+        assertArrayEquals(expectedIsNullDescItems, av.nullCriteria());
+    }
+
+    @Test
+    public void testIsNotNullCriteriaQuery() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final List<Item> expectedIsNotNullDescItemsList = session.createQuery("From Item where itemDescription is not null").list();
+        final String expectedIsNotNullDescItems[] = new String[expectedIsNotNullDescItemsList.size()];
+        for (int i = 0; i < expectedIsNotNullDescItemsList.size(); i++) {
+            expectedIsNotNullDescItems[i] = expectedIsNotNullDescItemsList.get(i).getItemName();
+        }
+        session.close();
+        assertArrayEquals(expectedIsNotNullDescItems, av.notNullCriteria());
+
+    }
+
+    @Test
+    public void testAverageProjection() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final List<Double> expectedAvgProjItemsList = session.createQuery("Select avg(itemPrice) from Item item").list();
+
+        final Double expectedAvgProjItems[] = new Double[expectedAvgProjItemsList.size()];
+        for (int i = 0; i < expectedAvgProjItemsList.size(); i++) {
+            expectedAvgProjItems[i] = expectedAvgProjItemsList.get(i);
+        }
+        session.close();
+        assertArrayEquals(expectedAvgProjItems, av.projectionAverage());
+
+    }
+
+    @Test
+    public void testRowCountProjection() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final List<Long> expectedCountProjItemsList = session.createQuery("Select count(*) from Item").list();
+        final Long expectedCountProjItems[] = new Long[expectedCountProjItemsList.size()];
+        for (int i = 0; i < expectedCountProjItemsList.size(); i++) {
+            expectedCountProjItems[i] = expectedCountProjItemsList.get(i);
+        }
+        session.close();
+        assertArrayEquals(expectedCountProjItems, av.projectionRowCount());
+    }
+
+    @Test
+    public void testOrCriteriaQuery() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final List<Item> expectedOrCritItemsList = session.createQuery("From Item where itemPrice>1000 or itemName like 'Chair%'").list();
+        final String expectedOrCritItems[] = new String[expectedOrCritItemsList.size()];
+        for (int i = 0; i < expectedOrCritItemsList.size(); i++) {
+            expectedOrCritItems[i] = expectedOrCritItemsList.get(i).getItemName();
+        }
+        session.close();
+        assertArrayEquals(expectedOrCritItems, av.orLogicalCriteria());
+    }
+
+    @Test
+    public void testAndCriteriaQuery() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final List<Item> expectedAndCritItemsList = session.createQuery("From Item where itemPrice>1000 and itemName like 'Chair%'").list();
+        final String expectedAndCritItems[] = new String[expectedAndCritItemsList.size()];
+        for (int i = 0; i < expectedAndCritItemsList.size(); i++) {
+            expectedAndCritItems[i] = expectedAndCritItemsList.get(i).getItemName();
+        }
+        session.close();
+        assertArrayEquals(expectedAndCritItems, av.andLogicalCriteria());
+    }
+
+    @Test
+    public void testMultiCriteriaQuery() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final List<Item> expectedMultiCritItemsList = session.createQuery("From Item where itemDescription is null and itemName like'chair%'").list();
+        final String expectedMultiCritItems[] = new String[expectedMultiCritItemsList.size()];
+        for (int i = 0; i < expectedMultiCritItemsList.size(); i++) {
+            expectedMultiCritItems[i] = expectedMultiCritItemsList.get(i).getItemName();
+        }
+        session.close();
+        assertArrayEquals(expectedMultiCritItems, av.twoCriteria());
+    }
+
+    @Test
+    public void testSortCriteriaQuery() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final List<Item> expectedSortCritItemsList = session.createQuery("From Item order by itemName asc, itemPrice desc").list();
+        final String expectedSortCritItems[] = new String[expectedSortCritItemsList.size()];
+        for (int i = 0; i < expectedSortCritItemsList.size(); i++) {
+            expectedSortCritItems[i] = expectedSortCritItemsList.get(i).getItemName();
+        }
+        session.close();
+        assertArrayEquals(expectedSortCritItems, av.sortingCriteria());
+    }
+
+    @Test
+    public void testGreaterThanCriteriaQuery() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final List<Item> expectedGreaterThanList = session.createQuery("From Item where itemPrice>1000").list();
+        final String expectedGreaterThanItems[] = new String[expectedGreaterThanList.size()];
+        for (int i = 0; i < expectedGreaterThanList.size(); i++) {
+            expectedGreaterThanItems[i] = expectedGreaterThanList.get(i).getItemName();
+        }
+        session.close();
+        assertArrayEquals(expectedGreaterThanItems, av.greaterThanCriteria());
+    }
+
+    @Test
+    public void testLessThanCriteriaQuery() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final List<Item> expectedLessList = session.createQuery("From Item where itemPrice<1000").list();
+        final String expectedLessThanItems[] = new String[expectedLessList.size()];
+        for (int i = 0; i < expectedLessList.size(); i++) {
+            expectedLessThanItems[i] = expectedLessList.get(i).getItemName();
+        }
+        session.close();
+        assertArrayEquals(expectedLessThanItems, av.lessThanCriteria());
+    }
+
+    @Test
+    public void betweenCriteriaQuery() {
+        final Session session = HibernateUtil.getHibernateSession();
+        final List<Item> expectedBetweenList = session.createQuery("From Item where itemPrice between 100 and 200").list();
+        final String expectedPriceBetweenItems[] = new String[expectedBetweenList.size()];
+        for (int i = 0; i < expectedBetweenList.size(); i++) {
+            expectedPriceBetweenItems[i] = expectedBetweenList.get(i).getItemName();
+        }
+        session.close();
+        assertArrayEquals(expectedPriceBetweenItems, av.betweenCriteria());
+    }
+
+    @Test
+    public void givenNewItemPrice_whenCriteriaUpdate_thenReturnAffectedResult() {
+
+        int oldPrice = 10, newPrice = 20;
+
+        Session session = HibernateUtil.getHibernateSession();
+
+        Item item = new Item(12, "Test Item 12", "This is a description");
+        item.setItemPrice(oldPrice);
+        session.save(item);
+
+        CriteriaBuilder cb = session.getCriteriaBuilder();
+        CriteriaUpdate<Item> criteriaUpdate = cb.createCriteriaUpdate(Item.class);
+        Root<Item> root = criteriaUpdate.from(Item.class);
+        criteriaUpdate.set("itemPrice", newPrice);
+        criteriaUpdate.where(cb.equal(root.get("itemPrice"), oldPrice));
+
+        Transaction transaction = session.beginTransaction();
+        session.createQuery(criteriaUpdate).executeUpdate();
+        transaction.commit();
+
+        Item updatedItem = session.createQuery("FROM Item WHERE itemPrice = " + newPrice, Item.class).getSingleResult();
+        session.refresh(updatedItem);
+        assertEquals(newPrice, updatedItem.getItemPrice().intValue());
+    }
+
+    @Test
+    public void givenTargetItemPrice_whenCriteriaDelete_thenDeleteMatched() {
+
+        int targetPrice = 1000;
+
+        Session session = HibernateUtil.getHibernateSession();
+        CriteriaBuilder cb = session.getCriteriaBuilder();
+        CriteriaDelete<Item> criteriaDelete = cb.createCriteriaDelete(Item.class);
+        Root<Item> root = criteriaDelete.from(Item.class);
+        criteriaDelete.where(cb.greaterThan(root.get("itemPrice"), targetPrice));
+
+        Transaction transaction = session.beginTransaction();
+        session.createQuery(criteriaDelete).executeUpdate();
+        transaction.commit();
+
+        List<Item> deletedItem = session.createQuery("FROM Item WHERE itemPrice > " + targetPrice, Item.class).list();
+        assertTrue(deletedItem.isEmpty());
+
+    }
+
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/hibernate/criteria/HibernateCriteriaTestRunner.java

@@ -0,0 +1,15 @@
+package com.baeldung.hibernate.criteria;
+
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+
+public class HibernateCriteriaTestRunner {
+
+    public static void main(final String[] args) {
+        Result result = JUnitCore.runClasses(HibernateCriteriaTestSuite.class);
+        for (Failure failure : result.getFailures()) {
+
+        }
+    }
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/hibernate/criteria/HibernateCriteriaTestSuite.java

@@ -0,0 +1,11 @@
+package com.baeldung.hibernate.criteria;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+@RunWith(Suite.class)
+@Suite.SuiteClasses({ HibernateCriteriaIntegrationTest.class })
+
+public class HibernateCriteriaTestSuite {
+
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/hibernate/dynamicupdate/DynamicUpdateIntegrationTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.hibernate.dynamicupdate;
+
+import javax.transaction.Transactional;
+
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.MethodSorters;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.annotation.Commit;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import com.baeldung.hibernate.dynamicupdate.model.Account;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = DynamicUpdateConfig.class, loader = AnnotationConfigContextLoader.class)
+@Transactional
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class DynamicUpdateIntegrationTest {
+
+    private static final Integer ACCOUNT_ID = 1;
+
+    @Autowired
+    private AccountRepository accountRepository;
+
+    @Test
+    @Commit
+    public void testA_whenTestAccountIsSaved_thenSuccess() {
+        Account account = new Account(ACCOUNT_ID, "account1", "regional", true);
+        accountRepository.save(account);
+    }
+
+    @Test
+    @Commit
+    // Enable Hibernate's debug logging in logback.xml to see the generated SQL statement.
+    public void testB_whenAccountNameUpdated_thenSuccess() {
+        Account account = accountRepository.findOne(ACCOUNT_ID);
+        account.setName("Test Account");
+        accountRepository.save(account);
+    }
+
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/hibernate/immutable/HibernateImmutableIntegrationTest.java

@@ -0,0 +1,124 @@
+package com.baeldung.hibernate.immutable;
+
+import com.baeldung.hibernate.immutable.entities.Event;
+import com.baeldung.hibernate.immutable.entities.EventGeneratedId;
+import com.baeldung.hibernate.immutable.util.HibernateUtil;
+import com.google.common.collect.Sets;
+import org.hibernate.Session;
+import org.junit.*;
+import org.junit.rules.ExpectedException;
+
+import javax.persistence.PersistenceException;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsEqual.equalTo;
+
+/**
+ * Configured in: immutable.cfg.xml
+ */
+public class HibernateImmutableIntegrationTest {
+
+    private static Session session;
+
+    @Rule
+    public final ExpectedException exception = ExpectedException.none();
+
+    @Before
+    public void before() {
+        session = HibernateUtil.getSessionFactory().openSession();
+        session.beginTransaction();
+    }
+
+    @BeforeClass
+    public static void setup() {
+        session = HibernateUtil.getSessionFactory().getCurrentSession();
+    }
+
+    @AfterClass
+    public static void teardown() {
+        HibernateUtil.getSessionFactory().close();
+    }
+
+    @Test
+    public void addEvent() {
+        Event event = new Event();
+        event.setId(2L);
+        event.setTitle("Public Event");
+        session.save(event);
+        session.getTransaction().commit();
+        session.close();
+    }
+
+    @Test
+    public void updateEvent() {
+        createEvent();
+        Event event = (Event) session.createQuery("FROM Event WHERE title='New Event'").list().get(0);
+        event.setTitle("Private Event");
+        session.update(event);
+        session.flush();
+        session.refresh(event);
+        session.close();
+
+        assertThat(event.getTitle(), equalTo("New Event"));
+        assertThat(event.getId(), equalTo(5L));
+    }
+
+    @Test
+    public void deleteEvent() {
+        createEvent();
+        Event event = (Event) session.createQuery("FROM Event WHERE title='New Event'").list().get(0);
+        session.delete(event);
+        session.getTransaction().commit();
+        session.close();
+    }
+
+    @Test
+    public void addGuest() {
+        createEvent();
+        Event event = (Event) session.createQuery("FROM Event WHERE title='New Event'").list().get(0);
+        String newGuest = "Sara";
+        event.getGuestList().add(newGuest);
+
+        exception.expect(PersistenceException.class);
+        session.save(event);
+        session.getTransaction().commit();
+        session.close();
+    }
+
+    @Test
+    public void deleteCascade() {
+        Event event = (Event) session.createQuery("FROM Event WHERE title='New Event'").list().get(0);
+        String guest = event.getGuestList().iterator().next();
+        event.getGuestList().remove(guest);
+
+        exception.expect(PersistenceException.class);
+        session.saveOrUpdate(event);
+        session.getTransaction().commit();
+    }
+
+    @Test
+    public void updateEventGenerated() {
+        createEventGenerated();
+        EventGeneratedId eventGeneratedId = (EventGeneratedId) session.createQuery("FROM EventGeneratedId WHERE name LIKE '%John%'").list().get(0);
+        
+        eventGeneratedId.setName("Mike");
+        session.update(eventGeneratedId);
+        session.flush();
+        session.refresh(eventGeneratedId);
+        session.close();
+
+        assertThat(eventGeneratedId.getName(), equalTo("John"));
+        assertThat(eventGeneratedId.getId(), equalTo(1L));
+    }
+
+    private static void createEvent() {
+        Event event = new Event(5L, "New Event", Sets.newHashSet("guest"));
+        session.save(event);
+    }
+
+    private static void createEventGenerated() {
+        EventGeneratedId eventGeneratedId = new EventGeneratedId("John", "Doe");
+        session.save(eventGeneratedId);
+    }
+
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/hibernate/manytomany/HibernateManyToManyAnnotationJavaConfigMainIntegrationTest.java

@@ -0,0 +1,49 @@
+package com.baeldung.hibernate.manytomany;
+
+import java.util.HashSet;
+import java.util.Set;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+import com.baeldung.hibernate.manytomany.model.Employee;
+import com.baeldung.hibernate.manytomany.model.Project;
+import com.baeldung.manytomany.spring.PersistenceConfig;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { PersistenceConfig.class }, loader = AnnotationConfigContextLoader.class)
+public class HibernateManyToManyAnnotationJavaConfigMainIntegrationTest {
+
+    @Autowired
+    private SessionFactory sessionFactory;
+
+    private Session session;
+
+    @Before
+    public final void before() {
+        session = sessionFactory.openSession();
+        session.beginTransaction();
+    }
+
+    @After
+    public final void after() {
+        session.getTransaction().commit();
+        session.close();
+    }
+
+    @Test
+    public final void whenEntitiesAreCreated_thenNoExceptions() {
+        Set<Project> projects = new HashSet<Project>();
+        projects.add(new Project("IT Project"));
+        projects.add(new Project("Networking Project"));
+        session.persist(new Employee("Peter", "Oven", projects));
+        session.persist(new Employee("Allan", "Norman", projects));
+    }
+
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/hibernate/manytomany/HibernateManyToManyAnnotationMainIntegrationTest.java

@@ -0,0 +1,80 @@
+package com.baeldung.hibernate.manytomany;
+
+import static org.junit.Assert.assertNotNull;
+import static junit.framework.TestCase.assertEquals;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.baeldung.hibernate.manytomany.util.HibernateUtil;
+import com.baeldung.hibernate.manytomany.model.Employee;
+import com.baeldung.hibernate.manytomany.model.Project;
+
+/**
+ * Configured in: manytomany.cfg.xml
+ */
+public class HibernateManyToManyAnnotationMainIntegrationTest {
+    private static SessionFactory sessionFactory;
+
+    private Session session;
+
+    @BeforeClass
+    public static void beforeTests() {
+        sessionFactory = HibernateUtil.getSessionFactory();
+    }
+
+    @Before
+    public void setUp() {
+        session = sessionFactory.openSession();
+        session.beginTransaction();
+    }
+
+    @Test
+    public void givenData_whenInsert_thenCreatesMtoMrelationship() {
+        String[] employeeData = { "Peter Oven", "Allan Norman" };
+        String[] projectData = { "IT Project", "Networking Project" };
+        Set<Project> projects = new HashSet<Project>();
+
+        for (String proj : projectData) {
+            projects.add(new Project(proj));
+        }
+
+        for (String emp : employeeData) {
+            Employee employee = new Employee(emp.split(" ")[0], emp.split(" ")[1]);
+            assertEquals(0, employee.getProjects().size());
+            employee.setProjects(projects);
+            session.persist(employee);
+            assertNotNull(employee);
+        }
+    }
+
+    @Test
+    public void givenSession_whenRead_thenReturnsMtoMdata() {
+        @SuppressWarnings("unchecked")
+        List<Employee> employeeList = session.createQuery("FROM Employee").list();
+        assertNotNull(employeeList);
+        for(Employee employee : employeeList) {
+            assertNotNull(employee.getProjects());
+        }
+    }
+
+    @After
+    public void tearDown() {
+        session.getTransaction()
+            .commit();
+        session.close();
+    }
+
+    @AfterClass
+    public static void afterTests() {
+        sessionFactory.close();
+    }
+
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/hibernatesearch/HibernateSearchIntegrationTest.java

@@ -0,0 +1,187 @@
+package com.baeldung.hibernatesearch;
+
+import com.baeldung.hibernatesearch.model.Product;
+
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+import static org.junit.Assert.*;
+
+import org.hibernate.search.jpa.FullTextEntityManager;
+import org.hibernate.search.jpa.Search;
+import org.junit.Before;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.MethodSorters;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.annotation.Commit;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { HibernateSearchConfig.class }, loader = AnnotationConfigContextLoader.class)
+@Transactional
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class HibernateSearchIntegrationTest {
+
+    @Autowired
+    ProductSearchDao dao;
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    private List<Product> products;
+
+    @Before
+    public void setupTestData() {
+
+        products = Arrays.asList(new Product(1, "Apple iPhone X 256 GB", 256, "The current high-end smartphone from Apple, with lots of memory and also Face ID"),
+            new Product(2, "Apple iPhone X 128 GB", 128, "The current high-end smartphone from Apple, with Face ID"), new Product(3, "Apple iPhone 8 128 GB", 128, "The latest smartphone from Apple within the regular iPhone line, supporting wireless charging"),
+            new Product(4, "Samsung Galaxy S7 128 GB", 64, "A great Android smartphone"), new Product(5, "Microsoft Lumia 650 32 GB", 32, "A cheaper smartphone, coming with Windows Mobile"),
+            new Product(6, "Microsoft Lumia 640 32 GB", 32, "A cheaper smartphone, coming with Windows Mobile"), new Product(7, "Microsoft Lumia 630 16 GB", 16, "A cheaper smartphone, coming with Windows Mobile"));
+    }
+
+    @Commit
+    @Test
+    public void testA_whenInitialTestDataInserted_thenSuccess() {
+
+        for (int i = 0; i < products.size() - 1; i++) {
+            entityManager.persist(products.get(i));
+        }
+    }
+
+    @Test
+    public void testB_whenIndexInitialized_thenCorrectIndexSize() throws InterruptedException {
+
+        FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
+        fullTextEntityManager.createIndexer()
+            .startAndWait();
+        int indexSize = fullTextEntityManager.getSearchFactory()
+            .getStatistics()
+            .getNumberOfIndexedEntities(Product.class.getName());
+
+        assertEquals(products.size() - 1, indexSize);
+    }
+
+    @Commit
+    @Test
+    public void testC_whenAdditionalTestDataInserted_thenSuccess() {
+
+        entityManager.persist(products.get(products.size() - 1));
+    }
+
+    @Test
+    public void testD_whenAdditionalTestDataInserted_thenIndexUpdatedAutomatically() {
+
+        FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
+        int indexSize = fullTextEntityManager.getSearchFactory()
+            .getStatistics()
+            .getNumberOfIndexedEntities(Product.class.getName());
+
+        assertEquals(products.size(), indexSize);
+    }
+
+    @Test
+    public void testE_whenKeywordSearchOnName_thenCorrectMatches() {
+        List<Product> expected = Arrays.asList(products.get(0), products.get(1), products.get(2));
+        List<Product> results = dao.searchProductNameByKeywordQuery("iphone");
+
+        assertThat(results, containsInAnyOrder(expected.toArray()));
+    }
+
+    @Test
+    public void testF_whenFuzzySearch_thenCorrectMatches() {
+        List<Product> expected = Arrays.asList(products.get(0), products.get(1), products.get(2));
+        List<Product> results = dao.searchProductNameByFuzzyQuery("iPhaen");
+
+        assertThat(results, containsInAnyOrder(expected.toArray()));
+    }
+
+    @Test
+    public void testG_whenWildcardSearch_thenCorrectMatches() {
+        List<Product> expected = Arrays.asList(products.get(4), products.get(5), products.get(6));
+        List<Product> results = dao.searchProductNameByWildcardQuery("6*");
+
+        assertThat(results, containsInAnyOrder(expected.toArray()));
+
+    }
+
+    @Test
+    public void testH_whenPhraseSearch_thenCorrectMatches() {
+        List<Product> expected = Arrays.asList(products.get(2));
+        List<Product> results = dao.searchProductDescriptionByPhraseQuery("with wireless charging");
+
+        assertThat(results, containsInAnyOrder(expected.toArray()));
+
+    }
+
+    @Test
+    public void testI_whenSimpleQueryStringSearch_thenCorrectMatches() {
+        List<Product> expected = Arrays.asList(products.get(0), products.get(1));
+        List<Product> results = dao.searchProductNameAndDescriptionBySimpleQueryStringQuery("Aple~2 + \"iPhone X\" + (256 | 128)");
+
+        assertThat(results, containsInAnyOrder(expected.toArray()));
+
+    }
+
+    @Test
+    public void testJ_whenRangeSearch_thenCorrectMatches() {
+        List<Product> expected = Arrays.asList(products.get(0), products.get(1), products.get(2), products.get(3));
+        List<Product> results = dao.searchProductNameByRangeQuery(64, 256);
+
+        assertThat(results, containsInAnyOrder(expected.toArray()));
+
+    }
+
+    @Test
+    public void testK_whenMoreLikeThisSearch_thenCorrectMatchesInOrder() {
+        List<Product> expected = products;
+        List<Object[]> resultsWithScore = dao.searchProductNameByMoreLikeThisQuery(products.get(0));
+        List<Product> results = new LinkedList<Product>();
+
+        for (Object[] resultWithScore : resultsWithScore) {
+            results.add((Product) resultWithScore[0]);
+        }
+
+        assertThat(results, contains(expected.toArray()));
+
+    }
+
+    @Test
+    public void testL_whenKeywordSearchOnNameAndDescription_thenCorrectMatches() {
+        List<Product> expected = Arrays.asList(products.get(0), products.get(1), products.get(2));
+        List<Product> results = dao.searchProductNameAndDescriptionByKeywordQuery("iphone");
+
+        assertThat(results, containsInAnyOrder(expected.toArray()));
+    }
+
+    @Test
+    public void testM_whenMoreLikeThisSearchOnProductNameAndDescription_thenCorrectMatchesInOrder() {
+        List<Product> expected = products;
+        List<Object[]> resultsWithScore = dao.searchProductNameAndDescriptionByMoreLikeThisQuery(products.get(0));
+        List<Product> results = new LinkedList<Product>();
+
+        for (Object[] resultWithScore : resultsWithScore) {
+            results.add((Product) resultWithScore[0]);
+        }
+
+        assertThat(results, contains(expected.toArray()));
+    }
+
+    @Test
+    public void testN_whenCombinedSearch_thenCorrectMatches() {
+        List<Product> expected = Arrays.asList(products.get(1), products.get(2));
+        List<Product> results = dao.searchProductNameAndDescriptionByCombinedQuery("apple", 64, 128, "face id", "samsung");
+
+        assertThat(results, containsInAnyOrder(expected.toArray()));
+    }
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/persistence/dao/common/HibernateDaoIntegrationTest.java

@@ -0,0 +1,46 @@
+package com.baeldung.persistence.dao.common;
+
+import com.baeldung.persistence.model.Foo;
+import com.baeldung.spring.PersistenceConfig;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+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 = { PersistenceConfig.class }, loader = AnnotationConfigContextLoader.class)
+public class HibernateDaoIntegrationTest {
+
+    @Autowired
+    private SessionFactory sessionFactory;
+
+    private Session session;
+
+    @Before
+    public final void before() {
+        session = sessionFactory.openSession();
+    }
+
+    @After
+    public final void after() {
+        session.close();
+    }
+
+    @Test
+    public final void whenContextIsBootstrapped_thenNoExceptions() {
+        //
+    }
+
+    @Test
+    public final void whenPersistEntity_thenSuccess() {
+        session.persist(new Foo(RandomStringUtils.randomAlphabetic(5).toUpperCase()));
+    }
+
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/persistence/deletion/config/PersistenceJPAConfigDeletion.java

@@ -0,0 +1,15 @@
+package com.baeldung.persistence.deletion.config;
+
+import com.baeldung.spring.PersistenceJPAConfigL2Cache;
+
+public class PersistenceJPAConfigDeletion extends PersistenceJPAConfigL2Cache {
+
+    public PersistenceJPAConfigDeletion() {
+        super();
+    }
+
+    @Override
+    protected String[] getPackagesToScan() {
+        return new String[] { "com.baeldung.persistence.deletion.model", "com.baeldung.persistence.model" };
+    }
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/persistence/deletion/model/Bar.java

@@ -0,0 +1,60 @@
+package com.baeldung.persistence.deletion.model;
+
+import javax.persistence.*;
+import java.util.ArrayList;
+import java.util.List;
+
+@Entity
+@Table(name = "BAR")
+public class Bar {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private long id;
+
+    @Column(nullable = false)
+    private String name;
+
+    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
+    List<Baz> bazList = new ArrayList<>();
+
+    public Bar() {
+        super();
+    }
+
+    public Bar(final String name) {
+        super();
+        this.name = name;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(final long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+
+    public List<Baz> getBazList() {
+        return bazList;
+    }
+
+    public void setBazList(final List<Baz> bazList) {
+        this.bazList = bazList;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder builder = new StringBuilder();
+        builder.append("Bar [name=").append(name).append("]");
+        return builder.toString();
+    }
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/persistence/deletion/model/Baz.java

@@ -0,0 +1,47 @@
+package com.baeldung.persistence.deletion.model;
+
+import javax.persistence.*;
+
+@Entity
+@Table(name = "BAZ")
+public class Baz {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private long id;
+
+    @Column(nullable = false)
+    private String name;
+
+    public Baz() {
+        super();
+    }
+
+    public Baz(final String name) {
+        super();
+        this.name = name;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(final long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder builder = new StringBuilder();
+        builder.append("Bar [name=").append(name).append("]");
+        return builder.toString();
+    }
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/persistence/deletion/model/Foo.java

@@ -0,0 +1,63 @@
+package com.baeldung.persistence.deletion.model;
+
+import org.hibernate.annotations.Where;
+
+import javax.persistence.*;
+
+@Entity
+@Table(name = "FOO")
+@Where(clause = "DELETED = 0")
+public class Foo {
+
+    public Foo() {
+        super();
+    }
+
+    public Foo(final String name) {
+        super();
+        this.name = name;
+    }
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    @Column(name = "ID")
+    private long id;
+
+    @Column(name = "NAME")
+    private String name;
+
+    @Column(name = "DELETED")
+    private Integer deleted = 0;
+
+    @ManyToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
+    @JoinColumn(name = "BAR_ID")
+    private Bar bar;
+
+    public Bar getBar() {
+        return bar;
+    }
+
+    public void setBar(final Bar bar) {
+        this.bar = bar;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(final int id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+
+    public void setDeleted() {
+        this.deleted = 1;
+    }
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/persistence/service/DeletionIntegrationTest.java

@@ -0,0 +1,158 @@
+package com.baeldung.persistence.service;
+
+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;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.baeldung.persistence.deletion.config.PersistenceJPAConfigDeletion;
+import com.baeldung.persistence.deletion.model.Bar;
+import com.baeldung.persistence.deletion.model.Baz;
+import com.baeldung.persistence.deletion.model.Foo;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+
+import static org.hamcrest.Matchers.notNullValue;
+import static org.hamcrest.Matchers.nullValue;
+import static org.junit.Assert.assertThat;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { PersistenceJPAConfigDeletion.class }, loader = AnnotationConfigContextLoader.class)
+@DirtiesContext
+public class DeletionIntegrationTest {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+    @Autowired
+    private PlatformTransactionManager platformTransactionManager;
+
+    @Before
+    public final void before() {
+        entityManager.getEntityManagerFactory().getCache().evictAll();
+    }
+
+    @Test
+    @Transactional
+    public final void givenEntityIsRemoved_thenItIsNotInDB() {
+        Foo foo = new Foo("foo");
+        entityManager.persist(foo);
+        flushAndClear();
+
+        foo = entityManager.find(Foo.class, foo.getId());
+        assertThat(foo, notNullValue());
+
+        entityManager.remove(foo);
+        flushAndClear();
+
+        assertThat(entityManager.find(Foo.class, foo.getId()), nullValue());
+    }
+
+    @Test
+    @Transactional
+    public final void givenEntityIsRemovedAndReferencedByAnotherEntity_thenItIsNotRemoved() {
+        Bar bar = new Bar("bar");
+        Foo foo = new Foo("foo");
+        foo.setBar(bar);
+        entityManager.persist(foo);
+        flushAndClear();
+
+        foo = entityManager.find(Foo.class, foo.getId());
+        bar = entityManager.find(Bar.class, bar.getId());
+        entityManager.remove(bar);
+        flushAndClear();
+
+        bar = entityManager.find(Bar.class, bar.getId());
+        assertThat(bar, notNullValue());
+
+        foo = entityManager.find(Foo.class, foo.getId());
+        foo.setBar(null);
+        entityManager.remove(bar);
+        flushAndClear();
+
+        assertThat(entityManager.find(Bar.class, bar.getId()), nullValue());
+    }
+
+    @Test
+    @Transactional
+    public final void givenEntityIsRemoved_thenRemovalIsCascaded() {
+        Bar bar = new Bar("bar");
+        Foo foo = new Foo("foo");
+        foo.setBar(bar);
+        entityManager.persist(foo);
+        flushAndClear();
+
+        foo = entityManager.find(Foo.class, foo.getId());
+        entityManager.remove(foo);
+        flushAndClear();
+
+        assertThat(entityManager.find(Foo.class, foo.getId()), nullValue());
+        assertThat(entityManager.find(Bar.class, bar.getId()), nullValue());
+    }
+
+    @Test
+    @Transactional
+    public final void givenEntityIsDisassociated_thenOrphanRemovalIsApplied() {
+        Bar bar = new Bar("bar");
+        Baz baz = new Baz("baz");
+        bar.getBazList().add(baz);
+        entityManager.persist(bar);
+        flushAndClear();
+
+        bar = entityManager.find(Bar.class, bar.getId());
+        baz = bar.getBazList().get(0);
+        bar.getBazList().remove(baz);
+        flushAndClear();
+
+        assertThat(entityManager.find(Baz.class, baz.getId()), nullValue());
+    }
+
+    @Test
+    @Transactional
+    public final void givenEntityIsDeletedWithJpaBulkDeleteStatement_thenItIsNotInDB() {
+        Foo foo = new Foo("foo");
+        entityManager.persist(foo);
+        flushAndClear();
+
+        entityManager.createQuery("delete from Foo where id = :id").setParameter("id", foo.getId()).executeUpdate();
+
+        assertThat(entityManager.find(Foo.class, foo.getId()), nullValue());
+    }
+
+    @Test
+    @Transactional
+    public final void givenEntityIsDeletedWithNativeQuery_thenItIsNotInDB() {
+        Foo foo = new Foo("foo");
+        entityManager.persist(foo);
+        flushAndClear();
+
+        entityManager.createNativeQuery("delete from FOO where ID = :id").setParameter("id", foo.getId()).executeUpdate();
+
+        assertThat(entityManager.find(Foo.class, foo.getId()), nullValue());
+    }
+
+    @Test
+    @Transactional
+    public final void givenEntityIsSoftDeleted_thenItIsNotReturnedFromQueries() {
+        Foo foo = new Foo("foo");
+        entityManager.persist(foo);
+        flushAndClear();
+
+        foo = entityManager.find(Foo.class, foo.getId());
+        foo.setDeleted();
+        flushAndClear();
+
+        assertThat(entityManager.find(Foo.class, foo.getId()), nullValue());
+    }
+
+    private void flushAndClear() {
+        entityManager.flush();
+        entityManager.clear();
+    }
+}

persistence-modules/spring-hibernate-5/src/test/java/com/baeldung/persistence/service/SecondLevelCacheIntegrationTest.java

@@ -0,0 +1,84 @@
+package com.baeldung.persistence.service;
+
+import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.junit.Assert.assertThat;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.Query;
+
+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;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.support.TransactionTemplate;
+
+import com.baeldung.hibernate.cache.model.Bar;
+import com.baeldung.hibernate.cache.model.Foo;
+import com.baeldung.hibernate.cache.service.FooService;
+import com.baeldung.spring.PersistenceJPAConfigL2Cache;
+
+import net.sf.ehcache.CacheManager;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { PersistenceJPAConfigL2Cache.class }, loader = AnnotationConfigContextLoader.class)
+@DirtiesContext
+public class SecondLevelCacheIntegrationTest {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+    @Autowired
+    private FooService fooService;
+    @Autowired
+    private PlatformTransactionManager platformTransactionManager;
+
+    @Before
+    public final void before() {
+        entityManager.getEntityManagerFactory().getCache().evictAll();
+    }
+
+    @Test
+    public final void givenEntityIsLoaded_thenItIsCached() {
+        final Foo foo = new Foo(randomAlphabetic(6));
+        fooService.create(foo);
+        fooService.findOne(foo.getId());
+        final int size = CacheManager.ALL_CACHE_MANAGERS.get(0).getCache("com.baeldung.hibernate.cache.model.Foo").getSize();
+        assertThat(size, greaterThan(0));
+    }
+
+    @Test
+    public final void givenBarIsUpdatedInNativeQuery_thenFoosAreNotEvicted() {
+        final Foo foo = new Foo(randomAlphabetic(6));
+        fooService.create(foo);
+        fooService.findOne(foo.getId());
+
+        new TransactionTemplate(platformTransactionManager).execute(status -> {
+            final Bar bar = new Bar(randomAlphabetic(6));
+            entityManager.persist(bar);
+            final Query nativeQuery = entityManager.createNativeQuery("update BAR set NAME = :updatedName where ID = :id");
+            nativeQuery.setParameter("updatedName", "newName");
+            nativeQuery.setParameter("id", bar.getId());
+            nativeQuery.unwrap(org.hibernate.SQLQuery.class).addSynchronizedEntityClass(Bar.class);
+            return nativeQuery.executeUpdate();
+        });
+
+        final int size = CacheManager.ALL_CACHE_MANAGERS.get(0).getCache("com.baeldung.hibernate.cache.model.Foo").getSize();
+        assertThat(size, greaterThan(0));
+    }
+
+    @Test
+    public final void givenCacheableQueryIsExecuted_thenItIsCached() {
+        new TransactionTemplate(platformTransactionManager).execute(status -> {
+            return entityManager.createQuery("select f from Foo f").setHint("org.hibernate.cacheable", true).getResultList();
+        });
+
+        final int size = CacheManager.ALL_CACHE_MANAGERS.get(0).getCache("org.hibernate.cache.internal.StandardQueryCache").getSize();
+        assertThat(size, greaterThan(0));
+    }
+}

persistence-modules/spring-hibernate-5/src/test/java/org/baeldung/SpringContextIntegrationTest.java

@@ -0,0 +1,18 @@
+package org.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import com.baeldung.spring.PersistenceConfig;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { PersistenceConfig.class }, loader = AnnotationConfigContextLoader.class)
+public class SpringContextIntegrationTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

persistence-modules/spring-hibernate-5/src/test/java/org/baeldung/SpringContextTest.java

@@ -0,0 +1,18 @@
+package org.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import com.baeldung.spring.PersistenceConfig;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { PersistenceConfig.class }, loader = AnnotationConfigContextLoader.class)
+public class SpringContextTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

persistence-modules/spring-hibernate-5/src/test/resources/.gitignore

@@ -0,0 +1,13 @@
+*.class
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+
+# Packaged files #
+*.jar
+*.war
+*.ear

persistence-modules/spring-hibernate-5/src/test/resources/com/baeldung/hibernate/criteria/model/Item.hbm.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0"?>
+<!DOCTYPE hibernate-mapping PUBLIC
+    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
+    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
+<hibernate-mapping>
+	<class name="com.baeldung.hibernate.criteria.model.Item" table="ITEM">
+		<id name="itemId" type="java.lang.Integer">
+			<column name="ITEM_ID" />
+			<generator class="identity" />
+		</id>
+		<property name="itemDescription" type="string">
+			<column name="ITEM_DESC" length="100" />
+		</property>
+		<property name="itemPrice" type="java.lang.Integer">
+			<column name="ITEM_PRICE" not-null="true" />
+		</property>
+		<property name="itemName" type="string">
+			<column name="ITEM_NAME" not-null="true" />
+		</property>
+	</class>
+	
+</hibernate-mapping>

persistence-modules/spring-hibernate-5/src/test/resources/criteria.cfg.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE hibernate-configuration PUBLIC
+"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
+
+<hibernate-configuration>
+	<session-factory>
+	    <property name="hibernate.connection.driver_class">org.h2.Driver</property>
+		<property name="hibernate.connection.url">jdbc:h2:mem:testdb</property>
+		<property name="hibernate.connection.username">sa</property>
+		<property name="hibernate.connection.password"></property>
+		<property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
+	    <property name="hibernate.hbm2ddl.auto">create-drop</property>
+	    <property name="show_sql">false</property>        
+	    <mapping resource="com/baeldung/hibernate/criteria/model/Item.hbm.xml" />
+	</session-factory>
+</hibernate-configuration>

persistence-modules/spring-hibernate-5/src/test/resources/import.sql

@@ -0,0 +1,21 @@
+insert into item (item_id, item_name, item_desc, item_price) values(1,'item One', 'test 1', 35.12);
+
+insert into item (item_id, item_name, item_desc, item_price) values(2,'Pogo stick', 'Pogo stick', 466.12);
+
+insert into item (item_id, item_name, item_desc, item_price) values(3,'Raft', 'Raft', 345.12);
+
+insert into item (item_id, item_name, item_desc, item_price) values(4,'Skate Board', 'Skating', 135.71);
+
+insert into item (item_id, item_name, item_desc, item_price) values(5,'Umbrella', 'Umbrella for Rain', 619.25);
+
+insert into item (item_id, item_name, item_desc, item_price) values(6,'Glue', 'Glue for home', 432.73);
+
+insert into item (item_id, item_name, item_desc, item_price) values(7,'Paint', 'Paint for Room', 1311.40);
+
+insert into item (item_id, item_name, item_desc, item_price) values(8,'Red paint', 'Red paint for room', 1135.71);
+
+insert into item (item_id, item_name, item_desc, item_price) values(9,'Household Chairs', 'Chairs for house', 25.71);
+
+insert into item (item_id, item_name, item_desc, item_price) values(10,'Office Chairs', 'Chairs for office', 395.98);
+
+insert into item (item_id, item_name, item_desc, item_price) values(11,'Outdoor Chairs', 'Chairs for outdoor activities', 1234.36);

persistence-modules/spring-hibernate-5/src/test/resources/manytomany.cfg.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE hibernate-configuration PUBLIC
+		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+		"http://hibernate.org/dtd/hibernate-configuration-3.0.dtd">
+<hibernate-configuration>
+    <session-factory>
+        <property name="hibernate.connection.driver_class">org.h2.Driver</property>
+        <property name="hibernate.connection.password"></property>
+        <property name="hibernate.connection.url">jdbc:h2:mem:spring_hibernate_many_to_many</property>
+        <property name="hibernate.connection.username">sa</property>
+        <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
+        <property name="hibernate.current_session_context_class">thread</property>
+        <property name="hibernate.show_sql">true</property>
+        <property name="hibernate.hbm2ddl.auto">create-drop</property>
+    </session-factory>
+</hibernate-configuration>