Mybatis源码解析(七)：Mapper代理原理

Mybatis源码系列文章

手写源码（了解源码整体流程及重要组件）

Mybatis源码解析(一)：环境搭建

Mybatis源码解析(二)：全局配置文件的解析

Mybatis源码解析(三)：映射配置文件的解析

Mybatis源码解析(四)：sql语句及#{}、${}的解析

Mybatis源码解析(五)：SqlSession会话的创建

Mybatis源码解析(六)：缓存执行器操作流程

Mybatis源码解析(七)：查询数据库主流程

Mybatis源码解析(八)：Mapper代理原理

Mybatis源码解析(九)：插件机制

Mybatis源码解析(十)：一级缓存和二级缓存

---

---

前言

• 文章主要围绕着如下几个点，展开源码解析：
  • ；是如何进行解析的？
  • sqlSession.getMapper(UserMapper.class)；是如何生成的代理对象？
  • mapperProxy.findById(1)；是怎么完成的增删改查操作？

---

一、环境准备

• java代码

@Test
public void test2() throws IOException {

  // 1. 通过类加载器对配置文件进行加载，加载成了字节输入流，存到内存中 注意：配置文件并没有被解析
  InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");

  // 2. (1)解析了配置文件，封装configuration对象 （2）创建了DefaultSqlSessionFactory工厂对象
  SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

  // 3. (1)创建事务对象 （2）创建了执行器对象cachingExecutor (3)创建了DefaultSqlSession对象
  SqlSession sqlSession = sqlSessionFactory.openSession();

  // 4. JDK动态代理生成代理对象
  UserMapper mapperProxy = sqlSession.getMapper(UserMapper.class);

  // 5.代理对象调用方法
  User user = mapperProxy.findUserById(100);

  System.out.println("MyBatis源码环境搭建成功....");

  sqlSession.close();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

• 核心配置文件sqlMapConfig.xml

DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    
    <environments default="development">
        <environment id="development">
            
            <transactionManager type="JDBC"/>
            
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="123456789"/>
            dataSource>
        environment>
    environments>

    
    <mappers>
        
        
        
        
        
        
        
        <package name="com.xc.mapper"/>
    mappers>
configuration>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

• 实体映射配置文件UserMapper.xml

DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xc.mapper.UserMapper">
    <select id="findUserById" parameterType="int" resultType="com.xc.pojo.User"  >
        SELECT id,username FROM  user WHERE id = #{id}
    select>
mapper>
1
2
3
4
5
6
7
8
9

二、引入映射配置文件方式

先说个结论，后续源码验证：如果不指定xml，则会在Mapper接口同目录下寻找

• 方式一： 指定xml，缺点需要每个映射xml都要手动添加
• 方式二： 没有指定xml，会从同目录下寻找xml，缺点也是需要每个Mapper接口都要手动添加
• 方式三： 没有指定xml，会从同目录下寻找xml，会遍历此包下所有Mappe接口

三、标签的解析

• 为什么单独讲这个标签？
  1. 这个标签是多种引入映射文件的最佳选，也是工作中必用的
  2. 创建代理类工厂，为以后通过Mapper接口类生成代理实现类做准备
• 标签在核心配置文件的标签下
• 方式一也会创建代理类工厂，不过是在解析xml文件后，方式三是先创建代理类工厂，再解析xml
• Mybatis源码解析(三)：映射配置文件的解析：这篇单独讲了指定配置文件的解析

进入解析标签方法

• 子标签的解析在Mybatis源码解析(三)：映射配置文件的解析里详细讲了，这里讲下子标签的解析
• 获取包名，调用addMappers方法

private void mapperElement(XNode parent) throws Exception {
  if (parent != null) {
    // 获取标签的子标签
    for (XNode child : parent.getChildren()) {
      // 子标签
      if ("package".equals(child.getName())) {
        // 获取mapper接口和mapper映射文件对应的package包名
        String mapperPackage = child.getStringAttribute("name");
        // 将包下所有的mapper接口以及它的代理工厂对象存储到一个Map集合中，key为mapper接口类型，value为代理对象工厂
        configuration.addMappers(mapperPackage);
      } else {// 子标签
        // 获取子标签的resource属性
        String resource = child.getStringAttribute("resource");
        // 获取子标签的url属性
        String url = child.getStringAttribute("url");
        // 获取子标签的class属性
        String mapperClass = child.getStringAttribute("class");
        // 它们是互斥的
        if (resource != null && url == null && mapperClass == null) {
          ErrorContext.instance().resource(resource);
          try(InputStream inputStream = Resources.getResourceAsStream(resource)) {
            // 专门用来解析mapper映射文件
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            // 通过XMLMapperBuilder解析mapper映射文件
            mapperParser.parse();
          }
        } else if (resource == null && url != null && mapperClass == null) {
          ErrorContext.instance().resource(url);
          try(InputStream inputStream = Resources.getUrlAsStream(url)){
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            // 通过XMLMapperBuilder解析mapper映射文件
            mapperParser.parse();
          }
        } else if (resource == null && url == null && mapperClass != null) {
          Class<?> mapperInterface = Resources.classForName(mapperClass);
          // 将指定mapper接口以及它的代理对象存储到一个Map集合中，key为mapper接口类型，value为代理对象工厂
          configuration.addMapper(mapperInterface);
        } else {
          throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
        }
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

进入configuration的addMappers方法

public void addMappers(String packageName) {
  mapperRegistry.addMappers(packageName);
}
1
2
3

• mapperRegistry对象中核心属性就是knownMappers
  • key：Mapper接口的Class对象
  • value：Mapper接口代理类工厂

public class MapperRegistry {

  private final Configuration config;
  private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();
  ...
}
1
2
3
4
5
6

进入mapperRegistry的addMappers方法

public void addMappers(String packageName) {
  addMappers(packageName, Object.class);
}
1
2
3

1、通过包路径获取Mapper接口

• resolverUtil.find方法：加载包路径下Mapper接口
• mapperSet：mapper接口Class对象集合
• addMapper方法：将Mapper接口添加到上面所说的Map集合knownMappers中

public void addMappers(String packageName, Class<?> superType) {
  ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
  // 根据package名称，加载该包下Mapper接口文件（不是映射文件）
  resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
  // 获取加载的Mapper接口
  Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
  for (Class<?> mapperClass : mapperSet) {
    // 将Mapper接口添加到MapperRegistry中
    addMapper(mapperClass);
  }
}
1
2
3
4
5
6
7
8
9
10
11

resolverUtil.find方法

• getPackagePath方法：将包名-com.xc.mapper转换为资源路径-com/xc/mapper(.替换成/)
• children：获取资源路径下的资源，如下
  
• addIfMatching方法：将Mapper接口的Class对象添加到matches集合中

public ResolverUtil<T> find(Test test, String packageName) {
  String path = getPackagePath(packageName);

  try {
    List<String> children = VFS.getInstance().list(path);
    for (String child : children) {
      if (child.endsWith(".class")) {
        addIfMatching(test, child);
      }
    }
  } catch (IOException ioe) {
    log.error("Could not read package: " + packageName, ioe);
  }

  return this;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

resolverUtil.getClasses()

private Set<Class<? extends T>> matches = new HashSet<>();
...  
public Set<Class<? extends T>> getClasses() {
  return matches;
}
1
2
3
4
5

addMapper方法

• 循环遍历matches集合，将所有Mapper接口Class对象添加到knownMappers
  • key：Mapper接口的Class对象
  • value：Mapper接口代理类工厂
• 创建注解解析Builder，调用parse解析方法(xml的解析也包含在内)

public <T> void addMapper(Class<T> type) {
  if (type.isInterface()) {
    // 如果Map集合中已经有该mapper接口的映射，就不需要再存储了
    if (hasMapper(type)) {
      throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
    }
    boolean loadCompleted = false;
    try {
      // 将mapper接口以及它的代理对象存储到一个Map集合中，key为mapper接口类型，value为代理对象工厂
      knownMappers.put(type, new MapperProxyFactory<>(type));
      // 用来解析注解方式的mapper接口
      MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
      // 解析注解方式的mapper接口
      parser.parse();
      loadCompleted = true;
    } finally {
      if (!loadCompleted) {
        knownMappers.remove(type);
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2、注解方式mapper接口的解析

• loadXmlResource方法：xml文件的解析
• parseStatement方法：原理其实和Mybatis源码解析(三)：映射配置文件的解析差不多
  • 不同点：xml解析标签内的属性，注解解析@select注解里的属性
    相同点：最终目的都是解析成MappedStatement对象

    public void parse() {
      // 获取mapper接口的全路径
      String resource = type.toString();
      // 是否解析过该mapper接口
      if (!configuration.isResourceLoaded(resource)) {
        // 先解析mapper映射文件
        loadXmlResource();
        // 设置解析标识
        configuration.addLoadedResource(resource);
        assistant.setCurrentNamespace(type.getName());
        // 解析CacheNamespace注解
        parseCache();
        // 解析CacheNamespaceRef注解
        parseCacheRef();
        for (Method method : type.getMethods()) {
          if (!canHaveStatement(method)) {
            continue;
          }
          if (getAnnotationWrapper(method, false, Select.class, SelectProvider.class).isPresent()
              && method.getAnnotation(ResultMap.class) == null) {
            parseResultMap(method);
          }
          try {
            // 每个mapper接口中的方法，都解析成MappedStatement对象
            parseStatement(method);
          } catch (IncompleteElementException e) {
            configuration.addIncompleteMethod(new MethodResolver(this, method));
          }
        }
      }
      parsePendingMethods();
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32

    3、xml和mapper接口需要同包同名的原因？

    进入上步骤的xml解析方法loadXmlResource方法

    • type：Mapper接口的Class对象
    • 通过Mapper接口名字(com.xc.UserMapper)，.替换/转换成资源路径，再添加后缀.xml获取mapper对应的xml
    • 通过资源路径加载为输入流
    • 然后创建xml解析Builder对象，再调用解析方法，就是Mybatis源码解析(三)：映射配置文件的解析的内容了

    private void loadXmlResource() {
      if (!configuration.isResourceLoaded("namespace:" + type.getName())) {
        String xmlResource = type.getName().replace('.', '/') + ".xml";
        // #1347
        InputStream inputStream = type.getResourceAsStream("/" + xmlResource);
        if (inputStream == null) {
          // Search XML mapper that is not in the module but in the classpath.
          try {
            inputStream = Resources.getResourceAsStream(type.getClassLoader(), xmlResource);
          } catch (IOException e2) {
            // ignore, resource is not required
          }
        }
        if (inputStream != null) {
          XMLMapperBuilder xmlParser = new XMLMapperBuilder(inputStream, assistant.getConfiguration(), xmlResource, configuration.getSqlFragments(), type.getName());
          xmlParser.parse();
        }
      }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19

    四、Mapper接口代理对象的生成

    sqlSession.getMapper(UserMapper.class)通过Mapper接口Class对象生成代理对象

    • 其实就是通过Mapper接口Class对象，获取上面说的接口代理类工厂
    • 代理类工厂调用.newInstance创建接口代理类

    @Override
    public <T> T getMapper(Class<T> type) {
      // 从Configuration对象中，根据Mapper接口，获取Mapper代理对象
      return configuration.getMapper(type, this);
    }
    1
    2
    3
    4
    5

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

    public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
      // 根据Mapper接口的类型，从Map集合中获取Mapper代理对象工厂
      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生产MapperProxy，通过MapperProxy产生Mapper代理对象
        return mapperProxyFactory.newInstance(sqlSession);
      } catch (Exception e) {
        throw new BindingException("Error getting mapper instance. Cause: " + e, e);
      }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

    进入newInstance方法

    • Proxy.newProxyInstance：jdk动态代理，Mapper接口的代理类，从这里创建
    • 代理方法第三个参数是InvocationHandler的实现类，invoke方法就是代理类实现接口类方法的内容

    public T newInstance(SqlSession sqlSession) {
      // InvocationHandler接口的实现类
      final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
      return newInstance(mapperProxy);
    }
    
    protected T newInstance(MapperProxy<T> mapperProxy) {
      // 使用JDK动态代理方式，生成代理对象
      return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

    五、代理对象执行接口方法的流程

    根据jdk动态代理可知，调用接口方法则会进入invoke方法，里面会有接口方法的实现内容

    • 如果是Object定义方法，则MapperProxy类直接调用方法
    • mapperProxy.findUserById(100)：代理类调用接口方法，debug则会进入invoke方法

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      try {
        // 如果是 Object 定义的方法，直接调用
        if (Object.class.equals(method.getDeclaringClass())) {
          return method.invoke(this, args);
        } else {
          // 代理逻辑在这
          return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
        }
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14

    进入cachedInvoker(method).invoke方法(代理逻辑)

    • command.getType()：增删改查类型标记
    • command.getName()：statementId(namespace:id)
    • sqlSession.selectOne(command.getName(), param)：Mybatis源码解析(六)：查询数据库主流程
    • sqlSession.insert、sqlSession.update、sqlSession.delete调用方法相同，都是executor.update，所有xml中三个标签的作用一样，只是为了看上去区分一下

    @Override
    public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
      return mapperMethod.execute(sqlSession, args);
    }
    1
    2
    3
    4

    public Object execute(SqlSession sqlSession, Object[] args) {
      Object result;
      // 判断mapper中的方法类型
      switch (command.getType()) {
        // 添加
        case INSERT: {
          // 转换参数
          Object param = method.convertArgsToSqlCommandParam(args);
          // 最终调用的还是sqlSession中的方法
          result = rowCountResult(sqlSession.insert(command.getName(), param));
          break;
        }
        // 更新
        case UPDATE: {
          Object param = method.convertArgsToSqlCommandParam(args);
          result = rowCountResult(sqlSession.update(command.getName(), param));
          break;
        }
        // 删除
        case DELETE: {
          Object param = method.convertArgsToSqlCommandParam(args);
          result = rowCountResult(sqlSession.delete(command.getName(), param));
          break;
        }
        // 查询
        case SELECT:
           // 无返回结果,并且有ResultHandler方法参数，将查询结果交给ResultHandler进行处理
          if (method.returnsVoid() && method.hasResultHandler()) {
            executeWithResultHandler(sqlSession, args);
            result = null;
            // 执行查询、返回列表
          } else if (method.returnsMany()) {
            result = executeForMany(sqlSession, args);
            // 执行查询、返回Map
          } else if (method.returnsMap()) {
            result = executeForMap(sqlSession, args);
            // 执行查询、返回Cursor
          } else if (method.returnsCursor()) {
            result = executeForCursor(sqlSession, args);
          } else {
            // 转换参数
            Object param = method.convertArgsToSqlCommandParam(args);
            // 查询单条
            result = sqlSession.selectOne(command.getName(), param);
            if (method.returnsOptional()
                && (result == null || !method.getReturnType().equals(result.getClass()))) {
              result = Optional.ofNullable(result);
            }
          }
          break;
        case FLUSH:
          result = sqlSession.flushStatements();
          break;
        default:
          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;
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62

    补充说明下SqlCommand: command对象

    • 通过接口方法名获取对应xml的MappedStatement对象(每一个赠送改查标签对应一个)，这里也说明了为啥接口名要与
    标签内的id一致，就是通过方法名匹配标签id获取MappedStatement
  • command.getType()：是标签解析出增删改查类型
    command.getName()：MappedStatement的id，statementId

    public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {
      // 当前调用的方法名称
      final String methodName = method.getName();
      // 当前执行的方法对应的Class
      final Class<?> declaringClass = method.getDeclaringClass();
      // 获取对应的MappedStatement
      MappedStatement ms = resolveMappedStatement(mapperInterface, methodName, declaringClass,
          configuration);
      if (ms == null) {
        if (method.getAnnotation(Flush.class) != null) {
          name = null;
          type = SqlCommandType.FLUSH;
        } else {
          throw new BindingException("Invalid bound statement (not found): "
              + mapperInterface.getName() + "." + methodName);
        }
      } else {
        name = ms.getId();
        type = ms.getSqlCommandType();
        if (type == SqlCommandType.UNKNOWN) {
          throw new BindingException("Unknown execution method for: " + name);
        }
      }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24

    ---

    总结

    • 标签配置的包名下的Mapper接口文件都会被加载成对应的代理类工厂
    • 通过Mapper接口获取同包同名的xml文件，并解析
    • Mapper接口通过jdk代理创建代理类，接口方法匹配xml中标签的id值，执行增删改查
    相关阅读:
    Intel FPGA的JESD204B例程的搭建
    生意不好如何逆风翻盘 | 多门店经营必读技巧（1）：导购管理 连锁店管理的技巧 连锁店生意经 如何做导购管理
    期货交易需要多大的本钱？仓位怎么分配？
    无题之2
    Quantlab整合Alpha158因子集，为机器学习大类资产配置策略做准备（代码+数据）
    传智教育|git实战技巧-本地刚做出的修改、暂存和提交如何进行撤销
    Node.js 支付宝支付
    恢复受感染的数据：如何应对.360勒索病毒的策略
    sql 分页查询 order by和group by一起使用导致排序失效问题解决
    Hibernate 一对多关系映射
    
    原文地址：https://blog.csdn.net/qq_35512802/article/details/128086834
    • 最新文章
    • 攻防演习之三天拿下官网站群
      数据安全治理学习——前期安全规划和安全管理体系建设
      企业安全 | 企业内一次钓鱼演练准备过程
      内网渗透测试 | Kerberos协议及其部分攻击手法
      0day的产生 | 不懂代码的"代码审计"
      安装scrcpy-client模块av模块异常，环境问题解决方案
      leetcode hot100【LeetCode 279. 完全平方数】java实现
      OpenWrt下安装Mosquitto
      AnatoMask论文汇总
      【AI日记】24.11.01 LangChain、openai api和github copilot
      

    • 热门文章
    • 十款代码表白小特效 一个比一个浪漫 赶紧收藏起来吧！！！
      奉劝各位学弟学妹们，该打造你的技术影响力了！
      五年了，我在 CSDN 的两个一百万。
      Java俄罗斯方块，老程序员花了一个周末，连接中学年代！
      面试官都震惊，你这网络基础可以啊！
      你真的会用百度吗？我不信 — 那些不为人知的搜索引擎语法
      心情不好的时候，用 Python 画棵樱花树送给自己吧
      通宵一晚做出来的一款类似CS的第一人称射击游戏Demo！原来做游戏也不是很难，连憨憨学妹都学会了！
      13 万字 C 语言从入门到精通保姆级教程2021 年版
      10行代码集2000张美女图，Python爬虫120例，再上征途