MyBatis源码解析(二)——动态代理实现函数调用

如果我们要使用MyBatis进行数据库操作的话,大致要做两件事情: 1. 定义DAO接口 在DAO接口中定义需要进行的数据库操作。 2. 创建映射文件 当有了DAO接口后,还需要为该接口创建映射文件。映射文件中定义了一系列SQL语句,这些SQL语句和DAO接口一一对应。

MyBatis在初始化的时候会将映射文件与DAO接口一一对应,并根据映射文件的内容为每个函数创建相应的数据库操作能力。而我们作为MyBatis使用者,只需将DAO接口注入给Service层使用即可。 那么MyBatis是如何根据映射文件为每个DAO接口创建具体实现的?答案是——动态代理。 下面进入正题。


首先来回顾一项MyBatis在初始化过程中所做的事情。 MyBatis在初始化过程中,首先会读取我们的配置文件流程,并使用XMLConfigBuilder来解析配置文件。XMLConfigBuilder会依次解析配置文件中的各个子节点,如:<settings><typeAliases><mappers>等。这些子节点在解析完成后都会被注册进configuration对象。然后configuration对象将作为参数,创建SqlSessionFactory对象。至此,初始化过程完毕! 下面我们重点分析<mapper>节点解析的过程。

PS:MyBatis详细的初始化过程请移步至:MyBatis源码解析(一)——MyBatis初始化过程解析


节点解析过程

XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
mapperParser.parse();

由上述代码可知,解析mapper节点的解析是由XMLMapperBuilder类的parse()函数来完成的,下面我们就详细看一下parse()函数。

  public void parse() {
    // 若当前Mapper.xml尚未加载,则加载
    if (!configuration.isResourceLoaded(resource)) {
      // 解析<mapper>节点
      configurationElement(parser.evalNode("/mapper"));
      // 将当前Mapper.xml标注为『已加载』(下回就不用再加载了)
      configuration.addLoadedResource(resource);
      // 【关键】将Mapper Class添加至Configuration中
      bindMapperForNamespace();
    }

    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
  }

这个函数主要做了两件事: 1. 解析<mapper>节点,并将解析结果注册进configuration中; 2. 将当前映射文件所对应的DAO接口的Class对象注册进configuration中 这一步极为关键!是为了给DAO接口创建代理对象,下文会详细介绍。

下面再进入bindMapperForNamespace()函数,看一看它做了什么:

  private void bindMapperForNamespace() {
    // 获取当前映射文件对应的DAO接口的全限定名
    String namespace = builderAssistant.getCurrentNamespace();
    if (namespace != null) {
      // 将全限定名解析成Class对象
      Class<?> boundType = null;
      try {
        boundType = Resources.classForName(namespace);
      } catch (ClassNotFoundException e) {
      }
      if (boundType != null) {
        if (!configuration.hasMapper(boundType)) {
          // 将当前Mapper.xml标注为『已加载』(下回就不用再加载了)
          configuration.addLoadedResource("namespace:" + namespace);
          // 将DAO接口的Class对象注册进configuration中
          configuration.addMapper(boundType);
        }
      }
    }
  }

这个函数主要做了两件事: 1. 将<mapper>节点上定义的namespace属性(即:当前映射文件所对应的DAO接口的权限定名)解析成Class对象 2. 将该Class对象存储在configuration对象的MapperRegistry容器中。

可以看一下MapperRegistry

public class MapperRegistry {
  private final Configuration config;
  private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>();
}

MapperRegistry有且仅有两个属性:ConfigurationknownMappers。 其中,knownMappers的类型为Map<Class<?>, MapperProxyFactory<?>>,由此可见,它是一个Map,key为DAO接口的Class对象,而Value为该DAO接口代理对象的工厂。 那么,这个代理对象工厂是何许人也?它又是如何产生的呢?我们先来看一下MapperRegistryaddMapper()函数。

  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 {
        // 创建MapperProxyFactory对象,并put进knownMappers中
        knownMappers.put(type, new MapperProxyFactory<T>(type));
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }

从这个函数可知,MapperProxyFactory是在这里创建,并put进knownMappers中的。 下面我们就来看一下MapperProxyFactory这个类究竟有些啥:

public class MapperProxyFactory<T> {

  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();

  public MapperProxyFactory(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }

  public Class<T> getMapperInterface() {
    return mapperInterface;
  }

  public Map<Method, MapperMethod> getMethodCache() {
    return methodCache;
  }

  @SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }
}

这个类有三个重要成员: 1. mapperInterface属性 这个属性就是DAO接口的Class对象,当创建MapperProxyFactory对象的时候需要传入 2. methodCache属性 这个属性用于存储当前DAO接口中所有的方法。 3. newInstance函数 这个函数用于创建DAO接口的代理对象,它需要传入一个MapperProxy对象作为参数。而MapperProxy类实现了InvocationHandler接口,由此可知它是动态代理中的处理类,所有对目标函数的调用请求都会先被这个处理类截获,所以可以在这个处理类中添加目标函数调用前、调用后的逻辑。


DAO函数调用过程

当MyBatis初始化完毕后,configuration对象中存储了所有DAO接口的Class对象和相应的MapperProxyFactory对象(用于创建DAO接口的代理对象)。接下来,就到了使用DAO接口中函数的阶段了。

