Mybatis中Mapper动态代理的实现原理

╰半夏微凉° 2021-09-23 03:58 230阅读 0赞

#     #

原创  2017年07月28日 10:42:19

*  292
 *  0
 *  0

## 一、概述 ##

我们知道，Mybatis实现增删改查需要进行XML的配置，其基本的配置如下：

<?xml version="1.0" encoding="UTF-8" ?>  
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
    <mapper namespace="org.mybatis.example.BlogMapper">  
      <select id="selectBlog" resultType="Blog">  
        select * from Blog where id = #{id}  
      </select>  
    </mapper>  
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9

上面的配置表示我们在命名空间org.mybatis.example.BlogMapper下定义一个ID为selectBlog的查询操作，其操作结果集为Blog，对应的语句为`select * from Blog where id = #{id}`

那么在实际使用时，我们可以采用如下形式：

SqlSession session = sqlSessionFactory.openSession();  
    try {  
      Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);  
    } finally {  
      session.close();  
    }  
       
        
         1
         2
         3
         4
         5
         6

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

在Mybatis的新版本中做了一些改进，支持这种方式调用：定义一个接口 方法名，参数需要与XML定义保持一致。

*  1、新建一个com.kang.mapper的包，定义map接口，接口名任意，这里是UserMapper。

package com.kang.mapper;  
    
    
    import java.util.List;  
    import com.kang.pojo.User;  
    public interface UserMapper {   
        //根据用户id查询用户信息 
        public User findUserById(int id) throws Exception;  
        //查询用户列表 
        public List<User> findUserByUsername(String username) throws Exception;  
        //添加用户信息 
        public void insertUser(User user)throws Exception;   
    }  
    
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14

*  2、配置xml文件 UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>  
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
    <mapper namespace="com.kang.mapper.UserMapper">  
      
        <select id="findUserById" parameterType="int" resultType="user">  
            select * from user where id = #{id}  
        </select>  
    
        <select id="findUserByUsername" parameterType="java.lang.String" resultType="user">  
            select * from user where username like '%${value}%'  
        </select>  
    
        <insert id="insertUser" parameterType="user">  
            <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">  
                select LAST_INSERT_ID()  
            </selectKey>  
            insert into user(username,birthday,sex,address)  
            values(#{username},#{birthday},#{sex},#{address})  
        </insert>  
    </mapper>  
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23

注意到配置文件中的id属性值和map接口中的方法名是一一对应的。

*  3、在SqlMapConfig.xml中加入映射文件

<mappers>  
            <mapper resource="map/UserMapper.xml" />  
        </mappers>  
       
        
         1
         2
         3
         4

*  4、调用方法

//获取session  
            SqlSession session = sqlSessionFactory.openSession(); 
            //获取mapper接口的代理对象  
            UserMapper userMapper = session.getMapper(UserMapper.class); 
            //调用代理对象方法  
            User user = userMapper.findUserById(27); 
            System.out.println(user); 
            //关闭session  
            session.close(); 
            System.out.println("---------执行完毕-----------"); 
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10

这样以来当我们修改了XML的ID以后，只需要修改接口中的方法就可以了，编译器会在其他使用该接口的地方报错，很容易进行修改。当然好处还不只这些，还可以通过与spring进行无缝集成，动态注入 等等。   
关于Mybatis的Mapp接口使用方法请参考这篇博文[Mybatis之Mapper动态代理][Mybatis_Mapper]   
在上面的例子当中呢，UserMapper是一个接口 它并没有实现类，为什么接口可以直接使用呢? 那是因为MyBbatis使用了JDK动态代理机制动态生成了代理类，那么代理类又是如何多SqlSession进行封装的呢?带着这些疑问，让我们通过分析源代码的方式来解释这些问题。

## 二、源码解析 ##

Mybatis关于包装Mapper的代码都在org.apache.ibatis.binding 这个包下面。其中有4个类：   
MapperRegistry 类是注册Mapper接口与获取代理类实例的工具类。其源码如下：

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

类的getMapper方法里面最后会去调用MapperProxyFactory类的newInstance方法。从上面的源码可以看出来，在调用getMapper方法前会初始化MapperProxyFactory，它是创建Mapper代理对象的工厂，其源码如下：

package org.apache.ibatis.binding;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    import org.apache.ibatis.session.SqlSession;
    //这个类负责创建具体Mapper接口代理对象的工厂类
    public class MapperProxyFactory<T> {
      //具体Mapper接口的Class对象
      private final Class<T> mapperInterface;
      //该接口下面方法的缓存 key是方法对象 value是对接口中方法对象的封装
      private 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) {
        //创建了一个代理类并返回
        //关于Proxy的API 可以查看java官方的API
        return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
      }
      //在这里传入sqlSession 创建一个Mapper接口的代理类
      public T newInstance(SqlSession sqlSession) {
        //在这里创建了MapperProxy对象 这个类实现了JDK的动态代理接口 InvocationHandler
        final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
        //调用上面的方法 返回一个接口的代理类
        return newInstance(mapperProxy);
      }
    }
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36

