我们以往使用ibatis或者mybatis 都是以这种方式调用XML当中定义的CRUD标签来执行SQL 比如这样

1. 无Mapper使用方法

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="org.mybatis.example.BlogMapper">
  6.   <select id="selectBlog" resultType="Blog">
  7.     select * from Blog where id = #{id}
  8.   </select>
  9. </mapper>
  1. SqlSession session = sqlSessionFactory.openSession();
  2. try {
  3.   Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);
  4. } finally {
  5.   session.close();
  6. }

这种方式有很明显的缺点就是通过字符串去调用标签定义的SQL，第一容易出错，第二是当XML当中的id修改过以后你不知道在程序当中有多少个地方使用了这个ID,需要手工查找并一一修改。在Mybatis这个版本中做了一些改进，支持这种方式调用。
**

2. 定义Mapper接口方法

定义一个接口 方法名，参数需要与XML定义保持一致。

  2. org.mybatis.example.BlogMapper.selectBlog
  3. public interface BlogMapper {
  4.   Blog selectBlog(int id);
  5. }

然后这么调用，这样以来当我们修改了XML的ID以后，只需要修改接口中的方法就可以了，编译器会在其他使用该接口的地方报错，很容易进行修改。当然好处还不只这些，还可以通过与Spring进行无缝集成，动态注入 等等。后面会一一讲到。

  1. SqlSession session = sqlSessionFactory.openSession();
  2. try {
  3.   BlogMapper mapper = session.getMapper(BlogMapper.class);
  4.   Blog blog = mapper.selectBlog(101);
  5. } finally {
  6.   session.close();
  7. }

本文的重点不是去讲解如何使用MyBatis(关于如何使用Mybatis可以参考官方API http://mybatis.github.io/mybatis-3/zh/getting-started.html),,)而是讲解MyBatis是如何通过接口对SqlSession进行动态封装的。

在上面的例子当中呢，BlogMapper是一个接口 它并没有实现类，为什么接口可以直接使用呢?

那是因为MyBbatis使用了JDK动态代理机制动态生成了代理类，那么代理类又是如何多SqlSession进行封装的呢?

带着这些疑问，让我们通过分析源代码的方式来解释这些问题。

Mybatis关于包装Mapper的代码都在org.apache.ibatis.binding 这个包下面。

其中有4个类。

Mybatis Mapper代理原理 - 图1

上面的4个类封装了Mapper接口动态生成代理类的全部细节

MapperRegistry 类是注册Mapper接口与获取代理类实例的工具类

3. MapperRegistry

  1. package org.apache.ibatis.binding;
  3. import org.apache.ibatis.builder.annotation.MapperAnnotationBuilder;
  4. import org.apache.ibatis.io.ResolverUtil;
  5. import org.apache.ibatis.session.Configuration;
  6. import org.apache.ibatis.session.SqlSession;
  8. import java.util.Collection;
  9. import java.util.Collections;
  10. import java.util.HashMap;
  11. import java.util.Map;
  12. import java.util.Set;
  14.  //这个类通过名字就可以看出 是用来注册Mapper接口与获取生成代理类实例的工具类 
  15. public class MapperRegistry {
  17.    //全局配置文件对象
  18.    private Configuration config;
  20.    //一个HashMap Key是mapper的类型对象, Value是MapperProxyFactory对象
  21.    //这个MapperProxyFactory是创建Mapper代理对象的工厂 我们一会在分析
  22.    private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>();
  24.    public MapperRegistry(Configuration config) {
  25.      this.config = config;
  26.    }
  28.    //获取生成的代理对象
  29.    @SuppressWarnings("unchecked")
  30.    public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  31.      //通过Mapper的接口类型 去Map当中查找 如果为空就抛异常
  32.      final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
  33.      if (mapperProxyFactory == null)
  34.        throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
  35.      try {
  36.        //否则创建一个当前接口的代理对象 并且传入sqlSession
  37.        return mapperProxyFactory.newInstance(sqlSession);
  38.      } catch (Exception e) {
  39.        throw new BindingException("Error getting mapper instance. Cause: " + e, e);
  40.      }
  41.    }
  43.    public <T> boolean hasMapper(Class<T> type) {
  44.      return knownMappers.containsKey(type);
  45.    }
  47.    //注册Mapper接口
  48.    public <T> void addMapper(Class<T> type) {
  49.      if (type.isInterface()) {
  50.        if (hasMapper(type)) {
  51.          throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
  52.        }
  53.        boolean loadCompleted = false;
  54.        try {
  55.          knownMappers.put(type, new MapperProxyFactory<T>(type));
  56.          // It's important that the type is added before the parser is run
  57.          // otherwise the binding may automatically be attempted by the
  58.          // mapper parser. If the type is already known, it won't try.
  59.          MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
  60.          parser.parse();
  61.          loadCompleted = true;
  62.        } finally {
  63.          if (!loadCompleted) {
  64.            knownMappers.remove(type);
  65.          }
  66.        }
  67.      }
  68.    }
  70.    public Collection<Class<?>> getMappers() {
  71.      return Collections.unmodifiableCollection(knownMappers.keySet());
  72.    }
  74.      ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
  75.      resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
  76.      Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
  77.      for (Class<?> mapperClass : mapperSet) {
  78.        addMapper(mapperClass);
  79.      }
  80.    }
  82.    //通过包名扫描下面所有接口
  83.    public void addMappers(String packageName) {
  84.      addMappers(packageName, Object.class);
  85.    }
  86.  }

