Issue/datarest 970

spring-data-rest-core/src/main/java/org/springframework/data/rest/core/event/AnnotatedEventHandlerInvoker.java

@@ -26,7 +26,9 @@
 import org.springframework.beans.factory.config.BeanPostProcessor;
 import org.springframework.context.ApplicationEvent;
 import org.springframework.context.ApplicationListener;
+import org.springframework.core.Ordered;
 import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.core.annotation.Order;
 import org.springframework.data.rest.core.annotation.HandleAfterCreate;
 import org.springframework.data.rest.core.annotation.HandleAfterDelete;
 import org.springframework.data.rest.core.annotation.HandleAfterLinkDelete;
@@ -39,8 +41,8 @@
 import org.springframework.data.rest.core.annotation.HandleBeforeSave;
 import org.springframework.data.rest.core.annotation.RepositoryEventHandler;
 import org.springframework.data.rest.core.util.Methods;
+import org.springframework.data.rest.core.util.SortedLinkedMultiValueMap;
 import org.springframework.util.ClassUtils;
-import org.springframework.util.LinkedMultiValueMap;
 import org.springframework.util.MultiValueMap;
 import org.springframework.util.ReflectionUtils;
 
@@ -49,13 +51,14 @@
  * 
  * @author Jon Brisbin
  * @author Oliver Gierke
+ * @author Joe Valerio
  */
 public class AnnotatedEventHandlerInvoker implements ApplicationListener<RepositoryEvent>, BeanPostProcessor {
 
 	private static final Logger LOG = LoggerFactory.getLogger(AnnotatedEventHandlerInvoker.class);
 	private static final String PARAMETER_MISSING = "Invalid event handler method %s! At least a single argument is required to determine the domain type for which you are interested in events.";
 
-	private final MultiValueMap<Class<? extends RepositoryEvent>, EventHandlerMethod> handlerMethods = new LinkedMultiValueMap<Class<? extends RepositoryEvent>, EventHandlerMethod>();
+	private final MultiValueMap<Class<? extends RepositoryEvent>, EventHandlerMethod> handlerMethods = new SortedLinkedMultiValueMap<Class<? extends RepositoryEvent>, EventHandlerMethod>();
 
 	/*
 	 * (non-Javadoc)
@@ -174,18 +177,25 @@ private <T extends Annotation> void inspect(Object handler, Method method, Class
 		handlerMethods.add(eventType, handlerMethod);
 	}
 
-	static class EventHandlerMethod {
+	static class EventHandlerMethod implements Comparable<EventHandlerMethod> {
 
 		final Class<?> targetType;
 		final Method method;
 		final Object handler;
+		private int order;
 
 		private EventHandlerMethod(Class<?> targetType, Object handler, Method method) {
 
 			this.targetType = targetType;
 			this.method = method;
 			this.handler = handler;
 
+			order = Ordered.LOWEST_PRECEDENCE;
+			if (method.isAnnotationPresent(Order.class)) {
+				Order orderAnno = method.getAnnotation(Order.class);
+				order = orderAnno.value();
+			}
+
 			ReflectionUtils.makeAccessible(this.method);
 		}
 
@@ -197,5 +207,11 @@ private EventHandlerMethod(Class<?> targetType, Object handler, Method method) {
 		public String toString() {
 			return String.format("EventHandlerMethod{ targetType=%s, method=%s, handler=%s }", targetType, method, handler);
 		}
+
+		@Override
+		public int compareTo(EventHandlerMethod o) {
+			return this.order - o.order;
+		}
 	}
+
 }

spring-data-rest-core/src/main/java/org/springframework/data/rest/core/util/SortedLinkedMultiValueMap.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2012-2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.rest.core.util;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.util.LinkedMultiValueMap;
+
+/**
+ * Extension of {@link LinkedMultiValueMap} that sorts the values List on update.
+ *
+ * <p>This Map implementation is generally not thread-safe. It is primarily designed
+ * for data structures exposed from request objects, for use in a single thread only.
+ *
+ * @author Joe Valerio
+ */
+public class SortedLinkedMultiValueMap<K,V extends Comparable<V>> extends LinkedMultiValueMap<K,V> {
+
+	private static final long serialVersionUID = 2075011697927127513L;
+
+	public SortedLinkedMultiValueMap() {
+		super();
+	}
+
+	public SortedLinkedMultiValueMap(int initialCapacity) {
+		super(initialCapacity);
+	}
+
+	public SortedLinkedMultiValueMap(Map<K, List<V>> otherMap) {
+		super(otherMap);
+	}
+
+	@Override
+	public void add(K key, V value) {
+		super.add(key, value);
+		List<V> values = get(key);
+		Collections.sort(values);
+	}
+
+	@Override
+	public void set(K key, V value) {
+		super.set(key, value);
+		List<V> values = get(key);
+		Collections.sort(values);
+	}
+
+}

spring-data-rest-core/src/test/java/org/springframework/data/rest/core/event/AnnotatedEventHandlerInvokerUnitTests.java

@@ -15,11 +15,13 @@
  */
 package org.springframework.data.rest.core.event;
 
-import static org.hamcrest.Matchers.*;
-import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
 
 import org.junit.Test;
 import org.springframework.aop.framework.ProxyFactory;
+import org.springframework.core.annotation.Order;
 import org.springframework.data.rest.core.annotation.HandleBeforeCreate;
 import org.springframework.data.rest.core.annotation.RepositoryEventHandler;
 import org.springframework.data.rest.core.domain.Person;
@@ -71,6 +73,27 @@ public void invokesPrivateEventHandlerMethods() {
 		assertThat(sampleHandler.wasCalled, is(true));
 	}
 
+	/**
+	 * @see DATAREST-970
+	 */
+	@Test
+	public void invokesEventHandlerInOrderMethods() {
+
+		SampleOrderEventHandler1 orderHandler1 = new SampleOrderEventHandler1();
+		SampleOrderEventHandler2 orderHandler2 = new SampleOrderEventHandler2();
+
+		AnnotatedEventHandlerInvoker invoker = new AnnotatedEventHandlerInvoker();
+		invoker.postProcessAfterInitialization(orderHandler1, "orderHandler1");
+		invoker.postProcessAfterInitialization(orderHandler2, "orderHandler2");
+
+		invoker.onApplicationEvent(new BeforeCreateEvent(new Person("Dave", "Matthews")));
+
+		assertThat(orderHandler1.wasCalled, is(true));
+		assertThat(orderHandler2.wasCalled, is(true));
+
+		assertThat(orderHandler1.timestamp - orderHandler2.timestamp > 0, is(true));
+	}
+
 	@RepositoryEventHandler
 	static class Sample {
 
@@ -88,4 +111,32 @@ private void method(Person sample) {
 			wasCalled = true;
 		}
 	}
+
+	@RepositoryEventHandler
+	static class SampleOrderEventHandler1 {
+
+		boolean wasCalled = false;
+		long timestamp;
+
+		@Order(2)
+		@HandleBeforeCreate
+		private void method(Person sample) {
+			wasCalled = true;
+			timestamp = System.nanoTime();
+		}
+	}
+
+	@RepositoryEventHandler
+	static class SampleOrderEventHandler2 {
+
+		boolean wasCalled = false;
+		long timestamp;
+
+		@Order(1)
+		@HandleBeforeCreate
+		private void method(Person sample) {
+			wasCalled = true;
+			timestamp = System.nanoTime();
+		}
+	}
 }