Mybatis执行查询过程源码分析

最新推荐文章于 2025-05-18 16:26:14 发布
最新推荐文章于 2025-05-18 16:26:14 发布
阅读量489 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： Java语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mashaokang1314/article/details/90168285

Mybatis的基本构成

核心组件

  • SqlSessionFactoryBuilder(构造器)：它会根据配置信息或者代码来生成SqlSessionFactory(工厂接口)；
  • SqlSessionFactory：依靠工厂来产生SqlSession会话；
  • SqlSession：是一个既可以发送SQL去执行并返回结果，也可以获取Mapper的接口；
  • SQL Mapper：是一个由Java和XML文件或注解构成的需要给出对应的SQL和映射规则。

看源码

正确方式：宏观>微观>画图

宏观：了解本质，了解这个东西是用来干嘛的；
微观：

以查询一条记录为线索；

public class SelectMapper {
    static SqlSessionFactory factory;
    static {
        try {
            InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
            factory = new SqlSessionFactoryBuilder().build(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void select(){
        SqlSession sqlSession = factory.openSession();
        Student stu = sqlSession.selectOne("mapper.StudentMapper.select", 1);
        sqlSession.close();
        System.out.println(stu);
    }
}

mybatis初始化的过程，如何获取SqlSessionFactory对象？

  1. 调用SqlSessionFactoryBuilder的build方法，会根据xml配置文件的输入流inputStream等信息创建XMLconfigBuilder对象；
  2. SqlSessionFactoryBuilder调用XMLConfiguration对象的parse方法，这个方法会返回一个Configuration对象;
  3. SqlSessionFactoryBuilder根据Configuration对象创建一个DefaultSessionFactory对象；
  4. 将这个对象返回供Client使用。
/* SqlSessionFactoryBuilder*/
public SqlSessionFactory build(InputStream inputStream) {
        return this.build((InputStream)inputStream, (String)null, (Properties)null);
    }
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
        SqlSessionFactory var5;
        try {
        	//1.创建XMLConfigBuilder对象用来解析XML配置文件，生成Configuration对象
            XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
            //2. parser.parse()将XML配置文件信息解析成Java的Configuration对象
            //3. 根据Configuration对象创建出SqlSessionFactory对象
            var5 = this.build(parser.parse());
        } catch (Exception var14) {
            throw ExceptionFactory.wrapException("Error building SqlSession.", var14);
        } finally {
            ErrorContext.instance().reset();

            try {
                inputStream.close();
            } catch (IOException var13) {
                ;
            }
        }
        return var5;
    }    
public SqlSessionFactory build(Configuration config) {
        return new DefaultSqlSessionFactory(config);
    }

参考文章：https://blog.youkuaiyun.com/u010349169/article/details/37744073
如何将mybatis-config.xml内容映射为Java中的Configuration对象

当SqlSessionFactoryBuilder执行build方法，调用XMLConfigBuilder的parse方法，然后返回Configuration对象。那么parse方法是如何处理XML文件，生成Configuration对象的？

/*SqlSessionFactoryBuilder*/
public SqlSessionFactory build(InputStream inputStream) {
        return this.build((InputStream)inputStream, (String)null, (Properties)null);
    }
    
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
        SqlSessionFactory var5;
        try {
        	//建造xmlConfiguration对象(1)
            XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
            //将XML配置文件的信息解析成Java的Configuration对象
            //this.build根据Configuration对象创建出DefaultSqlSessionFactory对象
            var5 = this.build(parser.parse());
        } catch (Exception var14) {
            throw ExceptionFactory.wrapException("Error building SqlSession.", var14);
        } finally {
            ErrorContext.instance().reset();

            try {
                inputStream.close();
            } catch (IOException var13) {
                ;
            }

        }
        return var5;
    }
  1. XMLConfigBuilder会将XML配置文件的信息转换为Document对象，而XML配置定义文件DTD转换成XMLMapperEntityResolver对象，然后将二者封装到XpathParser对象中，XpathParser的作用是提供根据Xpath表达式获取基本DOM节点Node信息的操作。
(1)/*XMLConfigBuilder*/
public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
        this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
    }

