这里主要是说动态代理的方式来进行流程的，基本上前三个步骤都是一样的，不会有什么变化，重点在解析配置文件那一步，要知道代理类是什么时候加载的。

  1. // 还是那个parse方法，重点在于 parseConfiguration 里面的 mapperElement 方法
  2. private void mapperElement(XNode parent) throws Exception {
  3.     if (parent != null) {
  4.         for (XNode child : parent.getChildren()) {
  5.             if ("package".equals(child.getName())) {
  6.                 String mapperPackage = child.getStringAttribute("name");
  7.                 configuration.addMappers(mapperPackage);
  8.             } 
  9.             。。。。。// 忽略其它代码
  10.             }
  11.     }
  12. }
  14. // addMappers 找到最终的实现类
  15. public <T> void addMapper(Class<T> type) {
  16.     if (type.isInterface()) {
  17.         if (hasMapper(type)) {
  18.             throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
  19.         }
  20.         boolean loadCompleted = false;
  21.         try {
  22.             knownMappers.put(type, new MapperProxyFactory<>(type));
  23.             // It's important that the type is added before the parser is run
  24.             // otherwise the binding may automatically be attempted by the
  25.             // mapper parser. If the type is already known, it won't try.
  26.             MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
  27.             parser.parse();
  28.             loadCompleted = true;
  29.         } finally {
  30.             if (!loadCompleted) {
  31.                 knownMappers.remove(type);
  32.             }
  33.         }
  34.     }
  35. }
  37. // 关于 knowMappers 的声明
  38. private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();
  40. // 也就是说一个接口对应了一个 MapperProxyFactory

上面是额外说的内容，方面下面获取代理对象的说明

  1. // getMappers 方法继续向下找
  2. public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  3.     return mapperRegistry.getMapper(type, sqlSession);
  4. }
  6. public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  7.     final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
  8.     if (mapperProxyFactory == null) {
  9.         throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
  10.     }
  11.     try {
  12.         return mapperProxyFactory.newInstance(sqlSession);
  13.     } catch (Exception e) {
  14.         throw new BindingException("Error getting mapper instance. Cause: " + e, e);
  15.     }
  16. }
  18. protected T newInstance(MapperProxy<T> mapperProxy) {
  19.     return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  20. }
  22. public T newInstance(SqlSession sqlSession) {
  23.     final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
  24.     return newInstance(mapperProxy);
  25. }
  27. // 这里要知道生成代理对象，主要是哪个类的代理，后续执行方法都是执行该类的invoke方法，很明显，是 MapperProxy 代理

invoke方法

  1. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  2.     try {
  3.         if (Object.class.equals(method.getDeclaringClass())) {
  4.             return method.invoke(this, args);
  5.         } else {
  6.             return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
  7.         }
  8.     } catch (Throwable t) {
  9.         throw ExceptionUtil.unwrapThrowable(t);
  10.     }
  11. }
  13. // cachedInvoker
  14. private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
  15.     try {
  16.         // A workaround for https://bugs.openjdk.java.net/browse/JDK-8161372
  17.         // It should be removed once the fix is backported to Java 8 or
  18.         // MyBatis drops Java 8 support. See gh-1929
  19.         MapperMethodInvoker invoker = methodCache.get(method);
  20.         if (invoker != null) {
  21.             return invoker;
  22.         }
  24.         return methodCache.computeIfAbsent(method, m -> {
  25.             if (m.isDefault()) {
  26.                 try {
  27.                     if (privateLookupInMethod == null) {
  28.                         return new DefaultMethodInvoker(getMethodHandleJava8(method));
  29.                     } else {
  30.                         return new DefaultMethodInvoker(getMethodHandleJava9(method));
  31.                     }
  32.                 } catch (IllegalAccessException | InstantiationException | InvocationTargetException
  33.                          | NoSuchMethodException e) {
  34.                     throw new RuntimeException(e);
  35.                 }
  36.             } else {
  37.                 // 这里是重点
  38.                 return new PlainMethodInvoker(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
  39.             }
  40.         });
  41.     } catch (RuntimeException re) {
  42.         Throwable cause = re.getCause();
  43.         throw cause == null ? re : cause;
  44.     }
  45. }
  46. // 最后寻找到 PlainMethodInvoker invoke方法
  47. @Override
  48. public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
  49.     return mapperMethod.execute(sqlSession, args);
  50. }
  52. // 最终执行的executor方法
  53. public Object execute(SqlSession sqlSession, Object[] args) {
  54.     Object result;
  55.     switch (command.getType()) {
  56.         case INSERT: {
  57.             Object param = method.convertArgsToSqlCommandParam(args);
  58.             result = rowCountResult(sqlSession.insert(command.getName(), param));
  59.             break;
  60.         }
  61.         case UPDATE: {
  62.             Object param = method.convertArgsToSqlCommandParam(args);
  63.             result = rowCountResult(sqlSession.update(command.getName(), param));
  64.             break;
  65.         }
  66.         case DELETE: {
  67.             Object param = method.convertArgsToSqlCommandParam(args);
  68.             result = rowCountResult(sqlSession.delete(command.getName(), param));
  69.             break;
  70.         }
  71.         case SELECT:
  72.             if (method.returnsVoid() && method.hasResultHandler()) {
  73.                 executeWithResultHandler(sqlSession, args);
  74.                 result = null;
  75.             } else if (method.returnsMany()) {
  76.                 result = executeForMany(sqlSession, args);
  77.             } else if (method.returnsMap()) {
  78.                 result = executeForMap(sqlSession, args);
  79.             } else if (method.returnsCursor()) {
  80.                 result = executeForCursor(sqlSession, args);
  81.             } else {
  82.                 Object param = method.convertArgsToSqlCommandParam(args);
  83.                 result = sqlSession.selectOne(command.getName(), param);
  84.                 if (method.returnsOptional()
  85.                     && (result == null || !method.getReturnType().equals(result.getClass()))) {
  86.                     result = Optional.ofNullable(result);
  87.                 }
  88.             }
  89.             break;
  90.         case FLUSH:
  91.             result = sqlSession.flushStatements();
  92.             break;
  93.         default:
  94.             throw new BindingException("Unknown execution method for: " + command.getName());
  95.     }
  96.     if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
  97.         throw new BindingException("Mapper method '" + command.getName()
  98.                                    + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
  99.     }
  100.     return result;
  101. }

可以看到最后还是执行的是sqlSession的方法。