4. MapperProxyFactory

  1. package org.apache.ibatis.binding;
  3. import java.lang.reflect.Method;
  4. import java.lang.reflect.Proxy;
  5. import java.util.Map;
  6. import java.util.concurrent.ConcurrentHashMap;
  8. import org.apache.ibatis.session.SqlSession;
  10. //这个类负责创建具体Mapper接口代理对象的工厂类
  11. public class MapperProxyFactory<T> {
  13.   //具体Mapper接口的Class对象
  14.   private final Class<T> mapperInterface;
  15.   //该接口下面方法的缓存 key是方法对象 value是对接口中方法对象的封装
  16.   private Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();
  18.   //构造参数没啥好说的
  19.   public MapperProxyFactory(Class<T> mapperInterface) {
  20.     this.mapperInterface = mapperInterface;
  21.   }
  23.   public Class<T> getMapperInterface() {
  24.     return mapperInterface;
  25.   }
  27.   public Map<Method, MapperMethod> getMethodCache() {
  28.     return methodCache;
  29.   }
  31.   @SuppressWarnings("unchecked")
  32.   protected T newInstance(MapperProxy<T> mapperProxy) {
  33.     //创建了一个代理类并返回
  34.     //关于Proxy的API 可以查看java官方的API
  35.     return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  36.   }
  38.   //在这里传入sqlSession 创建一个Mapper接口的代理类
  39.   public T newInstance(SqlSession sqlSession) {
  40.     //在这里创建了MapperProxy对象 这个类实现了JDK的动态代理接口 InvocationHandler
  41.     final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
  42.     //调用上面的方法 返回一个接口的代理类
  43.     return newInstance(mapperProxy);
  44.   }
  46. }

5. MapperProxy

  1. package org.apache.ibatis.binding;
  3. import java.io.Serializable;
  4. import java.lang.reflect.InvocationHandler;
  5. import java.lang.reflect.Method;
  6. import java.util.Map;
  8. import org.apache.ibatis.session.SqlSession;
  10. //实现了JDK动态代理的接口 InvocationHandler
  11. //在invoke方法中实现了代理方法调用的细节
  12. public class MapperProxy<T> implements InvocationHandler, Serializable {
  14.   private static final long serialVersionUID = -6424540398559729838L;
  15.   //SqlSession
  16.   private final SqlSession sqlSession;
  17.   //接口的类型对象
  18.   private final Class<T> mapperInterface;
  20.   //接口中方法的缓存 有MapperProxyFactory传递过来的。
  21.   private final Map<Method, MapperMethod> methodCache;
  23.   //构造参数
  24.   public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
  25.     this.sqlSession = sqlSession;
  26.     this.mapperInterface = mapperInterface;
  27.     this.methodCache = methodCache;
  28.   }
  30.   //接口代理对象所有的方法调用 都会调用该方法
  31.   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  32.     //判断是不是基础方法 比如toString() hashCode()等，这些方法直接调用不需要处理
  33.     if (Object.class.equals(method.getDeclaringClass())) {
  34.       return method.invoke(this, args);
  35.     }
  36.     //这里进行缓存
  37.     final MapperMethod mapperMethod = cachedMapperMethod(method);
  38.     //调用mapperMethod.execute 核心的地方就在这个方法里，这个方法对才是真正对SqlSession进行的包装调用
  39.     return mapperMethod.execute(sqlSession, args);
  40.   }
  42.   //缓存处理
  43.   private MapperMethod cachedMapperMethod(Method method) {
  44.     MapperMethod mapperMethod = methodCache.get(method);
  45.     if (mapperMethod == null) {
  46.       mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
  47.       methodCache.put(method, mapperMethod);
  48.     }
  49.     return mapperMethod;
  50.   }
  52. }

