Merge pull request #87 from mercyblitz/dev-1.x

Milestone 0.1.1

microsphere-spring-web/src/main/java/io/microsphere/spring/web/event/WebEventPublisher.java

@@ -54,11 +54,6 @@ public void beforeExecute(HandlerMethod handlerMethod, Object[] args, NativeWebR
         context.publishEvent(new HandlerMethodArgumentsResolvedEvent(request, handlerMethod, args));
     }
 
-    @Override
-    public void afterExecute(HandlerMethod handlerMethod, Object[] args, Object returnValue, Throwable error, NativeWebRequest request) throws Exception {
-        // DO NOTHING
-    }
-
     @Override
     protected void doStart() {
         WebEndpointMappingRegistry webEndpointMappingRegistry = context.getBean(WebEndpointMappingRegistry.class);

microsphere-spring-web/src/main/java/io/microsphere/spring/web/method/support/HandlerMethodAdvice.java

@@ -41,8 +41,9 @@ public interface HandlerMethodAdvice {
      * @param webRequest    the current request
      * @throws Exception in case of errors with the preparation of argument values
      */
-    void beforeResolveArgument(MethodParameter parameter, HandlerMethod handlerMethod, NativeWebRequest webRequest)
-            throws Exception;
+    default void beforeResolveArgument(MethodParameter parameter, HandlerMethod handlerMethod, NativeWebRequest webRequest)
+            throws Exception {
+    }
 
     /**
      * callback after the {@link MethodParameter} being resolved
@@ -54,8 +55,9 @@ void beforeResolveArgument(MethodParameter parameter, HandlerMethod handlerMetho
      * @return the resolved argument value, or {@code null} if not resolvable
      * @throws Exception in case of errors with the preparation of argument values
      */
-    void afterResolveArgument(MethodParameter parameter, Object resolvedArgument, HandlerMethod handlerMethod,
-                              NativeWebRequest webRequest) throws Exception;
+    default void afterResolveArgument(MethodParameter parameter, Object resolvedArgument, HandlerMethod handlerMethod,
+                                      NativeWebRequest webRequest) throws Exception {
+    }
 
     /**
      * Interception point before the execution of a {@link HandlerMethod}. Called after
@@ -67,7 +69,8 @@ void afterResolveArgument(MethodParameter parameter, Object resolvedArgument, Ha
      * @param request       {@link WebRequest}
      * @throws Exception if any error caused
      */
-    void beforeExecuteMethod(HandlerMethod handlerMethod, Object[] args, NativeWebRequest request) throws Exception;
+    default void beforeExecuteMethod(HandlerMethod handlerMethod, Object[] args, NativeWebRequest request) throws Exception {
+    }
 
     /**
      * Interception point after successful execution of a {@link HandlerMethod}.
@@ -80,7 +83,8 @@ void afterResolveArgument(MethodParameter parameter, Object resolvedArgument, Ha
      * @param request       {@link WebRequest}
      * @throws Exception if any error caused
      */
-    void afterExecuteMethod(HandlerMethod handlerMethod, Object[] args, @Nullable Object returnValue, @Nullable Throwable error,
-                            NativeWebRequest request) throws Exception;
+    default void afterExecuteMethod(HandlerMethod handlerMethod, Object[] args, @Nullable Object returnValue, @Nullable Throwable error,
+                                    NativeWebRequest request) throws Exception {
+    }
 
 }

microsphere-spring-web/src/main/java/io/microsphere/spring/web/method/support/HandlerMethodArgumentInterceptor.java

@@ -20,7 +20,6 @@
 import org.springframework.web.context.request.NativeWebRequest;
 import org.springframework.web.method.HandlerMethod;
 
-
 /**
  * The interceptor interface for the resolvable {@link HandlerMethod HandlerMethods'} {@link MethodParameter}
  *
@@ -39,8 +38,9 @@ public interface HandlerMethodArgumentInterceptor {
      * @param webRequest    the current request
      * @throws Exception in case of errors with the preparation of argument values
      */
-    void beforeResolveArgument(MethodParameter parameter, HandlerMethod handlerMethod, NativeWebRequest webRequest)
-            throws Exception;
+    default void beforeResolveArgument(MethodParameter parameter, HandlerMethod handlerMethod, NativeWebRequest webRequest)
+            throws Exception {
+    }
 
     /**
      * callback after the {@link MethodParameter} being resolved
@@ -52,8 +52,8 @@ void beforeResolveArgument(MethodParameter parameter, HandlerMethod handlerMetho
      * @return the resolved argument value, or {@code null} if not resolvable
      * @throws Exception in case of errors with the preparation of argument values
      */
-    void afterResolveArgument(MethodParameter parameter, Object resolvedArgument, HandlerMethod handlerMethod,
-                              NativeWebRequest webRequest) throws Exception;
-
+    default void afterResolveArgument(MethodParameter parameter, Object resolvedArgument, HandlerMethod handlerMethod,
+                                      NativeWebRequest webRequest) throws Exception {
+    }
 
-}
+}

