MyBatis动态代理原理

最新推荐文章于 2024-08-18 22:46:40 发布
最新推荐文章于 2024-08-18 22:46:40 发布
阅读量3.3k 收藏 31
点赞数 9
分类专栏： MyBatis
原文链接：https://segmentfault.com/a/1190000019130222
版权

1. MyBatis核心组件

在详细探究MyBatis中动态代理机制之前，先来补充一下基础知识，认识一下MyBatis的核心组件。

  • SqlSessionFactoryBuilder(构造器)： 它可以从XML、注解或者手动配置Java代码来创建SqlSessionFactory。
  • SqlSessionFactory: 用于创建SqlSession (会话) 的工厂
  • SqlSession: SqlSession是Mybatis最核心的类，可以用于执行语句、提交或回滚事务以及获取映射器Mapper的接口
  • SQL Mapper： 它是由一个Java接口和XML文件（或注解）构成的，需要给出对应的SQL和映射规则，它负责发送SQL去执行，并返回结果

注意： 现在我们使用Mybatis一般都是和Spring框架整合在一起使用，这种情况下SqlSession将被Spring框架所创建，所以往往不需要我们使用SqlSessionFactoryBuilder或者SqlSessionFactory去创建SqlSession。

2. MyBatis动态代理实现

public static void main(String[] args) {
    try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);// <1>
        User user = userMapper.selectById(1);
        System.out.println("User : " + user);
    }
}

在前面的例子中，我们使用sqlSession.getMapper()方法获取UserMapper对象，实际上这里我们是获取了UserMapper接口的代理类，然后再由代理类执行方法。那么这个代理类是如何生成的呢？在探究动态代理类如何生成之前，我们先来看下SqlSessionFactory工厂的创建过程做了哪些准备工作，比如说mybatis-config配置文件是如何读取的，映射器文件是如何读取的？

2.1 MyBatis全局配置文件解析

private static SqlSessionFactory sqlSessionFactory;
static {
    try {
        sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(Resources.getResourceAsStream("mybatis-config.xml"));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

我们使用new SqlSessionFactoryBuilder().build()的方式创建SqlSessionFactory工厂，走进build方法

public SqlSessionFactory build(InputStream inputStream, Properties properties) {
    return build(inputStream, null, properties);
  }

  public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        inputStream.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }

对于mybatis的全局配置文件的解析，相关解析代码位于XMLConfigBuilder的parse()方法中：

public Configuration parse() {
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    //解析全局配置文件
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

  private void parseConfiguration(XNode root) {
    try {
      //issue #117 read properties first
      propertiesElement(root.evalNode("properties"));
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      loadCustomLogImpl(settings);
      typeAliasesElement(root.evalNode("typeAliases"));
      pluginElement(root.evalNode("plugins"));
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      environmentsElement(root.evalNode("environments"));
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      typeHandlerElement(root.evalNode("typeHandlers"));
      //解析mapper映射器文件
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

从parseConfiguration方法的源代码中很容易就可以看出它对mybatis全局配置文件中各个元素属性的解析。当然最终解析后返回一个Configuration对象，Configuration是一个很重要的类，它包含了Mybatis的所有配置信息，它是通过XMLConfigBuilder取钱构建的，Mybatis通过XMLConfigBuilder读取mybatis-config.xml中配置的信息，然后将这些信息保存到Configuration中

2.2 映射器Mapper文件的解析

//解析mapper映射器文件
  mapperElement(root.evalNode("mappers"));

该方法是对全局配置文件中mappers属性的解析，走进去：

mapper xml

mapperParser.parse()方法就是XMLMapperBuilder对Mapper映射器文件进行解析，可与XMLConfigBuilder进行类比

public void parse() {
    if (!configuration.isResourceLoaded(resource)) {
      configurationElement(parser.evalNode("/mapper")); //解析映射文件的根节点mapper元素
      configuration.addLoadedResource(resource);  
      bindMapperForNamespace(); //重点方法，这个方法内部会根据namespace属性值，生成动态代理类
    }
    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
  }

2.2.1 configurationElement(XNode context)方法

该方法主要用于将mapper文件中的元素信息，比如insert、select这等信息解析到MappedStatement对象，并保存到Configuration类中的mappedStatements属性中，以便于后续动态代理类执行CRUD操作时能够获取真正的Sql语句信息

configurationElement

buildStatementFromContext方法就用于解析insert、select这类元素信息，并将其封装成MappedStatement对象，具体的实现细节这里就不细说了。

2.2.2 bindMapperForNamespace()方法

该方法是核心方法，它会根据mapper文件中的namespace属性值，为接口生成动态代理类，这就来到了我们的主题内容——动态代理类是如何生成的。

2.3 动态代理类的生成

bindMapperForNamespace方法源码如下所示：

private void bindMapperForNamespace() {
    //获取mapper元素的namespace属性值
    String namespace = builderAssistant.getCurrentNamespace();
    if (namespace != null) {
      Class<?> boundType = null;
      try {
        // 获取namespace属性值对应的Class对象
        boundType = Resources.classForName(namespace);
      } catch (ClassNotFoundException e) {
        //如果没有这个类，则直接忽略，这是因为namespace属性值只需要唯一即可，并不一定对应一个XXXMapper接口
        //没有XXXMapper接口的时候，我们可以直接使用SqlSession来进行增删改查
      }
      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);
          //如果namespace属性值有对应的Java类，调用Configuration的addMapper方法，将其添加到MapperRegistry中
          configuration.addMapper(boundType);
        }
      }
    }
  }

这里提到了Configuration的addMapper方法，实际上Configuration类里面通过MapperRegistry对象维护了所有要生成动态代理类的XxxMapper接口信息，可见Configuration类确实是相当重要一类

public class Configuration {
    ...
    protected MapperRegistry mapperRegistry = new MapperRegistry(this);
    ...
    public <T> void addMapper(Class<T> type) {
      mapperRegistry.addMapper(type);
    }
    public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
      return mapperRegistry.getMapper(type, sqlSession);
    }
    ...
}

