persistence work

spring-hibernate3/.classpath

@@ -6,6 +6,7 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
+	<classpathentry kind="src" path="src/test/java"/>
 	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>

spring-hibernate3/.project

@@ -5,17 +5,6 @@
 	<projects>
 	</projects>
 	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.ui.externaltools.ExternalToolBuilder</name>
-			<triggers>full,incremental,</triggers>
-			<arguments>
-				<dictionary>
-					<key>LaunchConfigHandle</key>
-					<value>&lt;project&gt;/.externalToolBuilders/org.eclipse.wst.jsdt.core.javascriptValidator.launch
-					</value>
-				</dictionary>
-			</arguments>
-		</buildCommand>
 		<buildCommand>
 			<name>org.eclipse.jdt.core.javabuilder</name>
 			<arguments>

spring-hibernate3/.settings/org.eclipse.jdt.core.prefs

@@ -1,4 +1,9 @@
 eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation=ignore
+org.eclipse.jdt.core.compiler.annotation.nonnull=org.eclipse.jdt.annotation.NonNull
+org.eclipse.jdt.core.compiler.annotation.nonnullbydefault=org.eclipse.jdt.annotation.NonNullByDefault
+org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
+org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled
 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
 org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
@@ -6,7 +11,85 @@ org.eclipse.jdt.core.compiler.compliance=1.7
 org.eclipse.jdt.core.compiler.debug.lineNumber=generate
 org.eclipse.jdt.core.compiler.debug.localVariable=generate
 org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
 org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
+org.eclipse.jdt.core.compiler.problem.comparingIdentical=warning
+org.eclipse.jdt.core.compiler.problem.deadCode=warning
+org.eclipse.jdt.core.compiler.problem.deprecation=warning
+org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
+org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
+org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
+org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
 org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=ignore
+org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore
+org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
+org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
+org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
+org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
+org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts=disabled
+org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
+org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=warning
+org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
+org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
+org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
+org.eclipse.jdt.core.compiler.problem.missingDefaultCase=ignore
+org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
+org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault=disabled
+org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=ignore
+org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
+org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation=enabled
+org.eclipse.jdt.core.compiler.problem.missingSerialVersion=ignore
+org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=ignore
+org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
+org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
+org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
+org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict=error
+org.eclipse.jdt.core.compiler.problem.nullReference=warning
+org.eclipse.jdt.core.compiler.problem.nullSpecViolation=error
+org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion=warning
+org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
+org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore
+org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
+org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore
+org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable=ignore
+org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning
+org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
+org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=ignore
+org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=ignore
+org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
+org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=ignore
+org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
+org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
+org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors=disabled
+org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
+org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
+org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
+org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems=enabled
+org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
+org.eclipse.jdt.core.compiler.problem.unclosedCloseable=warning
+org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
+org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
+org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
+org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore
+org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
+org.eclipse.jdt.core.compiler.problem.unusedImport=warning
+org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
+org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
+org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation=ignore
+org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
+org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled
+org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
+org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
+org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
+org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
+org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
 org.eclipse.jdt.core.compiler.source=1.7

spring-hibernate3/.settings/org.eclipse.wst.common.component

@@ -4,6 +4,7 @@
         <wb-resource deploy-path="/" source-path="/src/main/webapp" tag="defaultRootSource"/>
         <wb-resource deploy-path="/WEB-INF/classes" source-path="/src/main/java"/>
         <wb-resource deploy-path="/WEB-INF/classes" source-path="/src/main/resources"/>
+        <wb-resource deploy-path="/WEB-INF/classes" source-path="/src/test/java"/>
         <property name="java-output-path" value="/spring-hibernate3/target/classes"/>
         <property name="context-root" value="spring-hibernate3"/>
     </wb-module>

spring-hibernate3/pom.xml

@@ -56,6 +56,20 @@
 
         <!-- test scoped -->
 
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.1</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <version>${org.springframework.version}</version>
+            <scope>test</scope>
+        </dependency>
+
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit-dep</artifactId>

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

