Mybatis源码分析

最新推荐文章于 2023-04-24 16:52:07 发布
最新推荐文章于 2023-04-24 16:52:07 发布
阅读量136 收藏
点赞数
版权声明：本文为博主原创文章，遵循 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 851
Mybatis if标签非String类型参数校验逻辑
mybatis源码解析（一）
qq_31157401的博客
04-15 826
Mybatis 源码解析 （一） 一、 ORM框架的作用 实际开发系统时，我们可通过JDBC完成多种数据库操作。这里以传统JDBC编程过程中的查询操作为例进行说明，其主要步骤如下： （1）注册数据库驱动类，明确指定数据库 URL地址、数据库用户名、密码等连接信息。 （2）通过 DriverManager 打开数据库连接。 （3）通过数据库连接创建 Statement 对象。 （4）通过 Statement 对象执行SQL 语句，得到 ResultSet 对象。 （5）通过 ResultSet 读取数据，并将
Mybatis解析动态sql原理分析
多看多听多总结
08-11 5778
前言 废话不多说，直接进入文章。 我们在使用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 322
//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 409
java基础-反射 一. 概述 再运行时去获取一个类的变量和方法信息. 通过获取到的信息来创建对象,调用方法.这种方法称为反射. 二. 获取Class类的对象 使用类的class属性来获取该类对应的class对象 调用对象的getClass()方法, 返回该对象所属类对应的Class对象,该方法时Object类中的方法,所有的java对象都可以调用该方法 使用Class类中的静态方法forName(String className), 该方法传入类的全路径 三.代码获取Class类对象 package
Mybatis 之 MapperMethod
zsg88的专栏
09-10 1416
从 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 1468
我们在代码中使用： 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 4391
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 2090
Mybatis系列十五：SQL及执行结果日志输出 概述 每个MappedStatement创建一个日志对象，可以控制每个运行时SQL语句的打印以及执行结果的打印。 日志Debug级别打印SQL语句：PreparedStatement(prepareStatement、prepareCall)创建时打印SQL语句，执行时打印参数值。Statement执行时打印SQL语句。 日志Trace级别打印执行...
mybatis源码分析
最新发布
06-06
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 免除了几乎...总之，MyBatis 的源码分析可以让我们更深入地了解 MyBatis 的实现原理和内部机制，从而更好地应用和优化 MyBatis。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值