Mybatis的工作流程及原理

已于 2023-10-07 08:29:59 修改
阅读量229 收藏
点赞数 2
分类专栏： 技术问答 源码解析 文章标签： mybatis tomcat java
于 2023-09-01 09:16:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42113716/article/details/132616127
版权

Mybatis是在Java实际开发中用到的最多的ORM框架了。我们只需要引入Mybatis依赖，配置好mybatis-config.xml文件，写一个接口dao层，再写一个对应的xml文件，就可以了。上手真的很简单方便，相比于hibernate而言，学习成本要低很多。

既然是用的最多的，那么对于它的相关工作流程以及原理我们肯定是需要掌握的。
在这里插入图片描述

@Test
    public void MybatisTest() throws IOException {
        String resource = "mybatis-config.xml";
        //获取mybatis配置文件的IO流
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        DailyReportDao mapper = sqlSession.getMapper(DailyReportDao.class);

        mapper.findList(null);
    }

在这里插入图片描述

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
    //创建出一个解析对象，重点看parser.parse()方法
      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.
      }
    }
  }

public Configuration parse() {
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    //mybatis-config.xml总是从<configuratin> . . .</configuration>开始的
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

在这里插入图片描述

private void parseConfiguration(XNode root) {
    try {
      //将mybatis-config.xml中的各个配置set到Configuration对象实例中去
      propertiesElement(root.evalNode("properties"));
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(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"));
      //看这里，mappers是我们配置的包扫描路径
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

在这里插入图片描述

<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

在这里插入图片描述

<mappers>
 <mapper url="file:///var/mappers/AuthorMapper.xml"/>
 <mapper url="file:///var/mappers/BlogMapper.xml"/>
 <mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>

在这里插入图片描述

<mappers>
 <mapper class="org.mybatis.builder.AuthorMapper"/>
 <mapper class="org.mybatis.builder.BlogMapper"/>
 <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

在这里插入图片描述

<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

在这里插入图片描述

private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
    //遍历mappers标签下的所有子标签
      for (XNode child : parent.getChildren()) {
      //如果是package，说明是配置的包扫描路径
        if ("package".equals(child.getName())) {
          String mapperPackage = child.getStringAttribute("name");
          //调用addMappers()方法，下面再说这个方法
          configuration.addMappers(mapperPackage);
        } else {
          //其他三种方法都是直接告诉了mybatis应该去哪里去取
          String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");
          if (resource != null && url == null && mapperClass == null) {
            ErrorContext.instance().resource(resource);
            InputStream inputStream = Resources.getResourceAsStream(resource);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url != null && mapperClass == null) {
            ErrorContext.instance().resource(url);
            InputStream inputStream = Resources.getUrlAsStream(url);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url == null && mapperClass != null) {
            Class<?> mapperInterface = Resources.classForName(mapperClass);
            configuration.addMapper(mapperInterface);
          } else {
            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
          }
        }
      }
    }
  }

在这里插入图片描述

public <T> void addMapper(Class<T> type) {
	//先判断dao是不是接口，不是接口不会去进行处理
    if (type.isInterface()) {
      if (hasMapper(type)) {
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
      //将type放入map中，这里发现实际的value类型是MapperProxyFactory，后面getMapper的时候再来看为什么？
        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);
        }
      }
    }
  }

在这里插入图片描述

public void parse() {
    String resource = type.toString();
    //判断是不是已经加载
    if (!configuration.isResourceLoaded(resource)) {
    //顾名思义，加载xml资源文件
      loadXmlResource();
      configuration.addLoadedResource(resource);
      assistant.setCurrentNamespace(type.getName());
      parseCache();
      parseCacheRef();
      Method[] methods = type.getMethods();
      for (Method method : methods) {
        try {
          // issue #237
          if (!method.isBridge()) {
          //这里是获取注解式的SQL，很贴心
            parseStatement(method);
          }
        } catch (IncompleteElementException e) {
          configuration.addIncompleteMethod(new MethodResolver(this, method));
        }
      }
    }
    parsePendingMethods();
  }

