MyBatis执行过程

已于 2023-03-22 00:46:16 修改
阅读量795 收藏 1
点赞数
分类专栏： mybatis 文章标签： mybatis java spring boot
于 2023-03-21 00:38:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ruoshui77/article/details/129679053
版权

文章目录

一、SpringBoot 集成MyBatis

1. pom.xml添加依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-jdbc</artifactId>
 </dependency>
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 <dependency>
     <groupId>org.mybatis.spring.boot</groupId>
     <artifactId>mybatis-spring-boot-starter</artifactId>
     <version>2.3.0</version>
 </dependency>
 <dependency>
     <groupId>com.mysql</groupId>
     <artifactId>mysql-connector-j</artifactId>
     <scope>runtime</scope>
 </dependency>

2.yml文件配置

server:
  port: 9994  #服务端口号

logging:
  level:
    root: INFO

spring:
  application:
    name: mybatis-test #提供者的服务名称--调用的时候根据改名称来调用对应服务的方法
  datasource:
    url: jdbc:mysql://127.0.0.1:3326/db?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root


mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.johar.mybatis.mybatistest.mapper

3.定义PO

public class Company {
    private Integer id;

    private String name;

    private String address;
}

public class User {
    private Integer id;

    private String name;

    private Integer age;

    private Integer sex;

    private Company company;
}

4. 定义mapper

public interface CompanyMapper {
    Company selectCompanyById(Integer id);
}

public interface UserMapper {

    User selectUserById(Integer id);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.johar.mybatis.mybatistest.mapper.CompanyMapper">
    <select id="selectCompanyById" resultType="com.johar.mybatis.mybatistest.po.Company">
        select * from t_company where id = #{id}
    </select>
</mapper>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.johar.mybatis.mybatistest.mapper.UserMapper">
    <resultMap id="BaseResultMap" type="com.johar.mybatis.mybatistest.po.User">
        <id property="id" javaType="java.lang.Integer" column="id" jdbcType="INTEGER"/>
        <result property="name" javaType="java.lang.String" column="name" jdbcType="VARCHAR"/>
        <result property="age" javaType="java.lang.Integer" column="age" jdbcType="TINYINT" />
        <result property="sex" javaType="java.lang.Integer" column="sex" jdbcType="TINYINT"/>
        <association property="company" javaType="com.johar.mybatis.mybatistest.po.Company" column="company_id" select="com.johar.mybatis.mybatistest.mapper.CompanyMapper.selectCompanyById">
            <id property="id" javaType="java.lang.Integer" column="id" jdbcType="INTEGER"/>
            <result property="name" javaType="java.lang.String" column="name" jdbcType="VARCHAR"/>
            <result property="address" javaType="java.lang.String" column="address" jdbcType="VARCHAR"/>
        </association>
    </resultMap>

    <select id="selectUserById" parameterType="java.lang.Integer" resultMap="BaseResultMap">
        select * from t_user where id = #{id}
    </select>
</mapper>

5.启动类

@SpringBootApplication
@MapperScan(basePackages = {"com.johar.mybatis.mybatistest.mapper"})
public class MybatisTestApplication {

    public static void main(String[] args) {
        SpringApplication.run(MybatisTestApplication.class, args);
    }

}

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User getById(Integer id){
        return userMapper.selectUserById(id);
    }

}

二、sql执行过程

MyBatis作为常用的ORM框架之一，了解MyBatis中sql执行过程是应用开发必备的技能。如下图是MyBatis 的整体架构：
在这里插入图片描述
MyBatis的整体流程如下所示：
在这里插入图片描述
MyBatis的详细执行流程如下所示：
在这里插入图片描述

1.加载mapper

@MapperScan注解中默认的factoryBean是MapperFactoryBean，负责将CompanyMapper，UserMapper注入到Spring IOC。

@Override
  public T getObject() throws Exception {
    return getSqlSession().getMapper(this.mapperInterface);
  }

最终调用的是MapperProxyFactory的newInstance，最终生成的是一个MapperProxy。

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<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

2.将UserMapper.selectUserById方法映射为Mapper.xml的sql

前面说到，Mapper实际上时一个MapperProxy的实例，因此调用selectUserById实际调用的是MapperProxy的invoke方法。

@Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
      	// Object的方法直接调用
        return method.invoke(this, args);
      } else {
        // 将mapper中方法映射为Mapper.xml的sql
        return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }

  private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
    try {
      return MapUtil.computeIfAbsent(methodCache, method, m -> {
        if (m.isDefault()) {
          // 默认方法执行逻辑
          try {
            if (privateLookupInMethod == null) {
              return new DefaultMethodInvoker(getMethodHandleJava8(method));
            } else {
              return new DefaultMethodInvoker(getMethodHandleJava9(method));
            }
          } catch (IllegalAccessException | InstantiationException | InvocationTargetException
              | NoSuchMethodException e) {
            throw new RuntimeException(e);
          }
        } else {
          // 非默认方法执行逻辑
          return new PlainMethodInvoker(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
        }
      });
    } catch (RuntimeException re) {
      Throwable cause = re.getCause();
      throw cause == null ? re : cause;
    }
  }

接下来就是实际映射逻辑：

public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
    // 映射逻辑见其构造函数中调用的resolveMappedStatement
    this.command = new SqlCommand(config, mapperInterface, method);
    this.method = new MethodSignature(config, mapperInterface, method);
  }

 // 实际执行的逻辑，将方法转换成sql：insert,update,delete,select
  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;
  }

private MappedStatement resolveMappedStatement(Class<?> mapperInterface, String methodName,
        Class<?> declaringClass, Configuration configuration) {
      // 接口类名.方法名 作为唯一值，查询对应的sql
      String statementId = mapperInterface.getName() + "." + methodName;
      if (configuration.hasStatement(statementId)) {
        return configuration.getMappedStatement(statementId);
      } else if (mapperInterface.equals(declaringClass)) {
        return null;
      }
      for (Class<?> superInterface : mapperInterface.getInterfaces()) {
        if (declaringClass.isAssignableFrom(superInterface)) {
          MappedStatement ms = resolveMappedStatement(superInterface, methodName,
              declaringClass, configuration);
          if (ms != null) {
            return ms;
          }
        }
      }
      return null;
    }
  }

3. SqlSessionTemplate拦截器SqlSessionInterceptor

MapperMethod#execute将实际执行的方法转换为SqlSession的sql执行，SqlSession实际是SqlSessionTemplate，SqlSessionTemplate#selectOne方法代理是调用sqlSessionProxy，也就是经过SqlSessionInterceptor增强过的DefaultSqlSession.

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
      PersistenceExceptionTranslator exceptionTranslator) {

    notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
    notNull(executorType, "Property 'executorType' is required");

    this.sqlSessionFactory = sqlSessionFactory;
    this.executorType = executorType;
    this.exceptionTranslator = exceptionTranslator;
    // 给SqlSession 增强
    this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),
        new Class[] { SqlSession.class }, new SqlSessionInterceptor());
  }

  @Override
  public <T> T selectOne(String statement) {
    // sqlSession代理对象
    return this.sqlSessionProxy.selectOne(statement);
  }

private class SqlSessionInterceptor implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      // 获取session，若在Spring 事务管理器当前线程有session则直接复用，否则调用SqlSessionFactory#openSession创建session
      SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);
      try {
        // 实际执行sql
        Object result = method.invoke(sqlSession, args);
        // 若session没有被spring事务管理器管理，则强制提交
        if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
          // force commit even on non-dirty sessions because some databases require
          // a commit/rollback before calling close()
          sqlSession.commit(true);
        }
        return result;
      } catch (Throwable t) {
        Throwable unwrapped = unwrapThrowable(t);
        if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
          // release the connection to avoid a deadlock if the translator is no loaded. See issue #22
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
          sqlSession = null;
          Throwable translated = SqlSessionTemplate.this.exceptionTranslator
              .translateExceptionIfPossible((PersistenceException) unwrapped);
          if (translated != null) {
            unwrapped = translated;
          }
        }
        throw unwrapped;
      } finally {
        if (sqlSession != null) {
          // 关闭session，若session被spring管理，则引用减一，否则，直接释放session，从这里也可以看出来mybatis中session的范围是事务级
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
        }
      }
    }
  }

4. 创建SqlSession

public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType,
      PersistenceExceptionTranslator exceptionTranslator) {

    notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
    notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);

    SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);

    SqlSession session = sessionHolder(executorType, holder);
    // 若spring 事务管理器中存在本线程的session，则直接返回
    if (session != null) {
      return session;
    }

    LOGGER.debug(() -> "Creating a new SqlSession");
    // 若spring中不存在本线程的session，则创建session
    session = sessionFactory.openSession(executorType);
	// 将session 注册到spring 事务管理器
    registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);

    return session;
  }

@Override
  public SqlSession openSession(ExecutorType execType) {
    return openSessionFromDataSource(execType, null, false);
  }
  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      // 创建事务
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      // 创建Executor 
      final Executor executor = configuration.newExecutor(tx, execType);
      // 创建DefaultSqkSession
      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();
    }
  }

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    Executor executor;
    // 根据executorType 创建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 (cacheEnabled) {
      // 使用装饰者模式 增加缓存能力
      executor = new CachingExecutor(executor);
    }
    // mybatis 插件拦截机制
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

