Mybatis源码解析

已于 2022-04-13 20:59:15 修改
阅读量1.5k 收藏
点赞数 1
文章标签： java
于 2022-04-13 20:58:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56382177/article/details/124133159
版权

  1. 目录

    关于源码解析，我们首先提出以上10个问题，然后根据问题去查看mybatis的源码

    1.框架如何初始化？ 

    2.如何映射数据类型？

    3.如何创建SqlSession？

    4.如何调用Mapper接口的【抽象方法】完成SQL语句？

    框架如何初始化？
  2. 如何映射数据类型？
  3. 如何创建SqlSession？
  4. 如何调用Mapper接口的【抽象方法】完成SQL语句？
  5. 如何解析SQL语法？
  6. 如何设置SQL参数？
  7. 缓存如何起作用？
  8. 如何执行insert/update/delete？
  9. 如何执行查询？
  10. 如何映射查询结果？

关于源码解析，我们首先提出以上10个问题，然后根据问题去查看mybatis的源码

1.框架如何初始化？ 

 创建 SqlSessionFactory(数据库连接池) 实例

private static SqlSessionFactory factory;

    static {//通过静态代码块，唯一一次创建 SqlSessionFactory 实例
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");//创建输入流
            factory = new SqlSessionFactoryBuilder().build(is);//调用build方法实例化一个SqlSessionFactory
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

通过一个输入流读取MyBatis配置文件，

通过构建器SqlSessionFactoryBuilder的build(InputStream)方法将配置文件中的配置

在build(InputStream)方法中会根据传过去的输入流生成XMLConfigBuilder实例。

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      return build(parser.parse());//build返回初始过的SqlSessionFactory对象
    } 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.
      }
    }
  }
XMLConfigBuilder的作用就是解析xml配置文件。在parse()方法中解析原生DOM文档初始化所有的配置参数 。

然后调用本类中的parseConfiguration(XNode root)将所有的配置保存到Configuration属性中

