《Yangzai的知识地图》- MyBatis源码

约定不等于承诺〃 2022-10-29 07:41 146阅读 0赞

# Mybatis源码分析及一些理解 #

系类文章  
1、[Spring源码分析][Spring]

--------------------

### 文章目录 ###

*  Mybatis源码分析及一些理解
 *  前言
 *  一、Mybatis是什么？
 *  二、主要的Factory
 *   *  1.SqlSessionFactory
     *   *  1.1 DefaultSqlSessionFactory
         *  1.2 SqlSessionManager
     *  2.MapperProxyFactory
     *   *  2.1 MapperProxy
     *  3.Transaction
     *   *  3.1.JdbcTransaction
         *  3.2.ManagedTransaction
     *  4.Configuration
     *  5.DataSourceFactory

--------------------

# 前言 #

这是个人技术学习总结的相关文章，是对自己的查缺补漏。

--------------------

# 一、Mybatis是什么？ #

> [官方文档][Link 1]

*  个人理解

> Mybatis就是对JDBC的封装，对一些东西的封装的最根本原因就是解决易用性和不足或提供一些扩展，如jdbc方式操作数据库，存在频繁开启、关闭数据库链接，这样就涉及到了磁盘IO和网络IO的开销，此外还存在硬编码的现象如：sql语句、结果值处理、等，而mybatis解决了这些问题，并且提升了易用性。总之它就是一个ORM工具，会将数据库字段和Java实体做对应。

# 二、主要的Factory #

## 1.SqlSessionFactory ##

代码如下（示例）：

public interface SqlSessionFactory { 
    
      //8个方法可以用来创建SqlSession实例
      SqlSession openSession();
    
      //自动提交
      SqlSession openSession(boolean autoCommit);
      //连接
      SqlSession openSession(Connection connection);
      //事务隔离级别
      SqlSession openSession(TransactionIsolationLevel level);
    
      //执行器的类型
      SqlSession openSession(ExecutorType execType);
      SqlSession openSession(ExecutorType execType, boolean autoCommit);
      SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
      SqlSession openSession(ExecutorType execType, Connection connection);
    
      Configuration getConfiguration();
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1lhbmd6YWlMZUhlSGU_size_16_color_FFFFFF_t_70_pic_center]

### 1.1 DefaultSqlSessionFactory ###

> 这两个类都是SqlSessionFactory的子类，而class DefaultSqlSessionFactory implements SqlSessionFactory，最主要的就是以下两个方法 org.apache.ibatis.session.defaults.DefaultSqlSessionFactory\#openSessionFromDataSource

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);
         //然后产生一个DefaultSqlSession
         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();
       }
     }

> org.apache.ibatis.session.defaults.DefaultSqlSessionFactory\#openSessionFromConnection

private SqlSession openSessionFromConnection(ExecutorType execType, Connection connection) { 
        try { 
          boolean autoCommit;
          try { 
            autoCommit = connection.getAutoCommit();
          } catch (SQLException e) { 
            // Failover to true, as most poor drivers
            // or databases won't support transactions
            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);
        } catch (Exception e) { 
          throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e);
        } finally { 
          ErrorContext.instance().reset();
        }
      }

> 也就是一个从connection中获取session、一个从datasource中获取session。

### 1.2 SqlSessionManager ###

> class SqlSessionManager implements SqlSessionFactory, SqlSession

private SqlSessionManager(SqlSessionFactory sqlSessionFactory) { 
        this.sqlSessionFactory = sqlSessionFactory;
        this.sqlSessionProxy = (SqlSession) Proxy.newProxyInstance(
            SqlSessionFactory.class.getClassLoader(),
            new Class[]{ SqlSession.class},
            new SqlSessionInterceptor());
      }

> 这个类主要是维护了SqlSession并对外提供SqlSession的代理类  
> SqlSession的获取主要是通过上面提到的DefaultSqlSessionFactory来获取，内置的SqlSessionInterceptor 通过动态代理来拓展SqlSession。