/*XPathParser*/
public XPathParser(InputStream inputStream, boolean validation, Properties variables, EntityResolver entityResolver) {
        this.commonConstructor(validation, variables, entityResolver);
        this.document = this.createDocument(new InputSource(inputStream));
    }
  1. 之后XMLConfigBuilder调用parse方法，会从XPathParser中取出<configuration>节点对应的Node对象，然后解析Node节点的子节点：包括properties, settings, typeAliases,typeHandlers, objectFactory, objectWrapperFactory, plugins, environments,databaseIdProvider, mappers。
/*XMLConfigBuilder*/
 public Configuration parse() {
        if (this.parsed) {
            throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        } else {
            this.parsed = true;
            this.parseConfiguration(this.parser.evalNode("/configuration"));
            return this.configuration;
        }
    }

/*
	解析"/configuration"节点下的子节点信息，然后将解析的结果设置到Configuration对象中
*/
    private void parseConfiguration(XNode root) {
        try {
            this.propertiesElement(root.evalNode("properties"));
            Properties settings = this.settingsAsProperties(root.evalNode("settings"));
            this.loadCustomVfs(settings);
            this.typeAliasesElement(root.evalNode("typeAliases"));
            this.pluginElement(root.evalNode("plugins"));
            this.objectFactoryElement(root.evalNode("objectFactory"));
            this.objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
            this.reflectorFactoryElement(root.evalNode("reflectorFactory"));
            this.settingsElement(settings);
            this.environmentsElement(root.evalNode("environments"));
            this.databaseIdProviderElement(root.evalNode("databaseIdProvider"));
            this.typeHandlerElement(root.evalNode("typeHandlers"));
            this.mapperElement(root.evalNode("mappers"));
        } catch (Exception var3) {
            throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + var3, var3);
        }
    }
  1. 然后将这些值解析出来设置到Configuration对象中，以Environments为例：

Configuration类包含的属性：

public class Configuration {
    protected Environment environment;
    protected boolean safeRowBoundsEnabled;
    protected boolean safeResultHandlerEnabled;
    protected boolean mapUnderscoreToCamelCase;
    protected boolean aggressiveLazyLoading;
    protected boolean multipleResultSetsEnabled;
    protected boolean useGeneratedKeys;
    protected boolean useColumnLabel;
    protected boolean cacheEnabled;
    protected boolean callSettersOnNulls;
  ...
    protected final Collection<ResultMapResolver> incompleteResultMaps;
    protected final Collection<MethodResolver> incompleteMethods;
    protected final Map<String, String> cacheRefMap;
  • Environment
    在这里插入图片描述
    其中TransactionFactory由ManagedTransactionFactory实现对应xml标签中的transactionManager；
/*XMLConfigBuilder*/
 private void environmentsElement(XNode context) throws Exception {
        if (context != null) {
            if (this.environment == null) {
                this.environment = context.getStringAttribute("default");
            }

            Iterator var2 = context.getChildren().iterator();

            while(var2.hasNext()) {
                XNode child = (XNode)var2.next();
                String id = child.getStringAttribute("id");
                if (this.isSpecifiedEnvironment(id)) {
                //1. 创建事务工厂
                    TransactionFactory txFactory = this.transactionManagerElement(child.evalNode("transactionManager"));
                //2. 创建数据源    
                    DataSourceFactory dsFactory = this.dataSourceElement(child.evalNode("dataSource"));
                    DataSource dataSource = dsFactory.getDataSource();
                //3. 构造Environment对象    
                    Builder environmentBuilder = (new Builder(id)).transactionFactory(txFactory).dataSource(dataSource);
                //4. 将创建Environment对象设置到Configuration对象中。   
                    this.configuration.setEnvironment(environmentBuilder.build());
                }
            }
        }

    }

/*Environment*/
/*
	注意：创建environment时，如果SqlSessionFactoryBuilder制定了额特定环境；则返回指定数据眼的Environment对象，否则返回默认的Environment对象；这种方式实现了Mybatis可以连接多数据源。
*/
public Environment build() {
            return new Environment(this.id, this.transactionFactory, this.dataSource);
        }
  1. 返回Configuration对象
    在这里插入图片描述
    在这里插入图片描述

如何获取sql语句