microsphere-spring-web/src/main/java/io/microsphere/spring/web/method/support/HandlerMethodInterceptor.java

@@ -37,7 +37,8 @@ public interface HandlerMethodInterceptor {
      * @param request       {@link WebRequest}
      * @throws Exception if any error caused
      */
-    void beforeExecute(HandlerMethod handlerMethod, Object[] args, NativeWebRequest request) throws Exception;
+    default void beforeExecute(HandlerMethod handlerMethod, Object[] args, NativeWebRequest request) throws Exception {
+    }
 
     /**
      * Interception point after successful execution of a {@link HandlerMethod}.
@@ -50,7 +51,8 @@ public interface HandlerMethodInterceptor {
      * @param request       {@link WebRequest}
      * @throws Exception if any error caused
      */
-    void afterExecute(HandlerMethod handlerMethod, Object[] args, @Nullable Object returnValue, @Nullable Throwable error,
-                      NativeWebRequest request) throws Exception;
+    default void afterExecute(HandlerMethod handlerMethod, Object[] args, @Nullable Object returnValue, @Nullable Throwable error,
+                              NativeWebRequest request) throws Exception {
+    }
 
 }

microsphere-spring-webmvc/src/test/java/io/microsphere/spring/webmvc/annotation/AbstractEnableWebMvcExtensionTest.java

@@ -18,7 +18,11 @@
 
 import io.microsphere.spring.web.event.HandlerMethodArgumentsResolvedEvent;
 import io.microsphere.spring.web.event.WebEndpointMappingsReadyEvent;
+import io.microsphere.spring.web.event.WebEventPublisher;
+import io.microsphere.spring.web.metadata.SimpleWebEndpointMappingRegistry;
 import io.microsphere.spring.web.metadata.WebEndpointMapping;
+import io.microsphere.spring.web.method.support.DelegatingHandlerMethodAdvice;
+import io.microsphere.spring.web.method.support.HandlerMethodArgumentInterceptor;
 import io.microsphere.spring.webmvc.advice.StoringRequestBodyArgumentAdvice;
 import io.microsphere.spring.webmvc.advice.StoringResponseBodyReturnValueAdvice;
 import io.microsphere.spring.webmvc.controller.TestController;
@@ -32,17 +36,20 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Import;
 import org.springframework.context.event.EventListener;
+import org.springframework.core.MethodParameter;
 import org.springframework.test.context.junit4.SpringRunner;
 import org.springframework.test.context.web.WebAppConfiguration;
 import org.springframework.test.web.servlet.MockMvc;
 import org.springframework.web.context.ConfigurableWebApplicationContext;
+import org.springframework.web.context.request.NativeWebRequest;
 import org.springframework.web.method.HandlerMethod;
 import org.springframework.web.servlet.config.annotation.EnableWebMvc;
 
 import java.lang.reflect.Method;
 import java.util.Collection;
 
 import static io.microsphere.spring.beans.BeanUtils.isBeanPresent;
+import static io.microsphere.util.ArrayUtils.isNotEmpty;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
@@ -63,7 +70,7 @@
 @EnableWebMvc
 @Ignore
 @Import(TestController.class)
