Improve code layout of handler method classes.

Author: alexander-yevsyukov

server/src/main/java/org/spine3/server/aggregate/Aggregate.java

@@ -20,7 +20,6 @@
 package org.spine3.server.aggregate;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Predicate;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
@@ -94,10 +93,6 @@ public abstract class Aggregate<I, S extends Message, B extends Message.Builder>
                             extends Entity<I, S>
                             implements CommandHandler {
 
-    /* package */ static final Predicate<Method> IS_AGGREGATE_COMMAND_HANDLER = CommandHandlerMethod.PREDICATE;
-
-    /* package */ static final Predicate<Method> IS_EVENT_APPLIER = new EventApplier.FilterPredicate();
-
     /**
      * The builder for the aggregate state.
      *
@@ -160,8 +155,7 @@ public Aggregate(I id) {
      */
     @CheckReturnValue
     /* package */ static ImmutableSet<Class<? extends Message>> getCommandClasses(Class<? extends Aggregate> clazz) {
-        final ImmutableSet<Class<? extends Message>> classes = Classes.getHandledMessageClasses(clazz, IS_AGGREGATE_COMMAND_HANDLER);
-        return classes;
+        return Classes.getHandledMessageClasses(clazz, CommandHandlerMethod.PREDICATE);
     }
 
     /**
@@ -171,8 +165,7 @@ public Aggregate(I id) {
      * @return immutable set of event classes
      */
     /* package */ static ImmutableSet<Class<? extends Message>> getEventClasses(Class<? extends Aggregate> clazz) {
-        final ImmutableSet<Class<? extends Message>> classes = Classes.getHandledMessageClasses(clazz, IS_EVENT_APPLIER);
-        return classes;
+        return Classes.getHandledMessageClasses(clazz, EventApplier.PREDICATE);
     }
 
     /**
@@ -233,7 +226,9 @@ protected B getBuilder() {
      * Updates the aggregate state and closes the update phase of the aggregate.
      */
     private void updateState() {
-        @SuppressWarnings("unchecked") // It is safe to cast as we checked compatibility in init();
+        @SuppressWarnings("unchecked") // It is safe to assume that correct builder type is passed to aggregate,
+         // because otherwise it won't be possible to write the code of applier methods that make sense to the
+         // aggregate.
         final S newState = (S) getBuilder().build();
         setState(newState, getVersion(), whenModified());
 

server/src/main/java/org/spine3/server/aggregate/EventApplier.java

@@ -23,14 +23,11 @@
 import com.google.common.base.Predicate;
 import com.google.protobuf.Message;
 import org.spine3.server.internal.MessageHandlerMethod;
-import org.spine3.server.reflect.MethodMap;
-import org.spine3.server.reflect.Methods;
 
 import javax.annotation.Nullable;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
-import java.util.Map;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
@@ -41,6 +38,11 @@
  */
 /* package */ class EventApplier extends MessageHandlerMethod<Aggregate, Void> {
 
+    /**
+     * The instance of the predicate to filter event applier methods of an aggregate class.
+     */
+    /* package */ static final Predicate<Method> PREDICATE = new FilterPredicate();
+
     /**
      * Creates a new instance to wrap {@code method} on {@code target}.
      *
@@ -65,21 +67,19 @@ protected <R> R invoke(Message message) throws InvocationTargetException {
      * @param methods the map of methods to check
      * @see MessageHandlerMethod#log()
      */
-    public static void checkModifiers(MethodMap methods) {
-        for (Map.Entry<Class<? extends Message>, Method> entry : methods.entrySet()) {
-            final Method method = entry.getValue();
+    /* package */ static void checkModifiers(Iterable<Method> methods) {
+        for (Method method : methods) {
             final boolean isPrivate = Modifier.isPrivate(method.getModifiers());
             if (!isPrivate) {
-                log().warn(String.format("Event applier method %s must be declared 'private'.",
-                        Methods.getFullMethodName(method)));
+                warnOnWrongModifier("Event applier method {} must be declared 'private'.", method);
             }
         }
     }
 
     /**
      * The predicate for filtering event applier methods.
      */
-    /* package */ static class FilterPredicate implements Predicate<Method> {
+    private static class FilterPredicate implements Predicate<Method> {
 
         private static final int EVENT_PARAM_INDEX = 0;
 
@@ -98,8 +98,8 @@ public static boolean isEventApplier(Method method) {
             }
 
             final Class<?>[] parameterTypes = method.getParameterTypes();
-            final boolean hasOneParam = parameterTypes.length == NUMBER_OF_PARAMS;
-            if (!hasOneParam) {
+            final boolean paramCountValid = parameterTypes.length == NUMBER_OF_PARAMS;
+            if (!paramCountValid) {
                 return false;
             }
 

server/src/main/java/org/spine3/server/aggregate/Registry.java

@@ -20,12 +20,11 @@
 
 package org.spine3.server.aggregate;
 
+import org.spine3.server.internal.CommandHandlerMethod;
 import org.spine3.server.reflect.MethodMap;
 
 import javax.annotation.CheckReturnValue;
 
-import static org.spine3.server.internal.CommandHandlerMethod.checkModifiers;
-
 /**
  * The registry of method maps for all aggregate classes.
  *
@@ -41,11 +40,11 @@
     private final MethodMap.Registry<Aggregate> eventAppliers = new MethodMap.Registry<>();
 
     /* package */ void register(Class<? extends Aggregate> clazz) {
-        commandHandlers.register(clazz, Aggregate.IS_AGGREGATE_COMMAND_HANDLER);
-        checkModifiers(commandHandlers.get(clazz).values());
+        commandHandlers.register(clazz, CommandHandlerMethod.PREDICATE);
+        CommandHandlerMethod.checkModifiers(commandHandlers.get(clazz).values());
 
-        eventAppliers.register(clazz, Aggregate.IS_EVENT_APPLIER);
-        EventApplier.checkModifiers(eventAppliers.get(clazz));
+        eventAppliers.register(clazz, EventApplier.PREDICATE);
+        EventApplier.checkModifiers(eventAppliers.get(clazz).values());
     }
 
     @CheckReturnValue

server/src/main/java/org/spine3/server/internal/CommandHandlerMethod.java

@@ -27,7 +27,6 @@
 import org.spine3.server.Assign;
 import org.spine3.server.CommandHandler;
 import org.spine3.server.reflect.MethodMap;
-import org.spine3.server.reflect.Methods;
 import org.spine3.type.CommandClass;
 
 import javax.annotation.CheckReturnValue;
@@ -148,8 +147,7 @@ public static void checkModifiers(Iterable<Method> methods) {
         for (Method method : methods) {
             final boolean isPublic = Modifier.isPublic(method.getModifiers());
             if (!isPublic) {
-                final String fullMethodName = Methods.getFullMethodName(method);
-                log().warn(String.format("Command handler method %s should be declared 'public'.", fullMethodName));
+                warnOnWrongModifier("Command handler method {} should be declared 'public'.", method);
             }
         }
     }

server/src/main/java/org/spine3/server/internal/EventHandlerMethod.java

@@ -26,7 +26,6 @@
 import org.spine3.base.EventContext;
 import org.spine3.server.Subscribe;
 import org.spine3.server.reflect.MethodMap;
-import org.spine3.server.reflect.Methods;
 import org.spine3.type.EventClass;
 
 import javax.annotation.CheckReturnValue;
@@ -99,8 +98,7 @@ public static void checkModifiers(Iterable<Method> methods) {
         for (Method method : methods) {
             final boolean isPublic = Modifier.isPublic(method.getModifiers());
             if (!isPublic) {
-                log().warn(String.format("Event handler %s must be declared 'public'",
-                        Methods.getFullMethodName(method)));
+                warnOnWrongModifier("Event handler {} must be declared 'public'", method);
             }
         }
     }

server/src/main/java/org/spine3/server/internal/MessageHandlerMethod.java

@@ -70,6 +70,10 @@ protected MessageHandlerMethod(T target, Method method) {
         method.setAccessible(true);
     }
 
+    protected static void warnOnWrongModifier(String messageFormat, Method method) {
+        log().warn(messageFormat, Methods.getFullMethodName(method));
+    }
+
     /**
      * @return the target object on which the method call is made
      */

server/src/test/java/org/spine3/server/aggregate/EventApplierShould.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server.aggregate;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.protobuf.Message;
+import org.junit.Test;
+import org.spine3.base.EventContext;
+import org.spine3.test.project.Project;
+import org.spine3.test.project.event.ProjectCreated;
+
+import static org.junit.Assert.assertTrue;
+import static org.spine3.test.Verify.assertContains;
+
+@SuppressWarnings("InstanceMethodNamingConvention")
+public class EventApplierShould {
+
+    private static class AggregateWithTwoMethodsApplier extends Aggregate<Long, Project, Project.Builder> {
+
+        public AggregateWithTwoMethodsApplier(Long id) {
+            super(id);
+        }
+
+        @Apply
+        private void apply(ProjectCreated event, EventContext context) {
+            // Do nothing.
+        }
+    }
+
+    @Test
+    public void do_not_accept_methods_with_two_parameters() {
+        assertTrue(Aggregate.getEventClasses(AggregateWithTwoMethodsApplier.class)
+                            .isEmpty());
+    }
+
+    private static class AggregateWithNonPrivateApplier extends Aggregate<Long, Project, Project.Builder> {
+
+        public AggregateWithNonPrivateApplier(Long id) {
+            super(id);
+        }
+
+        @Apply
+        public void apply(ProjectCreated event) {
+            // Do nothing.
+        }
+    }
+
+    @Test
+    public void accept_non_private_appliers() {
+        final ImmutableSet<Class<? extends Message>> eventClasses = Aggregate.getEventClasses(
+                AggregateWithNonPrivateApplier.class);
+
+        // The method is counted and the event is present.
+        assertContains(ProjectCreated.class, eventClasses);
+    }
+
+}