5. DefaultSqlSession

@Override
  public <T> T selectOne(String statement) {
    return this.selectOne(statement, null);
  }

  @Override
  public <T> T selectOne(String statement, Object parameter) {
    // Popular vote was to return null on 0 results and throw exception on too many.
    List<T> list = this.selectList(statement, parameter);
    if (list.size() == 1) {
      return list.get(0);
    } else if (list.size() > 1) {
      throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
    } else {
      return null;
    }
  }

  private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
    try {
     // 最终调用的是这个方法
     // 获取xml文件对应sql配置
      MappedStatement ms = configuration.getMappedStatement(statement);
      // 调用executor.query执行sql
      return executor.query(ms, wrapCollection(parameter), rowBounds, handler);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

6. BaseExecutor

若没有开启二级缓存，则执行BaseExecutor

@Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    // 生成BoundSql
    BoundSql boundSql = ms.getBoundSql(parameter);
    // 生成缓存key
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
  }

  @SuppressWarnings("unchecked")
  @Override
  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.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      queryStack++;
      // 查询本地缓存
      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--;
    }
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        // 若一级缓存是statement级别，则直接清除缓存，若是session级别，先不清除缓存
        clearLocalCache();
      }
    }
    return list;
  }
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      localCache.removeObject(key);
    }
    localCache.putObject(key, list);
    if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
  }

7. SimpleExecutor

@Override
  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      // 创建stateHandler，也用插件机制
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      // 创建Statement 
      stmt = prepareStatement(handler, ms.getStatementLog());
      // 实际执行查询
      return handler.query(stmt, resultHandler);
    } finally {
      // 关闭
      closeStatement(stmt);
    }
  }
  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    Connection connection = getConnection(statementLog);
    //  用于创建一个具体的 Statement 对象的实现类或者是 Statement 对象
    stmt = handler.prepare(connection, transaction.getTimeout());
    // 用于初始化 Statement 对象以及对sql的占位符进行赋值
    handler.parameterize(stmt);
    return stmt;
  }

8. newStatementHandler

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
  }

public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    switch (ms.getStatementType()) {
      case STATEMENT:
        delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      case PREPARED:
        delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      case CALLABLE:
        delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      default:
        throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
    }

  }

9.PreparedStatementHandler

@Override
  public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    // 真正执行sql
    ps.execute();
    // 处理返回结果
    return resultSetHandler.handleResultSets(ps);
  }
