MyBatis实战之解析与运行 MyBatis之反射技术+JDK动态

  sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(resource));

/**
 *    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.binding;

import java.lang.reflect.Method;
 java.lang.reflect.Proxy;
 java.util.Map;
 java.util.concurrent.ConcurrentHashMap;

 org.apache.ibatis.session.SqlSession;


 * @author Lasse Voss
 public class MapperProxyFactory<T> {

  private final Class<T> mapperInterface;
  final Map<Method,MapperMethod> methodCache = new ConcurrentHashMap<Method,MapperMethod>();

  public MapperProxyFactory(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }

  public Class<T> getMapperInterface() {
    returnpublic Map<Method,1)"> getMethodCache() {
     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);
     newInstance(mapperProxy);
  }

}

 *    Copyright 2009-2017 the original author or authors.
 *
 *    Licensed under the Apache License,1)"> java.io.Serializable;
 java.lang.invoke.MethodHandles;
 java.lang.reflect.Constructor;
 java.lang.reflect.InvocationHandler;
 java.lang.reflect.Modifier;
 java.util.Map;

 org.apache.ibatis.lang.UsesJava7;
 org.apache.ibatis.reflection.ExceptionUtil;
 Clinton Begin
 *  Eduardo Macarron
 class MapperProxy<T> implements InvocationHandler,Serializable {

  static final long serialVersionUID = -6424540398559729838L;
  final SqlSession sqlSession;
   methodCache;

  public MapperProxy(SqlSession sqlSession,Class<T> mapperInterface,Map<Method,1)"> methodCache) {
    this.sqlSession = sqlSession;
     mapperInterface;
    this.methodCache = methodCache;
  }

  @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)) {
         invokeDefaultMethod(proxy,method,args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    final MapperMethod mapperMethod = cachedMapperMethod(method);
     mapperMethod.execute(sqlSession,args);
  }

  private MapperMethod cachedMapperMethod(Method method) {
    MapperMethod mapperMethod = methodCache.get(method);
    if (mapperMethod == null) {
      mapperMethod =  MapperMethod(mapperInterface,sqlSession.getConfiguration());
      methodCache.put(method,mapperMethod);
    }
     mapperMethod;
  }

  @UsesJava7
   Object invokeDefaultMethod(Object proxy,Object[] args)
      final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.
        .getDeclaredConstructor(Class.class,1)">int.);
    if (!constructor.isAccessible()) {
      constructor.setAccessible(true);
    }
    final Class<?> declaringClass = method.getDeclaringClass();
     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()
   */
  boolean isDefaultMethod(Method method) {
     (method.getModifiers()
        & (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC)) == Modifier.PUBLIC
        && method.getDeclaringClass().isInterface();
  }
}

 org.apache.ibatis.annotations.Flush;
 org.apache.ibatis.annotations.MapKey;
 org.apache.ibatis.cursor.Cursor;
 org.apache.ibatis.mapping.MappedStatement;
 org.apache.ibatis.mapping.SqlCommandType;
 org.apache.ibatis.mapping.StatementType;
 org.apache.ibatis.reflection.MetaObject;
 org.apache.ibatis.reflection.ParamNameResolver;
 org.apache.ibatis.reflection.TypeParameterResolver;
 org.apache.ibatis.session.Configuration;
 org.apache.ibatis.session.ResultHandler;
 org.apache.ibatis.session.RowBounds;
 java.lang.reflect.Array;
 java.lang.reflect.ParameterizedType;
 java.lang.reflect.Type;
