Merge branch 'aliaksandr-adzinets-master'

spring-hibernate4/pom.xml

@@ -15,6 +15,16 @@
             <artifactId>spring-context</artifactId>
             <version>${org.springframework.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-aspects</artifactId>
+            <version>${org.springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-core</artifactId>
+            <version>${org.springframework.security.version}</version>
+        </dependency>
 
         <!-- persistence -->
 
@@ -23,21 +33,35 @@
             <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.javassist</groupId>
+            <groupId>org.hibernate</groupId>
-            <artifactId>javassist</artifactId>
+            <artifactId>hibernate-envers</artifactId>
-            <version>${javassist.version}</version>
+            <version>${hibernate-envers.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.transaction</groupId>
+            <artifactId>jta</artifactId>
+            <version>${jta.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.el</groupId>
+            <artifactId>javax.el-api</artifactId>
+            <version>${el-api.version}</version>
         </dependency>
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
             <version>${mysql-connector-java.version}</version>
-            <scope>runtime</scope>
         </dependency>
 
         <dependency>
@@ -82,7 +106,7 @@
             <version>${org.springframework.version}</version>
             <scope>test</scope>
         </dependency>
-
+        
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
@@ -90,12 +114,27 @@
             <scope>test</scope>
         </dependency>
 
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-test</artifactId>
+            <version>${org.springframework.security.version}</version>
+            <scope>test</scope>
+        </dependency>
+
         <dependency>
             <groupId>org.hamcrest</groupId>
             <artifactId>hamcrest-core</artifactId>
             <version>${org.hamcrest.version}</version>
             <scope>test</scope>
         </dependency>
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit-dep</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+
         <dependency>
             <groupId>org.hamcrest</groupId>
             <artifactId>hamcrest-library</artifactId>
@@ -175,18 +214,22 @@
     <properties>
         <!-- Spring -->
         <org.springframework.version>4.2.4.RELEASE</org.springframework.version>
-        <org.springframework.security.version>4.0.3.RELEASE</org.springframework.security.version>
+	<org.springframework.security.version>4.0.3.RELEASE</org.springframework.security.version>
-        <javassist.version>3.20.0-GA</javassist.version>
+	<org.springframework.data.version>1.9.2.RELEASE</org.springframework.data.version>
-
+	<javassist.version>3.20.0-GA</javassist.version>
+        
         <!-- persistence -->
         <hibernate.version>4.3.11.Final</hibernate.version>
+        <hibernate-envers.version>${hibernate.version}</hibernate-envers.version>
         <mysql-connector-java.version>5.1.37</mysql-connector-java.version>
         <tomcat-dbcp.version>7.0.42</tomcat-dbcp.version>
+        <jta.version>1.1</jta.version>
+        <el-api.version>2.2.4</el-api.version>
 
         <!-- logging -->
         <org.slf4j.version>1.7.13</org.slf4j.version>
         <logback.version>1.1.3</logback.version>
-
+        
         <!-- various -->
         <hibernate-validator.version>5.2.2.Final</hibernate-validator.version>
 
@@ -196,7 +239,7 @@
 
         <!-- testing -->
         <org.hamcrest.version>1.3</org.hamcrest.version>
-        <junit.version>4.12</junit.version>
+        <junit.version>4.11</junit.version>
         <mockito.version>1.10.19</mockito.version>
 
         <httpcore.version>4.4.1</httpcore.version>
@@ -209,7 +252,8 @@
         <maven-surefire-plugin.version>2.18.1</maven-surefire-plugin.version>
         <maven-resources-plugin.version>2.7</maven-resources-plugin.version>
         <cargo-maven2-plugin.version>1.4.15</cargo-maven2-plugin.version>
+        <!-- <hibernate4-maven-plugin.version>1.1.0</hibernate4-maven-plugin.version> -->
 
     </properties>
 
-</project>
+</project>

spring-hibernate4/src/main/java/org/baeldung/persistence/dao/IBarAuditableDao.java

@@ -0,0 +1,8 @@
+package org.baeldung.persistence.dao;
+
+import org.baeldung.persistence.dao.common.IAuditOperations;
+import org.baeldung.persistence.model.Bar;
+
+public interface IBarAuditableDao extends IBarDao, IAuditOperations<Bar> {
+    //
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/dao/IBarCrudRepository.java

@@ -0,0 +1,10 @@
+package org.baeldung.persistence.dao;
+
+import java.io.Serializable;
+
+import org.baeldung.persistence.model.Bar;
+import org.springframework.data.repository.CrudRepository;
+
+public interface IBarCrudRepository extends CrudRepository<Bar, Serializable> {
+    //
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/dao/IBarDao.java

@@ -0,0 +1,8 @@
+package org.baeldung.persistence.dao;
+
+import org.baeldung.persistence.dao.common.IOperations;
+import org.baeldung.persistence.model.Bar;
+
+public interface IBarDao extends IOperations<Bar> {
+    //
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/dao/IFooAuditableDao.java

@@ -0,0 +1,8 @@
+package org.baeldung.persistence.dao;
+
+import org.baeldung.persistence.dao.common.IAuditOperations;
+import org.baeldung.persistence.model.Foo;
+
+public interface IFooAuditableDao extends IFooDao, IAuditOperations<Foo> {
+    //
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/dao/common/AbstractDao.java

@@ -0,0 +1,14 @@
+package org.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);
+    }
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/dao/common/AbstractHibernateAuditableDao.java

@@ -0,0 +1,37 @@
+package org.baeldung.persistence.dao.common;
+
+import java.io.Serializable;
+import java.util.List;
+
+import org.hibernate.envers.AuditReader;
+import org.hibernate.envers.AuditReaderFactory;
+import org.hibernate.envers.query.AuditQuery;
+
+@SuppressWarnings("unchecked")
+public class AbstractHibernateAuditableDao<T extends Serializable> extends AbstractHibernateDao<T> implements IAuditOperations<T> {
+
+    @Override
+    public List<T> getEntitiesAtRevision(final Number revision) {
+        final AuditReader auditReader = AuditReaderFactory.get(getCurrentSession());
+        final AuditQuery query = auditReader.createQuery().forEntitiesAtRevision(clazz, revision);
+        final List<T> resultList = query.getResultList();
+        return resultList;
+    }
+
+    @Override
+    public List<T> getEntitiesModifiedAtRevision(final Number revision) {
+        final AuditReader auditReader = AuditReaderFactory.get(getCurrentSession());
+        final AuditQuery query = auditReader.createQuery().forEntitiesModifiedAtRevision(clazz, revision);
+        final List<T> resultList = query.getResultList();
+        return resultList;
+    }
+
+    @Override
+    public List<T> getRevisions() {
+        final AuditReader auditReader = AuditReaderFactory.get(getCurrentSession());
+        final AuditQuery query = auditReader.createQuery().forRevisionsOfEntity(clazz, true, true);
+        final List<T> resultList = query.getResultList();
+        return resultList;
+    }
+
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/dao/common/AbstractHibernateDao.java

@@ -10,55 +10,49 @@ import org.springframework.beans.factory.annotation.Autowired;
 import com.google.common.base.Preconditions;
 
 @SuppressWarnings("unchecked")
-public abstract class AbstractHibernateDao<T extends Serializable> implements IOperations<T> {
+public abstract class AbstractHibernateDao<T extends Serializable> extends AbstractDao<T> implements IOperations<T> {
-    private Class<T> clazz;
 
     @Autowired
-    private SessionFactory sessionFactory;
+    protected SessionFactory sessionFactory;
 
     // API
 
-    protected final void setClazz(final Class<T> clazzToSet) {
-        clazz = Preconditions.checkNotNull(clazzToSet);
-    }
-
     @Override
-    public final T findOne(final long id) {
+    public T findOne(final long id) {
         return (T) getCurrentSession().get(clazz, id);
     }
 
     @Override
-    public final List<T> findAll() {
+    public List<T> findAll() {
         return getCurrentSession().createQuery("from " + clazz.getName()).list();
     }
 
     @Override
-    public final void create(final T entity) {
+    public void create(final T entity) {
         Preconditions.checkNotNull(entity);
-        // getCurrentSession().persist(entity);
         getCurrentSession().saveOrUpdate(entity);
     }
 
     @Override
-    public final T update(final T entity) {
+    public T update(final T entity) {
         Preconditions.checkNotNull(entity);
         return (T) getCurrentSession().merge(entity);
     }
 
     @Override
-    public final void delete(final T entity) {
+    public void delete(final T entity) {
         Preconditions.checkNotNull(entity);
         getCurrentSession().delete(entity);
     }
 
     @Override
-    public final void deleteById(final long entityId) {
+    public void deleteById(final long entityId) {
         final T entity = findOne(entityId);
         Preconditions.checkState(entity != null);
         delete(entity);
     }
 
-    protected final Session getCurrentSession() {
+    protected Session getCurrentSession() {
         return sessionFactory.getCurrentSession();
     }
 

spring-hibernate4/src/main/java/org/baeldung/persistence/dao/common/AbstractJpaDao.java

@@ -0,0 +1,56 @@
+package org.baeldung.persistence.dao.common;
+
+import java.io.Serializable;
+import java.util.List;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.TypedQuery;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+
+public class AbstractJpaDao<T extends Serializable> extends AbstractDao<T> implements IOperations<T> {
+
+    @PersistenceContext
+    private EntityManager em;
+
+    // API
+
+    @Override
+    public T findOne(final long id) {
+        return em.find(clazz, Long.valueOf(id).intValue());
+    }
+
+    @Override
+    public List<T> findAll() {
+        final CriteriaBuilder cb = em.getCriteriaBuilder();
+        final CriteriaQuery<T> cq = cb.createQuery(clazz);
+        final Root<T> rootEntry = cq.from(clazz);
+        final CriteriaQuery<T> all = cq.select(rootEntry);
+        final TypedQuery<T> allQuery = em.createQuery(all);
+        return allQuery.getResultList();
+    }
+
+    @Override
+    public void create(final T entity) {
+        em.persist(entity);
+    }
+
+    @Override
+    public T update(final T entity) {
+        em.merge(entity);
+        return entity;
+    }
+
+    @Override
+    public void delete(final T entity) {
+        em.remove(entity);
+    }
+
+    @Override
+    public void deleteById(final long entityId) {
+        delete(findOne(entityId));
+    }
+
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/dao/common/IAuditOperations.java

@@ -0,0 +1,14 @@
+package org.baeldung.persistence.dao.common;
+
+import java.io.Serializable;
+import java.util.List;
+
+public interface IAuditOperations<T extends Serializable> {
+
+    List<T> getEntitiesAtRevision(Number revision);
+
+    List<T> getEntitiesModifiedAtRevision(Number revision);
+
+    List<T> getRevisions();
+
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/dao/impl/BarAuditableDao.java

@@ -0,0 +1,28 @@
+package org.baeldung.persistence.dao.impl;
+
+import java.util.List;
+
+import org.baeldung.persistence.dao.IBarAuditableDao;
+import org.baeldung.persistence.dao.common.AbstractHibernateAuditableDao;
+import org.baeldung.persistence.model.Bar;
+
+public class BarAuditableDao extends AbstractHibernateAuditableDao<Bar> implements IBarAuditableDao {
+
+    public BarAuditableDao() {
+        super();
+
+        setClazz(Bar.class);
+    }
+
+    // API
+
+    @Override
+    public List<Bar> getRevisions() {
+        final List<Bar> resultList = super.getRevisions();
+        for (final Bar bar : resultList) {
+            bar.getFooSet().size(); // force FooSet initialization
+        }
+        return resultList;
+    }
+
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/dao/impl/BarDao.java

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

spring-hibernate4/src/main/java/org/baeldung/persistence/dao/impl/BarJpaDao.java

@@ -0,0 +1,19 @@
+package org.baeldung.persistence.dao.impl;
+
+import org.baeldung.persistence.dao.IBarDao;
+import org.baeldung.persistence.dao.common.AbstractJpaDao;
+import org.baeldung.persistence.model.Bar;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class BarJpaDao extends AbstractJpaDao<Bar> implements IBarDao {
+
+    public BarJpaDao() {
+        super();
+
+        setClazz(Bar.class);
+    }
+
+    // API
+
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/dao/impl/FooAuditableDao.java

@@ -0,0 +1,17 @@
+package org.baeldung.persistence.dao.impl;
+
+import org.baeldung.persistence.dao.IFooAuditableDao;
+import org.baeldung.persistence.dao.common.AbstractHibernateAuditableDao;
+import org.baeldung.persistence.model.Foo;
+
+public class FooAuditableDao extends AbstractHibernateAuditableDao<Foo> implements IFooAuditableDao {
+
+    public FooAuditableDao() {
+        super();
+
+        setClazz(Foo.class);
+    }
+
+    // API
+
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/dao/impl/FooDao.java

@@ -6,7 +6,7 @@ import org.baeldung.persistence.model.Foo;
 import org.springframework.stereotype.Repository;
 
 @Repository
-public class FooDao extends AbstractHibernateDao<Foo>implements IFooDao {
+public class FooDao extends AbstractHibernateDao<Foo> implements IFooDao {
 
     public FooDao() {
         super();

spring-hibernate4/src/main/java/org/baeldung/persistence/model/Bar.java

@@ -1,26 +1,66 @@
 package org.baeldung.persistence.model;
 
 import java.io.Serializable;
+import java.util.Date;
 import java.util.Set;
 
 import javax.persistence.CascadeType;
 import javax.persistence.Column;
 import javax.persistence.Entity;
+import javax.persistence.EntityListeners;
 import javax.persistence.FetchType;
 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
 import javax.persistence.Id;
 import javax.persistence.NamedQuery;
 import javax.persistence.OneToMany;
+import javax.persistence.PrePersist;
+import javax.persistence.PreRemove;
+import javax.persistence.PreUpdate;
 
 import org.hibernate.annotations.OrderBy;
+import org.hibernate.envers.Audited;
+import org.jboss.logging.Logger;
+import org.springframework.data.annotation.CreatedBy;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.annotation.LastModifiedBy;
+import org.springframework.data.annotation.LastModifiedDate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
 
 import com.google.common.collect.Sets;
 
 @Entity
 @NamedQuery(name = "Bar.findAll", query = "SELECT b FROM Bar b")
+@Audited
+@EntityListeners(AuditingEntityListener.class)
 public class Bar implements Serializable {
 
+    private static Logger logger = Logger.getLogger(Bar.class);
+
+    public enum OPERATION {
+        INSERT, UPDATE, DELETE;
+        private String value;
+
+        OPERATION() {
+            value = toString();
+        }
+
+        public String getValue() {
+            return value;
+        }
+
+        public static OPERATION parse(final String value) {
+            OPERATION operation = null;
+            for (final OPERATION op : OPERATION.values()) {
+                if (op.getValue().equals(value)) {
+                    operation = op;
+                    break;
+                }
+            }
+            return operation;
+        }
+    };
+
     @Id
     @GeneratedValue(strategy = GenerationType.AUTO)
     @Column(name = "id")
@@ -31,8 +71,31 @@ public class Bar implements Serializable {
 
     @OneToMany(mappedBy = "bar", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
     @OrderBy(clause = "NAME DESC")
+    // @NotAudited
     private Set<Foo> fooSet = Sets.newHashSet();
 
+    @Column(name = "operation")
+    private String operation;
+
+    @Column(name = "timestamp")
+    private long timestamp;
+
+    @Column(name = "created_date")
+    @CreatedDate
+    private long createdDate;
+
+    @Column(name = "modified_date")
+    @LastModifiedDate
+    private long modifiedDate;
+
+    @Column(name = "created_by")
+    @CreatedBy
+    private String createdBy;
+
+    @Column(name = "modified_by")
+    @LastModifiedBy
+    private String modifiedBy;
+
     public Bar() {
         super();
     }
@@ -69,7 +132,57 @@ public class Bar implements Serializable {
         this.name = name;
     }
 
-    //
+    public OPERATION getOperation() {
+        return OPERATION.parse(operation);
+    }
+
+    public void setOperation(final OPERATION operation) {
+        this.operation = operation.getValue();
+    }
+
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    public void setTimestamp(final long timestamp) {
+        this.timestamp = timestamp;
+    }
+
+    public long getCreatedDate() {
+        return createdDate;
+    }
+
+    public void setCreatedDate(final long createdDate) {
+        this.createdDate = createdDate;
+    }
+
+    public long getModifiedDate() {
+        return modifiedDate;
+    }
+
+    public void setModifiedDate(final long modifiedDate) {
+        this.modifiedDate = modifiedDate;
+    }
+
+    public String getCreatedBy() {
+        return createdBy;
+    }
+
+    public void setCreatedBy(final String createdBy) {
+        this.createdBy = createdBy;
+    }
+
+    public String getModifiedBy() {
+        return modifiedBy;
+    }
+
+    public void setModifiedBy(final String modifiedBy) {
+        this.modifiedBy = modifiedBy;
+    }
+
+    public void setOperation(final String operation) {
+        this.operation = operation;
+    }
 
     @Override
     public int hashCode() {
@@ -103,4 +216,27 @@ public class Bar implements Serializable {
         return builder.toString();
     }
 
+    @PrePersist
+    public void onPrePersist() {
+        logger.info("@PrePersist");
+        audit(OPERATION.INSERT);
+    }
+
+    @PreUpdate
+    public void onPreUpdate() {
+        logger.info("@PreUpdate");
+        audit(OPERATION.UPDATE);
+    }
+
+    @PreRemove
+    public void onPreRemove() {
+        logger.info("@PreRemove");
+        audit(OPERATION.DELETE);
+    }
+
+    private void audit(final OPERATION operation) {
+        setOperation(operation);
+        setTimestamp((new Date()).getTime());
+    }
+
 }

spring-hibernate4/src/main/java/org/baeldung/persistence/model/Foo.java

@@ -12,7 +12,11 @@ import javax.persistence.Id;
 import javax.persistence.JoinColumn;
 import javax.persistence.ManyToOne;
 
+import org.hibernate.envers.Audited;
+
 @Entity
+@Audited
+// @Proxy(lazy = false)
 public class Foo implements Serializable {
 
     @Id

spring-hibernate4/src/main/java/org/baeldung/persistence/service/IBarAuditableService.java

@@ -0,0 +1,8 @@
+package org.baeldung.persistence.service;
+
+import org.baeldung.persistence.dao.common.IAuditOperations;
+import org.baeldung.persistence.model.Bar;
+
+public interface IBarAuditableService extends IBarService, IAuditOperations<Bar> {
+
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/service/IBarService.java

@@ -0,0 +1,8 @@
+package org.baeldung.persistence.service;
+
+import org.baeldung.persistence.dao.common.IOperations;
+import org.baeldung.persistence.model.Bar;
+
+public interface IBarService extends IOperations<Bar> {
+    //
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/service/IFooAuditableService.java

@@ -0,0 +1,8 @@
+package org.baeldung.persistence.service;
+
+import org.baeldung.persistence.dao.common.IAuditOperations;
+import org.baeldung.persistence.model.Foo;
+
+public interface IFooAuditableService extends IFooService, IAuditOperations<Foo> {
+    //
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/service/common/AbstractHibernateAuditableService.java

@@ -0,0 +1,30 @@
+package org.baeldung.persistence.service.common;
+
+import java.io.Serializable;
+import java.util.List;
+
+import org.baeldung.persistence.dao.common.IAuditOperations;
+import org.baeldung.persistence.dao.common.IOperations;
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional(value = "hibernateTransactionManager")
+public abstract class AbstractHibernateAuditableService<T extends Serializable> extends AbstractHibernateService<T> implements IOperations<T>, IAuditOperations<T> {
+
+    @Override
+    public List<T> getEntitiesAtRevision(final Number revision) {
+        return getAuditableDao().getEntitiesAtRevision(revision);
+    }
+
+    @Override
+    public List<T> getEntitiesModifiedAtRevision(final Number revision) {
+        return getAuditableDao().getEntitiesModifiedAtRevision(revision);
+    }
+
+    @Override
+    public List<T> getRevisions() {
+        return getAuditableDao().getRevisions();
+    }
+
+    abstract protected IAuditOperations<T> getAuditableDao();
+
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/service/common/AbstractHibernateService.java

@@ -0,0 +1,42 @@
+package org.baeldung.persistence.service.common;
+
+import java.io.Serializable;
+import java.util.List;
+
+import org.baeldung.persistence.dao.common.IOperations;
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional(value = "hibernateTransactionManager")
+public abstract class AbstractHibernateService<T extends Serializable> extends AbstractService<T> implements IOperations<T> {
+
+    @Override
+    public T findOne(final long id) {
+        return super.findOne(id);
+    }
+
+    @Override
+    public List<T> findAll() {
+        return super.findAll();
+    }
+
+    @Override
+    public void create(final T entity) {
+        super.create(entity);
+    }
+
+    @Override
+    public T update(final T entity) {
+        return super.update(entity);
+    }
+
+    @Override
+    public void delete(final T entity) {
+        super.delete(entity);
+    }
+
+    @Override
+    public void deleteById(final long entityId) {
+        super.deleteById(entityId);
+    }
+
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/service/common/AbstractJpaService.java

@@ -0,0 +1,42 @@
+package org.baeldung.persistence.service.common;
+
+import java.io.Serializable;
+import java.util.List;
+
+import org.baeldung.persistence.dao.common.IOperations;
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional(value = "jpaTransactionManager")
+public abstract class AbstractJpaService<T extends Serializable> extends AbstractService<T> implements IOperations<T> {
+
+    @Override
+    public T findOne(final long id) {
+        return super.findOne(id);
+    }
+
+    @Override
+    public List<T> findAll() {
+        return super.findAll();
+    }
+
+    @Override
+    public void create(final T entity) {
+        super.create(entity);
+    }
+
+    @Override
+    public T update(final T entity) {
+        return super.update(entity);
+    }
+
+    @Override
+    public void delete(final T entity) {
+        super.delete(entity);
+    }
+
+    @Override
+    public void deleteById(final long entityId) {
+        super.deleteById(entityId);
+    }
+
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/service/common/AbstractService.java

@@ -4,9 +4,7 @@ import java.io.Serializable;
 import java.util.List;
 
 import org.baeldung.persistence.dao.common.IOperations;
-import org.springframework.transaction.annotation.Transactional;
 
-@Transactional
 public abstract class AbstractService<T extends Serializable> implements IOperations<T> {
 
     @Override

spring-hibernate4/src/main/java/org/baeldung/persistence/service/common/AbstractSpringDataJpaService.java

@@ -0,0 +1,46 @@
+package org.baeldung.persistence.service.common;
+
+import java.io.Serializable;
+import java.util.List;
+
+import org.baeldung.persistence.dao.common.IOperations;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.google.common.collect.Lists;
+
+@Transactional(value = "jpaTransactionManager")
+public abstract class AbstractSpringDataJpaService<T extends Serializable> implements IOperations<T> {
+
+    @Override
+    public T findOne(final long id) {
+        return getDao().findOne(Long.valueOf(id));
+    }
+
+    @Override
+    public List<T> findAll() {
+        return Lists.newArrayList(getDao().findAll());
+    }
+
+    @Override
+    public void create(final T entity) {
+        getDao().save(entity);
+    }
+
+    @Override
+    public T update(final T entity) {
+        return getDao().save(entity);
+    }
+
+    @Override
+    public void delete(final T entity) {
+        getDao().delete(entity);
+    }
+
+    @Override
+    public void deleteById(final long entityId) {
+        getDao().delete(Long.valueOf(entityId));
+    }
+
+    protected abstract CrudRepository<T, Serializable> getDao();
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/service/impl/BarAuditableService.java

@@ -0,0 +1,41 @@
+package org.baeldung.persistence.service.impl;
+
+import org.baeldung.persistence.dao.IBarAuditableDao;
+import org.baeldung.persistence.dao.IBarDao;
+import org.baeldung.persistence.dao.common.IAuditOperations;
+import org.baeldung.persistence.dao.common.IOperations;
+import org.baeldung.persistence.model.Bar;
+import org.baeldung.persistence.service.IBarAuditableService;
+import org.baeldung.persistence.service.common.AbstractHibernateAuditableService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Service;
+
+@Service
+public class BarAuditableService extends AbstractHibernateAuditableService<Bar> implements IBarAuditableService {
+
+    @Autowired
+    @Qualifier("barHibernateDao")
+    private IBarDao dao;
+
+    @Autowired
+    @Qualifier("barHibernateAuditableDao")
+    private IBarAuditableDao auditDao;
+
+    public BarAuditableService() {
+        super();
+    }
+
+    // API
+
+    @Override
+    protected IOperations<Bar> getDao() {
+        return dao;
+    }
+
+    @Override
+    protected IAuditOperations<Bar> getAuditableDao() {
+        return auditDao;
+    }
+
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/service/impl/BarJpaService.java

@@ -0,0 +1,30 @@
+package org.baeldung.persistence.service.impl;
+
+import org.baeldung.persistence.dao.IBarDao;
+import org.baeldung.persistence.dao.common.IOperations;
+import org.baeldung.persistence.model.Bar;
+import org.baeldung.persistence.service.IBarService;
+import org.baeldung.persistence.service.common.AbstractJpaService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Service;
+
+@Service
+public class BarJpaService extends AbstractJpaService<Bar> implements IBarService {
+
+    @Autowired
+    @Qualifier("barJpaDao")
+    private IBarDao dao;
+
+    public BarJpaService() {
+        super();
+    }
+
+    // API
+
+    @Override
+    protected IOperations<Bar> getDao() {
+        return dao;
+    }
+
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/service/impl/BarService.java

@@ -0,0 +1,30 @@
+package org.baeldung.persistence.service.impl;
+
+import org.baeldung.persistence.dao.IBarDao;
+import org.baeldung.persistence.dao.common.IOperations;
+import org.baeldung.persistence.model.Bar;
+import org.baeldung.persistence.service.IBarService;
+import org.baeldung.persistence.service.common.AbstractHibernateService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Service;
+
+@Service
+public class BarService extends AbstractHibernateService<Bar> implements IBarService {
+
+    @Autowired
+    @Qualifier("barHibernateDao")
+    private IBarDao dao;
+
+    public BarService() {
+        super();
+    }
+
+    // API
+
+    @Override
+    protected IOperations<Bar> getDao() {
+        return dao;
+    }
+
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/service/impl/BarSpringDataJpaService.java

@@ -0,0 +1,26 @@
+package org.baeldung.persistence.service.impl;
+
+import java.io.Serializable;
+
+import org.baeldung.persistence.dao.IBarCrudRepository;
+import org.baeldung.persistence.model.Bar;
+import org.baeldung.persistence.service.IBarService;
+import org.baeldung.persistence.service.common.AbstractSpringDataJpaService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.CrudRepository;
+
+public class BarSpringDataJpaService extends AbstractSpringDataJpaService<Bar> implements IBarService {
+
+    @Autowired
+    private IBarCrudRepository dao;
+
+    public BarSpringDataJpaService() {
+        super();
+    }
+
+    @Override
+    protected CrudRepository<Bar, Serializable> getDao() {
+        return dao;
+    }
+
+}

spring-hibernate4/src/main/java/org/baeldung/persistence/service/impl/ChildService.java

@@ -4,12 +4,12 @@ import org.baeldung.persistence.dao.IChildDao;
 import org.baeldung.persistence.dao.common.IOperations;
 import org.baeldung.persistence.model.Child;
 import org.baeldung.persistence.service.IChildService;
-import org.baeldung.persistence.service.common.AbstractService;
+import org.baeldung.persistence.service.common.AbstractHibernateService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 @Service
-public class ChildService extends AbstractService<Child>implements IChildService {
+public class ChildService extends AbstractHibernateService<Child>implements IChildService {
 
     @Autowired
     private IChildDao dao;