其中两个重要的方法：getMapper()和addMapper()

  • getMapper(): 用于创建接口的动态类
  • addMapper(): mybatis在解析配置文件时，会将需要生成动态代理类的接口注册到其中

2.3.1 Configuration#addMappper()

Configuration将addMapper方法委托给MapperRegistry的addMapper进行的，源码如下：

public <T> void addMapper(Class<T> type) {
    // 这个class必须是一个接口，因为是使用JDK动态代理，所以需要是接口，否则不会针对其生成动态代理
    if (type.isInterface()) {
      if (hasMapper(type)) {
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
        // 生成一个MapperProxyFactory，用于之后生成动态代理类
        knownMappers.put(type, new MapperProxyFactory<>(type));
        //以下代码片段用于解析我们定义的XxxMapper接口里面使用的注解，这主要是处理不使用xml映射文件的情况
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }

MapperRegistry内部维护一个映射关系，每个接口对应一个MapperProxyFactory（生成动态代理工厂类）

private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();

这样便于在后面调用MapperRegistry的getMapper()时，直接从Map中获取某个接口对应的动态代理工厂类，然后再利用工厂类针对其接口生成真正的动态代理类。

2.3.2 Configuration#getMapper()

Configuration的getMapper()方法内部就是调用MapperRegistry的getMapper()方法，源代码如下：

 public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    //根据Class对象获取创建动态代理的工厂对象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 {
      //这里可以看到每次调用都会创建一个新的代理对象返回
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }

从上面可以看出，创建动态代理类的核心代码就是在MapperProxyFactory.newInstance方法中，源码如下：

protected T newInstance(MapperProxy<T> mapperProxy) {
    //这里使用JDK动态代理，通过Proxy.newProxyInstance生成动态代理类
    // newProxyInstance的参数：类加载器、接口类、InvocationHandler接口实现类
    // 动态代理可以将所有接口的调用重定向到调用处理器InvocationHandler，调用它的invoke方法
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

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

这里的InvocationHandler接口的实现类是MapperProxy，其源码如下：

public class MapperProxy<T> implements InvocationHandler, Serializable {

  private static final long serialVersionUID = -6424540398559729838L;
  private final SqlSession sqlSession;
  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethod> methodCache;

  public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
    this.sqlSession = sqlSession;
    this.mapperInterface = mapperInterface;
    this.methodCache = methodCache;
  }

  @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 if (isDefaultMethod(method)) {
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    //调用XxxMapper接口自定义的方法，进行代理
    //首先将当前被调用的方法Method构造成一个MapperMethod对象，然后掉用其execute方法真正的开始执行。
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
  }
  private MapperMethod cachedMapperMethod(Method method) {
    return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
  }
  ...
}

最终的执行逻辑在于MapperMethod类的execute方法，源码如下：

public class MapperMethod {

  private final SqlCommand command;
  private final MethodSignature method;

  public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
    this.command = new SqlCommand(config, mapperInterface, method);
    this.method = new MethodSignature(config, mapperInterface, method);
  }
  public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    switch (command.getType()) {
      //insert语句的处理逻辑
      case INSERT: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.insert(command.getName(), param));
        break;
      }
      //update语句的处理逻辑
      case UPDATE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.update(command.getName(), param));
        break;
      }
      //delete语句的处理逻辑
      case DELETE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.delete(command.getName(), param));
        break;
      }
      //select语句的处理逻辑
      case SELECT:
        if (method.returnsVoid() && method.hasResultHandler()) {
          executeWithResultHandler(sqlSession, args);
          result = null;
        } else if (method.returnsMany()) {
          result = executeForMany(sqlSession, args);
        } else if (method.returnsMap()) {
          result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {
          result = executeForCursor(sqlSession, args);
        } else {
          Object param = method.convertArgsToSqlCommandParam(args);
          //调用sqlSession的selectOne方法
          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;
  }
  ...
}