Johar
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
mybatis执行流程
Beyond_Xuz的博客
03-22 599
目录 一、mybatis执行流程 二、流程图 一、mybatis执行流程 1.加载配置文件并初始化(SqlSession) 配置文件来源于两个地方，一个是配置文件(主配置文件conf.xml,mapper文件*.xml)，一个是java代码中的注释，将sql的配置信息加载成为一个mappedstatement对象，存储在内存之中（包括传入参数的映射配置，结果映射配置，执行的sql...
MyBatis的执行流程详解
AI课工场
06-22 287
说到流程这个事儿，大家可能最先想到的就是富士康的流水线，标准化的分工让每道工序都如丝一般润滑，所以才成就了富士康"世界工厂"的名号。 想当年猿小二也是众多流水线工人中的一员，每天成百上千次的重复着同一个动作；突然有一天猿小二顿悟了，他认为我不能在这里浪费青春，我要去改变世界，于是他决定学习Java，没想到这可一发不可收拾，学起Java来，如久旱逢甘霖，如鱼得水一样的轻松顺畅。 但是好景不长，最近他就在学习MyBatis这里遇到了点小麻烦，总是搞不清楚，MyBatis是怎么一个接口、一个映射文件（写s
Mybatis总体执行流程
qiuxinfa123的博客
12-03 1112
梳理mybatis的总体流程
MyBatis的工作流程和执行原理
0
12-19 1378
MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、获取结果集等jdbc繁杂的过程代码。
Mybatis执行流程、缓存原理以及相关面试题，java面试必看书籍
最新发布
2301_78416543的博客
03-30 539
3、创建SqlSessionFactoryBuilder对象4、创建SqlSessionFactory对象5、获取SqlSession对象，从SqlSessionFactory中获取6、【重点】执行我们的执行的的sql语句标识。sql文件中的namespace + sql标签的Id值7、执行sql语句，通过sqlId找到语句,并执行！8、关闭SqlSession总结。
MyBatis（一）执行流程概述
ACGkaka的博客
08-21 556
MyBatis（一）执行流程概述
mybatis原理(含图)
qq_44912064的博客
03-10 2773
上面中流程就是MyBatis内部核心流程，每一步流程的详细说明如下文所述： （1）读取MyBatis的配置文件。mybatis-config.xml为MyBatis的全局配置文件，用于配置数据库连接信息。 （2）加载映射文件。映射文件即SQL映射文件，该文件中配置了操作数据库的SQL语句，需要在MyBatis配置文件mybatis-config.xml中加载。mybatis-config.xml 文件可以加载多个映射文件，每个文件对应数据库中的一张表。 （3）构造会话工厂。通过MyBatis的环境配置信息.
Mybatis的执行流程解析
qq_51634677的博客
06-29 3684
​ 首先读取配置文件，然后加载映射文件，由SqlSessionFactory工厂对象去创建核心对象SqlSession，SqlSession对象会通过Executor执行器对象执行sql。然后Executor执行器对象会调用StatementHandler对象去真正的访问数据库执行sql语句。​ 在执行sql语句前会调用ParameterHandler去设置编译参数【#{}，${}】，编译在StatementHandler中进行。
MyBatis-执行流程简介
萌萌虎的博客
10-28 4724
SimpleExecutor是默认执行器，它的行为是每处理一次会话当中的SQl请求都会通过对应的StatementHandler 构建一个。负责处理 Statement 执行后产生的结果集，生成结果列表，并处理存储过程执行后的输出参数，返回给客户端。执行器在的角色更像是一个管理员，接收SQL请求，然后根据缓存、批处理等逻辑来决定。，处理完二级缓存逻辑之后，把SQL执行相关的逻辑交给实际的Executor处理（交由。: 管理 Statement 对象并向数据库中推送不需要预编译的SQL语句。
Mybatis执行过程详解
wang的博客
10-16 3260
Mybatis执行过程详解
Mybatis架构与原理
weixin_33980459的博客
08-06 613
MyBatis功能架构设计 image.png 功能架构讲解： 我们把Mybatis的功能架构分为三层： (1)API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。 (2)数据处理层：负责具体的SQL查找、...
MyBatis的核心API
a84860537的博客
05-07 322
MyBatis核心Api 上次简单的写了一个MyBatis的简介以及编写了一个MyBatis的入门程序，但是在入门程序中出现多很多比较陌生的词，比如SqlSessionFactoryBuilder、SqlSessionFactory等， 那这些单词到底代表什么意思呢，本篇文章将为你详细的讲解这些单词的作用 SqlSessionFactoryBuilder： SqlSe...
MyBatis 工作流程
wazlym的博客
03-18 506
mybatis工作流程分析 首先MyBatis启动的时，需要解析配置文件，包括全局配置文件和映射器配置文件，解析成Configuration对象。 然后，通过SqlSession对象，对数据进行操作（SqlSession是我们操作数据库的接口,它在应用程序和数据库中间，代表我们跟数据库之间的一次链接）。SqlSession的创建需要通过SqlSessionFactory创建，SqlSessio...
myBatis执行流程全解析1
08-08
在深入探讨myBatis执行流程之前，我们先回顾一下myBatis的核心组件和配置文件的结构。myBatis是一个优秀的持久层框架，它允许开发者将SQL语句与Java代码分离，提高了开发效率和代码可维护性。其核心配置文件通常包括...
mybatis执行流程.xmind
09-12
mybatis执行流程
MyBatis 执行动态 SQL语句详解
09-01
MyBatis 是一款著名的持久层框架，它支持定制化 SQL、存储过程以及高级映射。在 MyBatis 中，动态 SQL 是一个强大的特性，允许我们在 XML 映射文件或注解中编写条件语句，根据运行时的参数来决定 SQL 的具体执行内容...
MyBatis执行Sql的流程实例解析
08-25
MyBatis执行Sql的流程实例解析 ...MyBatis执行Sql的流程实例解析是一个复杂的过程，涉及到多个概念和步骤。但是，通过了解MyBatis的基本概念和执行流程，我们可以更好地使用MyBatis框架来开发高效的应用程序。
Mybatis执行查询接口流程
01-10
一图读懂 Mybatis执行查询接口流程
mybatis的执行流程
wangjinb的博客
11-15 789
mybatis执行流程 1、读取MyBatis的核心配置文件。 mybatis-config.xml为MyBatis的全局配置文件，用于配置数据库连接、属性、类型别名、类型处理器、插件、环境配置、映射器（mapper.xml）等信息，这个过程中有一个比较重要的部分就是映射文件其实是配在这里的；这个核心配置文件最终会被封装成一个Configuration对象 2、加载映射文件。 映射文件即SQL映射文件，该文件中配置了操作数据库的SQL语句，映射文件是在mybatis-config.xml中加载；可以加载多个

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值