mybatis源码解读：session包

川长思鸟来 2022-10-29 12:26 230阅读 0赞

session包是整个mybatis应用的对外接口包。

1.SqlSession及其相关类

1.1 SqlSession的生成链

在进行查询操作时，只需要和SqlSession对象打交道，而SqlSession对象是由SqlSessionFactory生产出来的，而SqlSessionFactory又是由SqlSessionFactoryBuilder创建的。

public class SqlSessionFactoryBuilder {
    
      public SqlSessionFactory build(Reader reader) {
        return build(reader, null, null);
      }
    
      public SqlSessionFactory build(Reader reader, String environment) {
        return build(reader, environment, null);
      }
    
      public SqlSessionFactory build(Reader reader, Properties properties) {
        return build(reader, null, properties);
      }
    
      /**
       * 建造一个SqlSessionFactory对象
       * @param reader 读取字符流的抽象类
       * @param environment 环境信息
       * @param properties 配置信息
       * @return SqlSessionFactory对象
       */
      public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
        try {
          // 传入配置文件，创建一个XMLConfigBuilder类
          XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
          // 分两步：
          // 1、解析配置文件，得到配置文件对应的Configuration对象
          // 2、根据Configuration对象，获得一个DefaultSqlSessionFactory
          return build(parser.parse());
        } catch (Exception e) {
          throw ExceptionFactory.wrapException("Error building SqlSession.", e);
        } finally {
          ErrorContext.instance().reset();
          try {
            reader.close();
          } catch (IOException e) {
          }
        }
      }
    
      public SqlSessionFactory build(InputStream inputStream) {
        return build(inputStream, null, null);
      }
    
      public SqlSessionFactory build(InputStream inputStream, String environment) {
        return build(inputStream, environment, null);
      }
    
      public SqlSessionFactory build(InputStream inputStream, Properties properties) {
        return build(inputStream, null, properties);
      }
    
      public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
        try {
          XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
          return build(parser.parse());
        } catch (Exception e) {
          throw ExceptionFactory.wrapException("Error building SqlSession.", e);
        } finally {
          ErrorContext.instance().reset();
          try {
            inputStream.close();
          } catch (IOException e) {
          }
        }
      }
    
      /**
       * 根据配置信息建造一个SqlSessionFactory对象
       * @param config 配置信息
       * @return SqlSessionFactory对象
       */
      public SqlSessionFactory build(Configuration config) {
        return new DefaultSqlSessionFactory(config);
      }
    
    }

DefaultSqlSessionFactory对象可以创建出SqlSession的子类DefualtSqlSession类的对象，该过程由openSessionFromDataSourcce方法完成。

/**
       * 从数据源中获取SqlSession对象
       * @param execType 执行器类型
       * @param level 事务隔离级别
       * @param autoCommit 是否自动提交事务
       * @return SqlSession对象
       */
      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);
          throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
        } finally {
          ErrorContext.instance().reset();
        }
      }

至此，整个SqlSession生成链的相关操作，经过逐级生成后终于得到DefaultSqlSession对象。

1.2 DefaultSqlSessio类

DefaultSqlSessio类的主要工作是把接口包的工作交给执行器包处理。

public class DefaultSqlSession implements SqlSession {
      // 配置信息
      private final Configuration configuration;
      // 执行器
      private final Executor executor;
      // 是否自动提交
      private final boolean autoCommit;
      // 缓存是否已经被污染
      private boolean dirty;
      // 游标列表
      private List<Cursor<?>> cursorList;
    
      /**
       * 查询结果列表
       * @param <E> 返回的列表元素的类型
       * @param statement SQL语句
       * @param parameter 参数对象
       * @param rowBounds  翻页限制条件
       * @return 结果对象列表
       */
      @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();
        }
      }
    }

DefaultSqlSession类将主要操作都交给属性中的Executor对象处理，相关数据库查询操作都有Executor对象的query方法来完成。

1.3SqlSessionManager类

public class SqlSessionManager implements SqlSessionFactory, SqlSession {
    
      // 构造方法中传入的SqlSessionFactory对象
      private final SqlSessionFactory sqlSessionFactory;
      // 在构造方法中创建的SqlSession代理对象
      private final SqlSession sqlSessionProxy;
      // 该变量用来存储被代理的SqlSession对象
      private final ThreadLocal<SqlSession> localSqlSession = new ThreadLocal<>();
    