  • 通过调用SqlSessionFactoryBuilder的build方法的，返回DefaultSqlSessionFactory对象；
  • 将解析好的configuration对象传入DefaultSqlSessionFactory构造器中，创建一个DefaultSqlSessionFactory对象。
  • 再通过调用DefaultSqlSessionFactory的openSession方法返回一个DefaultSqlSession对象。
  • SqlSession接口里面包含了jdbc里面的增删改查方法，其实就是底层封装了jdbc，通过jdbc来操作数据库。
/*SqlSessionFactoryBuilder*/
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
        SqlSessionFactory var5;
        try {
        	//建造xmlConfiguration对象(1)
            XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
            //将XML配置文件的信息解析成Java的Configuration对象
            //this.build根据Configuration对象创建出DefaultSqlSessionFactory对象
            var5 = this.build(parser.parse());
        } catch (Exception var14) {
            throw ExceptionFactory.wrapException("Error building SqlSession.", var14);
        } finally {
            ErrorContext.instance().reset();

            try {
                inputStream.close();
            } catch (IOException var13) {
                ;
            }

        }
        return var5;
    }

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

/*DefaultSqlSessionFactory*/
 public SqlSession openSession() {
 		//第一个参数为配置中的指定的执行器类型包含    SIMPLE,REUSE,BATCH;
 		//第二个参数为配置中事务的隔离级别：NONE(0),
		  // READ_COMMITTED(2),
		  // READ_UNCOMMITTED(1),
		  // REPEATABLE_READ(4),
		  // SERIALIZABLE(8);
		//第三个参数表示是否自动提交事务
        return this.openSessionFromDataSource(this.configuration.getDefaultExecutorType(), (TransactionIsolationLevel)null, false);
    }

 private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
        Transaction tx = null;

        DefaultSqlSession var8;
        try {
            Environment environment = this.configuration.getEnvironment();
            //从environment对象中获取事务管理对象，如果没有则创建一个(1)；
            TransactionFactory transactionFactory = this.getTransactionFactoryFromEnvironment(environment);
            //创建一个事务实例
            tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
            //根据执行器类型个事务对象创建一个执行器(2)
            Executor executor = this.configuration.newExecutor(tx, execType);
            //创建DefaultSqlSession对象，并返回
            var8 = new DefaultSqlSession(this.configuration, executor, autoCommit);
        } catch (Exception var12) {
            this.closeTransaction(tx);
            throw ExceptionFactory.wrapException("Error opening session.  Cause: " + var12, var12);
        } finally {
            ErrorContext.instance().reset();
        }

        return var8;
    }

(1)获取事务工厂

//如果environment不为空并且environment配置中指定了事务工厂TransactionFactory则返回它，否则创建一个事务工厂管理对象。
 private TransactionFactory getTransactionFactoryFromEnvironment(Environment environment) {
        return (TransactionFactory)(environment != null && environment.getTransactionFactory() != null ? environment.getTransactionFactory() : new ManagedTransactionFactory());
    }

(2)创建执行器的方法

    public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    	//如果没有指定创建器类型，则默认使用SIMPLE类型
        executorType = executorType == null ? this.defaultExecutorType : executorType;
        executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
        Object executor;
        if (ExecutorType.BATCH == executorType) {
            executor = new BatchExecutor(this, transaction);
        } else if (ExecutorType.REUSE == executorType) {
            executor = new ReuseExecutor(this, transaction);
        } else {
            executor = new SimpleExecutor(this, transaction);
        }
        if (this.cacheEnabled) {
            executor = new CachingExecutor((Executor)executor);
        }

        Executor executor = (Executor)this.interceptorChain.pluginAll(executor);
        return executor;
    }

拿到sql如何去执行？

 @Test
    public void select(){
        SqlSession sqlSession = factory.openSession();
        Student stu = sqlSession.selectOne("mapper.StudentMapper.select", 1);
        sqlSession.close();
        System.out.println(stu);
    }

来看看Student stu = sqlSession.selectOne("mapper.StudentMapper.select", 1);都做了什么事。

  • 将获取到的MappedStatement对象传入query方法中。在BaseExecutor类中：
  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
        List var5;
        try {
            MappedStatement ms = this.configuration.getMappedStatement(statement);
            (1)
            var5 = this.executor.query(ms, this.wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
        } catch (Exception var9) {
            throw ExceptionFactory.wrapException("Error querying database.  Cause: " + var9, var9);
        } finally {
            ErrorContext.instance().reset();
        }

        return var5;
    }
  • select方法调用configuration的getMappedStatement方法传入sql语句statement返回这个语句节点对象；
    在这里插入图片描述
  • MappedStatement中包含BoundSql对象

