Mybatis源码分析

最新推荐文章于 2023-04-24 16:52:07 发布
最新推荐文章于 2023-04-24 16:52:07 发布
阅读量134 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jw598527338/article/details/86711516
版权

Mapper接口动态代理的实现原理

  • Mybatis关于包装Mapper的代码都在org.apache.ibatis.binding 这个包下面。其中有4个类： 

    • MapperRegistry :

      1. 该类主要维护了一个映射关系Map<Class<?>, MapperProxyFactory<?>> , 通过addMapper(Class<T> type)方法注册目标对象(接口对象) ,

      2. 通过getMapper(Class<T> type, SqlSession sqlSession)方法获取Mapper接口的实现类实例 , getMapper方法内部会调用MapperProxyFactory.newInstance

      3. MapperRegistry源码

        public class MapperRegistry {

  private final 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.
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }

  /**
   * @since 3.2.2
   */
  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);
  }
  
}

         

    • MapperProxyFactory

      1. 该类主要通过newInstance(MapperProxy<T> mapperProxy)创建Mapper接口的实现类实例

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

}

         

    • MapperProxy

      1. 该类实现了JDK动态代理的接口 InvocationHandler , 在invoke方法中实现了代理方法调用的细节

      2. 该类还对要执行的方法 MapperMethod 进行了缓存 , 缓存到一个不可变对象 final Map<Method, MapperMethod> 中

      3. 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 {
      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);
  }

  private MapperMethod cachedMapperMethod(Method method) {
    MapperMethod mapperMethod = methodCache.get(method);
    if (mapperMethod == null) {
      mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
      methodCache.put(method, mapperMethod);
    }
    return mapperMethod;
  }

  @UsesJava7
  private Object invokeDefaultMethod(Object proxy, Method method, Object[] args)
      throws Throwable {
    final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
        .getDeclaredConstructor(Class.class, int.class);
    if (!constructor.isAccessible()) {
      constructor.setAccessible(true);
    }
    final Class<?> declaringClass = method.getDeclaringClass();
    return constructor
        .newInstance(declaringClass,
            MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
                | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC)
        .unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);
  }

  /**
   * Backport of java.lang.reflect.Method#isDefault()
   */
  private boolean isDefaultMethod(Method method) {
    return ((method.getModifiers()
        & (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC)) == Modifier.PUBLIC)
        && method.getDeclaringClass().isInterface();
  }
}

         

    • MapperMethod

      1. 该类是整个代理机制的核心类，对Sqlsession当中的操作进行了封装

      2. 内部有两个重要的内部类 SqlCommand 和 MethodSignature

        1. SqlCommand 封装了具体执行的动作

        2. MethodSignature 封装了接口当中方法的 参数类型 返回值类型 等信息

      3. MapperMethod源码

        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()) {
      case INSERT: {
    	Object param = method.convertArgsToSqlCommandParam(args);
        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:
        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);
          result = sqlSession.selectOne(command.getName(), param);
        }
        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;
  }
....
}

         

    • 原理总结

      • mybatis通过jdk动态代理的方式动态生成目标接口的一个实现类，因此在调用所有目标接口的任意方法时，都会执行代理类MapperProxy中的invoke方法。在invoke方法中有一个MapperMethod类，该类封装了Sqlsession中的CRUD操作 ，所以我们在调用Mapper接口时 ，真正被执行的是invoke中的MapperMethod.execute(SqlSession sqlSession, Object[] args)方法，从而进行数据库操作。

Mapper接口的实例化过程

在mybatis的Spring配置中 , 单个Mapper接口的配置如下

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="configLocation" value="classpath:sqlMapConfig.xml" />
</bean>
<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="mapperInterface" value="com.tqd.dao.UserMapper"></property>
        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>
  1. 首先找到MapperFactoryBean<T>这个类 , 该类实现了FactoryBean<T>接口 , 通过getObject方法得到mapper接口的实例 
    @Override
  public T getObject() throws Exception {
    return getSqlSession().getMapper(this.mapperInterface);
  }

     

  2. 同时MapperFactoryBean<T>还继承了SqlSessionDaoSupport类 , 调用其父类的getSqlSession()方法得到SqlSession 
    public abstract class SqlSessionDaoSupport extends DaoSupport {
  private SqlSession sqlSession;
  private boolean externalSqlSession;
  
  public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
    if (!this.externalSqlSession) {
      this.sqlSession = new SqlSessionTemplate(sqlSessionFactory);
    }
  }
  public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
    this.sqlSession = sqlSessionTemplate;
    this.externalSqlSession = true;
  }
  /**
   * Users should use this method to get a SqlSession to call its statement methods
   * This is SqlSession is managed by spring. Users should not commit/rollback/close it
   * because it will be automatically done.
   *
   * @return Spring managed thread safe SqlSession
   */
  public SqlSession getSqlSession() {
    return this.sqlSession;
  }