private void loadXmlResource() {
    // Spring may not know the real resource name so we check a flag
    // to prevent loading again a resource twice
    // this flag is set at XMLMapperBuilder#bindMapperForNamespace
    //老规矩，先判断是不是已经加载过了
    if (!configuration.isResourceLoaded("namespace:" + type.getName())) {
    //获取xml的路,所以还是要求dao层的名称和mapper.xml的名称一样，直接替换后缀
      String xmlResource = type.getName().replace('.', '/') + ".xml";
      InputStream inputStream = null;
      try {
        inputStream = Resources.getResourceAsStream(type.getClassLoader(), xmlResource);
      } catch (IOException e) {
        // ignore, resource is not required
      }
      if (inputStream != null) {
      	//和加载mybatis-config.xml一样的套路，我们不关心是怎么把xml文件流转化为XMLMapperBuilder 解析对象的哈
        XMLMapperBuilder xmlParser = new XMLMapperBuilder(inputStream, assistant.getConfiguration(), xmlResource, configuration.getSqlFragments(), type.getName());
        //还是深入parse()方法看一下
        xmlParser.parse();
      }
    }
  }

public void parse() {
    if (!configuration.isResourceLoaded(resource)) {
      //解析出mapper.xml中的各个标签，并且将一个mapper.xml最终转化为了一个MappedStatement对象
      configurationElement(parser.evalNode("/mapper"));
      //已经加载过这个dao，做标记
      configuration.addLoadedResource(resource);
      //这个方法看起来像是为了整合Spring弄出来的一个，会重新走一遍addMapper()方法
      bindMapperForNamespace();
    }

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

//这个方法会解析出mapper.xml里的所有的标签以及相应的sql语句，至于到底是怎么解析的，后面有时间可以去深入研究一下
private void configurationElement(XNode context) {
    try {
      String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.equals("")) {
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      builderAssistant.setCurrentNamespace(namespace);
      cacheRefElement(context.evalNode("cache-ref"));
      cacheElement(context.evalNode("cache"));
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      sqlElement(context.evalNodes("/mapper/sql"));
//构建一个MappedStatement对象
buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
    }
  }

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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

在这里插入图片描述
转载：https://blog.csdn.net/weixin_41392674/article/details/120890084

天空～之城
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解Mybatis工作流程及其原理
weixin_51495453的博客
10-28 1137
一、MyBatis的重要组件 Mybatis底层封装了JDBC,使用了动态代理模式。 1.SqlSessionFactoryBuilder （构造器）：使用Builder模式根据mybatis-config.xml配置或者代码来生成SqISessionFactory。 2.SqlSessionFactory （工厂接口）：使用工厂模式生成SqlSession。 3.SqlSession （会话）： 一个既可以发送 SQL 执行返回结果，也可以获取Mapper的接口。 4.SQL Mapper （映射器）：
MyBatis的工作流程和执行原理
0
12-19 1415
MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、获取结果集等jdbc繁杂的过程代码。
MyBatis详细教程！！（入门版）
ii804070359的博客
05-26 886
MyBatis是一款持久层框架，用于简化JDBC开发持久层：持久化操作的层，通常指数据访问层（DAO），是用来操作数据库的。
Mybatis工作流程及原理详解
qq_42077317的博客
09-19 1399
5.Executor：Executor（执行器）接口有两个实现类，其中BaseExecutor有三个继承类分别是BatchExecutor（重用语句并执行批量更新），ReuseExecutor（重用预处理语句prepared statement，跟Simple的唯一区别就是内部缓存statement），SimpleExecutor（默认，每次都会创建新的statement）。本文结合Mybatis源码，详细的阐述了业务编码中通过Mapper接口方式来操作数据库的底层实现原理。二、MyBatis的重要组件。
mybatis工作流程
m0_37840000的博客
08-20 5098
Mysatis架构分为三层及各层作用： 接口层：对象是SqlSession，它是上层应用和MyBatis打交道的桥梁，sqlSession提供了数据库的操作方法，调用核心处理 层的相应模块来完成具体的数据库操作。 核心处理层：配置解析、参数映射、sql解析、sql执行、结果集映射、插件也属于核心层,这是 由于它的工作方式和拦截的对象决定的 Statement放到基础执行器，基础执行器逻辑将会非常臃肿，事务、缓存等.. 放到实现又会产生大量重复代码。所以MyBatis 作者才设计出State...
mybatis基本操作流程
m0_58476311的博客
09-09 4778
Mybatis的基本操作流程
Mybatis工作流程
weixin_51912083的博客
12-28 513
Mybatis是开源的持久层框架，半自动的框架手写sql便于定制sql，更容易调优。不自带日志可使用Log4j进行日志记录。与hibernate相比更加简单，小白也容易上手学习。获取SqlSessionFactory对象需要先创建SqlSessionFactoryBuilder对象，然后调用它的build（）方法，在这个方法中需要放入输入流。编写SqlMapConfig.xml配置文件。mapper接口和mapper.xml映射。创建mapper.xml文件编写sql。自动生成当前接口代理实现类。
Mybatis Mapper接口工作原理实例解析
08-24
"Mybatis Mapper接口工作原理实例解析" Mybatis 作为一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。在使用 Mybatis 进行开发...
Mybatis之工作原理
02-24
mybatis底层还是采用原生jdbc来对数据库进行操作的，只是通过SqlSessionFactory，SqlSessionExecutor,StatementHandler，ParameterHandler,ResultHandler和TypeHandler等几个处理器封装了这些过程执行器：Executor...
MyBatis 的工作原理.pdf
最新发布
06-27
#### 三、MyBatis 工作流程 1. **创建 SqlSessionFactory** - 加载全局配置文件（例如 `mybatis-config.xml`）。 - 解析配置文件，构建 `Configuration` 对象。 - 创建 `SqlSessionFactory` 实例。 - 配置文件的...
MyBatis 工作原理和详解
09-29
MyBatis是一个强大的持久层框架，它专注于SQL的编写与管理，从而解放了开发者在处理数据库操作时的繁琐工作。作为一个Apache的顶级项目，MyBatis最初托管在Google Code上，后来迁移到GitHub，继续其开源发展。 ...
Mybatis工作原理与流程
进化的深山猿
02-25 5313
引言 在mybatis的基础知识中我们已经可以对mybatis的工作方式窥斑见豹（参考：《MyBatis————基础知识》）。 本片博客针对Mybatis内部工作原理进行阐述。 一、Mybatis工作原理图 mybatis 原理图如下所示： 二、工作原理解析 mybatis应用程序通过SqlSessionFactoryBuilder从mybatis-config.xml配置文件（也可以用...
MyBatis 工作流程
wazlym的博客
03-18 516
mybatis工作流程分析 首先MyBatis启动的时，需要解析配置文件，包括全局配置文件和映射器配置文件，解析成Configuration对象。 然后，通过SqlSession对象，对数据进行操作（SqlSession是我们操作数据库的接口,它在应用程序和数据库中间，代表我们跟数据库之间的一次链接）。SqlSession的创建需要通过SqlSessionFactory创建，SqlSessio...
Mybatis架构与原理
weixin_33980459的博客
08-06 629
MyBatis功能架构设计 image.png 功能架构讲解： 我们把Mybatis的功能架构分为三层： (1)API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。 (2)数据处理层：负责具体的SQL查找、...
Mybatis的执行流程解析
qq_51634677的博客
06-29 4009
​ 首先读取配置文件，然后加载映射文件，由SqlSessionFactory工厂对象去创建核心对象SqlSession，SqlSession对象会通过Executor执行器对象执行sql。然后Executor执行器对象会调用StatementHandler对象去真正的访问数据库执行sql语句。​ 在执行sql语句前会调用ParameterHandler去设置编译参数【#{}，${}】，编译在StatementHandler中进行。
mybatis工作原理（附全网最详细流程图）
热门推荐
zwx987的博客
09-10 1万+
#mybatis流程分析第一步 任何源码分析的第一步建议都是先自己写一个基本的HelloWorld程序断点调试分析，mybatis主要工作流程分为以下四个步骤，下面会带大家对每个步骤的核心点进行底层源码解读 1.获取sqlSessionFactory对象 2.获取sqlSession对象 3.获取mapper接口的代理对象（MapperProxy） 4.执行增删改查方法 #mybatis架构分层图 #步骤一：获取sqlSessionFactory对象 ...
mybatis工作原理
05-20
MyBatis是一款持久层框架，它的工作原理是将 Java 对象映射到数据库表中的行，通过 SQL 语句实现数据的存取。下面是 MyBatis 的工作原理： 1.配置文件加载：MyBatis 首先会读取配置文件，即 mybatis-config.xml ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值