@@ -0,0 +1,64 @@
+package org.baeldung.spring.persistence.dao;
+
+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> implements IOperations<T> {
+    private Class<T> clazz;
+
+    @Autowired
+    private SessionFactory sessionFactory;
+
+    // API
+
+    protected final void setClazz(final Class<T> clazzToSet) {
+        clazz = clazzToSet;
+    }
+
+    @Override
+    public final T findOne(final long id) {
+        return ((T) getCurrentSession().get(clazz, id));
+    }
+
+    @Override
+    public final List<T> findAll() {
+        return getCurrentSession().createQuery("from " + clazz.getName()).list();
+    }
+
+    @Override
+    public final long create(final T entity) {
+        Preconditions.checkNotNull(entity);
+        return (Long) getCurrentSession().save(entity);
+    }
+
+    @Override
+    public final T update(final T entity) {
+        Preconditions.checkNotNull(entity);
+        return (T) getCurrentSession().merge(entity);
+    }
+
+    @Override
+    public final void delete(final T entity) {
+        Preconditions.checkNotNull(entity);
+        getCurrentSession().delete(entity);
+    }
+
+    @Override
+    public final void deleteById(final long entityId) {
+        final T entity = findOne(entityId);
+        Preconditions.checkState(entity != null);
+        delete(entity);
+    }
+
+    protected final Session getCurrentSession() {
+        return sessionFactory.getCurrentSession();
+    }
+
+}

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

@@ -1,12 +1,15 @@
 package org.baeldung.spring.persistence.dao;
 
+import org.baeldung.spring.persistence.model.Foo;
 import org.springframework.stereotype.Repository;
 
 @Repository