......
}

     

mybatis-config.xml加载过程

mapper.xml加载过程

jw598527338
关注
MyBatis源码分析.pdf
05-23
MyBatis源码分析 MyBatis是一款流行的Java持久层框架，提供了强大的数据库访问能力，本文将对MyBatis的源码进行深入分析，从而帮助读者更好地理解MyBatis的工作机理。 1. MyBatis入门 MyBatis是一款基于Java的...
mybatis源码分析视频
02-19
本资源“mybatis源码分析视频”是针对MyBatis框架进行深入剖析的教程，通过视频和文档的形式帮助学习者理解其内部工作机制。 1. **MyBatis简介** MyBatis消除了几乎所有的JDBC代码和手动设置参数以及获取结果集。...
Mybatis if标签非String类型参数校验逻辑
weixin_42505381的博客
04-24 846
Mybatis if标签非String类型参数校验逻辑
mybatis源码解析（一）
qq_31157401的博客
04-15 825
Mybatis 源码解析 （一） 一、 ORM框架的作用 实际开发系统时，我们可通过JDBC完成多种数据库操作。这里以传统JDBC编程过程中的查询操作为例进行说明，其主要步骤如下： （1）注册数据库驱动类，明确指定数据库 URL地址、数据库用户名、密码等连接信息。 （2）通过 DriverManager 打开数据库连接。 （3）通过数据库连接创建 Statement 对象。 （4）通过 Statement 对象执行SQL 语句，得到 ResultSet 对象。 （5）通过 ResultSet 读取数据，并将
Mybatis解析动态sql原理分析
多看多听多总结
08-11 5775
前言 废话不多说，直接进入文章。 我们在使用mybatis的时候，会在xml中编写sql语句。 比如这段动态sql代码： "update" parameterType="org.format.dynamicproxy.mybatis.bean.User"> UPDATE users "SET" prefixOverrides=","> if test="
mybatis的if判断用法
热门推荐
喜欢分享,善于记录工作中遇到的问题,和自己的思考
06-23 1万+
mybatis的if判断语句其实跟el表达式的if条件判断有些类似。 例如： 1 如果参数为数字类型的时候没有特俗需求的情况只需要判断是否为null即可。 例如： 如果有特俗需求，例如判断是否大于某个数的时候才行。只需要加上对应的条件判断即可 例如： mybatis对于这种大于小于等等还有另一种形式。 例如： 对应关系： gt 对应 > gte 对应 >= lt 对应
MyBatis3源码阅读（二）2020-12-24
lujiedebaba的博客
12-15 597
SELECT的执行过程 前言 前一节我们通过源码认识了SqlSessionFactoryBuilder、SqlSessionFactory 和 SqlSession的创建过程，开胃菜算是尝过了，今天该开始吃正餐了,因为想把详细的过程呈现和记录下来，所以本篇有过多的截图，请保持耐心，我会在每一步下有详细的理解。 step1：得到sqlSession对象，创建与表users对应的pojo对象users，通过setUserName("king")赋值, 获取mapper接口对象，调用方法接口 测试代码如.
Mybatis源码分析.pdf
08-30
总结起来，MyBatis源码分析涵盖了从配置加载到数据库操作的全过程，涉及到了配置解析、SQL执行、结果映射等多个关键环节，以及Executor、StatementHandler等核心组件。通过深入学习MyBatis的源码，开发者不仅可以...
Java架构师之源码分析专题SpringBoot2.x、Spring5、SpringMVC、Mybatis源码分析
08-23
最后，Mybatis作为持久层框架，它的源码分析主要集中在SQL映射文件的解析，动态SQL的生成，以及与数据库的交互。你将了解到Executor执行器的执行策略，StatementHandler如何处理SQL语句，以及ResultHandler如何处理...
Mybatis源码解析
qq_56382177的博客
04-13 1514
框架如何初始化？ 如何映射数据类型？ 如何创建SqlSession？ 如何调用Mapper接口的【抽象方法】完成SQL语句？ 如何解析SQL语法？ 如何设置SQL参数？ 缓存如何起作用？ 如何执行insert/update/delete？ 如何执行查询？ 如何映射查询结果？ 1.框架如何初始化？ 创建 SqlSessionFactory 实例 private static SqlSessionFactory factory; static {//通过静态代码块，唯一一次..
mybatis源码解析-如何执行查询操作
Alphr的博客
06-07 321
//1.通过输入流解析xml配置文件 InputStream inputstream = Resources.getResourceAsStream("xxx.xml") SqlsessionFactory sqlsessionfactory = new SqlsessionFactoryBuilder().build(inputstream); //2.获取和数据库的链接，创建会话 SqlSession openSession = sqlsessionfactory.openSession(); //3.
精通MyBatis原理，看这两篇就够了！（二）
Daniel的博客
12-25 711
本文是关于MyBatis源码的第二篇，解读了MyBatis的核心执行SQL流程，对源码做了详细注释。内容较长，推荐电脑阅读。点击上方“后端开发技术”，选择“设为星标” ，优质资源及时送达执行阶段流程第一篇文章讲解了Mybatis启动阶段的流程，大家自行阅读。这里将讲解剩余的执行阶段流程，涉及的主要内容如下：根据方法签名，获得mapper对应的代理对象。通过JDK动态代理找到对应的执行逻辑，获得数据...
java基础-反射
QiyunJzz的博客
08-30 407
java基础-反射 一. 概述 再运行时去获取一个类的变量和方法信息. 通过获取到的信息来创建对象,调用方法.这种方法称为反射. 二. 获取Class类的对象 使用类的class属性来获取该类对应的class对象 调用对象的getClass()方法, 返回该对象所属类对应的Class对象,该方法时Object类中的方法,所有的java对象都可以调用该方法 使用Class类中的静态方法forName(String className), 该方法传入类的全路径 三.代码获取Class类对象 package
Mybatis 之 MapperMethod
zsg88的专栏
09-10 1414
从 Mybatis 之 构造Mapper (MapperProxy)  http://blog.csdn.net/zsg88/article/details/77921009  一文中我们已经知道 UserMapper userMapper = sqlSession.getMapper(UserMapper.class); 返回的其实是一个MapperProxy代理类 org
Mybatis 之 构造Mapper (MapperProxy)
zsg88的专栏
09-10 1467
我们在代码中使用： UserMapper userMapper = sqlSession.getMapper(UserMapper.class); 查看DefaultSqlSession的getMapper方法： @Override public T getMapper(Class type) { return configuration.getMapper(typ
Mybatis系列五：MapperRegistry注册并解析Mapper Class
lemon
03-09 4382
Mybatis系列五：MapperRegistry注册并解析Mapper Class 概述 在《Mybatis系列一：构建SqlSessionFactory》一文中了解了Mybatis配置文件的解析，其中对mappers元素解析使用到了MapperRegistryr这个类，现在分析下这个类是如何解析Mapper Class的。当然也用到XMLMapperBuilder解析Mapper XML配置文...
第九篇：mybatis的接口访问原理
zxc_user的博客
07-15 181
mybatis代理执行原理过程
Mybatis系列十一：SQL及执行结果日志输出
lemon
03-15 2087
Mybatis系列十五：SQL及执行结果日志输出 概述 每个MappedStatement创建一个日志对象，可以控制每个运行时SQL语句的打印以及执行结果的打印。 日志Debug级别打印SQL语句：PreparedStatement(prepareStatement、prepareCall)创建时打印SQL语句，执行时打印参数值。Statement执行时打印SQL语句。 日志Trace级别打印执行...
mybatis源码分析
最新发布
06-06
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 使用简单的 XML 或注解来配置和映射原始类型、接口和 Java 的 POJO（Plain Old Java Objects）为数据库中的记录。 MyBatis 的源码分析可以从以下几个方面入手： 1. 核心组件分析：MyBatis 的核心组件包括 SqlSessionFactory、SqlSession、Executor、StatementHandler、ParameterHandler、ResultSetHandler、MappedStatement 等，可以从这些组件的实现方式、交互方式、职责分工等方面进行深入研究。 2. SQL 解析和执行分析：MyBatis 通过解析 XML 文件或注解，生成对应的 SQL 语句，并将其交由 Executor 执行。可以研究 MyBatis 如何解析 SQL 语句、如何生成对应的 SQL 语句、如何执行 SQL 语句等。 3. 缓存机制分析：MyBatis 支持多级缓存机制，包括本地缓存和二级缓存。可以研究 MyBatis 的缓存机制实现方式、缓存清理策略、缓存更新方式等。 4. 插件机制分析：MyBatis 的插件机制可以对 MyBatis 的核心组件进行拦截和增强，可以研究 MyBatis 插件机制的实现方式、插件的生命周期、插件的应用场景等。 总之，MyBatis 的源码分析可以让我们更深入地了解 MyBatis 的实现原理和内部机制，从而更好地应用和优化 MyBatis。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值