SqlSession sqlSession = sqlSessionFactory.openSession();
try {
    ProductMapper productMapper = sqlSession.getMapper(ProductMapper.class);
    List<Product> productList = productMapper.selectProductList();
    for (Product product : productList) {
        System.out.printf(product.toString());
    }
} finally {
    sqlSession.close();
}

我们首先需要从sqlSessionFactory对象中创建一个SqlSession对象,然后调用sqlSession.getMapper(ProductMapper.class)来获取代理对象。 我们先来看一下sqlSession.getMapper()是如何创建代理对象的?

  public <T> T getMapper(Class<T> type) {
    return configuration.<T>getMapper(type, this);
  }

sqlSession.getMapper()调用了configuration.getMapper(),那我们再看一下configuration.getMapper()

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

configuration.getMapper()又调用了mapperRegistry.getMapper(),那好,我们再深入看一下mapperRegistry.getMapper()

  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);
    }
  }

看到这里我们就恍然大悟了,原来它根据上游传递进来DAO接口的Class对象,从configuration中取出了该DAO接口对应的代理对象生成工厂:MapperProxyFactory; 在有了这个工厂后,再通过newInstance函数创建该DAO接口的代理对象,并返回给上游。

OK,此时我们已经获取了代理对象,接下来就可以使用这个代理对象调用相应的函数了。

SqlSession sqlSession = sqlSessionFactory.openSession();
try {
    ProductMapper productMapper = sqlSession.getMapper(ProductMapper.class);
    List<Product> productList = productMapper.selectProductList();
    for (Product product : productList) {
        System.out.printf(product.toString());
    }
} finally {
    sqlSession.close();
}

以上述代码为例,当我们获取到ProductMapper的代理对象后,我们调用了它的selectProductList()函数。 下面我们就来分析下代理函数调用过程。


当调用了代理对象的某一个代理函数后,这个调用请求首先会被发送给代理对象处理类MapperProxyinvoke()函数:

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, args);
      } else if (isDefaultMethod(method)) {
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    // 【核心代理在这里】
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
  }

先来解释下invoke函数的几个参数: 1. Object proxy:代理对象 2. Method method:当前正在被调用的代理对象的函数对象 3. Object[] args:调用函数的所有入参

然后,直接看invoke函数最核心的两行代码: 1. cachedMapperMethod(method):从当前代理对象处理类MapperProxymethodCache属性中获取method方法的详细信息(即:MapperMethod对象)。如果methodCache中没有就创建并加进去。 2. 有了MapperMethod对象后执行它的execute()方法,该方法就会调用JDBC执行相应的SQL语句,并将结果返回给上游调用者。至此,代理对象函数的调用过程结束! 那么execute()函数究竟做了什么?它是如何执行SQL语句的? 预知后事如何,且听下回分解。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏技术墨客

Spring核心——@Configuration与混合使用

在介绍Spring核心容器的系列文章中已经多次出现这个注解,从使用的角度来说可以把他理解为XML配置中的<beans>标签,但是两者肯定是不等价的。

993
来自专栏李家的小酒馆

SpringMVC知识一锅烩

Spring简介 SpringMVC和Struts2一样都是属于表现层的框架,将前段发出的请求分发给对应的后端处理器即Controller 处理流程 用户请求被...

1810
来自专栏刘晓杰

Glide中request的调用和管理

3357
来自专栏西安-晁州

jsp、servlet笔记

1、init    初始化Jsp&Servlet方法    destroy 销毁Jsp&Servlet之前的方法    service 对用户请求生成响应的方法...

1900
来自专栏JAVA高级架构

我们为什么要使用 AOP

前言 一年半前写了一篇文章Spring3:AOP,是当时学习如何使用Spring AOP的时候写的,比较基础。这篇文章最后的推荐以及回复认为我写的对大家有帮助的...

3177
来自专栏Java帮帮-微信公众号-技术文章全总结

Java设计模式-模板方式模式

模板方法模式: 定义一个操作中的算法的骨架, 而将一些步骤延迟到子类中. 模板方法使得子类可以在不改变一个算法的结构的前提下重定义该算法的某些特定步骤. ? ...

4478
来自专栏编程心路

SSH框架之旅-spring(2)

Spring 创建对象可以使用配置 xml 文件的方式,也可以使用注解来创建对象,更加的简单。这就需要另外引入一个 spring-aop 的 jar 包,还要在...

632
来自专栏EAWorld

了解、接受和利用Java中的Optional (类)

作者:EUGEN PARASCHIV 译者:海松 原题: Understanding, Accepting and Leveraging Optional in...

3226
来自专栏Android 研究

Retrofit解析8之核心解析——ServiceMethod及注解1

上篇文章已经介绍了Retrofit里面的大多数类,今天就重点介绍ServiceMethod,本片文章主要内容如下:

674
来自专栏不会写文章的程序员不是好厨师

使用ASM实现简单的AOP

之前一直使用greys及其内部升级二次开发版来排查问题。最近周末刚好事情不多,作为一名程序员本能地想要弄懂这么神奇的greys到底是怎么实现的?周末从githu...

642

扫描关注云+社区