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方法的呢？下一篇繼續分析......