mybatis源码解析8---执行mapper接口方法到执行mapper.xml的sql的过程

上一篇文章分析到mapper.xml中的sql标签对应的MappedStatement是如何初始化的，而之前也分析了Mapper接口是如何被加载的，那么问题来了，这两个是分别加载的到Configuration中的，那么问题来了，在使用过程中MappedStatement又是如何和加载的mapper接口进行关联的呢？本文将进行分析。

首先还是SqlSession接口的一个方法说起，也就是

<T> T getMapper(Class<T> type);

很显然这个方法是更加Class名获取该类的一个实例，而Mapper接口只定义了接口没有实现类，那么猜想可知返回的应该就是更加mapper.xml生成的实例了。具体是如何实现的呢， 先看下这个方法是如何实现的？

DefaultSqlSession实现该方法的代码如下：

 @Override
   public <T> T getMapper(Class<T> type) {
     return configuration.<T>getMapper(type, this);
   }

方法很简单，调用了Configuration对象的getMapper方法，那么接下来再看下Configuration里面是如何实现的。代码如下：

 public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
     return mapperRegistry.getMapper(type, sqlSession);
   }

调用了mapperRegistry的getMapper方法,参数分别是Class对象和sqlSession，再继续看MapperRegistry的实现，代码如下：

  @SuppressWarnings("unchecked")
     public <T> T getMapper(Class<T> type, SqlSession sqlSession)
     {
         // 从konwMappers获取MapperProxyFactory对象
         final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>)knownMappers.get(type);
         if (mapperProxyFactory == null)
         {
             throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
         }
         try
         {
             // 通过mapper代理工厂创建新实例
             return mapperProxyFactory.newInstance(sqlSession);
         }
         catch (Exception e)
         {
             throw new BindingException("Error getting mapper instance. Cause: " + e, e);
         }
     }

可以看出是根据type从knowMappers集合中获取该mapper的代理工厂类，如何通过该代理工厂新建一个实例。再看下代理工厂是如何创建实例的，代码如下:

  @SuppressWarnings("unchecked")
     protected T newInstance(MapperProxy<T> mapperProxy) {
         //通过代理获取mapper接口的新实例
       return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
     }

     public T newInstance(SqlSession sqlSession) {
       //创建mapper代理对象,调用newInstance方法
       final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
       return newInstance(mapperProxy);
     }

那么现在我们就知道是如何根据Mapper.class来获取Mapper接口的实例的了，不过，到目前为止貌似还是没有看到和MappedStatement产生联系啊，别急，再往下看通过代理产生的mapper实例执行具体的方法是如何进行的。代码如下：

 @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       //判断执行的方法是否是来自父类Object类的方法,也就是如toString、hashCode等方法
       //如果是则直接通过反射执行该方法,如果不是Object的方法则再往下走,如果不加这个判断会发生什么呢？
       //由于mapper接口除了定义的接口方法还包括继承于Object的方法,如果不加判断则会继续往下走,而下面的执行过程是从mapper.xml寻找对应的实现方法，
       //由于mapper.xml只实现了mapper中的接口方法,而没有toString和hashCode方法，从而就会导致这些方法无法被实现。
       if (Object.class.equals(method.getDeclaringClass())) {
         try {
           return method.invoke(this, args);
         } catch (Throwable t) {
           throw ExceptionUtil.unwrapThrowable(t);
         }
       }
       final MapperMethod mapperMethod = cachedMapperMethod(method);
       //执行mapperMethod对象的execute方法
       return mapperMethod.execute(sqlSession, args);
     }

     private MapperMethod cachedMapperMethod(Method method) {
       //从缓存中根据method对象获取MapperMethod对象
       MapperMethod mapperMethod = methodCache.get(method);
       if (mapperMethod == null) {
         //如果mapperMethod为空则新建MapperMethod方法
         mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
         methodCache.put(method, mapperMethod);
       }
       return mapperMethod;
     }