在MapperMethod中还有两个内部类，SqlCommand和MethodSignature类，在execute方法中首先用switch case语句根据SqlCommand的getType()方法，判断要执行的sql类型，比如INSET、UPDATE、DELETE、SELECT和FLUSH，然后分别调用SqlSession的增删改查等方法。

慢着，说了这么多，那么这个getMapper()方法什么时候被调用呀？实际是一开始我们调用SqlSession的getMapper()方法：

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

public class DefaultSqlSession implements SqlSession {

  private final Configuration configuration;
  private final Executor executor;
  @Override
  public <T> T getMapper(Class<T> type) {
    return configuration.getMapper(type, this);
  }
  ...
}

所以getMapper方法的大致调用逻辑链是：
SqlSession#getMapper() ——> Configuration#getMapper() ——> MapperRegistry#getMapper() ——> MapperProxyFactory#newInstance() ——> Proxy#newProxyInstance()

还有一点我们需要注意：我们通过SqlSession的getMapper方法获得接口代理来进行CRUD操作，其底层还是依靠的是SqlSession的使用方法。

3. 小结

根据上面的探究过程，简单画了一个逻辑图（不一定准确）：

Mybatis动态代理

本篇文章主要介绍了MyBatis的动态原理，回过头来，我们需要知道我们使用UserMapper的动态代理类进行CRUD操作，本质上还是通过SqlSession这个关键类执行增删改查操作，但是对于SqlSession如何具体执行CRUD的操作并没有仔细阐述，有兴趣的同学可以查阅相关资料。