//jdk动态代理模式
      private class SqlSessionInterceptor implements InvocationHandler { 
        public SqlSessionInterceptor() { 
            // Prevent Synthetic Access
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
          final SqlSession sqlSession = SqlSessionManager.this.localSqlSession.get();
          if (sqlSession != null) { 
              //如果当前线程已经有SqlSession了，则直接调用
            try { 
              return method.invoke(sqlSession, args);
            } catch (Throwable t) { 
              throw ExceptionUtil.unwrapThrowable(t);
            }
          } else { 
              //如果当前线程没有SqlSession，先打开session，再调用,最后提交
            final SqlSession autoSqlSession = openSession();
            try { 
              final Object result = method.invoke(autoSqlSession, args);
              autoSqlSession.commit();
              return result;
            } catch (Throwable t) { 
              autoSqlSession.rollback();
              throw ExceptionUtil.unwrapThrowable(t);
            } finally { 
              autoSqlSession.close();
            }
          }
        }
      }

## 2.MapperProxyFactory ##

code：

> 这个其实和SqlSessionFactory的思想类似只不过这个工厂类不是接口而是一个class而已。

public class MapperProxyFactory<T> { 
    
      private final Class<T> mapperInterface;
      private Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();
    
      public MapperProxyFactory(Class<T> mapperInterface) { 
        this.mapperInterface = mapperInterface;
      }
    
      public Class<T> getMapperInterface() { 
        return mapperInterface;
      }
    
      public Map<Method, MapperMethod> getMethodCache() { 
        return methodCache;
      }
    
      @SuppressWarnings("unchecked")
      protected T newInstance(MapperProxy<T> mapperProxy) { 
        //用JDK自带的动态代理生成映射器
        return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] {  mapperInterface }, mapperProxy);
      }
    
      public T newInstance(SqlSession sqlSession) { 
        final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
        return newInstance(mapperProxy);
      }
    
    }

### 2.1 MapperProxy ###

> public class MapperProxy implements InvocationHandler, Serializable

> 这个类是MapperMethod的代理类 ，而MapperMethod 【其实就是我们在使用mybatis时定义的接口类】通过execute方法来获取MappedStatement【也就是接口中我们定义好的SQL语句】

//执行
      public Object execute(SqlSession sqlSession, Object[] args) { 
        Object result;
        //可以看到执行时就是4种情况，insert|update|delete|select，分别调用SqlSession的4大类方法
        if (SqlCommandType.INSERT == command.getType()) { 
          Object param = method.convertArgsToSqlCommandParam(args);
          result = rowCountResult(sqlSession.insert(command.getName(), param));
        } else if (SqlCommandType.UPDATE == command.getType()) { 
          Object param = method.convertArgsToSqlCommandParam(args);
          result = rowCountResult(sqlSession.update(command.getName(), param));
        } else if (SqlCommandType.DELETE == command.getType()) { 
          Object param = method.convertArgsToSqlCommandParam(args);
          result = rowCountResult(sqlSession.delete(command.getName(), param));
        } else if (SqlCommandType.SELECT == command.getType()) { 
          if (method.returnsVoid() && method.hasResultHandler()) { 
            //如果有结果处理器
            executeWithResultHandler(sqlSession, args);
            result = null;
          } else if (method.returnsMany()) { 
            //如果结果有多条记录
            result = executeForMany(sqlSession, args);
          } else if (method.returnsMap()) { 
            //如果结果是map
            result = executeForMap(sqlSession, args);
          } else { 
            //否则就是一条记录
            Object param = method.convertArgsToSqlCommandParam(args);
            result = sqlSession.selectOne(command.getName(), param);
          }
        } else { 
          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 void executeWithResultHandler(SqlSession sqlSession, Object[] args) { 
        MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(command.getName());
        if (void.class.equals(ms.getResultMaps().get(0).getType())) { 
          throw new BindingException("method " + command.getName() 
              + " needs either a @ResultMap annotation, a @ResultType annotation," 
              + " or a resultType attribute in XML so a ResultHandler can be used as a parameter.");
        }
        Object param = method.convertArgsToSqlCommandParam(args);
        if (method.hasRowBounds()) { 
          RowBounds rowBounds = method.extractRowBounds(args);
          sqlSession.select(command.getName(), param, rowBounds, method.extractResultHandler(args));
        } else { 
          sqlSession.select(command.getName(), param, method.extractResultHandler(args));
        }
      }

## 3.Transaction ##

> 定义事务的接口Transaction

### 3.1.JdbcTransaction ###

> class JdbcTransaction implements Transaction  
> 默认使用jsbc的事务开启、断开、提交回滚通过JdbcTransactionFactory来进行管理。

public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit) { 
        dataSource = ds;
        level = desiredLevel;
        autoCommmit = desiredAutoCommit;
      }
    
      public JdbcTransaction(Connection connection) { 
        this.connection = connection;
      }
    
      @Override
      public Connection getConnection() throws SQLException { 
        if (connection == null) { 
          openConnection();
        }
        return connection;
      }
    
      @Override
      public void commit() throws SQLException { 
        if (connection != null && !connection.getAutoCommit()) { 
          if (log.isDebugEnabled()) { 
            log.debug("Committing JDBC Connection [" + connection + "]");
          }
          connection.commit();
        }
      }
    
      @Override
      public void rollback() throws SQLException { 
        if (connection != null && !connection.getAutoCommit()) { 
          if (log.isDebugEnabled()) { 
            log.debug("Rolling back JDBC Connection [" + connection + "]");
          }
          connection.rollback();
        }
      }
    
      @Override
      public void close() throws SQLException { 
        if (connection != null) { 
          resetAutoCommit();
          if (log.isDebugEnabled()) { 
            log.debug("Closing JDBC Connection [" + connection + "]");
          }
          connection.close();
        }
      }

### 3.2.ManagedTransaction ###

> ManagedTransactionFactoryimplements TransactionFactory  
> 通过ManagedTransactionFactory来进行管理。

public class ManagedTransactionFactory implements TransactionFactory { 
    
      private boolean closeConnection = true;
    
      @Override
      public void setProperties(Properties props) { 
    		//设置closeConnection属性
        if (props != null) { 
          String closeConnectionProperty = props.getProperty("closeConnection");
          if (closeConnectionProperty != null) { 
            closeConnection = Boolean.valueOf(closeConnectionProperty);
          }
        }
      }
    
      @Override
      public Transaction newTransaction(Connection conn) { 
        return new ManagedTransaction(conn, closeConnection);
      }
    
      @Override
      public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) { 
        // Silently ignores autocommit and isolation level, as managed transactions are entirely
        // controlled by an external manager. It's silently ignored so that
        // code remains portable between managed and unmanaged configurations.
        return new ManagedTransaction(ds, level, closeConnection);
      }
    }