      /**
       * SqlSessionManager构造方法
       * @param sqlSessionFactory SqlSession工厂
       */
      private SqlSessionManager(SqlSessionFactory sqlSessionFactory) {
        this.sqlSessionFactory = sqlSessionFactory;
        this.sqlSessionProxy = (SqlSession) Proxy.newProxyInstance(
            SqlSessionFactory.class.getClassLoader(),
            new Class[]{SqlSession.class},
            new SqlSessionInterceptor());
      }
    
    @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          // 尝试从当前线程中取出SqlSession对象
          final SqlSession sqlSession = SqlSessionManager.this.localSqlSession.get();
          if (sqlSession != null) { // 当前线程中确实取出了SqlSession对象
            try {
              // 使用取出的SqlSession对象进行操作
              return method.invoke(sqlSession, args);
            } catch (Throwable t) {
              throw ExceptionUtil.unwrapThrowable(t);
            }
          } else { // 当前线程中还没有SqlSession对象
            // 使用属性中的SqlSessionFactory对象创建一个SqlSession对象
            try (SqlSession autoSqlSession = openSession()) {
              try {
                // 使用新创建的SqlSession对象进行操作
                final Object result = method.invoke(autoSqlSession, args);
                autoSqlSession.commit();
                return result;
              } catch (Throwable t) {
                autoSqlSession.rollback();
                throw ExceptionUtil.unwrapThrowable(t);
              }
            }
          }
        }
      }
    }

SqlSessionManager类主要提供产品复用功能。工厂生成的产品可以放入线程ThreadLocal保存，从而实现产品的复用，这样即保证了线程安全又提升了效率。

1.4 Configuration类

配置文件mybatis-config.xml是mybatis配置主入口，该配置文件的信息经过解析后都存入了Configuration对象中，因此Configuration类包含了mybatis运行的所有配置信息。而且Configuration类还对配置信息进行了进一步加工，为许多配置项设置了默认值，为许多实体类定义了别名等。

public class Configuration {
    
      // <environment>节点的信息
      protected Environment environment;
    
      // 以下为<settings>节点中的配置信息
      protected boolean safeRowBoundsEnabled;
      protected boolean safeResultHandlerEnabled = true;
      protected boolean mapUnderscoreToCamelCase;
      protected boolean aggressiveLazyLoading;
      protected boolean multipleResultSetsEnabled = true;
      protected boolean useGeneratedKeys;
      protected boolean useColumnLabel = true;
      protected boolean cacheEnabled = true;
      protected boolean callSettersOnNulls;
      protected boolean useActualParamName = true;
      protected boolean returnInstanceForEmptyRow;
    
      protected String logPrefix;
      protected Class<? extends Log> logImpl;
      protected Class<? extends VFS> vfsImpl;
      protected LocalCacheScope localCacheScope = LocalCacheScope.SESSION;
      protected JdbcType jdbcTypeForNull = JdbcType.OTHER;
      protected Set<String> lazyLoadTriggerMethods = new HashSet<>(Arrays.asList("equals", "clone", "hashCode", "toString"));
      protected Integer defaultStatementTimeout;
      protected Integer defaultFetchSize;
      protected ResultSetType defaultResultSetType;
      protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;
      protected AutoMappingBehavior autoMappingBehavior = AutoMappingBehavior.PARTIAL;
      protected AutoMappingUnknownColumnBehavior autoMappingUnknownColumnBehavior = AutoMappingUnknownColumnBehavior.NONE;
      // 以上为<settings>节点中的配置信息
    
