MyBatis源码解析（四）：初始化Mapper

女爷i 2022-02-26 14:22 441阅读 0赞

前沿：在[MyBatis源码解析（三）：初始化SqlSession][MyBatis_SqlSession]博客中，已经对 openSession() 底层进行解析，并获取到 SqlSession 对象；接着，需要通过 SqlSession.getMapper()，获取 Mapper 的代理对象去执行 Statement，getMapper()分析会与之前已经分析过的addMapper() 相比较进行分析，以确保流程清晰，具体 addMapper() 流程可参考[MyBatis源码解析（二）：初始化SqlSessionFactory][MyBatis_SqlSessionFactory]

一，初始化 Mapper 流程图

1，流程图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE5NzYzODg_size_16_color_FFFFFF_t_70][]

2，流程解析

\* 在 SqlSessionFactory 解析中，MyBatis会将配置文件解析到的 Mapper 文件添加到 Configuration对象中，Configuration对调用 MapperRegistery 对象保存 Mapper 实例其内部一 Map 容器中；

\* getMapper()时，会根据上一步 addMapper()，相同方式走一遍 getMapper()流程，并最终通过JDK动态代理初始化代理对象

二，初始化步骤

1，获取 Mapper 实例

\* 通过 DefaultSqlSession 来 getMapper()

UserMapper mapper = sqlSession.getMapper(UserMapper.class);

\* DefaultSqlSession 从 Configuration 中 getMapper()

@Override
      public <T> T getMapper(Class<T> type) {
        // 触发Mapper获取, 从Configuration配置对象中获取Mapper
        // 在初始化配置信息时, Configuration.addMapper会调用MapperRegistery存储Mapper到Map容器中
        // 存储过程可以参考前一篇博客, 初始化SqlSessionFactory
        return configuration.<T>getMapper(type, this);
      }

\* Configuration 从 MapperRegistery 中 getMapper()

-- 初始化 SqlSessionFactory 时， 通过调用 addMapper() 已经存储 Mapper 到 MapperRegistery 中

public <T> void addMapper(Class<T> type) {
        // 存储时调用MapperRegistry存储
        mapperRegistry.addMapper(type);
      }

-- getMapper() 时，同样根据 MapperRegistery 进行获取

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
        // 获取时同样调用MapperRegistry进行获取
        return mapperRegistry.getMapper(type, sqlSession);
      }

\* MapperRegistery 根据传递的 Mapper 类型从 Map 容器中获取已经初始化的 MapperProxyFactory 对象

-- 初始化 SqlSessionFactory 时，已经添加 Mapper 映射到 Map容器中，并初始化 MapperProxyFactory 传递了 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 {
            // 添加Mapper将Mapper添加到Map容器中, 并初始化value为MapperProxyFactory
            // 此时MapperProxyFactory初始化已经传递Mapper类型到工厂类中
            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);
            }
          }
        }
      }

-- getMapper()时，直接从 MapperRegistery 的 Map容器中根据类型，获取 Mapper 的对应 MapperProxyFactory 对象，并进行初始化

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
        // 从Map容器中获取该对象, 获取初始化的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 {
          // 从MapperProxyFactory中实例化一个Mapper代理对象
          return mapperProxyFactory.newInstance(sqlSession);
        } catch (Exception e) {
          throw new BindingException("Error getting mapper instance. Cause: " + e, e);
        }
      }

2，通过JDK动态代理初始化代理对象

\* 从上一步获取的 MapperProxyFactory 中初始化实例

public T newInstance(SqlSession sqlSession) {
        // 初始化MapperProxy, 该类为InvocationHandler实现类, 动态代理最终执行该类的Invoke方法
        // mapperInterface 在初始化传递过程中已经初始化为当前Mapper类型
        // methodCache可以理解为statement缓存容器, 实例为ConcurrentHashMap
        final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
        return newInstance(mapperProxy);
      }

\* 调用JDK动态代理最终生成 Mapper 代理对象并返回

protected T newInstance(MapperProxy<T> mapperProxy) {
        // 通过JDK动态代理方式, 生成Mapper的代理对象,
        return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
      }

[MyBatis_SqlSession]: https://blog.csdn.net/u011976388/article/details/88904251
[MyBatis_SqlSessionFactory]: https://blog.csdn.net/u011976388/article/details/88903330
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE5NzYzODg_size_16_color_FFFFFF_t_70]: /images/20220226/726a95a9e31a4f66805d6f2b629a3383.png