public ManagedTransaction(DataSource ds, TransactionIsolationLevel level, boolean closeConnection) { 
        this.dataSource = ds;
        this.level = level;
        this.closeConnection = closeConnection;
      }
    
      @Override
      public Connection getConnection() throws SQLException { 
        if (this.connection == null) { 
          openConnection();
        }
        return this.connection;
      }
    
      //托管事务commit和rollback都是不做事的，交给容器管理
      @Override
      public void commit() throws SQLException { 
        // Does nothing
      }
    
      @Override
      public void rollback() throws SQLException { 
        // Does nothing 交给运行服务的容器如tomcat或者Spring来管理
      }
    
      @Override
      public void close() throws SQLException { 
        //如果properties文件配置了closeConnection=false,则不关闭连接
        if (this.closeConnection && this.connection != null) { 
          if (log.isDebugEnabled()) { 
            log.debug("Closing JDBC Connection [" + this.connection + "]");
          }
          this.connection.close();
        }
      }

## 4.Configuration ##

> 这个类其实主要知道是所有配置或者注解的对应的类就可以了，什么数据源啊，环境都从这里拿。

public class Configuration { 
    
      //环境
      protected Environment environment;
    
      //---------以下都是<settings>节点-------
      protected boolean safeRowBoundsEnabled = false;
      protected boolean safeResultHandlerEnabled = true;
      protected boolean mapUnderscoreToCamelCase = false;
      protected boolean aggressiveLazyLoading = true;
      protected boolean multipleResultSetsEnabled = true;
      protected boolean useGeneratedKeys = false;
      protected boolean useColumnLabel = true;
      //默认启用缓存
      protected boolean cacheEnabled = true;
      protected boolean callSettersOnNulls = false;
      
      protected String logPrefix;
      protected Class <? extends Log> logImpl;
      protected LocalCacheScope localCacheScope = LocalCacheScope.SESSION;
      protected JdbcType jdbcTypeForNull = JdbcType.OTHER;
      protected Set<String> lazyLoadTriggerMethods = new HashSet<String>(Arrays.asList(new String[] {  "equals", "clone", "hashCode", "toString" }));
      protected Integer defaultStatementTimeout;
      //默认为简单执行器
      protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;
      protected AutoMappingBehavior autoMappingBehavior = AutoMappingBehavior.PARTIAL;
      //---------以上都是<settings>节点-------
    
      protected Properties variables = new Properties();
      //对象工厂和对象包装器工厂
      protected ObjectFactory objectFactory = new DefaultObjectFactory();
      protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();
      //映射注册机
      protected MapperRegistry mapperRegistry = new MapperRegistry(this);
    