      // <properties>节点信息
      protected Properties variables = new Properties();
      // 反射工厂
      protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory();
      // 对象工厂
      protected ObjectFactory objectFactory = new DefaultObjectFactory();
      // 对象包装工厂
      protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();
      // 是否启用懒加载，该配置来自<settings>节点
      protected boolean lazyLoadingEnabled = false;
      // 代理工厂
      protected ProxyFactory proxyFactory = new JavassistProxyFactory(); // #224 Using internal Javassist instead of OGNL
      // 数据库编号
      protected String databaseId;
      // 配置工厂，用来创建用于加载反序列化的未读属性的配置。
      protected Class<?> configurationFactory;
      // 映射注册表
      protected final MapperRegistry mapperRegistry = new MapperRegistry(this);
      // 拦截器链（用来支持插件的插入）
      protected final InterceptorChain interceptorChain = new InterceptorChain();
      // 类型处理器注册表，内置许多，可以通过<typeHandlers>节点补充
      protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry();
      // 类型别名注册表，内置许多，可以通过<typeAliases>节点补充
      protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
      // 语言驱动注册表
      protected final LanguageDriverRegistry languageRegistry = new LanguageDriverRegistry();
      // 映射的数据库操作语句
      protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection")
          .conflictMessageProducer((savedValue, targetValue) ->
              ". please check " + savedValue.getResource() + " and " + targetValue.getResource());
      // 缓存
      protected final Map<String, Cache> caches = new StrictMap<>("Caches collection");
      // 结果映射，即所有的<resultMap>节点
      protected final Map<String, ResultMap> resultMaps = new StrictMap<>("Result Maps collection");
      // 参数映射，即所有的<parameterMap>节点
      protected final Map<String, ParameterMap> parameterMaps = new StrictMap<>("Parameter Maps collection");
      // 主键生成器映射
      protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<>("Key Generators collection");
      // 载入的资源，例如映射文件资源
      protected final Set<String> loadedResources = new HashSet<>();
      // SQL语句片段，即所有的<sql>节点
      protected final Map<String, XNode> sqlFragments = new StrictMap<>("XML fragments parsed from previous mappers");
    
      // 暂存未处理完成的一些节点
      protected final Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<>();
      protected final Collection<CacheRefResolver> incompleteCacheRefs = new LinkedList<>();
      protected final Collection<ResultMapResolver> incompleteResultMaps = new LinkedList<>();
      protected final Collection<MethodResolver> incompleteMethods = new LinkedList<>();
    
      // 用来存储跨namespace的缓存共享设置
      protected final Map<String, String> cacheRefMap = new HashMap<>();
    }

为了便于配置信息的快速查询，Configuration类中还设置了一个内部类StrictMap，是HashMap的子类。

protected static class StrictMap<V> extends HashMap<String, V> {
    
        private static final long serialVersionUID = -4950446264854982944L;
        private final String name;
        private BiFunction<V, V, String> conflictMessageProducer;
    
    
        /**
         * 向Map中写入键值对
         * @param key 键
         * @param value 值
         * @return 旧值，如果不存在旧值则为null。因为StrictMap不允许覆盖，则只能返回null
         */
        @Override
        @SuppressWarnings("unchecked")
        public V put(String key, V value) {
          if (containsKey(key)) {
            //如果已经存在此key了，直接报错
            throw new IllegalArgumentException(name + " already contains value for " + key
                + (conflictMessageProducer == null ? "" : conflictMessageProducer.apply(super.get(key), value)));
          }
          if (key.contains(".")) {
            // 例如key=“com.github.yeecode.clazzName”，则shortName = “clazzName”，即获取一个短名称
            final String shortKey = getShortName(key);
            if (super.get(shortKey) == null) {
              // 以短名称为键，放置一次
              super.put(shortKey, value);
            } else {
              // 放入该对象，表示短名称会引发歧义
              super.put(shortKey, (V) new Ambiguity(shortKey));
            }
          }
          // 以长名称为键，放置一次
          return super.put(key, value);
        }
    
        @Override
        public V get(Object key) {
          V value = super.get(key);
          if (value == null) {
            throw new IllegalArgumentException(name + " does not contain value for " + key);
          }
          if (value instanceof Ambiguity) {
            throw new IllegalArgumentException(((Ambiguity) value).getSubject() + " is ambiguous in " + name
                + " (try using the full name including the namespace, or rename one of the entries)");
          }
          return value;
        }
    
        // 含糊，是说短名称指代不明，引发歧义
        // 因此，只要拿到该类型的value，说明：
        // 1，用户一定使用了shortName进行了查询
        // 2, 这个shortName存在重名
        protected static class Ambiguity {
          final private String subject;
    
          public Ambiguity(String subject) {
            this.subject = subject;
          }
    
          public String getSubject() {
            return subject;
          }
        }
    
        private String getShortName(String key) {
          final String[] keyParts = key.split("\\.");
          return keyParts[keyParts.length - 1];
        }
      }

欢迎关注本人公众号：

![20201220181855568.png][]

[20201220181855568.png]: /images/20221024/1bd5a6dec8e742c8bd798229de259569.png