上述代码中的关键代码是

final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
       
        
         1

在这里创建了MapperProxy对象 这个类实现了JDK的动态代理接口 InvocationHandler,其源码如下：

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

从源码的意思：从缓存中获得执行方法对应的MapperMethod类实例。如果MapperMethod类实例不存在的情况，创建加入缓存并返回相关的实例。最后调用MapperMethod类的execute方法。   
到这里我们可以看到，getMapper方法就是用来获得相关的数据操作类接口。而事实数据操作类邦定了动态代理。所以操据操作类执行方法的时候，会触动每个方法相应的MapperProxy类的invoke方法。所以invoke方法返回的结果就是根据操作类执行方法的结果。这样子我们就知道最后的任务交给了MapperMethod类实例。   
那么MapperMethod的详细源码如下：

package org.apache.ibatis.binding;
    import org.apache.ibatis.annotations.MapKey;
    import org.apache.ibatis.annotations.Param;
    import org.apache.ibatis.mapping.MappedStatement;
    import org.apache.ibatis.mapping.SqlCommandType;
    import org.apache.ibatis.reflection.MetaObject;
    import org.apache.ibatis.session.Configuration;
    import org.apache.ibatis.session.ResultHandler;
    import org.apache.ibatis.session.RowBounds;
    import org.apache.ibatis.session.SqlSession;
    import java.lang.reflect.Array;
    import java.lang.reflect.Method;
    import java.util.*;
    //这个类是整个代理机制的核心类，对Sqlsession当中的操作进行了封装
    public class MapperMethod {
      //一个内部封 封装了SQL标签的类型 insert update delete select
      private final SqlCommand command;
      //一个内部类 封装了方法的参数信息 返回类型信息等
      private final MethodSignature method;
      //构造参数
      public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
        this.command = new SqlCommand(config, mapperInterface, method);
        this.method = new MethodSignature(config, method);
      }
      //这个方法是对SqlSession的包装调用
      public Object execute(SqlSession sqlSession, Object[] args) {
        //定义返回结果
        Object result;
        //如果是INSERT操作
        if (SqlCommandType.INSERT == command.getType()) {
          //处理参数
          Object param = method.convertArgsToSqlCommandParam(args);
          //调用sqlSession的insert方法
          result = rowCountResult(sqlSession.insert(command.getName(), param));
          //如果是UPDATE操作 同上
        } else if (SqlCommandType.UPDATE == command.getType()) {
          Object param = method.convertArgsToSqlCommandParam(args);
          result = rowCountResult(sqlSession.update(command.getName(), param));
          //如果是DELETE操作 同上
        } else if (SqlCommandType.DELETE == command.getType()) {
          Object param = method.convertArgsToSqlCommandParam(args);
          result = rowCountResult(sqlSession.delete(command.getName(), param));
          //如果是SELECT操作 那么情况会多一些 但是也都和sqlSession的查询方法一一对应
        } else if (SqlCommandType.SELECT == command.getType()) {
          //如果返回void 并且参数有resultHandler
          //则调用 void select(String statement, Object parameter, ResultHandler handler);方法
          if (method.returnsVoid() && method.hasResultHandler()) {
            executeWithResultHandler(sqlSession, args);
            result = null;
          //如果返回多行结果这调用 <E> List<E> selectList(String statement, Object parameter);
          //executeForMany这个方法调用的
          } else if (method.returnsMany()) {
            result = executeForMany(sqlSession, args);
          //如果返回类型是MAP 则调用executeForMap方法
          } else if (method.returnsMap()) {
            result = executeForMap(sqlSession, args);
          } else {
            //否则就是查询单个对象
            Object param = method.convertArgsToSqlCommandParam(args);
            result = sqlSession.selectOne(command.getName(), param);
          }
        } else {
          //如果全都不匹配 说明mapper中定义的方法不对
          throw new BindingException("Unknown execution method for: " + command.getName());
        }
        //如果返回值为空 并且方法返回值类型是基础类型 并且不是VOID 则抛出异常
        if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
          throw new BindingException("Mapper method '" + command.getName() 
              + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
        }
        return result;
      }
      private Object rowCountResult(int rowCount) {
        final Object result;
        if (method.returnsVoid()) {
          result = null;
        } else if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) {
          result = rowCount;
        } else if (Long.class.equals(method.getReturnType()) || Long.TYPE.equals(method.getReturnType())) {
          result = (long) rowCount;
        } else if (Boolean.class.equals(method.getReturnType()) || Boolean.TYPE.equals(method.getReturnType())) {
          result = (rowCount > 0);
        } else {
          throw new BindingException("Mapper method '" + command.getName() + "' has an unsupported return type: " + method.getReturnType());
        }
        return result;
      }
      private void executeWithResultHandler(SqlSession sqlSession, Object[] args) {
        MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(command.getName());
        if (void.class.equals(ms.getResultMaps().get(0).getType())) {
          throw 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);
        if (method.hasRowBounds()) {
          RowBounds rowBounds = method.extractRowBounds(args);
          sqlSession.select(command.getName(), param, rowBounds, method.extractResultHandler(args));
        } else {
          sqlSession.select(command.getName(), param, method.extractResultHandler(args));
        }
      }
      //返回多行结果 调用sqlSession.selectList方法
      private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
        List<E> result;
        Object param = method.convertArgsToSqlCommandParam(args);
        //如果参数含有rowBounds则调用分页的查询
        if (method.hasRowBounds()) {
          RowBounds rowBounds = method.extractRowBounds(args);
          result = sqlSession.<E>selectList(command.getName(), param, rowBounds);
        } else {
          //没有分页则调用普通查询
          result = sqlSession.<E>selectList(command.getName(), param);
        }
        // issue #510 Collections & arrays support
        if (!method.getReturnType().isAssignableFrom(result.getClass())) {
          if (method.getReturnType().isArray()) {
            return convertToArray(result);
          } else {
            return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
          }
        }
        return result;
      }
      private <E> Object convertToDeclaredCollection(Configuration config, List<E> list) {
        Object collection = config.getObjectFactory().create(method.getReturnType());
        MetaObject metaObject = config.newMetaObject(collection);
        metaObject.addAll(list);
        return collection;
      }
      @SuppressWarnings("unchecked")
      private <E> E[] convertToArray(List<E> list) {
        E[] array = (E[]) Array.newInstance(method.getReturnType().getComponentType(), list.size());
        array = list.toArray(array);
        return array;
      }
      private <K, V> Map<K, V> executeForMap(SqlSession sqlSession, Object[] args) {
        Map<K, V> result;
        Object param = method.convertArgsToSqlCommandParam(args);
        if (method.hasRowBounds()) {
          RowBounds rowBounds = method.extractRowBounds(args);
          result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey(), rowBounds);
        } else {
          result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey());
        }
        return result;
      }
      public static class ParamMap<V> extends HashMap<String, V> {
        private static final long serialVersionUID = -2212268410512043556L;
        @Override
        public V get(Object key) {
          if (!super.containsKey(key)) {
            throw new BindingException("Parameter '" + key + "' not found. Available parameters are " + keySet());
          }
          return super.get(key);
        }
      }
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59
         60
         61
         62
         63
         64
         65
         66
         67
         68
         69
         70
         71
         72
         73
         74
         75
         76
         77
         78
         79
         80
         81
         82
         83
         84
         85
         86
         87
         88
         89
         90
         91
         92
         93
         94
         95
         96
         97
         98
         99
         100
         101
         102
         103
         104
         105
         106
         107
         108
         109
         110
         111
         112
         113
         114
         115
         116
         117
         118
         119
         120
         121
         122
         123
         124
         125
         126
         127
         128
         129
         130
         131
         132
         133
         134
         135
         136
         137
         138
         139
         140
         141
         142
         143
         144
         145
         146
         147
         148
         149
         150
         151
         152
         153
         154
         155
         156
         157