6. MapperMethod

  1. package org.apache.ibatis.binding;
  3. import org.apache.ibatis.annotations.MapKey;
  4. import org.apache.ibatis.annotations.Param;
  5. import org.apache.ibatis.mapping.MappedStatement;
  6. import org.apache.ibatis.mapping.SqlCommandType;
  7. import org.apache.ibatis.reflection.MetaObject;
  8. import org.apache.ibatis.session.Configuration;
  9. import org.apache.ibatis.session.ResultHandler;
  10. import org.apache.ibatis.session.RowBounds;
  11. import org.apache.ibatis.session.SqlSession;
  13. import java.lang.reflect.Array;
  14. import java.lang.reflect.Method;
  15. import java.util.*;
  17. //这个类是整个代理机制的核心类，对Sqlsession当中的操作进行了封装
  18. public class MapperMethod {
  20.   //一个内部封 封装了SQL标签的类型 insert update delete select
  21.   private final SqlCommand command;
  22.   //一个内部类 封装了方法的参数信息 返回类型信息等
  23.   private final MethodSignature method;
  25.   //构造参数
  26.   public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
  27.     this.command = new SqlCommand(config, mapperInterface, method);
  28.     this.method = new MethodSignature(config, method);
  29.   }
  31.   //这个方法是对SqlSession的包装调用
  32.   public Object execute(SqlSession sqlSession, Object[] args) {
  33.     //定义返回结果
  34.     Object result;
  35.     //如果是INSERT操作
  36.     if (SqlCommandType.INSERT == command.getType()) {
  37.       //处理参数
  38.       Object param = method.convertArgsToSqlCommandParam(args);
  39.       //调用sqlSession的insert方法
  40.       result = rowCountResult(sqlSession.insert(command.getName(), param));
  42.       //如果是UPDATE操作 同上
  43.     } else if (SqlCommandType.UPDATE == command.getType()) {
  44.       Object param = method.convertArgsToSqlCommandParam(args);
  45.       result = rowCountResult(sqlSession.update(command.getName(), param));
  47.       //如果是DELETE操作 同上
  48.     } else if (SqlCommandType.DELETE == command.getType()) {
  49.       Object param = method.convertArgsToSqlCommandParam(args);
  50.       result = rowCountResult(sqlSession.delete(command.getName(), param));
  52.       //如果是SELECT操作 那么情况会多一些 但是也都和sqlSession的查询方法一一对应
  53.     } else if (SqlCommandType.SELECT == command.getType()) {
  54.       //如果返回void 并且参数有resultHandler
  55.       //则调用 void select(String statement, Object parameter, ResultHandler handler);方法
  56.       if (method.returnsVoid() && method.hasResultHandler()) {
  57.         executeWithResultHandler(sqlSession, args);
  58.         result = null;
  59.       //如果返回多行结果这调用 <E> List<E> selectList(String statement, Object parameter);
  60.       //executeForMany这个方法调用的
  61.       } else if (method.returnsMany()) {
  62.         result = executeForMany(sqlSession, args);
  63.       //如果返回类型是MAP 则调用executeForMap方法
  64.       } else if (method.returnsMap()) {
  65.         result = executeForMap(sqlSession, args);
  66.       } else {
  67.         //否则就是查询单个对象
  68.         Object param = method.convertArgsToSqlCommandParam(args);
  69.         result = sqlSession.selectOne(command.getName(), param);
  70.       }
  71.     } else {
  72.       //如果全都不匹配 说明mapper中定义的方法不对
  73.       throw new BindingException("Unknown execution method for: " + command.getName());
  74.     }
  75.     //如果返回值为空 并且方法返回值类型是基础类型 并且不是VOID 则抛出异常
  76.     if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
  77.       throw new BindingException("Mapper method '" + command.getName() 
  78.           + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
  79.     }
  80.     return result;
  81.   }
  83.   private Object rowCountResult(int rowCount) {
  84.     final Object result;
  85.     if (method.returnsVoid()) {
  86.       result = null;
  87.     } else if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) {
  88.       result = rowCount;
  89.     } else if (Long.class.equals(method.getReturnType()) || Long.TYPE.equals(method.getReturnType())) {
  90.       result = (long) rowCount;
  91.     } else if (Boolean.class.equals(method.getReturnType()) || Boolean.TYPE.equals(method.getReturnType())) {
  92.       result = (rowCount > 0);
  93.     } else {
  94.       throw new BindingException("Mapper method '" + command.getName() + "' has an unsupported return type: " + method.getReturnType());
  95.     }
  96.     return result;
  97.   }
  99.   private void executeWithResultHandler(SqlSession sqlSession, Object[] args) {
  100.     MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(command.getName());
  101.     if (void.class.equals(ms.getResultMaps().get(0).getType())) {
  102.       throw new BindingException("method " + command.getName() 
  103.           + " needs either a @ResultMap annotation, a @ResultType annotation," 
  104.           + " or a resultType attribute in XML so a ResultHandler can be used as a parameter.");
  105.     }
  106.     Object param = method.convertArgsToSqlCommandParam(args);
  107.     if (method.hasRowBounds()) {
  108.       RowBounds rowBounds = method.extractRowBounds(args);
  109.       sqlSession.select(command.getName(), param, rowBounds, method.extractResultHandler(args));
  110.     } else {
  111.       sqlSession.select(command.getName(), param, method.extractResultHandler(args));
  112.     }
  113.   }
  115.   //返回多行结果 调用sqlSession.selectList方法
  116.   private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
  117.     List<E> result;
  118.     Object param = method.convertArgsToSqlCommandParam(args);
  119.     //如果参数含有rowBounds则调用分页的查询
  120.     if (method.hasRowBounds()) {
  121.       RowBounds rowBounds = method.extractRowBounds(args);
  122.       result = sqlSession.<E>selectList(command.getName(), param, rowBounds);
  123.     } else {
  124.       //没有分页则调用普通查询
  125.       result = sqlSession.<E>selectList(command.getName(), param);
  126.     }
  127.     // issue #510 Collections & arrays support
  128.     if (!method.getReturnType().isAssignableFrom(result.getClass())) {
  129.       if (method.getReturnType().isArray()) {
  130.         return convertToArray(result);
  131.       } else {
  132.         return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
  133.       }
  134.     }
  135.     return result;
  136.   }
  138.   private <E> Object convertToDeclaredCollection(Configuration config, List<E> list) {
  139.     Object collection = config.getObjectFactory().create(method.getReturnType());
  140.     MetaObject metaObject = config.newMetaObject(collection);
  141.     metaObject.addAll(list);
  142.     return collection;
  143.   }
  145.   @SuppressWarnings("unchecked")
  146.   private <E> E[] convertToArray(List<E> list) {
  147.     E[] array = (E[]) Array.newInstance(method.getReturnType().getComponentType(), list.size());
  148.     array = list.toArray(array);
  149.     return array;
  150.   }
  152.   private <K, V> Map<K, V> executeForMap(SqlSession sqlSession, Object[] args) {
  153.     Map<K, V> result;
  154.     Object param = method.convertArgsToSqlCommandParam(args);
  155.     if (method.hasRowBounds()) {
  156.       RowBounds rowBounds = method.extractRowBounds(args);
  157.       result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey(), rowBounds);
  158.     } else {
  159.       result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey());
  160.     }
  161.     return result;
  162.   }
  164.   public static class ParamMap<V> extends HashMap<String, V> {
  166.     private static final long serialVersionUID = -2212268410512043556L;
  168.     @Override
  169.     public V get(Object key) {
  170.       if (!super.containsKey(key)) {
  171.         throw new BindingException("Parameter '" + key + "' not found. Available parameters are " + keySet());
  172.       }
  173.       return super.get(key);
  174.     }
  176.   }
  178.   //一个内部类 封装了具体执行的动作
  179.   public static class SqlCommand {
  181.     //xml标签的id
  182.     private final String name;
  183.     //insert update delete select的具体类型
  184.     private final SqlCommandType type;
  187.     public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) throws BindingException {
  188.       //拿到全名 比如 org.mybatis.example.BlogMapper.selectBlog
  189.       String statementName = mapperInterface.getName() + "." + method.getName();
  190.       MappedStatement ms = null;
  191.       //获取MappedStatement对象 这个对象封装了XML当中一个标签的所有信息 比如下面
  192.       //<select id="selectBlog" resultType="Blog">
  193.       //select * from Blog where id = #{id}
  194.       //</select>
  195.       if (configuration.hasStatement(statementName)) {
  196.         ms = configuration.getMappedStatement(statementName);
  197.       } else if (!mapperInterface.equals(method.getDeclaringClass().getName())) { // 这里是一个BUG
  198.         String parentStatementName = method.getDeclaringClass().getName() + "." + method.getName();
  199.         if (configuration.hasStatement(parentStatementName)) {
  200.           ms = configuration.getMappedStatement(parentStatementName);
  201.         }
  202.       }
  203.       //为空抛出异常
  204.       if (ms == null) {
  205.         throw new BindingException("Invalid bound statement (not found): " + statementName);
  206.       }
  207.       name = ms.getId();
  208.       type = ms.getSqlCommandType();
  209.       //判断SQL标签类型 未知就抛异常
  210.       if (type == SqlCommandType.UNKNOWN) {
  211.         throw new BindingException("Unknown execution method for: " + name);
  212.       }
  213.     }
  215.     public String getName() {
  216.       return name;
  217.     }
  219.     public SqlCommandType getType() {
  220.       return type;
  221.     }
  222.   }
  224.   //内部类 封装了接口当中方法的 参数类型 返回值类型 等信息
  225.   public static class MethodSignature {
  227.     //是否返回多调结果
  228.     private final boolean returnsMany;
  229.     //返回值是否是MAP
  230.     private final boolean returnsMap;
  231.     //返回值是否是VOID
  232.     private final boolean returnsVoid;
  233.     //返回值类型
  234.     private final Class<?> returnType;
  235.     //mapKey
  236.     private final String mapKey;
  237.     //resultHandler类型参数的位置
  238.     private final Integer resultHandlerIndex;
  239.     //rowBound类型参数的位置
  240.     private final Integer rowBoundsIndex;
  241.     //用来存放参数信息
  242.     private final SortedMap<Integer, String> params;
  243.     //是否存在命名参数
  244.     private final boolean hasNamedParameters;
  246.     //在这里对上面的属性进行初始化 就不一一详细说明了 具体实现细节可以看下面的代码。
  247.     public MethodSignature(Configuration configuration, Method method) throws BindingException {
  248.       this.returnType = method.getReturnType();
  249.       this.returnsVoid = void.class.equals(this.returnType);
  250.       this.returnsMany = (configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray());
  251.       this.mapKey = getMapKey(method);
  252.       this.returnsMap = (this.mapKey != null);
  253.       this.hasNamedParameters = hasNamedParams(method);
  254.       this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
  255.       this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
  256.       this.params = Collections.unmodifiableSortedMap(getParams(method, this.hasNamedParameters));
  257.     }
  259.     public Object convertArgsToSqlCommandParam(Object[] args) {
  260.       final int paramCount = params.size();
  261.       if (args == null || paramCount == 0) {
  262.         return null;
  263.       } else if (!hasNamedParameters && paramCount == 1) {
  264.         return args[params.keySet().iterator().next()];
  265.       } else {
  266.         final Map<String, Object> param = new ParamMap<Object>();
  267.         int i = 0;
  268.         for (Map.Entry<Integer, String> entry : params.entrySet()) {
  269.           param.put(entry.getValue(), args[entry.getKey()]);
  270.           // issue #71, add param names as param1, param2...but ensure backward compatibility
  271.           final String genericParamName = "param" + String.valueOf(i + 1);
  272.           if (!param.containsKey(genericParamName)) {
  273.             param.put(genericParamName, args[entry.getKey()]);
  274.           }
  275.           i++;
  276.         }
  277.         return param;
  278.       }
  279.     }
  281.     public boolean hasRowBounds() {
  282.       return (rowBoundsIndex != null);
  283.     }
  285.     public RowBounds extractRowBounds(Object[] args) {
  286.       return (hasRowBounds() ? (RowBounds) args[rowBoundsIndex] : null);
  287.     }
  289.     public boolean hasResultHandler() {
  290.       return (resultHandlerIndex != null);
  291.     }
  293.     public ResultHandler extractResultHandler(Object[] args) {
  294.       return (hasResultHandler() ? (ResultHandler) args[resultHandlerIndex] : null);
  295.     }
  297.     public String getMapKey() {
  298.       return mapKey;
  299.     }
  301.     public Class<?> getReturnType() {
  302.       return returnType;
  303.     }
  305.     public boolean returnsMany() {
  306.       return returnsMany;
  307.     }
  309.     public boolean returnsMap() {
  310.       return returnsMap;
  311.     }
  313.     public boolean returnsVoid() {
  314.       return returnsVoid;
  315.     }
  317.     private Integer getUniqueParamIndex(Method method, Class<?> paramType) {
  318.       Integer index = null;
  319.       final Class<?>[] argTypes = method.getParameterTypes();
  320.       for (int i = 0; i < argTypes.length; i++) {
  321.         if (paramType.isAssignableFrom(argTypes[i])) {
  322.           if (index == null) {
  323.             index = i;
  324.           } else {
  325.             throw new BindingException(method.getName() + " cannot have multiple " + paramType.getSimpleName() + " parameters");
  326.           }
  327.         }
  328.       }
  329.       return index;
  330.     }
  332.     private String getMapKey(Method method) {
  333.       String mapKey = null;
  334.       if (Map.class.isAssignableFrom(method.getReturnType())) {
  335.         final MapKey mapKeyAnnotation = method.getAnnotation(MapKey.class);
  336.         if (mapKeyAnnotation != null) {
  337.           mapKey = mapKeyAnnotation.value();
  338.         }
  339.       }
  340.       return mapKey;
  341.     }
  343.     private SortedMap<Integer, String> getParams(Method method, boolean hasNamedParameters) {
  344.       final SortedMap<Integer, String> params = new TreeMap<Integer, String>();
  345.       final Class<?>[] argTypes = method.getParameterTypes();
  346.       for (int i = 0; i < argTypes.length; i++) {
  347.         if (!RowBounds.class.isAssignableFrom(argTypes[i]) && !ResultHandler.class.isAssignableFrom(argTypes[i])) {
  348.           String paramName = String.valueOf(params.size());
  349.           if (hasNamedParameters) {
  350.             paramName = getParamNameFromAnnotation(method, i, paramName);
  351.           }
  352.           params.put(i, paramName);
  353.         }
  354.       }
  355.       return params;
  356.     }
  358.     private String getParamNameFromAnnotation(Method method, int i, String paramName) {
  359.       final Object[] paramAnnos = method.getParameterAnnotations()[i];
  360.       for (Object paramAnno : paramAnnos) {
  361.         if (paramAnno instanceof Param) {
  362.           paramName = ((Param) paramAnno).value();
  363.         }
  364.       }
  365.       return paramName;
  366.     }
  368.     private boolean hasNamedParams(Method method) {
  369.       boolean hasNamedParams = false;
  370.       final Object[][] paramAnnos = method.getParameterAnnotations();
  371.       for (Object[] paramAnno : paramAnnos) {
  372.         for (Object aParamAnno : paramAnno) {
  373.           if (aParamAnno instanceof Param) {
  374.             hasNamedParams = true;
  375.             break;
  376.           }
  377.         }
  378.       }
  379.       return hasNamedParams;
  380.     }
  382.   }
  384. }

通过上面的分析就很容易弄清楚Mybatis是如何利用JDK动态代理的机制生成代理类来对各种Mapper接口进行封装的了。

Mybatis Mapper代理原理 - 图2