Added experimental (but unused) building block pattern base classes

dddsample/src/main/java/se/citerus/dddsample/domain/shared/experimental/DomainEvent.java

@@ -0,0 +1,17 @@
+package se.citerus.dddsample.domain.shared.experimental;
+
+/**
+ * A domain event is something that is unique, but does not have a lifecycle.
+ * The identity may be explicit, for example the sequence number of a payment,
+ * or it could be derived from various aspects of the event such as where, when and what
+ * has happened.
+ */
+public interface DomainEvent<T> {
+
+  /**
+   * @param other The other domain event.
+   * @return <code>true</code> if the given domain event and this event are regarded as being the same event.
+   */
+  boolean sameEventAs(T other);
+
+}

dddsample/src/main/java/se/citerus/dddsample/domain/shared/experimental/Entity.java

@@ -0,0 +1,19 @@
+package se.citerus.dddsample.domain.shared.experimental;
+
+/**
+ * An entity, as explained in the DDD book.
+ *
+ */
+public interface Entity<T,ID> {
+
+  /**
+   * Entities compare by identity, not by attributes.
+   *
+   * @param other The other entity.
+   * @return true if the identities are the same, regardles of other attributes.
+   */
+  boolean sameIdentityAs(T other);
+
+  ID identity();
+
+}

dddsample/src/main/java/se/citerus/dddsample/domain/shared/experimental/EntitySupport.java

