mybatis执行原理

r囧r小猫 2023-08-17 16:54 61阅读 0赞

1.  创建`SqlSessionFactoryBuilder`对象,通过外部配置创建`SqlSessionFactory`对象
2.  使用`SqlSessionFactory`创建`SqlSession`对象,此处创建的是`DefaultSqlSession`
3.  使用`SqlSession`进行查询

### 初始化工作 ###

#### 解析外部配置 ####

读取外部配置的是`SqlSessionFactoryBuilder`

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

最终调用的都是一个传入`Configuration`的build方法.

也就是说外部配置实际上都会被解析成一个`Configuration`

这个类是配置的抽象,`Configuration`的生成代码如下

XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
    return build(parser.parse());

public Configuration parse() { 
        if (parsed) { 
          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`对象,所以也可以直接配置这个字段.

### 执行sql ###

> SqlSession是一个接口,有两个实现 DefaultSqlSession 和 SqlSessionManager(弃用)
> 
> SqlSession是MyBatis中用于和数据库交互的`顶层类`,一般与`ThreadLocal`绑定,并且使用后需要close.

在`DefaultSqlSession`中存在两个关键对象`configuration`与初始化时的相同，`Executor`为执行器.

Executor分为3种

*  SimpleExecutor
    
    > 普通语句的执行器(默认),默认值在
    > 
    >     class Configuration{ 
    >      protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;
    >     }
 *  ReuseExecutor
    
    > 重用语句的执行器
 *  BatchExecutor
    
    > 批量的执行器

#### SqlSession API方式 ####

获取sqlSession的方法

public SqlSession openSession(ExecutorType execType, Connection connection) { 
        return openSessionFromConnection(execType, connection);
    }
    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);//创建一个事务
            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();
        }
    }

执行query时最终调用到了

@Override
      public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { 
        try { 
          MappedStatement ms = configuration.getMappedStatement(statement);
          return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
        } catch (Exception e) { 
          throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
        } finally { 
          ErrorContext.instance().reset();
        }
      }

从`configuration`对象中获取一个`MappedStatement`,然后调用`executor`的`query`执行

在`configuration`中实际上存储的是一个`MappedStatement`的hash表.key是全限定类名 + 方法名，value = 对应的MappedStatement对象

`MappedStatement`类描述了在配置中的select/update/insert/delete节点

query方法,实际上调用的是`BaseExecutor`

@Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException { 
        BoundSql boundSql = ms.getBoundSql(parameter);
        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
                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;
    }
    //-------------------doQuery时被分配到了具体的实现中执行------
    //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();
            StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
            stmt = prepareStatement(handler, ms.getStatementLog());
            return handler.query(stmt, resultHandler);
        } finally { 
            closeStatement(stmt);
        }
    }

#### 接口方式查询 ####

使用了动态代理的方式.

在`Configuration`中存在一个`MapperRegistry`的属性

public class MapperRegistry { 
    
      private final Configuration config;
      private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();
    }

knownMappers保存了class和MapperProxyFactory的映射关系.

实际上处理的标签是

class MapperRegistry{ 
        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<>(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);
            }
          }
        }
      }
    }

如果是接口,则创建这个接口的`MapperProxyFactory`对象,并且加入到`knownMappers`中.

在sqlSession.getMapper()时

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

在`MapperProxyFactory`的newInstance中

public T newInstance(SqlSession sqlSession) { 
        final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
        return newInstance(mapperProxy);
    }  
    protected T newInstance(MapperProxy<T> mapperProxy) { 
        return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] {  mapperInterface }, mapperProxy);
    }

然后可以调用具体的执行方法

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

最后还是回到了`sqlSession.selectList`方法.