import java.util.*;

 Eduardo Macarron
 *  MapperMethod {

   SqlCommand command;
   MethodSignature method;

  public MapperMethod(Class<?> mapperInterface,Configuration config) {
    this.command =  SqlCommand(config,method);
    this.method =  MethodSignature(config,method);
  }

   Object execute(SqlSession sqlSession,Object[] args) {
    Object result;
    switch (command.getType()) {
      case INSERT: {
      Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.insert(command.getName(),param));
        break;
      }
       UPDATE: {
        Object param = rowCountResult(sqlSession.update(command.getName(),1)"> DELETE: {
        Object param = rowCountResult(sqlSession.delete(command.getName(),1)"> SELECT:
        if (method.returnsVoid() && method.hasResultHandler()) {
          executeWithResultHandler(sqlSession,args);
          result = ;
        }  (method.returnsMany()) {
          result = executeForMany(sqlSession,args);
        }  (method.returnsMap()) {
          result = executeForMap(sqlSession,1)"> (method.returnsCursor()) {
          result = executeForCursor(sqlSession,1)">else {
          Object param = method.convertArgsToSqlCommandParam(args);
          result = sqlSession.selectOne(command.getName(),param);
        }
        ;
       FLUSH:
        result = sqlSession.flushStatements();
        default:
        throw new BindingException("Unknown execution method for: " + command.getName());
    }
    if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
      new BindingException("Mapper method '" + command.getName() 
          + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ")." result;
  }

  private Object rowCountResult(int rowCount) {
     Object result;
     (method.returnsVoid()) {
      result = ;
    } if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) {
      result = rowCount;
    } if (Long. Long.TYPE.equals(method.getReturnType())) {
      result = (long)rowCount;
    } if (Boolean. Boolean.TYPE.equals(method.getReturnType())) {
      result = rowCount > 0new BindingException("Mapper method '" + command.getName() + "' has an unsupported return type: " + method.getReturnType());
    }
    void executeWithResultHandler(SqlSession sqlSession,Object[] args) {
    MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(command.getName());
    StatementType.CALLABLE.equals(ms.getStatementType())
        && void.class.equals(ms.getResultMaps().get(0).getType())) {
      new BindingException("method " + command.getName()
          + " needs either a @ResultMap annotation,a @ResultType annotation,"
          + " or a resultType attribute in XML so a ResultHandler can be used as a parameter.");
    }
    Object param = method.convertArgsToSqlCommandParam(args);
     (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      sqlSession.select(command.getName(),param,rowBounds,method.extractResultHandler(args));
    }  {
      sqlSession.select(command.getName(),method.extractResultHandler(args));
    }
  }

  private <E> Object executeForMany(SqlSession sqlSession,Object[] args) {
    List<E> result;
    Object param = method.extractRowBounds(args);
      result = sqlSession.<E>selectList(command.getName(),rowBounds);
    }  {
      result = sqlSession.<E>// issue #510 Collections & arrays support
    method.getReturnType().isAssignableFrom(result.getClass())) {
       (method.getReturnType().isArray()) {
         convertToArray(result);
      }  {
         convertToDeclaredCollection(sqlSession.getConfiguration(),result);
      }
    }
    private <T> Cursor<T> executeForCursor(SqlSession sqlSession,Object[] args) {
    Cursor<T> method.extractRowBounds(args);
      result = sqlSession.<T>selectCursor(command.getName(),1)"> {
      result = sqlSession.<T>private <E> Object convertToDeclaredCollection(Configuration config,List<E> list) {
    Object collection = config.getObjectFactory().create(method.getReturnType());
    MetaObject metaObject = config.newMetaObject(collection);
    metaObject.addAll(list);
     collection;
  }

  @SuppressWarnings("unchecked"private <E> Object convertToArray(List<E> list) {
    Class<?> arrayComponentType = method.getReturnType().getComponentType();
    Object array = Array.newInstance(arrayComponentType,list.size());
     (arrayComponentType.isPrimitive()) {
      for (int i = 0; i < list.size(); i++) {
        Array.set(array,i,list.get(i));
      }
       array;
    }  list.toArray((E[])array);
    }
  }

  private <K,V> Map<K,V> executeForMap(SqlSession sqlSession,Object[] args) {
    Map<K,1)"> method.extractRowBounds(args);
      result = sqlSession.<K,1)">selectMap(command.getName(),method.getMapKey(),1)"> {
      result = sqlSession.<K,method.getMapKey());
    }
    class ParamMap<V> extends HashMap<String,1)"> {

    long serialVersionUID = -2212268410512043556L;

    @Override
     V get(Object key) {
      super.containsKey(key)) {
        new BindingException("Parameter '" + key + "' not found. Available parameters are " + keySet());
      }
      return .get(key);
    }

  }

   SqlCommand {

     String name;
     SqlCommandType type;

    public SqlCommand(Configuration configuration,Class<?>final String methodName = method.getName();
       method.getDeclaringClass();
      MappedStatement ms = resolveMappedStatement(mapperInterface,methodName,declaringClass,configuration);
      if (ms == ) {
        if (method.getAnnotation(Flush.class) != ) {
          name = ;
          type = SqlCommandType.FLUSH;
        }  {
          new BindingException("Invalid bound statement (not found): "
              + mapperInterface.getName() + "." + methodName);
        }
      }  {
        name = ms.getId();
        type = ms.getSqlCommandType();
        if (type == SqlCommandType.UNKNOWN) {
           name);
        }
      }
    }

     String getName() {
       name;
    }

     SqlCommandType getType() {
       type;
    }

    private MappedStatement resolveMappedStatement(Class<?> declaringClass,Configuration configuration) {
      String statementId = mapperInterface.getName() + "." + methodName;
       (configuration.hasStatement(statementId)) {
         configuration.getMappedStatement(statementId);
      }  (mapperInterface.equals(declaringClass)) {
        for (Class<?> superInterface : mapperInterface.getInterfaces()) {
         (declaringClass.isAssignableFrom(superInterface)) {
          MappedStatement ms = resolveMappedStatement(superInterface,configuration);
          if (ms != ) {
             ms;
          }
        }
      }
      ;
    }
  }

   MethodSignature {

     returnsMany;
     returnsMap;
     returnsVoid;
     returnsCursor;
    final Class<?> returnType;
     String mapKey;
     Integer resultHandlerIndex;
     Integer rowBoundsIndex;
     ParamNameResolver paramNameResolver;

    public MethodSignature(Configuration configuration,Method method) {
      Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method,mapperInterface);
      if (resolvedReturnType instanceof Class<?>this.returnType = (Class<?>) resolvedReturnType;
      } instanceof ParameterizedType) {
        ) ((ParameterizedType) resolvedReturnType).getRawType();
      } this.returnType = method.getReturnType();
      }
      this.returnsVoid = class.equals(.returnType);
      this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) || .returnType.isArray();
      this.returnsCursor = Cursor.this.mapKey = getMapKey(method);
      this.returnsMap = this.mapKey != this.rowBoundsIndex = getUniqueParamIndex(method,RowBounds.);
      this.resultHandlerIndex = getUniqueParamIndex(method,ResultHandler.this.paramNameResolver =  ParamNameResolver(configuration,method);
    }

     Object convertArgsToSqlCommandParam(Object[] args) {
       paramNameResolver.getNamedParams(args);
    }

     hasRowBounds() {
      return rowBoundsIndex != ;
    }

     RowBounds extractRowBounds(Object[] args) {
      return hasRowBounds() ? (RowBounds) args[rowBoundsIndex] :  hasResultHandler() {
      return resultHandlerIndex !=  ResultHandler extractResultHandler(Object[] args) {
      return hasResultHandler() ? (ResultHandler) args[resultHandlerIndex] :  String getMapKey() {
       mapKey;
    }

    public Class<?> getReturnType() {
       returnType;
    }

     returnsMany() {
       returnsMany;
    }

     returnsMap() {
       returnsMap;
    }

     returnsVoid() {
       returnsVoid;
    }

     returnsCursor() {
       returnsCursor;
    }

    private Integer getUniqueParamIndex(Method method,1)"> paramType) {
      Integer index = final Class<?>[] argTypes = method.getParameterTypes();
      int i = 0; i < argTypes.length; i++ (paramType.isAssignableFrom(argTypes[i])) {
          if (index == ) {
            index = i;
          }  {
            new BindingException(method.getName() + " cannot have multiple " + paramType.getSimpleName() + " parameters");
          }
        }
      }
       index;
    }

     String getMapKey(Method method) {
      String mapKey = if (Map..isAssignableFrom(method.getReturnType())) {
        final MapKey mapKeyAnnotation = method.getAnnotation(MapKey.);
        if (mapKeyAnnotation != ) {
          mapKey = mapKeyAnnotation.value();
        }
      }
       mapKey;
    }
  }

}