-abstract class AbstractEnableWebMvcExtensionTest {
+abstract class AbstractEnableWebMvcExtensionTest implements HandlerMethodArgumentInterceptor {
 
     @Autowired
     protected ConfigurableWebApplicationContext wac;
@@ -89,15 +96,23 @@ public void setup() {
         this.registerWebEndpointMappings = enableWebMvcExtension.registerWebEndpointMappings();
         this.interceptHandlerMethods = enableWebMvcExtension.interceptHandlerMethods();
         this.publishEvents = enableWebMvcExtension.publishEvents();
-        this.registerHandlerInterceptors = enableWebMvcExtension.registerHandlerInterceptors();
+        this.registerHandlerInterceptors = enableWebMvcExtension.registerHandlerInterceptors() ? true :
+                isNotEmpty(enableWebMvcExtension.handlerInterceptors());
         this.storeRequestBodyArgument = enableWebMvcExtension.storeRequestBodyArgument();
         this.storeResponseBodyReturnValue = enableWebMvcExtension.storeResponseBodyReturnValue();
     }
 
     @Test
     public void testRegisteredBeans() {
         assertTrue(isBeanPresent(this.wac, WebMvcExtensionConfiguration.class));
+        // From @EnableWebExtension
+        assertEquals(this.registerWebEndpointMappings, isBeanPresent(this.wac, SimpleWebEndpointMappingRegistry.class));
+        assertEquals(this.interceptHandlerMethods, this.wac.containsBean(DelegatingHandlerMethodAdvice.BEAN_NAME));
+        assertEquals(this.publishEvents, isBeanPresent(this.wac, WebEventPublisher.class));
+
+        // From @EnableWebMvcExtension
         assertEquals(this.registerWebEndpointMappings, isBeanPresent(this.wac, WebEndpointMappingRegistrar.class));
+        assertEquals(this.interceptHandlerMethods, isBeanPresent(this.wac, DelegatingHandlerMethodAdvice.class));
         assertEquals(this.interceptHandlerMethods, this.wac.containsBean(InterceptingHandlerMethodProcessor.BEAN_NAME));
         assertEquals(this.interceptHandlerMethods, isBeanPresent(this.wac, InterceptingHandlerMethodProcessor.class));
         assertEquals(this.registerHandlerInterceptors, isBeanPresent(this.wac, LazyCompositeHandlerInterceptor.class));
@@ -136,24 +151,79 @@ public void onWebEndpointMappingsReadyEvent(WebEndpointMappingsReadyEvent event)
     @EventListener(HandlerMethodArgumentsResolvedEvent.class)
     public void onHandlerMethodArgumentsResolvedEvent(HandlerMethodArgumentsResolvedEvent event) {
         Method method = event.getMethod();
+        assertMethod(method);
+
+        HandlerMethod handlerMethod = event.getHandlerMethod();
+        assertEquals(method, handlerMethod.getMethod());
+
+        assertHandlerMethod(handlerMethod);
+
+        Object[] arguments = event.getArguments();
+        assertArguments(arguments);
+    }
+
+    /**
+     * callback before the {@link MethodParameter} being resolved
+     *
+     * @param parameter     the method parameter to resolve.
+     * @param handlerMethod the method to handle
+     * @param webRequest    the current request
+     * @throws Exception in case of errors with the preparation of argument values
+     */
+    @Override
+    public void beforeResolveArgument(MethodParameter parameter, HandlerMethod handlerMethod, NativeWebRequest webRequest) throws Exception {
+        assertMethodParameter(parameter);
+        assertHandlerMethod(handlerMethod);
+        assertNativeWebRequest(webRequest);
+    }
+
+    /**
+     * callback after the {@link MethodParameter} being resolved
+     *
+     * @param parameter        the method parameter to resolve.
+     * @param resolvedArgument the resolved argument
+     * @param handlerMethod    the method to handle
+     * @param webRequest       the current request
+     * @return the resolved argument value, or {@code null} if not resolvable
+     * @throws Exception in case of errors with the preparation of argument values
+     */
+    @Override
+    public void afterResolveArgument(MethodParameter parameter, Object resolvedArgument, HandlerMethod handlerMethod, NativeWebRequest webRequest) throws Exception {
+        // Reuse
+        beforeResolveArgument(parameter, handlerMethod, webRequest);
+        assertEquals("hello", resolvedArgument);
+    }
+
+    private void assertMethod(Method method) {
         assertEquals("echo", method.getName());
         assertEquals(String.class, method.getReturnType());
 
         Class<?>[] parameterTypes = method.getParameterTypes();
         assertEquals(1, parameterTypes.length);
         assertEquals(String.class, parameterTypes[0]);
+    }
 
-        HandlerMethod handlerMethod = event.getHandlerMethod();
+    private void assertHandlerMethod(HandlerMethod handlerMethod) {
         assertNotNull(handlerMethod);
-
         Object bean = handlerMethod.getBean();
         assertNotNull(bean);
         assertEquals(TestController.class, bean.getClass());
-        assertEquals(method, handlerMethod.getMethod());
+        assertMethod(handlerMethod.getMethod());
+    }
 
-        Object[] arguments = event.getArguments();
+    private void assertArguments(Object[] arguments) {
         assertEquals(1, arguments.length);
         assertEquals("hello", arguments[0]);
+    }
 
+    private void assertMethodParameter(MethodParameter parameter) {
+        assertNotNull(parameter);
+        assertEquals(0, parameter.getParameterIndex());
+        assertEquals(String.class, parameter.getParameterType());
     }
+
+    private void assertNativeWebRequest(NativeWebRequest webRequest) {
+    }
+
+
 }

microsphere-spring-webmvc/src/test/java/io/microsphere/spring/webmvc/annotation/EnableWebMvcExtensionInterceptorsTest.java

@@ -0,0 +1,51 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 io.microsphere.spring.webmvc.annotation;
+
+import io.microsphere.spring.webmvc.interceptor.IdempotentAnnotatedMethodHandlerInterceptor;
+import org.junit.Test;
+import org.springframework.test.context.ContextConfiguration;
+
+import static io.microsphere.spring.webmvc.interceptor.IdempotentAnnotatedMethodHandlerInterceptor.MOCK_TOKEN_VALUE;
+import static io.microsphere.spring.webmvc.interceptor.IdempotentAnnotatedMethodHandlerInterceptor.TOKEN_HEADER_NAME;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+/**
+ * {@link EnableWebMvcExtension} Test with interceptors
+ *
+ * @author <a href="mailto:mercyblitz@gmail.com">Mercy<a/>
+ * @see EnableWebMvcExtension
+ * @since 1.0.0
+ */
+@ContextConfiguration(classes = {
+        EnableWebMvcExtensionInterceptorsTest.class
+})
+@EnableWebMvcExtension(handlerInterceptors = {
+        IdempotentAnnotatedMethodHandlerInterceptor.class
+})
+public class EnableWebMvcExtensionInterceptorsTest extends AbstractEnableWebMvcExtensionTest {
+
+    @Test
+    @Override
+    public void test() throws Exception {
+        this.mockMvc.perform(get("/echo/hello").header(TOKEN_HEADER_NAME, MOCK_TOKEN_VALUE))
+                .andExpect(status().isOk())
+                .andExpect(content().json("[ECHO] : hello"));
+    }
+}

microsphere-spring-webmvc/src/test/java/io/microsphere/spring/webmvc/interceptor/IdempotentAnnotatedMethodHandlerInterceptor.java

@@ -16,6 +16,7 @@
  */
 package io.microsphere.spring.webmvc.interceptor;
 
+import io.microsphere.logging.Logger;
 import io.microsphere.spring.web.event.HandlerMethodArgumentsResolvedEvent;
 import io.microsphere.spring.webmvc.IdempotentException;
 import io.microsphere.spring.webmvc.annotation.Idempotent;
@@ -26,25 +27,31 @@
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
-import javax.servlet.http.HttpSession;
 import java.lang.reflect.Method;
-import java.util.Arrays;
+import java.util.Objects;
+import java.util.UUID;
+
+import static io.microsphere.logging.LoggerFactory.getLogger;
+import static java.util.Arrays.asList;
 
 /**
  * {@link AnnotatedMethodHandlerInterceptor} for {@link Idempotent} annotation
  *
  * @author <a href="mailto:mercyblitz@gmail.com">Mercy</a>
  * @since 1.0.0
  */
-public class IdempotentAnnotatedMethodHandlerInterceptor extends AnnotatedMethodHandlerInterceptor<Idempotent> implements ApplicationListener<HandlerMethodArgumentsResolvedEvent> {
+public class IdempotentAnnotatedMethodHandlerInterceptor extends AnnotatedMethodHandlerInterceptor<Idempotent>
+        implements ApplicationListener<HandlerMethodArgumentsResolvedEvent> {
+
+    private static final Logger logger = getLogger(IdempotentAnnotatedMethodHandlerInterceptor.class);
+
+    public static final String TOKEN_HEADER_NAME = "_token_";
+
+    public static final String MOCK_TOKEN_VALUE = UUID.randomUUID().toString();
 
     @Override
     protected boolean preHandle(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod,
                                 Idempotent idempotent) throws Exception {
-
-        System.out.println(handlerMethod);
-        System.out.println(idempotent);
-
         return true;
     }
 
@@ -54,19 +61,14 @@ protected boolean preHandle(HttpServletRequest request, HttpServletResponse resp
     public void onApplicationEvent(HandlerMethodArgumentsResolvedEvent event) {
         Method method = event.getMethod();
         Object[] args = event.getArguments();
-        System.out.println("method : " + method + " , args : " + Arrays.asList(args));
         WebRequest webRequest = event.getWebRequest();
+        logger.trace("The method : {} , args : {} , webRequest : {}", method, asList(args), webRequest);
         if (webRequest instanceof ServletWebRequest) {
             ServletWebRequest servletWebRequest = (ServletWebRequest) webRequest;
             HttpServletRequest request = servletWebRequest.getNativeRequest(HttpServletRequest.class);
-            // HttpSession based on Spring Redis
-            // Spring Session
-            HttpSession httpSession = request.getSession();
-            String token = request.getHeader("token");
-            Object tokenValue = httpSession.getAttribute(token);
-            if (tokenValue != null) {
-                //
-                throw new IdempotentException("");
+            String token = request.getHeader(TOKEN_HEADER_NAME);
+            if (!Objects.equals(MOCK_TOKEN_VALUE, token)) {
+                throw new IdempotentException("Illegal token");
             }
         }
     }