Configuration用来保存所有的配置信息

 public Configuration parse() {
    if (parsed) {//解析标识，true表示已经解析创建过,false则表示没有
      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"));
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }
然后将保存了所有配置信息的Configuration参数调用buide()方法返回一个SqlSessionFactory的默认实现类DefaultSqlSessionFactory 

public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

2.如何映射数据类型？

Configuration中的属性TypeHandlerRegistry的构造函数对数据库的数据类型和java的数据类型进行了一一对应。

 protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry();
public TypeHandlerRegistry() {
    register(Boolean.class, new BooleanTypeHandler());
    register(boolean.class, new BooleanTypeHandler());
    register(JdbcType.BOOLEAN, new BooleanTypeHandler());
    register(JdbcType.BIT, new BooleanTypeHandler());

    register(Byte.class, new ByteTypeHandler());
    register(byte.class, new ByteTypeHandler());
    register(JdbcType.TINYINT, new ByteTypeHandler());

    register(Short.class, new ShortTypeHandler());
    register(short.class, new ShortTypeHandler());
    register(JdbcType.SMALLINT, new ShortTypeHandler());

    register(Integer.class, new IntegerTypeHandler());
    register(int.class, new IntegerTypeHandler());
    register(JdbcType.INTEGER, new IntegerTypeHandler());

    register(Long.class, new LongTypeHandler());
    register(long.class, new LongTypeHandler());

    register(Float.class, new FloatTypeHandler());
    register(float.class, new FloatTypeHandler());
    register(JdbcType.FLOAT, new FloatTypeHandler());

    register(Double.class, new DoubleTypeHandler());
    register(double.class, new DoubleTypeHandler());
    register(JdbcType.DOUBLE, new DoubleTypeHandler());

    register(Reader.class, new ClobReaderTypeHandler());
    register(String.class, new StringTypeHandler());
    register(String.class, JdbcType.CHAR, new StringTypeHandler());
    register(String.class, JdbcType.CLOB, new ClobTypeHandler());
    register(String.class, JdbcType.VARCHAR, new StringTypeHandler());
    register(String.class, JdbcType.LONGVARCHAR, new StringTypeHandler());
    register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());
    register(String.class, JdbcType.NCHAR, new NStringTypeHandler());
    register(String.class, JdbcType.NCLOB, new NClobTypeHandler());
    register(JdbcType.CHAR, new StringTypeHandler());
    register(JdbcType.VARCHAR, new StringTypeHandler());
    register(JdbcType.CLOB, new ClobTypeHandler());
    register(JdbcType.LONGVARCHAR, new StringTypeHandler());
    register(JdbcType.NVARCHAR, new NStringTypeHandler());
    register(JdbcType.NCHAR, new NStringTypeHandler());
    register(JdbcType.NCLOB, new NClobTypeHandler());

    register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());
    register(JdbcType.ARRAY, new ArrayTypeHandler());

    register(BigInteger.class, new BigIntegerTypeHandler());
    register(JdbcType.BIGINT, new LongTypeHandler());

    register(BigDecimal.class, new BigDecimalTypeHandler());
    register(JdbcType.REAL, new BigDecimalTypeHandler());
    register(JdbcType.DECIMAL, new BigDecimalTypeHandler());
    register(JdbcType.NUMERIC, new BigDecimalTypeHandler());

    register(InputStream.class, new BlobInputStreamTypeHandler());
    register(Byte[].class, new ByteObjectArrayTypeHandler());
    register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());
    register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());
    register(byte[].class, new ByteArrayTypeHandler());
    register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());
    register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());
    register(JdbcType.LONGVARBINARY, new BlobTypeHandler());
    register(JdbcType.BLOB, new BlobTypeHandler());

    register(Object.class, unknownTypeHandler);
    register(Object.class, JdbcType.OTHER, unknownTypeHandler);
    register(JdbcType.OTHER, unknownTypeHandler);

    register(Date.class, new DateTypeHandler());
    register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());
    register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());
    register(JdbcType.TIMESTAMP, new DateTypeHandler());
    register(JdbcType.DATE, new DateOnlyTypeHandler());
    register(JdbcType.TIME, new TimeOnlyTypeHandler());

    register(java.sql.Date.class, new SqlDateTypeHandler());
    register(java.sql.Time.class, new SqlTimeTypeHandler());
    register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());

    register(String.class, JdbcType.SQLXML, new SqlxmlTypeHandler());

    register(Instant.class, InstantTypeHandler.class);
    register(LocalDateTime.class, LocalDateTimeTypeHandler.class);
    register(LocalDate.class, LocalDateTypeHandler.class);
    register(LocalTime.class, LocalTimeTypeHandler.class);
    register(OffsetDateTime.class, OffsetDateTimeTypeHandler.class);
    register(OffsetTime.class, OffsetTimeTypeHandler.class);
    register(ZonedDateTime.class, ZonedDateTimeTypeHandler.class);
    register(Month.class, MonthTypeHandler.class);
    register(Year.class, YearTypeHandler.class);
    register(YearMonth.class, YearMonthTypeHandler.class);
    register(JapaneseDate.class, JapaneseDateTypeHandler.class);

    // issue #273
    register(Character.class, new CharacterTypeHandler());
    register(char.class, new CharacterTypeHandler());
  }

Configuration中的属性TypeAliasRegistry主要是对JavaBean和mybatis中的核心配置文件中的类型的别名进行一一对应。

  protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();

3.如何创建SqlSession？

 SqlSession类似JDBC 中的 Connection 对象。

调用SqlSessionFactory的openSession方法会调用DefaultSqlSessionFactory方法

@Override
  public SqlSession openSession() {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  }

在DefaultSqlSessionFactory​​​​​​​方法中做了以下几件事：

1.在configuration获取mybatis配置中的数据库连接所需要的参数

2.创建事务实例

3.创建事务工厂

4.创建执行器

5.最终返回一个默认的DefaultSqlSession

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;//声明事务变量
    try {
      final Environment environment = configuration.getEnvironment();//获取mybatis配置中的数据库连接所需要的参数
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);//创建事务工厂
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);//创建事务实例
      final Executor executor = configuration.newExecutor(tx, execType);
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

Executor执行器，是Mybatis内的核心对象，负责执行SQL语句（总负责人）Mybatis默认用的是Simple执行器这个实现类

4.如何调用Mapper接口的【抽象方法】完成SQL语句？

调用初始化过的SqlSession对象的getMapper方法

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

然后在Configuration的getMapper方法中会调用mapperRegistry（保存了之前初始化时所有注册过的mapper）的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);
    }
  }

该处使用了代理模式。

在该方法中根据传过来的Class<T>作为key值取出相对应代理工厂，

最终返回了代理工厂的newInstance方法生成的实例对象。

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

在该newInstance方法中会初始化一个MapperProxy

