refactor the MapperProxy through MapperHandler, support for Optional, add @SqlRef for redirect the sql statement, add sql-config-function

src/main/java/org/apache/ibatis/annotations/SqlRef.java

@@ -0,0 +1,32 @@
+/**
+ * Copyright 2009-2015 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.apache.ibatis.annotations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author Felix Lin
+ * @since 3.4.6
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface SqlRef {
+
+    String value();
+}

src/main/java/org/apache/ibatis/binding/MapperProxy.java

@@ -1,17 +1,15 @@
 /**
- *    Copyright 2009-2017 the original author or authors.
+ * Copyright 2009-2017 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
+ * 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
+ * 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.
+ * 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.apache.ibatis.binding;
 
@@ -21,8 +19,12 @@
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.util.List;
 import java.util.Map;
 
+import org.apache.ibatis.binding.handler.MapperHandler;
+import org.apache.ibatis.binding.handler.MapperHandlerContext;
+import org.apache.ibatis.binding.handler.impl.DefaultMapperHandlerContext;
 import org.apache.ibatis.lang.UsesJava7;
 import org.apache.ibatis.reflection.ExceptionUtil;
 import org.apache.ibatis.session.SqlSession;
@@ -33,63 +35,105 @@
  */
 public class MapperProxy<T> implements InvocationHandler, Serializable {
 
-  private static final long serialVersionUID = -6424540398559729838L;
-  private final SqlSession sqlSession;
-  private final Class<T> mapperInterface;
-  private final Map<Method, MapperMethod> methodCache;
+    private static final long serialVersionUID = -6424540398559729838L;
+    private final SqlSession sqlSession;
+    private final Class<T> mapperInterface;
+    private final Map<Method, MapperMethod> methodCache;
+    /**
+     * @since 3.4.6
+     */
+    private final Map<Method, MapperHandlerContext> mapperHandlerContextCache;
 
-  public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
-    this.sqlSession = sqlSession;
-    this.mapperInterface = mapperInterface;
-    this.methodCache = methodCache;
-  }
+    public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
+        this(sqlSession, mapperInterface, methodCache, null);
+    }
 
-  @Override
-  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
-    try {
-      if (Object.class.equals(method.getDeclaringClass())) {
-        return method.invoke(this, args);
-      } else if (isDefaultMethod(method)) {
-        return invokeDefaultMethod(proxy, method, args);
-      }
-    } catch (Throwable t) {
-      throw ExceptionUtil.unwrapThrowable(t);
+    /**
+     * @since 3.4.6
+     */
+    public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache, Map<Method, MapperHandlerContext> mapperHandlerContextCache) {
+        this.sqlSession = sqlSession;
+        this.mapperInterface = mapperInterface;
+        this.methodCache = methodCache;
+        this.mapperHandlerContextCache = mapperHandlerContextCache;
     }
-    final MapperMethod mapperMethod = cachedMapperMethod(method);
-    return mapperMethod.execute(sqlSession, args);
-  }
 
-  private MapperMethod cachedMapperMethod(Method method) {
-    MapperMethod mapperMethod = methodCache.get(method);
-    if (mapperMethod == null) {
-      mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
-      methodCache.put(method, mapperMethod);
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        try {
+            if (Object.class.equals(method.getDeclaringClass())) {
+                return method.invoke(this, args);
+            } else if (isDefaultMethod(method)) {
+                return invokeDefaultMethod(proxy, method, args);
+            }
+        } catch (Throwable t) {
+            throw ExceptionUtil.unwrapThrowable(t);
+        }
+
+        if (null != mapperHandlerContextCache && sqlSession.getConfiguration().getHandlerRegistry().isEnableMapperHandler()) {
+            cachedMapperMethod(method);// for pass the test class org.apache.ibatis.binding.BindingTest
+            final MapperHandlerContext mapperHandlerContext = cachedMapperHandlerContext(method);
+            MapperHandler mapperHandler = this.getMapperHandler(mapperHandlerContext, method);
+            if (null != mapperHandler) {
+                return mapperHandler.execute(sqlSession, args, mapperHandlerContext);
+            }
+        }
+        final MapperMethod mapperMethod = cachedMapperMethod(method);
+        return mapperMethod.execute(sqlSession, args);
     }
-    return mapperMethod;
-  }
 
-  @UsesJava7
-  private Object invokeDefaultMethod(Object proxy, Method method, Object[] args)
-      throws Throwable {
-    final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
-        .getDeclaredConstructor(Class.class, int.class);
-    if (!constructor.isAccessible()) {
-      constructor.setAccessible(true);
+    private MapperHandler getMapperHandler(MapperHandlerContext mapperHandlerContext, Method method) {
+        List<MapperHandler> mapperHandlers = sqlSession.getConfiguration().getHandlerRegistry().getMapperHandlers();
+        if (null != mapperHandlers) {
+            for (MapperHandler mapperHandler : mapperHandlers) {
+                if (mapperHandler.supports(mapperHandlerContext)) {
+                    return mapperHandler;
+                }
+            }
+        }
+        return null;
     }
-    final Class<?> declaringClass = method.getDeclaringClass();
-    return constructor
-        .newInstance(declaringClass,
-            MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
-                | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC)
-        .unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);
-  }
 