MappedStatement维护了一条<select|update|delete|insert>节点的封装；获取的方式为命令空间+id；
SqlSource 负责根据用户传递的parameterObject动态的生成SQL语句，将信息封装到BoundSql对象中，并返回；
BoundSql表示动态生成的SQL语句以及相应的参数信息。有了BoundSql就可以执行sql语句了；

(1)

 public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
 		//获取BoundSql对象
 		(2)
        BoundSql boundSql = ms.getBoundSql(parameter);
        //创建一级缓存，再调用该对象的重载方法query
        CacheKey key = this.createCacheKey(ms, parameter, rowBounds, boundSql);
        return this.query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }

/*MappedStatement*/
public BoundSql getBoundSql(Object parameterObject) {
        BoundSql boundSql = this.sqlSource.getBoundSql(parameterObject);
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        if (parameterMappings == null || parameterMappings.isEmpty()) {
            boundSql = new BoundSql(this.configuration, boundSql.getSql(), this.parameterMap.getParameterMappings(), parameterObject);
        }

public class DynamicSqlSource implements SqlSource {
    private final Configuration configuration;
    private final SqlNode rootSqlNode;

/*DynamicSqlSource*/
    public DynamicSqlSource(Configuration configuration, SqlNode rootSqlNode) {
        this.configuration = configuration;
        this.rootSqlNode = rootSqlNode;
    }
//根据配置和参数对象动态sql生成
    public BoundSql getBoundSql(Object parameterObject) {
        DynamicContext context = new DynamicContext(this.configuration, parameterObject);
        //读取sql结点对象(1)，动态组建完整的sql语句
        this.rootSqlNode.apply(context);
        SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(this.configuration);
        Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
        //context.getSql()获取sql语句是完整的sql语句的原始形式包括#{}等
        //将sql语句解析为staticSqlSource(2)
        SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
        //用staticSqlSource构建boundSql
        BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
        Iterator var7 = context.getBindings().entrySet().iterator();
	//添加metaParameter
        while(var7.hasNext()) {
            Entry<String, Object> entry = (Entry)var7.next();
            boundSql.setAdditionalParameter((String)entry.getKey(), entry.getValue());
        }

        return boundSql;
    }
}
/*SqlSourceBuilder*/
public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
        SqlSourceBuilder.ParameterMappingTokenHandler handler = new SqlSourceBuilder.ParameterMappingTokenHandler(this.configuration, parameterType, additionalParameters);
        //解析#{}形式的参数
        GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
        //解析后的sql为用"?"替换#{}参数，且提取对应参数的ParameterMapping
        String sql = parser.parse(originalSql);
        //以StaticSqlSource为解析结果
        return new StaticSqlSource(this.configuration, sql, handler.getParameterMappings());
    }

动态sql结点对象，可以看到常用的<foreach>、<set>等标签；
在这里插入图片描述

 public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    //如果连接关闭则抛出异常
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    //如果查询栈中记录为0或者刷新了缓存则清空缓存；
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
  ...
 		//先从缓存中获取，如果缓存中没有则冲数据库中获取
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
      //处理本地缓存的输出参数
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
      //从数据库中查询
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }
private void handleLocallyCachedOutputParameters(MappedStatement ms, CacheKey key, Object parameter, BoundSql boundSql) {
        if (ms.getStatementType() == StatementType.CALLABLE) {
            Object cachedParameter = this.localOutputParameterCache.getObject(key);
            if (cachedParameter != null && parameter != null) {
                MetaObject metaCachedParameter = this.configuration.newMetaObject(cachedParameter);
                MetaObject metaParameter = this.configuration.newMetaObject(parameter);
                Iterator var8 = boundSql.getParameterMappings().iterator();

                while(var8.hasNext()) {
                    ParameterMapping parameterMapping = (ParameterMapping)var8.next();
                    if (parameterMapping.getMode() != ParameterMode.IN) {
                        String parameterName = parameterMapping.getProperty();
                        Object cachedValue = metaCachedParameter.getValue(parameterName);
                        metaParameter.setValue(parameterName, cachedValue);
                    }
                }
            }
        }
    }
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        this.localCache.putObject(key, ExecutionPlaceholder.EXECUTION_PLACEHOLDER);

        List list;
        try {
        	//执行查询
            list = this.doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        } finally {
        	//清空旧的缓存
            this.localCache.removeObject(key);
        }
			//创建新的缓存
        this.localCache.putObject(key, list);
        if (ms.getStatementType() == StatementType.CALLABLE) {
            this.localOutputParameterCache.putObject(key, parameter);
        }
        //返回查询结果的List集合
        return list;
    }
