原文地址
mybatis是一种非常流行的ORM框架,可以通过一些灵活简单的配置,大大提升我们操作数据库的效率,当然,我觉得它如此受欢迎的原因更主要的是,它的源码设计的非常简单。接下来我们就来聊聊使用mybatis做一次数据库查询操作背后都经历了什么。
首先我们先上一段非常简单的代码,这是原始的JDBC方式的数据库操作。
// 1. 创建数据源 DataSource dataSource = getDataSource(); // 2. 创建数据库连接 try (Connection conn = dataSource.getConnection()) { try { conn.setAutoCommit(false); // 3. 创建Statement PreparedStatement stat = conn.prepareStatement("select * from std_addr where id=?"); stat.setLong(1, 123456L); // 4. 执行Statement,获取结果集 ResultSet resultSet = stat.executeQuery(); // 5. 处理结果集,这一步往往是非常复杂的 processResultSet(resultSet); // 6.1 成功提交,对于查询操作,步骤6是不需要的 conn.commit(); } catch (Throwable throwable) { // 6.2 失败回滚 conn.rollback(); } } 复制代码
下面这段是mybatis连接数据库以及做同样的查询操作的代码。
DataSource dataSource = getDataSource(); TransactionFactory txFactory = new JdbcTransactionFactory(); Environment env = new Environment("test", txFactory, dataSource); Configuration conf = new Configuration(env); conf.setMapUnderscoreToCamelCase(true); conf.addMapper(AddressMapper.class); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(conf); try (SqlSession sqlSession = sqlSessionFactory.openSession(true)) { AddressMapper mapper = sqlSession.getMapper(AddressMapper.class); Address addr = mapper.getById(123456L); } 复制代码
这是mybatis的Mapper,也非常简单
@Mapper public interface AddressMapper { String TABLE = "std_addr"; @Select("select * from " + TABLE + " where id=#{id}") Address getById(long id); } 复制代码
从上面的代码可以看出,通过mybatis查询数据库需要以下几个步骤:
下面我们从源码逐步分析mybatis在一次select查询中这几个步骤的详细情况。
Environment有两个核心属性,dataSource和transactionFactory,下面是源码
public final class Environment { private final String id; private final TransactionFactory transactionFactory; private final DataSource dataSource; } 复制代码
其中,dataSource用来获取数据库连接,transactionFactory用来创建事务。
我们详细看一下mybatis的JdbcTransactionFactory的源码,这里可以通过数据源或者数据库连接来创建JdbcTransaction。
public class JdbcTransactionFactory implements TransactionFactory { public Transaction newTransaction(Connection conn) { return new JdbcTransaction(conn); } public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) { return new JdbcTransaction(ds, level, autoCommit); } } 复制代码
我把JdbcTransaction的源码精简了一下,大概是这个样子的。这里实际上就是把JDBC的DataSource或者一个Connection托管给了mybatis的Transaction对象,由Transaction来管理事务的提交与回滚。
public class JdbcTransaction implements Transaction { protected Connection connection; protected DataSource dataSource; protected TransactionIsolationLevel level; protected boolean autoCommmit; public Connection getConnection() throws SQLException { if (connection == null) { connection = dataSource.getConnection(); if (level != null) { connection.setTransactionIsolation(level.getLevel()); } if (connection.getAutoCommit() != autoCommmit) { connection.setAutoCommit(autoCommmit); } } return connection; } public void commit() throws SQLException { if (connection != null && !connection.getAutoCommit()) { connection.commit(); } } public void rollback() throws SQLException { if (connection != null && !connection.getAutoCommit()) { connection.rollback(); } } } 复制代码
到这里,运行环境Environment已经准备完毕,我们可以从Environment中获取DataSource或者创建一个新的Transaction,从而创建一个数据库连接。
Configuration类非常复杂,包含很多配置信息,我们优先关注以下核心属性
public class Configuration { protected Environment environment; protected boolean cacheEnabled = true; protected LocalCacheScope localCacheScope = LocalCacheScope.SESSION; protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE; // 保存着所有Mapper的动态代理对象 protected final MapperRegistry mapperRegistry; // 保存着所有类型处理器,处理Java类型和JDBC类型的转换 protected final TypeHandlerRegistry typeHandlerRegistry; // 保存配置的Statement信息,可以是XML或注解 protected final Map<String, MappedStatement> mappedStatements; // 保存二级缓存信息 protected final Map<String, Cache> caches; // 保存配置的ResultMap信息 protected final Map<String, ResultMap> resultMaps; } 复制代码
build
方法可以看出,mybatis提供了两种解析配置信息的方式,分别是XMLConfigBuilder和MapperAnnotationBuilder。解析配置的过程,其实就是填充上述Configuration核心属性的过程。 // 根据XML构建 InputStream xmlInputStream = Resources.getResourceAsStream("xxx.xml"); SqlSessionFactory xmlSqlSessionFactory = new SqlSessionFactoryBuilder().build(xmlInputStream); // 根据注解构建 Configuration configuration = new Configuration(environment); configuration.addMapper(AddressMapper.class); SqlSessionFactory annoSqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration); 复制代码
public interface TypeHandlerRegistry<T> { void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException; T getResult(ResultSet rs, String columnName) throws SQLException; T getResult(ResultSet rs, int columnIndex) throws SQLException; T getResult(CallableStatement cs, int columnIndex) throws SQLException; } 复制代码
总而言之,Configuration对象包含了mybatis的Statement、ResultMap、Cache等核心配置,这些配置信息是后续执行SQL操作的关键。
我们提供 new SqlSessionFactoryBuilder().build(conf)
构建了一个DefaultSqlSessionFactory,这是默认的SqlSessionFactory
public SqlSessionFactory build(Configuration config) { return new DefaultSqlSessionFactory(config); } 复制代码
DefaultSqlSessionFactory的核心方法有两个,代码精简过后是下面这个样子的。其实都是一个套路,通过数据源或者连接创建一个事务(上面提到的TransactionFactory创建事务的两种方式),然后创建执行器Executor,最终组合成一个DefaultSqlSession,代表着一次数据库会话,相当于一个JDBC的连接周期。
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) { final Environment environment = configuration.getEnvironment(); final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment); Transaction tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit); final Executor executor = configuration.newExecutor(tx, execType); return new DefaultSqlSession(configuration, executor, autoCommit); } private SqlSession openSessionFromConnection(ExecutorType execType, Connection connection) { boolean autoCommit; try { autoCommit = connection.getAutoCommit(); } catch (SQLException e) { autoCommit = true; } final Environment environment = configuration.getEnvironment(); final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment); final Transaction tx = transactionFactory.newTransaction(connection); final Executor executor = configuration.newExecutor(tx, execType); return new DefaultSqlSession(configuration, executor, autoCommit); } 复制代码
下面这段代码是Configuration对象创建执行器Executor的过程,默认的情况下会创建SimpleExecutor,然后在包装一层用于二级缓存的CachingExecutor,很明显Executor的设计是一个典型的装饰者模式。
public Executor newExecutor(Transaction transaction, ExecutorType executorType) { executorType = executorType == null ? defaultExecutorType : executorType; executorType = executorType == null ? ExecutorType.SIMPLE : executorType; Executor 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); } executor = (Executor) interceptorChain.pluginAll(executor); return executor; } 复制代码
进行一次数据库查询操作的步骤如下:
SqlSession sqlSession = sqlSessionFactory.openSession(true); 复制代码
AddressMapper mapper = sqlSession.getMapper(AddressMapper.class); 复制代码
DefaultSqlSession的 getMapper
方法参数是我们定义的Mapper接口的Class对象,最终是从Configuration对象的 mapperRegistry
注册表中获取这个Mapper的代理对象。
下面是MapperRegistry的 getMapper
方法的核心代码,可见这里是通过MapperProxyFactory创建代理
public <T> T getMapper(Class<T> type, SqlSession sqlSession) { final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type); return mapperProxyFactory.newInstance(sqlSession); } 复制代码
然后是MapperProxyFactory的newInstance方法,看上去是不是相当熟悉。很明显,这是一段JDK动态代理的代码,这里会返回Mapper接口的一个代理类实例。
public T newInstance(SqlSession sqlSession) { final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache); return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy); } 复制代码
Address byId = mapper.getById(110114); 复制代码
这里实际上是调用到Mapper对应的MapperProxy,下面是MapperProxy的 invoke
方法的一部分。可见,这里针对我们调用的Mapper的抽象方法,创建了一个对应的代理方法MapperMethod。
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { final MapperMethod mapperMethod = cachedMapperMethod(method); return mapperMethod.execute(sqlSession, args); } 复制代码
我精简了MapperMethod的 execute
方法的代码,如下所示。其实最终动态代理为我们调用了SqlSession的 select
方法。
public Object execute(SqlSession sqlSession, Object[] args) { Object result; switch (command.getType()) { case SELECT: Object param = method.convertArgsToSqlCommandParam(args); result = sqlSession.selectOne(command.getName(), param); break; } return result; } 复制代码
SqlSession的 selectOne
方法最终是调用的 selectList
,这个方法也非常简单,入参statement其实就是我们定义的Mapper中被调用的方法的全名,本例中就是 x.x.AddressMapper.getById
,通过statement获取对应的MappedStatement,然后交由executor执行query操作。
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { MappedStatement ms = configuration.getMappedStatement(statement); return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER); } 复制代码
前面我们提到过默认的执行器是SimpleExecutor再装饰一层CachingExecutor,下面看看CachingExecutor的query代码,在这个方法之前会先根据SQL和参数等信息创建一个缓存的CacheKey。下面这段代码也非常明了,如果配置了Mapper级别的二级缓存(默认是没有配置的),则优先从缓存中获取,否则将调用被装饰者也就是SimpleExecutor(其实是BaseExecutor)的 query
方法。
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { Cache cache = ms.getCache(); // cache不为空,表示当前Mapper配置了二级缓存 if (cache != null) { flushCacheIfRequired(ms); if (ms.isUseCache() && resultHandler == null) { List<E> list = (List<E>) tcm.getObject(cache, key); // 缓存未命中,查库 if (list == null) { list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); tcm.putObject(cache, key, list); } return list; } } return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); } 复制代码
BaseExecutor的 query
方法的核心代码如下所示,这里有个一级缓存,是开启的,默认的作用域是SqlSession级别的。如果一级缓存未命中,则调用 queryFromDatabase
方法从数据库中查询。
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { List<E> 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); } return list; } 复制代码
然后将调用子类SimpleExecutor的 doQuery
方法,核心代码如下。
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException { Statement stmt = null; Configuration configuration = ms.getConfiguration(); StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql); stmt = prepareStatement(handler, ms.getStatementLog()); return handler.<E>query(stmt, resultHandler); } 复制代码
通过源码发现Configuration创建的是一个RoutingStatementHandler,然后根据MappedStatement的 statementType
属性创建一个具体的StatementHandler(三种STATEMENT、PREPARED或者CALLABLE)。终于出现了一些熟悉的东西了,这不就是JDBC的三种Statement吗。我们选择其中的PreparedStatementHandler来看一看源码,这里就很清晰了,就是调用了JDBC的PreparedStatement的 execute
方法,然后将结果交由ResultHandler处理。
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException { PreparedStatement ps = (PreparedStatement) statement; ps.execute(); return resultSetHandler.<E> handleResultSets(ps); } 复制代码
从上面 doQuery
的代码可以看出,执行的Statement是由 prepareStatement
方法创建的,可以看出这里是调用了StatementHandler的prepare方法创建Statement,实际上是通过MappedStatement的SQL、参数等信息,创建了一个预编译的PrepareStatement。
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException { Statement stmt; Connection connection = getConnection(statementLog); stmt = handler.prepare(connection, transaction.getTimeout()); handler.parameterize(stmt); return stmt; } 复制代码
最终,这个PrepareStatement的执行结果ResultSet,会交由DefaultResultSetHandler来处理,然后根据配置中的类型、Results、返回值等信息,生成对应的实体对象。
到这里我们就分析完了mybatis做一次查询操作所经历的全部流程。当然,这里面还有一些细节没有提到,比如说二级缓存、参数和结果集的解析等,这些具体的内容可能会在后续的mybatis源码解析文章中详细描述。