@@ -0,0 +1,71 @@
+package se.citerus.dddsample.domain.shared.experimental;
+
+import java.lang.reflect.Field;
+
+/**
+ *
+ *
+ */
+public abstract class EntitySupport<T extends Entity, ID> implements Entity<T, ID> {
+
+    private static Field identityField;
+
+    @Override
+    public final boolean sameIdentityAs(final T other) {
+        return other != null && this.identity().equals(other.identity());
+    }
+
+    @Override
+    public final ID identity() {
+        if (identityField == null) {
+            identityField = identityFieldLazyDetermination(this.getClass());
+        }
+
+        try {
+            return (ID) identityField.get(this);
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static Field identityFieldLazyDetermination(final Class cls) {
+        Field identityField = null;
+
+        for (Field field : cls.getDeclaredFields()) {
+            if (field.getAnnotation(Identity.class) != null) {
+                field.setAccessible(true);
+                if (identityField != null) {
+                    throw new IllegalStateException("Only one field can be annotated with " + Identity.class);
+                } else {
+                    identityField = field;
+                }
+            }
+        }
+
+        if (identityField == null) {
+            if (cls == Object.class) {
+                throw new IllegalStateException(
+                  "This class, or one of its superclasses, " +
+                  "must have a unique field annotated with " + Identity.class);
+            } else {
+                return identityFieldLazyDetermination(cls.getSuperclass());
+            }
+        }
+
+        return identityField;
+    }
+
+    @Override
+    public final int hashCode() {
+        return identity().hashCode();
+    }
+
+    @Override
+    public final boolean equals(final Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        return sameIdentityAs((T) o);
+    }
+
+}

dddsample/src/main/java/se/citerus/dddsample/domain/shared/experimental/Identity.java

@@ -0,0 +1,15 @@
+package se.citerus.dddsample.domain.shared.experimental;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Every class that inherits from {@link se.citerus.dddsample.domain.shared.experimental.EntitySupport}
+ * must have exactly one field annotated with this annotation.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface Identity {
+}

dddsample/src/main/java/se/citerus/dddsample/domain/shared/experimental/ValueObject.java

@@ -0,0 +1,23 @@
+package se.citerus.dddsample.domain.shared.experimental;
+
+import java.io.Serializable;
+
+/**
+ * A value object.
+ *
+ */
+public interface ValueObject<T> extends Serializable {
+
+  /**
+   * Value objects compare by the values of their attributes, they don't have an identity.
+   *
+   * @param other The other value object.
+   * @return <code>true</code> if the given value object's and this value object's attributes are the same.
+   */
+  boolean sameValueAs(T other);
+
+
+  // Value objects can be safely copied:
+  // T copy();
+
+}

dddsample/src/main/java/se/citerus/dddsample/domain/shared/experimental/ValueObjectSupport.java

@@ -0,0 +1,42 @@
+package se.citerus.dddsample.domain.shared.experimental;
+
+import org.apache.commons.lang.builder.EqualsBuilder;
+import org.apache.commons.lang.builder.HashCodeBuilder;
+import se.citerus.dddsample.domain.model.ValueObject;
+
+public class ValueObjectSupport<T extends ValueObject> implements ValueObject<T> {
+
+    private transient int cachedHashCode = 0;
+
+    @Override
+    public final boolean sameValueAs(final T other) {
+        return other != null && EqualsBuilder.reflectionEquals(this, other, false);
+    }
+
+    @Override
+    public final int hashCode() {
+        // Using a local variable to ensure that we only do a single read
+        // of the cachedHashCode field, to avoid race conditions.
+        // It doesn't matter if several threads compute the hash code and overwrite
+        // each other, but it's important that we never return 0, which could happen
+        // with multiple field reads.
+        int h = cachedHashCode;
+        if (h == 0) {
+            // Lazy initialization of hash code.
+            // Value objects are immutable, so the hash code never changes.
+            h = HashCodeBuilder.reflectionHashCode(this, false);
+            cachedHashCode = h;
+        }
+
+        return h;
+    }
+
+    @Override
+    public final boolean equals(final Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        return sameValueAs((T) o);
+    }
+
+}

dddsample/src/test/java/se/citerus/dddsample/domain/shared/experimental/EntitySupportTest.java

@@ -0,0 +1,62 @@
+package se.citerus.dddsample.domain.shared.experimental;
+
+import junit.framework.TestCase;
+
+public class EntitySupportTest extends TestCase {
+
+    public void testNoIdentityAnnotationFail() {
+        NoAnnotationEntity entity = new NoAnnotationEntity();
+
+        try {
+            entity.identity();
+            fail("Entity must have a unique identity");
+        } catch (IllegalStateException expected) {
+        }
+    }
+
+    public void testTwoIdentityAnnotationsFail() {
+        TwoAnnotationsEntity entity = new TwoAnnotationsEntity();
+        try {
+            entity.identity();
+            fail("Entity must have a unique identity");
+        } catch (IllegalStateException expected) {
+        }
+    }
+
+    public void testOneAnnotationSuccess() {
+        OneAnnotationEntity entity = new OneAnnotationEntity("id");
+        assertEquals("id", entity.identity());
+    }
+
+    public void testSameIdentityEqualsHashcode() {
+        OneAnnotationEntity entity1 = new OneAnnotationEntity("A");
+        OneAnnotationEntity entity2 = new OneAnnotationEntity("A");
+        OneAnnotationEntity entity3 = new OneAnnotationEntity("B");
+
+        assertTrue(entity1.sameIdentityAs(entity2));
+        assertFalse(entity2.sameIdentityAs(entity3));
+
+        assertTrue(entity1.equals(entity2));
+        assertFalse(entity2.equals(entity3));
+
+        assertTrue(entity1.hashCode() == entity2.hashCode());
+        assertFalse(entity2.hashCode() == entity3.hashCode());
+    }
+
+    class NoAnnotationEntity extends EntitySupport<NoAnnotationEntity, String> {
+    }
+
+    class OneAnnotationEntity extends EntitySupport<OneAnnotationEntity, String> {
+        private @Identity String id;
+
+        OneAnnotationEntity(String id) {
+            this.id = id;
+        }
+    }
+
+    class TwoAnnotationsEntity extends EntitySupport<TwoAnnotationsEntity, String> {
+        private @Identity String id1 = "id1";
+        private @Identity String id2 = "id2";
+    }
+
+}

dddsample/src/test/java/se/citerus/dddsample/domain/shared/experimental/ValueObjectSupportTest.java

@@ -0,0 +1,43 @@
+package se.citerus.dddsample.domain.shared.experimental;
+
+import junit.framework.TestCase;
+
+
+public class ValueObjectSupportTest extends TestCase {
+
+    public void testEquals() {
+        final AValueObject vo1 = new AValueObject("A");
+        final AValueObject vo2 = new AValueObject("A");
+        final BValueObject vo3 = new BValueObject("A", 1);
+
+        assertEquals(vo1, vo2);
+        assertEquals(vo2, vo1);
+        assertFalse(vo2.equals(vo3));
+        assertFalse(vo3.equals(vo2));
+
+        assertTrue(vo1.sameValueAs(vo2));
+        assertFalse(vo2.sameValueAs(vo3));
+    }
+
+    class AValueObject extends ValueObjectSupport<AValueObject> {
+        String s;
+
+        AValueObject(String s) {
+            this.s = s;
+        }
+
+        AValueObject() {
+        }
+    }
+
+    class BValueObject extends AValueObject {
+        int x;
+
+        BValueObject(String s, int x) {
+            super(s);
+            this.x = x;
+        }
+
+    }
+
+}