mybatis源码解析，一步一步从浅入深：映射代理类的获取

public class Configuration {
  //映射注册表
  protected MapperRegistry mapperRegistry = new MapperRegistry(this);

  // 获取映射注册表
  public MapperRegistry getMapperRegistry() {
    return mapperRegistry;
  }

  //添加到映射注册表
  public void addMappers(String packageName, Class<?> superType) {
    mapperRegistry.addMappers(packageName, superType);
  }
  //添加到映射注册表
  public void addMappers(String packageName) {
    mapperRegistry.addMappers(packageName);
  }
  //添加到映射注册表
  public <T> void addMapper(Class<T> type) {
    mapperRegistry.addMapper(type);
  }
  //从映射注册表中获取
  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }
  //判断映射注册表中是否存在
  public boolean hasMapper(Class<?> type) {
    return mapperRegistry.hasMapper(type);
  }
}

public class MapperRegistry {

  private Configuration config;
  //映射缓存 键：类对象，值：映射代理工厂
  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) {
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null)
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    try {
      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);
  }
  //添加到映射注册表
  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.
        // 处理接口类(例如UserDao)中的注解
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }

  /**
   * @since 3.2.2
   */
  //获取缓存中所有的Key,并且是不可修改的
  public Collection<Class<?>> getMappers() {
    return Collections.unmodifiableCollection(knownMappers.keySet());
  }

  /**
   * @since 3.2.2
   */
  //添加到映射注册表
  public void addMappers(String packageName, Class<?> superType) {
    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);
    }
  }

  /**
   * @since 3.2.2
   */
  //添加到映射注册表
  public void addMappers(String packageName) {
    addMappers(packageName, Object.class);
  }
}

private void bindMapperForNamespace() {
    //获取当前命名空间（String：com.zcz.learnmybatis.dao.UserDao）
    String namespace = builderAssistant.getCurrentNamespace();
    if (namespace != null) {
      Class<?> boundType = null;
      try {
        // 使用类加载器加载，加载类，获取类对象
        boundType = Resources.classForName(namespace);
      } catch (ClassNotFoundException e) {
        //ignore, bound type is not required
      }
      if (boundType != null) {
        //判断映射注册表中是否存在
        if (!configuration.hasMapper(boundType)) {
          // Spring may not know the real resource name so we set a flag
          // to prevent loading again this resource from the mapper interface
          // look at MapperAnnotationBuilder#loadXmlResource
          // 添加到已经解析的缓存
          configuration.addLoadedResource("namespace:" + namespace);
          // 添加到映射这测表
          configuration.addMapper(boundType);
        }
      }
    }
  }

 1 //添加到映射注册表
 2   public <T> void addMapper(Class<T> type) {
 3     if (type.isInterface()) {
 4       if (hasMapper(type)) {
 5         throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
 6       }
 7       boolean loadCompleted = false;
 8       try {
 9 　　　　　// 在这里，保存的是new MapperProxyFactory实例对象。
10         knownMappers.put(type, new MapperProxyFactory<T>(type));
11         // It's important that the type is added before the parser is run
12         // otherwise the binding may automatically be attempted by the
13         // mapper parser. If the type is already known, it won't try.
14         // 处理接口类(例如UserDao)中的注解
15         MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
16         parser.parse();
17         loadCompleted = true;
18       } finally {
19         if (!loadCompleted) {
20           knownMappers.remove(type);
21         }
22       }
23     }
24   }

 1 //从映射注册表中获取  
 2   @SuppressWarnings("unchecked")
 3   public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
 4     final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
 5     if (mapperProxyFactory == null)
 6       throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
 7     try {
 8       return mapperProxyFactory.newInstance(sqlSession);
 9     } catch (Exception e) {
10       throw new BindingException("Error getting mapper instance. Cause: " + e, e);
11     }
12   }

 1 //映射代理工厂  
 2 public class MapperProxyFactory<T> {
 3   // 接口类对象（UserDao.class）    
 4   private final Class<T> mapperInterface;
 5   // 对象中的方法缓存
 6   private Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();
 7 
 8   //构造器
 9   public MapperProxyFactory(Class<T> mapperInterface) {
10     //为接口类对象赋值
11     this.mapperInterface = mapperInterface;
12   }
13 
14   public Class<T> getMapperInterface() {
15     return mapperInterface;
16   }
17 
18   public Map<Method, MapperMethod> getMethodCache() {
19     return methodCache;
20   }
21   
22   // 实例化映射代理类
23   @SuppressWarnings("unchecked")
24   protected T newInstance(MapperProxy<T> mapperProxy) {
25     return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
26   }
27   
28   // 实例化映射代理类
29   public T newInstance(SqlSession sqlSession) {
30     final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
31     return newInstance(mapperProxy);
32   }
33 
34 }

 1 // 映射代理  
 2 public class MapperProxy<T> implements InvocationHandler, Serializable {
 3   private static final long serialVersionUID = -6424540398559729838L;
 4   private final SqlSession sqlSession;
 5   private final Class<T> mapperInterface;
 6   private final Map<Method, MapperMethod> methodCache;
 7   
 8   //构造方法
 9   public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
10     this.sqlSession = sqlSession;
11     this.mapperInterface = mapperInterface;
12     this.methodCache = methodCache;
13   }
14   //代理类调用的时候执行的方法
15   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
16     // 检查Method方法所在的类是否是Object
17     if (Object.class.equals(method.getDeclaringClass())) {
18       try {
19         return method.invoke(this, args);
20       } catch (Throwable t) {
21         throw ExceptionUtil.unwrapThrowable(t);
22       }
23     }
24     // 应用缓存
25     final MapperMethod mapperMethod = cachedMapperMethod(method);
26     //执行查询
27     return mapperMethod.execute(sqlSession, args);
28   }
29   
30   //应用缓存
31   private MapperMethod cachedMapperMethod(Method method) {
32     MapperMethod mapperMethod = methodCache.get(method);
33     if (mapperMethod == null) {
34       mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
35       methodCache.put(method, mapperMethod);
36     }
37     return mapperMethod;
38   }
39 }