fedorafrog
关注
专栏目录
mybatis 动态代理原理分析
小样
02-09 510
一直以来都在使用MyBatis做持久化框架，也知道当我们定义XXXMapper接口类并利用它来做CRUD操作时，Mybatis是利用了动态代理的技术帮我们生成代理类。那么动态代理内部的实现细节到底是怎么的呀？XXXMapper.java类和XXXMapper.xml到底是如何关联起来的呀？本篇文章就来详细剖析下MyBatis的动态代理的具体实现机制。 MyBatis的核心组件及应用 在详细探究...
【mybatis】mybatis动态代理
qq_40939454的博客
02-25 337
代理模式 代理模式是设计模式之一，代理类和委托类有相同的接口，代理类主要负责为委托类预处理信息，过滤信息，把消息转发给委托类。 委托类（RealSubject）：实现类接口所给定的具体的方法实现 代理类（Proxy）：提供代理功能，对外提供服务（客户端Client访问代理类），代理类对象本身并不真正提供服务，而是由委托类提供服务 接口（Subject）：委托类和代理类是该接口的实现类 客户端（Client）：进行调用服务（与代理类打交道） 以房地产开发为例： 房地产公司即是接口类，负责设计房地产
Mybatis实现动态代理,动态SQL
09-07
Mybatis+JDBC实现的动态代理,动态SQL，步骤较为详细：1）接口绑定方案；2）实现查询：方法参数为多个基本类型；3）动态SQL；4）缓存
浅析MyBatis的动态代理原理
weixin_33724570的博客
05-09 240
原文博客地址: pjmike的博客 前言 一直以来都在使用MyBatis做持久化框架，也知道当我们定义XXXMapper接口类并利用它来做CRUD操作时，Mybatis是利用了动态代理的技术帮我们生成代理类。那么动态代理内部的实现细节到底是怎么的呀？XXXMapper.java类和XXXMapper.xml到底是如何关联起来的呀？本篇文章就来详细剖析下MyBatis的动态代理的具体实现机制。 ...
深入探索MyBatis的动态代理模式
最新发布
m0_71752625的博客
08-18 1218
动态代理是一种设计模式，它在运行时创建代理对象，以控制对某个对象的访问。MyBatis的动态代理模式允许开发者定义一个Mapper接口，而无需提供实现类。MyBatis会在运行时自动创建这个接口的代理对象，代理对象会拦截接口方法的调用，并执行相应的数据库操作。// 更多数据库操作方法...
Mybatis动态代理的原理详解
tsxiong123的博客
07-24 1430
1.MyBatis简介 MyBatis是一个ORM工具，通过声明查询接口，工具实现接口的查询。 1.引入依赖 采用Maven包依赖管理，mybatis-3.5.5版本；同时需要数据库连接驱动 <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.5</version>
延迟加载
NewBeeMu的博客
09-01 184
<!--配置延迟加载--> <settings> <!--打开延迟加载的全局开关--> <setting name="lazyLoadingEnabled" value="true"/> <setting name="aggressiveLazyLoading" value="false"...
MyBatis中的动态代理
m0_56336875的博客
07-04 1006
MyBatis
Mybatis mapper动态代理的原理解析
12-16
在开始动态代理的原理讲解以前，我们先看一下集成mybatis以后dao层不使用动态代理以及使用动态代理的两种实现方式，通过对比我们自己实现dao层接口以及mybatis动态代理可以更加直观的展现出mybatis动态代理替我们所...
从源码的角度弄懂MyBatis动态代理开发原理
01-20
MyBatis提供了一种动态代理实现SQL调用的功能，使用者只需要在映射文件中配置SQL语句与映射规则即可完成SQL调用和结果集封装。下面代码展示了动态代理调用的基本步骤： public void testMyBatisBuild() throws ...
Mybatis动态代理的原理详解，mybatis的分页原理
m0_64384350的博客
12-09 167
package com.xiongxin.mybatis; import com.alibaba.fastjson.JSON; import com.xiongxin.mybatis.entity.User; import com.xiongxin.mybatis.mapper.UserMapper; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ib
MyBatis之【动态代理】
weixin_48485216的博客
05-09 1388
一、代理模式 1、什么是代理模式 （1）目标对象不可访问，通过代理对象增强功能访问。 2、代理模式的作用 （1）控制目标对象的访问 （2）增强功能 3、代理模式的分类 （1）静态代理 （2）动态代理： ①JDK动态代理 ②CGLib动态代理 4、代理的实现方式 （1）静态代理实现 （2）动态代理的实现分为JDK动态代理和CGLib动态代理 二、静态代理 1、静态代理的特点 （1）目标对象和代理对象实现同一个业务接口 （2）目标对象必须实现接口 （3）代理对象在程序运行前就
MyBatis动态代理
weixin_30633405的博客
12-31 149
------------------------siwuxie095 MyBatis 动态代理 1、MyBatis 动态代理 是指 MyBatis 通过 JDK 动态代理机制动态生成代理类 和代理对象 「代理对象 即 代理类的对象」 2...
绝对干货，超全的 MyBatis 动态代理原理讲解！
Java知音
12-12 336
点击关注公众号，实用技术文章及时了解1.MyBatis简介MyBatis是一个ORM工具，封装了JDBC的操作，简化业务编程；Mybatis在web工程中，与Spring集成，提供业务读写数据库的能力。2.使用步骤1.引入依赖采用Maven包依赖管理，mybatis-3.5.5版本；同时需要数据库连接驱动<dependency> <groupId>org.mybat...
Mybatis核心原理，动态代理讲解
Java极客技术
01-22 819
Mybatis相信大家都用的很溜了，今天我鸭血粉丝来整点别的，给大家讲解一下Mybatis最核心的原理：动态生成Mapper代理对象，我会手动对整个过程进行模拟1.平常我们是如何使用Ma...
Mybatis工作原理
热门推荐
Morty的技术乐园
06-24 12万+
引言 在mybatis的基础知识中我们已经可以对mybatis的工作方式窥斑见豹（参考：《MyBatis————基础知识》）。 本片博客针对Mybatis内部工作原理进行阐述。 一、Mybatis工作原理图 mybatis 原理图如下所示： 二、工作原理解析 mybatis应用程序通过SqlSessionFactoryBuilder从mybatis-config.xml配置文件（也...
绝对肝货，超全的 MyBatis 动态代理原理讲解。
m0_71777195的博客
12-24 1324
MyBatis是一个ORM工具，封装了JDBC的操作，简化业务编程；Mybatis在web工程中，与Spring集成，提供业务读写数据库的能力。定义实体}接口定义}定义映射文件
mybatis接口动态代理原理
luoqinglong的专栏
03-02 774
mybatis接口动态代理原理
MyBatis（三）动态代理
duanduan_l的博客
06-12 667
在介绍MyBatis动态代理前。我们先介绍一下什么是代理模式。 代理模式 代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。 代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对...
Mybatis动态代理实战与原理解析
本文将深入解析Mybatis框架中mapper层动态代理的工作原理。首先，我们将对比两种不同的DAO层实现方式：一种是不使用动态代理，即手动编写接口实现，如`UserDaoImpl`类中仅实现`findAll`方法；另一种则是利用Mybatis...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值