MapperMethod类里面有俩个成员：SqlCommand类和MethodSignature类。从名字上我们大概的能想到一个可能跟SQL语句有关系，一个可能跟要执行的方法有关系。事实也是如此。   
上面代码使用一个内部类SqlCommand来封装底层的增删改查操作，确切来讲这一部分的内容跟XxxMapper的XML配置文件里面的select节点、delete节点等有关。我们都会知道节点上有id属性值。那么MyBatis框架会把每一个节点(如：select节点、delete节点）生成一个MappedStatement类。要找到MappedStatement类就必须通过id来获得。有一个细节要注意：代码用到的id = 当前接口类 + XML文件的节点的ID属性。其源码如下：

//一个内部类 封装了具体执行的动作
      public static class SqlCommand { 
        //xml标签的id
        private final String name;
        //insert update delete select的具体类型
        private final SqlCommandType type;
        public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) throws BindingException {
          //拿到全名 比如 org.mybatis.example.BlogMapper.selectBlog
          String statementName = mapperInterface.getName() + "." + method.getName();
          MappedStatement ms = null;
          //获取MappedStatement对象 这个对象封装了XML当中一个标签的所有信息 比如下面
          //<select id="selectBlog" resultType="Blog">
          //select * from Blog where id = #{id}
          //</select>
          if (configuration.hasStatement(statementName)) {
            ms = configuration.getMappedStatement(statementName);
          } else if (!mapperInterface.equals(method.getDeclaringClass().getName())) { // 这里是一个BUG
            String parentStatementName = method.getDeclaringClass().getName() + "." + method.getName();
            if (configuration.hasStatement(parentStatementName)) {
              ms = configuration.getMappedStatement(parentStatementName);
            }
          }
          //为空抛出异常
          if (ms == null) {
            throw new BindingException("Invalid bound statement (not found): " + statementName);
          }
          name = ms.getId();
          type = ms.getSqlCommandType();
          //判断SQL标签类型 未知就抛异常
          if (type == SqlCommandType.UNKNOWN) {
            throw new BindingException("Unknown execution method for: " + name);
          }
        }
        public String getName() {
          return name;
        }
        public SqlCommandType getType() {
          return type;
        }
      }
      //内部类 封装了接口当中方法的 参数类型 返回值类型 等信息
      public static class MethodSignature { 
        //是否返回多调结果
        private final boolean returnsMany;
        //返回值是否是MAP
        private final boolean returnsMap;
        //返回值是否是VOID
        private final boolean returnsVoid;
        //返回值类型
        private final Class<?> returnType;
        //mapKey
        private final String mapKey;
        //resultHandler类型参数的位置
        private final Integer resultHandlerIndex;
        //rowBound类型参数的位置
        private final Integer rowBoundsIndex;
        //用来存放参数信息
        private final SortedMap<Integer, String> params;
        //是否存在命名参数
        private final boolean hasNamedParameters;
        //在这里对上面的属性进行初始化 就不一一详细说明了 具体实现细节可以看下面的代码。
        public MethodSignature(Configuration configuration, Method method) throws BindingException {
          this.returnType = method.getReturnType();
          this.returnsVoid = void.class.equals(this.returnType);
          this.returnsMany = (configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray());
          this.mapKey = getMapKey(method);
          this.returnsMap = (this.mapKey != null);
          this.hasNamedParameters = hasNamedParams(method);
          this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
          this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
          this.params = Collections.unmodifiableSortedMap(getParams(method, this.hasNamedParameters));
        }
        public Object convertArgsToSqlCommandParam(Object[] args) {
          final int paramCount = params.size();
          if (args == null || paramCount == 0) {
            return null;
          } else if (!hasNamedParameters && paramCount == 1) {
            return args[params.keySet().iterator().next()];
          } else {
            final Map<String, Object> param = new ParamMap<Object>();
            int i = 0;
            for (Map.Entry<Integer, String> entry : params.entrySet()) {
              param.put(entry.getValue(), args[entry.getKey()]);
              // issue #71, add param names as param1, param2...but ensure backward compatibility
              final String genericParamName = "param" + String.valueOf(i + 1);
              if (!param.containsKey(genericParamName)) {
                param.put(genericParamName, args[entry.getKey()]);
              }
              i++;
            }
            return param;
          }
        }
        public boolean hasRowBounds() {
          return (rowBoundsIndex != null);
        }
        public RowBounds extractRowBounds(Object[] args) {
          return (hasRowBounds() ? (RowBounds) args[rowBoundsIndex] : null);
        }
        public boolean hasResultHandler() {
          return (resultHandlerIndex != null);
        }
        public ResultHandler extractResultHandler(Object[] args) {
          return (hasResultHandler() ? (ResultHandler) args[resultHandlerIndex] : null);
        }
        public String getMapKey() {
          return mapKey;
        }
        public Class<?> getReturnType() {
          return returnType;
        }
        public boolean returnsMany() {
          return returnsMany;
        }
        public boolean returnsMap() {
          return returnsMap;
        }
        public boolean returnsVoid() {
          return returnsVoid;
        }
        private Integer getUniqueParamIndex(Method method, Class<?> paramType) {
          Integer index = null;
          final Class<?>[] argTypes = method.getParameterTypes();
          for (int i = 0; i < argTypes.length; i++) {
            if (paramType.isAssignableFrom(argTypes[i])) {
              if (index == null) {
                index = i;
              } else {
                throw new BindingException(method.getName() + " cannot have multiple " + paramType.getSimpleName() + " parameters");
              }
            }
          }
          return index;
        }
        private String getMapKey(Method method) {
          String mapKey = null;
          if (Map.class.isAssignableFrom(method.getReturnType())) {
            final MapKey mapKeyAnnotation = method.getAnnotation(MapKey.class);
            if (mapKeyAnnotation != null) {
              mapKey = mapKeyAnnotation.value();
            }
          }
          return mapKey;
        }
        private SortedMap<Integer, String> getParams(Method method, boolean hasNamedParameters) {
          final SortedMap<Integer, String> params = new TreeMap<Integer, String>();
          final Class<?>[] argTypes = method.getParameterTypes();
          for (int i = 0; i < argTypes.length; i++) {
            if (!RowBounds.class.isAssignableFrom(argTypes[i]) && !ResultHandler.class.isAssignableFrom(argTypes[i])) {
              String paramName = String.valueOf(params.size());
              if (hasNamedParameters) {
                paramName = getParamNameFromAnnotation(method, i, paramName);
              }
              params.put(i, paramName);
            }
          }
          return params;
        }
        private String getParamNameFromAnnotation(Method method, int i, String paramName) {
          final Object[] paramAnnos = method.getParameterAnnotations()[i];
          for (Object paramAnno : paramAnnos) {
            if (paramAnno instanceof Param) {
              paramName = ((Param) paramAnno).value();
            }
          }
          return paramName;
        }
        private boolean hasNamedParams(Method method) {
          boolean hasNamedParams = false;
          final Object[][] paramAnnos = method.getParameterAnnotations();
          for (Object[] paramAnno : paramAnnos) {
            for (Object aParamAnno : paramAnno) {
              if (aParamAnno instanceof Param) {
                hasNamedParams = true;
                break;
              }
            }
          }
          return hasNamedParams;
        }
      }
    }
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59
         60
         61
         62
         63
         64
         65
         66
         67
         68
         69
         70
         71
         72
         73
         74
         75
         76
         77
         78
         79
         80
         81
         82
         83
         84
         85
         86
         87
         88
         89
         90
         91
         92
         93
         94
         95
         96
         97
         98
         99
         100
         101
         102
         103
         104
         105
         106
         107
         108
         109
         110
         111
         112
         113
         114
         115
         116
         117
         118
         119
         120
         121
         122
         123
         124
         125
         126
         127
         128
         129
         130
         131
         132
         133
         134
         135
         136
         137
         138
         139
         140
         141
         142
         143
         144
         145
         146
         147
         148
         149
         150
         151
         152
         153
         154
         155
         156
         157
         158
         159
         160
         161
         162
         163
         164
         165
         166
         167
         168
         169
         170
         171
         172
         173
         174
         175
         176
         177
         178
         179
         180
         181
         182

看到这里的时候，我们就可以回头去找一找在什么时候增加了MappedStatement类。上面之所以可以执行是建立在XML配置信息都被加载进来了。所以MappedStatement类也一定是在加载配置的时候就进行的。请读者们自行查看一下MapperBuilderAssistant类的addMappedStatement方法——加深理解。SqlCommand类的name成员和type成员我们还是关注一下。name成员就是节点的ID，type成员表示查寻还是更新或是删除。至于MethodSignature类呢。他用于说明方法的一些信息，主要有返回信息。

[Mybatis_Mapper]: http://blog.csdn.net/xiaokang123456kao/article/details/66476828