-public class FooDao implements IFooDao {
+public class FooDao extends AbstractHibernateDao<Foo> implements IFooDao {
 
     public FooDao() {
         super();
+
+        setClazz(Foo.class);
     }
 
     // API

spring-hibernate3/src/main/java/org/baeldung/spring/persistence/dao/IFooDao.java

@@ -1,5 +1,7 @@
 package org.baeldung.spring.persistence.dao;
 
-public interface IFooDao {
+import org.baeldung.spring.persistence.model.Foo;
+
+public interface IFooDao extends IOperations<Foo> {
     //
 }

spring-hibernate3/src/main/java/org/baeldung/spring/persistence/dao/IOperations.java

@@ -0,0 +1,20 @@
+package org.baeldung.spring.persistence.dao;
+
+import java.io.Serializable;
+import java.util.List;
+
+public interface IOperations<T extends Serializable> {
+
+    T findOne(final long id);
+
+    List<T> findAll();
+
+    long create(final T entity);
+
+    T update(final T entity);
+
+    void delete(final T entity);
+
+    void deleteById(final long entityId);
+
+}

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

@@ -1,21 +1,33 @@
 package org.baeldung.spring.persistence.model;
 
+import java.io.Serializable;
+
+import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
 import javax.persistence.Id;
 
 @Entity
-public class Foo {
+public class Foo implements Serializable {
 
     @Id
     @GeneratedValue(strategy = GenerationType.AUTO)
     private long id;
 
+    @Column(nullable = false)
+    private String name;
+
     public Foo() {
         super();
     }
 
+    public Foo(final String name) {
+        super();
+
+        this.name = name;
+    }
+
     // API
 
     public long getId() {
@@ -26,6 +38,46 @@ public class Foo {
         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();
+    }
+
 }

spring-hibernate3/src/main/java/org/baeldung/spring/persistence/service/FooService.java

@@ -1,6 +1,7 @@
 package org.baeldung.spring.persistence.service;
 
 import org.baeldung.spring.persistence.dao.IFooDao;
+import org.baeldung.spring.persistence.model.Foo;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -8,7 +9,7 @@ import org.springframework.stereotype.Service;
 public class FooService {
 
     @Autowired
-    private IFooDao fooDao;
+    private IFooDao dao;
 
     public FooService() {
         super();
@@ -16,4 +17,8 @@ public class FooService {
 
     // API
 
+    public void create(final Foo entity) {
+        dao.create(entity);
+    }
+
 }

spring-hibernate3/src/test/java/org/baeldung/spring/persistence/service/FooServicePersistenceIntegrationTest.java

@@ -0,0 +1,59 @@
+package org.baeldung.spring.persistence.service;
+
+import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
+
+import org.baeldung.spring.persistence.config.PersistenceConfig;
+import org.baeldung.spring.persistence.model.Foo;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.dao.InvalidDataAccessApiUsageException;
+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 FooServicePersistenceIntegrationTest {
+
+    @Autowired
+    private FooService service;
+
+    // tests
+
+    @Test
+    public final void whenContextIsBootstrapped_thenNoExceptions() {
+        //
+    }
+
+    @Test
+    public final void whenEntityIsCreated_thenNoExceptions() {
+        service.create(new Foo(randomAlphabetic(6)));
+    }
+
+    @Test(expected = DataIntegrityViolationException.class)
+    public final void whenInvalidEntityIsCreated_thenDataException() {
+        service.create(new Foo());
+    }
+
+    @Test(expected = DataIntegrityViolationException.class)
+    public final void whenEntityWithLongNameIsCreated_thenDataException() {
+        service.create(new Foo(randomAlphabetic(2048)));
+    }
+
+    @Test(expected = InvalidDataAccessApiUsageException.class)
+    public final void whenSameEntityIsCreatedTwice_thenDataException() {
+        final Foo entity = new Foo(randomAlphabetic(8));
+        service.create(entity);
+        service.create(entity);
+    }
+
+    @Test
+    @Ignore
+    public final void temp_whenInvalidEntityIsCreated_thenDataException() {
+        service.create(new Foo(randomAlphabetic(2048)));
+    }
+
+}

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

@@ -10,7 +10,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import com.google.common.base.Preconditions;
 
 @SuppressWarnings("unchecked")
-public abstract class AbstractHibernateDao<T extends Serializable> {
+public abstract class AbstractHibernateDao<T extends Serializable> implements IOperations<T> {
     private Class<T> clazz;
 
     @Autowired
@@ -22,31 +22,36 @@ public abstract class AbstractHibernateDao<T extends Serializable> {
         clazz = clazzToSet;
     }
 
-    public final T findOne(final Long id) {
+    @Override
-        Preconditions.checkArgument(id != null);
+    public final T findOne(final long id) {
         return ((T) getCurrentSession().get(clazz, id));
     }
 
+    @Override
     public final List<T> findAll() {
         return getCurrentSession().createQuery("from " + clazz.getName()).list();
     }
 
-    public final void create(final T entity) {
+    @Override
+    public final long create(final T entity) {
         Preconditions.checkNotNull(entity);
-        getCurrentSession().persist(entity);
+        return (Long) getCurrentSession().save(entity);
     }
 
+    @Override
     public final T update(final T entity) {
         Preconditions.checkNotNull(entity);
         return (T) getCurrentSession().merge(entity);
     }
 
+    @Override
     public final void delete(final T entity) {
         Preconditions.checkNotNull(entity);
         getCurrentSession().delete(entity);
     }
 
-    public final void deleteById(final Long entityId) {
+    @Override
+    public final void deleteById(final long entityId) {
         final T entity = findOne(entityId);
         Preconditions.checkState(entity != null);
         delete(entity);

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

@@ -1,21 +1,7 @@
 package org.baeldung.spring.persistence.dao;
 
-import java.util.List;
-
 import org.baeldung.spring.persistence.model.Foo;
 
-public interface IFooDao {
+public interface IFooDao extends IOperations<Foo> {
-
+    //
-    Foo findOne(final Long id);
-
-    List<Foo> findAll();
-
-    void create(final Foo entity);
-
-    Foo update(final Foo entity);
-
-    void delete(final Foo entity);
-
-    void deleteById(final Long entityId);
-
 }

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

@@ -0,0 +1,20 @@
+package org.baeldung.spring.persistence.dao;
+
+import java.io.Serializable;
+import java.util.List;
+
+public interface IOperations<T extends Serializable> {
+
+    T findOne(final long id);
+
+    List<T> findAll();
+
+    long create(final T entity);
+
+    T update(final T entity);
+
+    void delete(final T entity);
+
+    void deleteById(final long entityId);
+
+}