mybatis中一个查询方法的执行流程
qq47653423的博客
12-22 1148
一：简述 本文通过分析mybatis的源码来展示mybatis是如何帮我们实现一个查询的方法的。 二：时序图 三：源码分析 UserMapper mapper = sqlSession.getMapper(UserMapper.class); 注：这里获取的是一个代理对象，而我们一般从Spring容器中获取的也是同样的代理对象，只不过是交给Spring管理了而已） 1.获取代理类Mapper sqlSession的getMapper()方法会先调用configuration的getMap
【MyBatis-Plus 源码分析】核心组件、工作流程、SQL执行过程、源码分析
好好学习日记
05-29 2693
MyBatis-Plus 是一个增强版的 MyBatis 框架，它在 MyBatis 的基础上增加了许多实用的功能，例如乐观锁插件、字段自动填充、分页插件、条件构造器和 SQL 注入器等。MyBatis-Plus 允许开发者无需编写 XML 文件，直接通过继承 BaseMapper 接口的类来完成数据库操作。MyBatis-Plus 作为 MyBatis 的增强框架，其工作流程在继承 MyBatis 的基础上进行了优化和扩展。继承 BaseMapper。
Mybatis查询执行流程
liuqiang211的专栏
02-05 634
因为mapper是代理对象 所有执行目标方法会先执行代理类的 invoke方法 method.getDeclaringClass 是 Object里面的方法 不是我们写的接口中的方法 所有直接让他执行就可以了 我们写的方法执行 在红框中标注的 BoundSql里面包含了 sql语句 sql语句是带 占位符 ？的那种形式的sql语句 入：select * f...
Mybatis源码学习-sql执行流程
最新发布
qq_45325916的博客
05-18 991
在mapperRegistry 从已知的knownMappers 一个集合中获取 Mapper代理对象工厂，再由MapperProxyFactory 去创建一个实例，最终返回，BaseExecutor 中有一个 localCache ，应该就是Mybatis的一级缓存，CachingExecutor 中的是二级缓存，当缓存中不存在时，则从数据库中查询。在 mapperRegistry 中有一个 mapperRegistry的方法，我们在这里打一个断点，然后重新启动，观察是什么时候进入到这个方法的。
mybatis查询过程源码解析
Lisam Blog
07-04 3878
本文只讲解mybatis的源码 ，不涉及过多的用法讲解，用法请百度。 mybatis查询执行步骤（举SELECT分析） 第一步：获取mapperProxy 第二步：获取mapperMethod 第三步：找到对应的执行类型(SELECT\UPDATE\INSERT\DELETE) 第四步：查询前的缓存处理，判断是否需要从二级、一级缓存中取数据（先二级再一级） 第五步：真正调用用jdbc调数据库，先预编译、再注入参数 第六步：进行结果集解析填充 ...
MyBatis查询全流程源码分析
程序员小潘
07-25 599
MyBatis作为一款优秀的持久层框架，现在已经被越来越多的公司在用了。面对这个我们每天都在使用的框架，不好好读读它的源码怎么行呢？笔者花了几天的时间阅读和调试MyBatis源码，现在把我的一些理解分享给大家，如有错误，还望指正。 ​ MyBatis源码版本:3.5.8-SNAPSHOT，源码地址:https://github.com/mybatis/mybatis-3.git 1. 前言 MyBatis整体框架大致如下图所示，其中每个模块都可以单拎出来写一篇文章。篇幅原因，本篇文章只会介绍【查询】的全
mybatis查询过程的源码分析
u013905744的专栏
05-17 508
参考：咕泡学院的mybatis源码分析及手写实现教程 1. 运行hello world，提出问题 先自己运行一个demo，以mybatis为例，需要sqlsession，需要mapper，为什么需要呢？ 2. 看设计文档，看模块划分，理解大局 需要看其design设计文档或先从模块上来看，大局上是什么样的，之后再跟进去看 看其架构设计图，看其是如何设计其系统的 如果没有架构设计图，那么...
基于Java语言的Mybatis 0508版本设计源码分析
10-03
在深入探讨基于Java语言的Mybatis 0508版本设计源码之前，有必要对Mybatis本身有一个基本的理解。...通过本项目的源码分析，开发者将能够获得关于Mybatis框架更为深入的理解，并在实际开发中更加熟练地使用它。
MyBatis源码分析.pdf
05-23
MyBatis源码分析 MyBatis是一款流行的Java持久层框架，提供了强大的数据库访问能力，本文将对MyBatis的源码进行深入分析，从而帮助读者更好地理解MyBatis的工作机理。 1. MyBatis入门 MyBatis是一款基于Java的...
Mybatis源码分析.pdf
08-30
总结起来，MyBatis源码分析涵盖了从配置加载到数据库操作的全过程，涉及到了配置解析、SQL执行、结果映射等多个关键环节，以及Executor、StatementHandler等核心组件。通过深入学习MyBatis的源码，开发者不仅可以...
Mybatis – 执行流程分析（源码分析）
12-21
在深入分析Mybatis的执行流程之前，我们先回顾一下Mybatis的基本操作。Mybatis是一个轻量级的持久层框架，它允许开发者通过XML或注解定义SQL语句，然后通过接口与数据库进行交互。在使用Mybatis时，我们通常会经历...
Mybatis源码执行流程
a1926469520的博客
04-12 367
第一步:通过Resources加载配置好的mybatis.xml配置文件。 Resources是ibatis.io包下面的类，也就是一个io流，用于读写文件，通过getResourceAsStream把xml文件加载进来，把配置文件解析为一个流。 第二步:然后看第二句话，这句话是关键。我们首先new了一个SqlSessionFactoryBuilder对象，他是SqlSessionFactory的构建者。我们调用了他的build()方法。这个方法长什么样子呢?看一下他的源码： 我们发现里面有一个XM.
MyBatis 执行流程及源码解析
公众号：该用户快成仙了
10-13 318
我们在日常工作中广泛使用mybatis作为数据持久层框架，但是mybatis的执行流程是怎么样的，你了解过吗。本文将从源码角度，带你分析mybatis的工作原理。 先看一个简单的例子，以Service调用Mapper接口为，先写一个简单的Mapper： public interface StudentMapper { @Select("select * from student") public List<Map<String,Object>> query();
关于mybatis的查询执行流程
for justice
09-15 490
mapper有一个命名空间 像这样 &lt;select id="findUserByEntity" resultMap="UserResultMap" parameterType="com.ojama.business.entities.admin.User"&gt; select &lt;include refid="Base_Column_List" /&gt; from
mybatis源码解析 - 通过一个简单查询例子分析流程
weixin_34246551的博客
10-08 457
2019独角兽企业重金招聘Python工程师标准>>> ...
Mybatis执行流程源码分析
china_yang
02-01 1635
概要： 在单独使用Mybatis时通常需要以下几行代码： public class Demo { public static void main(String[] args) { // 第一阶段：MyBatis的初始化阶段 String resource = "mybatis-config.xml"; // 得到配置文件的输入流 InputStream inputStream = null; ...
MyBatis源码分析
qq_68974327的博客
04-14 386
1.首先我们先了解一下Mybatis是什么： MyBatis 是一个开源、轻量级的数据持久化框架，是 JDBC 和 Hibernate 的替代方案。MyBatis 内部封装了 JDBC，简化了加载驱动、创建连接、创建 statement 等繁杂的过程，开发者只需要关注 SQL 语句本身。 2.工作原理和示例代码：（如图所示） 这里是一个查询总行数的 Test类： 总体步骤为： 1、加载核心配置文件到Configuration 2、构建SqlSessionFactory 3、打开SqlS...
MyBatis查询的源码分析
iteye_3742的博客
12-31 188
如下为mybatis的一个集合查询：  String resource = "mybatis.cfg.xml"; Reader reader = Resources.getResourceAsReader(resource); SqlSessionFactory ssf = new SqlSessionFactoryBuilder().build(reader); S...
Mybatis源码(3)-查询执行流程
闪电大王
10-23 1288
上文介绍了mapper的创建过程，mybatis通过动态代理的方式生成了代理，MapperProxy实现了InvocationHandler类。下文以查询流程为例，分析sql的执行过程。 MapperProxy: @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { if (Object.class.equals(method.g
0基础入门：搭建Mybatis环境与ibatisTest源码分析
## iBatisTest 源码分析 在 `ibatisTest` 中，源码应该包含了一个简单的测试案例，展示如何使用 MyBatis 进行基本的 CRUD（创建、读取、更新、删除）操作。源码中应该包含： - 数据库配置信息 - 数据库表结构定义 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值