-  /**
-   * Backport of java.lang.reflect.Method#isDefault()
-   */
-  private boolean isDefaultMethod(Method method) {
-    return (method.getModifiers()
-        & (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC)) == Modifier.PUBLIC
-        && method.getDeclaringClass().isInterface();
-  }
+    private MapperHandlerContext cachedMapperHandlerContext(Method method) {
+        MapperHandlerContext mhc = mapperHandlerContextCache.get(method);
+        if (mhc == null) {
+            mhc = new DefaultMapperHandlerContext(mapperInterface, method, sqlSession.getConfiguration());
+            mapperHandlerContextCache.put(method, mhc);
+        }
+        return mhc;
+    }
+
+    private MapperMethod cachedMapperMethod(Method method) {
+        MapperMethod mapperMethod = methodCache.get(method);
+        if (mapperMethod == null) {
+            mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
+            methodCache.put(method, mapperMethod);
+        }
+        return mapperMethod;
+    }
+
+    @UsesJava7
+    private Object invokeDefaultMethod(Object proxy, Method method, Object[] args)
+            throws Throwable {
+        final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
+                .getDeclaredConstructor(Class.class, int.class);
+        if (!constructor.isAccessible()) {
+            constructor.setAccessible(true);
+        }
+        final Class<?> declaringClass = method.getDeclaringClass();
+        return constructor
+                .newInstance(declaringClass,
+                        MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
+                                | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC)
+                .unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);
+    }
+
+    /**
+     * Backport of java.lang.reflect.Method#isDefault()
+     */
+    private boolean isDefaultMethod(Method method) {
+        return (method.getModifiers()
+                & (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC)) == Modifier.PUBLIC
+                && method.getDeclaringClass().isInterface();
+    }
 }

src/main/java/org/apache/ibatis/binding/MapperProxyFactory.java

@@ -1,17 +1,15 @@
 /**
- *    Copyright 2009-2015 the original author or authors.
+ * Copyright 2009-2015 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
+ * 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
+ * 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.
+ * 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.apache.ibatis.binding;
 
@@ -20,36 +18,41 @@
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.apache.ibatis.binding.handler.MapperHandlerContext;
 import org.apache.ibatis.session.SqlSession;
 
 /**
  * @author Lasse Voss
  */
 public class MapperProxyFactory<T> {
 
-  private final Class<T> mapperInterface;
-  private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();
-
-  public MapperProxyFactory(Class<T> mapperInterface) {
-    this.mapperInterface = mapperInterface;
-  }
-
-  public Class<T> getMapperInterface() {
-    return mapperInterface;
-  }
-
-  public Map<Method, MapperMethod> getMethodCache() {
-    return methodCache;
-  }
-
-  @SuppressWarnings("unchecked")
-  protected T newInstance(MapperProxy<T> mapperProxy) {
-    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
-  }
-
-  public T newInstance(SqlSession sqlSession) {
-    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
-    return newInstance(mapperProxy);
-  }
+    private final Class<T> mapperInterface;
+    private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();
+    /**
+     * @since 3.4.6
+     */
+    private final Map<Method, MapperHandlerContext> mapperHandlerContextCache = new ConcurrentHashMap<Method, MapperHandlerContext>();
+
+    public MapperProxyFactory(Class<T> mapperInterface) {
+        this.mapperInterface = mapperInterface;
+    }
+
+    public Class<T> getMapperInterface() {
+        return mapperInterface;
+    }
+
+    public Map<Method, MapperMethod> getMethodCache() {
+        return methodCache;
+    }
+
+    @SuppressWarnings("unchecked")
+    protected T newInstance(MapperProxy<T> mapperProxy) {
+        return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] {mapperInterface}, mapperProxy);
+    }
+
+    public T newInstance(SqlSession sqlSession) {
+        final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache, mapperHandlerContextCache);
+        return newInstance(mapperProxy);
+    }
 
 }

src/main/java/org/apache/ibatis/binding/handler/MapperHandler.java

@@ -0,0 +1,27 @@
+/**
+ * Copyright 2009-2018 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.apache.ibatis.binding.handler;
+
+import org.apache.ibatis.session.SqlSession;
+
+/**
+ * @author Felix Lin
+ * @since 3.4.6
+ */
+public interface MapperHandler extends Ordered {
+
+    boolean supports(MapperHandlerContext context);
+
+    Object execute(SqlSession sqlSession, Object[] args, MapperHandlerContext context);
+}

src/main/java/org/apache/ibatis/binding/handler/MapperHandlerContext.java

@@ -0,0 +1,44 @@
+/**
+ * Copyright 2009-2018 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.apache.ibatis.binding.handler;
+
+import java.lang.reflect.Method;
+
+import org.apache.ibatis.mapping.MappedStatement;
+import org.apache.ibatis.session.Configuration;
+
+/**
+ * @author Felix Lin
+ * @since 3.4.6
+ */
+public interface MapperHandlerContext {
+
+    Class<?> getMapperInterface();
+
+    Method getMethod();
+
+    Configuration getConfiguration();
+
+    Class<?> getReturnType();
+
+    /**
+     * lazy init
+     */
+    MappedStatement getMappedStatement();
+
+    /**
+     * lazy init
+     */
+    ParamResolver getParamResolver();
+}