可以看出代理执行mapper接口的方法会先创建一个MapperMethod对象，然后执行execute方法，代码如下：

 public Object execute(SqlSession sqlSession, Object[] args) {
         Object result;
         if (SqlCommandType.INSERT == command.getType()) {//如果执行insert命令
           Object param = method.convertArgsToSqlCommandParam(args);//构建参数
           result = rowCountResult(sqlSession.insert(command.getName(), param));//调用sqlSession的insert方法
         } else if (SqlCommandType.UPDATE == command.getType()) {//如果执行update命令
           Object param = method.convertArgsToSqlCommandParam(args);//构建参数
           result = rowCountResult(sqlSession.update(command.getName(), param));//调用sqlSession的update方法
         } else if (SqlCommandType.DELETE == command.getType()) {//如果执行delete命令
           Object param = method.convertArgsToSqlCommandParam(args);//构建参数
           result = rowCountResult(sqlSession.delete(command.getName(), param));//调用sqlSession的delete方法
         } else if (SqlCommandType.SELECT == command.getType()) {//如果执行select命令
           if (method.returnsVoid() && method.hasResultHandler()) {//判断接口返回类型，更加返回数据类型执行对应的select语句
             executeWithResultHandler(sqlSession, args);
             result = null;
           } else if (method.returnsMany()) {
             result = executeForMany(sqlSession, args);
           } else if (method.returnsMap()) {
             result = executeForMap(sqlSession, args);
           } else if (method.returnsCursor()) {
             result = executeForCursor(sqlSession, args);
           } else {
             Object param = method.convertArgsToSqlCommandParam(args);
             result = sqlSession.selectOne(command.getName(), param);
           }
         } else if (SqlCommandType.FLUSH == command.getType()) {
             result = sqlSession.flushStatements();
         } else {
           throw new BindingException("Unknown execution method for: " + command.getName());
         }
         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;
       }

可以看出大致的执行过程就是更加MapperMethod的方法类型，然后构建对应的参数，然后执行sqlSession的方法。到现在还是没有MappedStatement的影子，再看看MapperMethod是被创建的。

   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, mapperInterface, method);
   }

这里涉及到了两个类SqlCommand和MethodSignature，先从SqlCommand看起。

 public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {
         String statementName = mapperInterface.getName() + "." + method.getName();//接口方法名
         MappedStatement ms = null;
         if (configuration.hasStatement(statementName)) {
             //从configuration中根据接口名获取MappedStatement对象
           ms = configuration.getMappedStatement(statementName);
         } else if (!mapperInterface.equals(method.getDeclaringClass())) { // issue #35
             //如果该方法不是该mapper接口的方法,则从mapper的父类中找寻该接口对应的MappedStatement对象
           String parentStatementName = method.getDeclaringClass().getName() + "." + method.getName();
           if (configuration.hasStatement(parentStatementName)) {
             ms = configuration.getMappedStatement(parentStatementName);
           }
         }
         if (ms == null) {
           if(method.getAnnotation(Flush.class) != null){
             name = null;
             type = SqlCommandType.FLUSH;
           } else {
             throw new BindingException("Invalid bound statement (not found): " + statementName);
           }
         } else {
           name = ms.getId();//设置name为MappedStatement的id，而id的值就是xml中对应的sql语句
           type = ms.getSqlCommandType();//设置type为MappedStatement的sql类型
           if (type == SqlCommandType.UNKNOWN) {
             throw new BindingException("Unknown execution method for: " + name);
           }
         }
       }

到这里终于是看到了MappedStatement的身影，根据mapper的Class对象和method对象从Configuration对象中获取指定的MappedStatement对象，然后根据MappedStatement对象的值初始化SqlCommand对象的属性。而MethodSignature则是sql语句的签名，主要作用就是对sql参数与返回结果类型的判断。

总结：

1、sqlSession调用configuration对象的getMapper方法，configuration调用mapperRegistry的getMapper方法

2、mapperRegistry根据mapper获取对应的Mapper代理工厂

3、通过mapper代理工厂创建mapper的代理

4、执行mapper方法时，通过代理调用，创建该mapper方法的MapperMethod对象

5、MapperMethod对象的创建是通过从configuration对象中获取指定的MappedStatement对象来获取具体的sql语句以及参数和返回结果类型

6、调用sqlSession对应的insert、update、delete和select方法执行mapper的方法

到目前为止知道了mapper接口和mapper.xml是如何进行关联的了，也知道mapper接口是如何获取实例的了，也知道了mapper方法最终会调用SqlSession的方法，那么SqlSession又是如何具体去执行每个Sql方法的呢？下一篇继续分析......