​​​​​​​MapperProxy中实现了InvocationHandler动态代理接口

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

try块中均为了过滤掉默认方法，是默认方法则不代理，直接反射使用原先的方法。

若过滤掉了，调用mapperMethod的execute​​​​​​​方法执行SQL语句。

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);
                    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;
    }
SqlCommand是MapperMethod的一个类部类，其中的SqlCommandType属性中封装了SQL标签
public enum SqlCommandType {
  UNKNOWN, INSERT, UPDATE, DELETE, SELECT, FLUSH;
}

判断SQL语句的标签，然后给SQL语句传值后执行，并返回结果

private Object rowCountResult(int rowCount) {
        final Object result;
        if (method.returnsVoid()) {
            result = null;
        } else if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) {
            result = rowCount;
        } else if (Long.class.equals(method.getReturnType()) || Long.TYPE.equals(method.getReturnType())) {
            result = (long) rowCount;
        } else if (Boolean.class.equals(method.getReturnType()) || Boolean.TYPE.equals(method.getReturnType())) {
            result = rowCount > 0;
        } else {
            throw new BindingException("Mapper method '" + command.getName() + "' has an unsupported return type: " + method.getReturnType());
        }
        return result;
    }

增删改操作都是执行的rowCountResult获得返回值

从代码中我们可以看出，返回值可以直接取Boolean，Long，Integer

查询操作：

  • private final boolean returnsMany;//是否多值查询
  • private final boolean returnsMap;//是否map查询
  • private final boolean returnsVoid;//是否void查询
  • private final boolean returnsCursor;//是否游标查询
  • private final Class<?> returnType; //返回类型
  • private final String mapKey;//获取mapKey的值

根据不同的判断执行相对应的方法获得对应的返回值 

5.未完待续...

7叔418
关注
mybatis源码解析
weixin_32629733的博客
11-22 308
mybatis动态代理的创建；和Spring如何结合；二级缓存
【Mybatis】源码分析-深入源码
下半夜的风
07-31 1255
问题在开发过程中很多时候我们并不需要总是在加载⽤户信息时就⼀定要加载他的订单信息。此时就是我们所说的延迟加载。在⼀对多中，当我们有⼀个⽤户，它有个100个订单。在查询⽤户的时候，要不要把关联的订单查出来？在查询订单的时候，要不要把关联的⽤户查出来？在查询⽤户时，⽤户下的订单应该是，什么时候⽤，什么时候查询。在查询订单时，订单所属的⽤户信息应该是随着订单⼀起查询出来。就是在需要⽤到数据时才进⾏加载，不需要⽤到数据时就不加载数据。延迟加载也称懒加载。
MyBatis源码解析
12-18
MyBatis源码解析
基于Java的Mybatis源码解析设计源码
05-22
Mybatis源码解析设计源码：该项目基于Java开发，包含37个文件，主要使用Java语言。该项目旨在对Mybatis框架的源代码进行深入解析，以帮助开发者更好地理解和使用Mybatis，提高开发效率和质量。
基于Java的HBNU后端学习之SpringBoot、Hibernate及MyBatis源码解析
最新发布
09-29
该学习项目记录了湖北师范大学后端开发过程中的SpringBoot、Hibernate和MyBatis框架源码解析，包含252个文件，主要包括91个Java源文件、87个XML配置文件、19个YAML文件，以及少量其他类型文件。项目内容旨在帮助...
Mybatis的源码解析
qq_43667317的博客
08-04 427
要想解析源码，我们首先要知道什么是Mybatis 一、Mybatis的介绍 MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。 MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。 MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。 ...
Mybatis解析（二）
weixin_43380444的博客
05-05 407
Mybatis解析二第七部分：Mybatis缓存7.1 ⼀级缓存7.2 ⼆级缓存 第七部分：Mybatis缓存 7.1 ⼀级缓存 ①、在⼀个sqlSession中，对User表根据id进⾏两次查询，查看他们发出sql语句的情况 @Test public void test1(){ //根据 sqlSessionFactory 产⽣ session SqlSession sqlSession = sessionFactory.openSession(); UserMapper userMapper = sql
Mybatis之源码剖析
qq_37589292的博客
04-15 185
Mybatis源码剖析 1、传统方式源码剖析 源码剖析-初始化 InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml"); // 初始化工作的开始 SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream); 进入源码剖析： // 1. 最初调用的build public SqlSessionFactory bui
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值