      //默认禁用延迟加载
      protected boolean lazyLoadingEnabled = false;
      protected ProxyFactory proxyFactory = new JavassistProxyFactory(); // #224 Using internal Javassist instead of OGNL
    
      protected String databaseId;
      /** * Configuration factory class. * Used to create Configuration for loading deserialized unread properties. * * @see <a href='https://code.google.com/p/mybatis/issues/detail?id=300'>Issue 300</a> (google code) */
      protected Class<?> configurationFactory;
    
      protected final InterceptorChain interceptorChain = new InterceptorChain();
      //类型处理器注册机
      protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry();
      //类型别名注册机
      protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
      protected final LanguageDriverRegistry languageRegistry = new LanguageDriverRegistry();
    
      //映射的语句,存在Map里
      protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection");
      //缓存,存在Map里
      protected final Map<String, Cache> caches = new StrictMap<Cache>("Caches collection");
      //结果映射,存在Map里
      protected final Map<String, ResultMap> resultMaps = new StrictMap<ResultMap>("Result Maps collection");
      protected final Map<String, ParameterMap> parameterMaps = new StrictMap<ParameterMap>("Parameter Maps collection");
      protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<KeyGenerator>("Key Generators collection");
    
      protected final Set<String> loadedResources = new HashSet<String>();
      protected final Map<String, XNode> sqlFragments = new StrictMap<XNode>("XML fragments parsed from previous mappers");
    
      //不完整的SQL语句
      protected final Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<XMLStatementBuilder>();
      protected final Collection<CacheRefResolver> incompleteCacheRefs = new LinkedList<CacheRefResolver>();
      protected final Collection<ResultMapResolver> incompleteResultMaps = new LinkedList<ResultMapResolver>();
      protected final Collection<MethodResolver> incompleteMethods = new LinkedList<MethodResolver>();
    
      /* * A map holds cache-ref relationship. The key is the namespace that * references a cache bound to another namespace and the value is the * namespace which the actual cache is bound to. */
      protected final Map<String, String> cacheRefMap = new HashMap<String, String>();
    
      public Configuration(Environment environment) { 
        this();
        this.environment = environment;
      }
    
      public Configuration() { 
        //注册更多的类型别名，至于为何不直接在TypeAliasRegistry里注册，还需进一步研究
        typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
        typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
    
        typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
        typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
        typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);
    
        typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
        typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
        typeAliasRegistry.registerAlias("LRU", LruCache.class);
        typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
        typeAliasRegistry.registerAlias("WEAK", WeakCache.class);
    
        typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);
    
        typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
        typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);
    
        typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
        typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
        typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
        typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
        typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
        typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
        typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);
    
        typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
        typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);
    
        languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
        languageRegistry.register(RawLanguageDriver.class);
      }
    }
    //...............................

## 5.DataSourceFactory ##

> 数据源工厂，提供了三种数据源的获取，但是我们也可以通过实现该接口来拓展使用其他的第三方数据源。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1lhbmd6YWlMZUhlSGU_size_16_color_FFFFFF_t_70_pic_center 1]

*  JndiDataSourceFactory

> class JndiDataSourceFactory implements DataSourceFactory  
> JNDI数据源工厂是为了使用如 Spring 或应用服务器这类的容器, 容器可以集 中或在外部配置数据源,然后放置一个 JNDI 上下文的引用。

*  UnpooledDataSourceFactory

> class UnpooledDataSourceFactory implements DataSourceFactory  
> 没有连接池的数据源工厂

*  PooledDataSourceFactory

> class PooledDataSourceFactory extends UnpooledDataSourceFactory  
> 有连接池的数据源工厂,通过集成UnpooledDataSourceFactory
> 
>     //数据源换成了PooledDataSource
>     public PooledDataSourceFactory() { 
>      this.dataSource = new PooledDataSource();
>     }

*  我们也可以使用第三方的数据库连接池如Druid.etc

--------------------

[Spring]: https://blog.csdn.net/YangzaiLeHeHe/article/details/113390665
[Link 1]: https://mybatis.org/mybatis-3/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1lhbmd6YWlMZUhlSGU_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/f594b2056f154d0abe5e11aadf5dadeb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1lhbmd6YWlMZUhlSGU_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221024/5beafd111ec140878f3f483bf95b4c7d.png