mybatis源码

你的名字 2021-10-01 10:44 333阅读 0赞

**mybatis的三种Executor**

*  **SimpleExecutor** ：简单执行器，每次执行都会新建statement对象，执行结束会关闭该对象退出
 *  **ReuseExecutor**：复用statment执行器，内部维护一个Map<String,Statement>,key为要执行的sql语句，每次执行sql时都会先进行查找该sql是否已有statement的缓存，有就取出来，没有就新建一个，然后添加到缓存
    
        private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
            Statement stmt;
            BoundSql boundSql = handler.getBoundSql();
            String sql = boundSql.getSql();
            // 判断缓存中是否有该sql对应的statement
            if (hasStatementFor(sql)) {
                // 去除statement
              stmt = getStatement(sql);
                // 设置sql执行的超时时间
              applyTransactionTimeout(stmt);
            } else {
                // 如果不存在sql对应的statemen就新建一个
              Connection connection = getConnection(statementLog);
              stmt = handler.prepare(connection, transaction.getTimeout());
                // 添加到缓存map中
              putStatement(sql, stmt);
            }
            handler.parameterize(stmt);
            return stmt;
          }
 *  **BatchExecutor**：批量执行器

**如何使用**

DataSource dataSource = BlogDataSourceFactory.getBlogDataSource();
    TransactionFactory transactionFactory = new JdbcTransactionFactory();
    Environment environment = new Environment("development", transactionFactory, dataSource);
    Configuration configuration = new Configuration(environment);
    configuration.getTypeAliasRegistry().registerAliases("com.elitetyc.model");
    configuration.addMapper(BlogMapper.class);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);

1.  获取一个数据源
2.  创建事务工场

public interface Transaction {
    
      /**
       * 获取数据库连接
       */
      Connection getConnection() throws SQLException;
    
      /**
       * 提交事务
       */
      void commit() throws SQLException;
    
      /**
       *回滚
       */
      void rollback() throws SQLException;
    
      /**
       *关闭数据库连接
       *           the SQL exception
       */
      void close() throws SQLException;
    
      /**
       * 获取事务超时时间
       *
       */
      Integer getTimeout() throws SQLException;
    
    }

1.  创建环境，建造者模式
    
        public final class Environment {
          private final String id;
          private final TransactionFactory transactionFactory;
          private final DataSource dataSource;
        
          public Environment(String id, TransactionFactory transactionFactory, DataSource dataSource) {
            if (id == null) {
              throw new IllegalArgumentException("Parameter 'id' must not be null");
            }
            if (transactionFactory == null) {
              throw new IllegalArgumentException("Parameter 'transactionFactory' must not be null");
            }
            this.id = id;
            if (dataSource == null) {
              throw new IllegalArgumentException("Parameter 'dataSource' must not be null");
            }
            this.transactionFactory = transactionFactory;
            this.dataSource = dataSource;
          }
        
          public static class Builder {
            private final String id;
            private TransactionFactory transactionFactory;
            private DataSource dataSource;
        
            public Builder(String id) {
              this.id = id;
            }
        
            public Builder transactionFactory(TransactionFactory transactionFactory) {
              this.transactionFactory = transactionFactory;
              return this;
            }
        
            public Builder dataSource(DataSource dataSource) {
              this.dataSource = dataSource;
              return this;
            }
        
            public String id() {
              return this.id;
            }
        
            public Environment build() {
              return new Environment(this.id, this.transactionFactory, this.dataSource);
            }
        
          }
        
          public String getId() {
            return this.id;
          }
        
          public TransactionFactory getTransactionFactory() {
            return this.transactionFactory;
          }
        
          public DataSource getDataSource() {
            return this.dataSource;
          }
        
        }
2.  创建configuration
    
        public Configuration(Environment environment) {
          this();
          this.environment = environment;
        }
        
        public Configuration() {
          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);
        }
    
     *  typeAliasRegistry：给一些类创建别名，就可以在xml mapper中不用写全类名~
3.  类别名注册-
    
        public void registerAliases(String packageName) {
          registerAliases(packageName, Object.class);
        }
        
        public void registerAliases(String packageName, Class<?> superType) {
          ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
          resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
          Set<Class<? extends Class<?>>> typeSet = resolverUtil.getClasses();
          for (Class<?> type : typeSet) {
            // 去除内部类和接口和匿名类
            if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
              registerAlias(type);
            }
          }
        }
        
        public void registerAlias(Class<?> type) {
          String alias = type.getSimpleName();
          Alias aliasAnnotation = type.getAnnotation(Alias.class);
          if (aliasAnnotation != null) {
            alias = aliasAnnotation.value();
          }
          registerAlias(alias, type);
        }
4.  添加具体增删改查mapper，先解析xml mapper再解析接口方法上面的注解，所以当同时书写了这两个地方的sql，会默认使用注解的，会覆盖xml中的配置
    
        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));
              // 将接口方法和xml mapper结合
              MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
              parser.parse();
              loadCompleted = true;
            } finally {
              if (!loadCompleted) {
                knownMappers.remove(type);
              }
            }
          }
        }

public void parse() {
      String resource = type.toString();
       // 如果这个资源没有被加载过--通过名称来判断的
      if (!configuration.isResourceLoaded(resource)) {
      // 将xml mapper解析--最终调用configuration.addMappedStatement(statement);
        loadXmlResource();
        configuration.addLoadedResource(resource);
        assistant.setCurrentNamespace(type.getName());
        parseCache();
        parseCacheRef();
        for (Method method : type.getMethods()) {
          if (!canHaveStatement(method)) {
            continue;
          }
            // 解析接口上面的查询语句结果集封装
          if (getAnnotationWrapper(method, false, Select.class, SelectProvider.class).isPresent()
              && method.getAnnotation(ResultMap.class) == null) {
            parseResultMap(method);
          }
          try {
            // 解析方法上面的注解信息--最终也调用了configuration.addMappedStatement(statement);
            parseStatement(method);
          } catch (IncompleteElementException e) {
            configuration.addIncompleteMethod(new MethodResolver(this, method));
          }
        }
      }
      parsePendingMethods();
    }

1.  开启一个会话连接-使用的是DefaultSqlSessionFactory实现类

@Override
    public SqlSession openSession() {
      return openSessionFromDataSource(configuration.getDefaultExecutorType(), 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);
            // 创建执行器
          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();
        }
      }
    
    public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
        // 未设置时默认使用SimpleExecutor
        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);
        }
        // 如果需要使用缓存，外包装一个类CachingExecutor
        if (cacheEnabled) {
          executor = new CachingExecutor(executor);
        }
        executor = (Executor) interceptorChain.pluginAll(executor);
        return executor;
      }

### configuration ###

/**
     *    Copyright 2009-2020 the original author or authors.
     *
     *    Licensed under the Apache License, Version 2.0 (the "License");
     *    you may not use this file except in compliance with the License.
     *    You may obtain a copy of the License at
     *
     *       http://www.apache.org/licenses/LICENSE-2.0
     *
     *    Unless required by applicable law or agreed to in writing, software
     *    distributed under the License is distributed on an "AS IS" BASIS,
     *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     *    See the License for the specific language governing permissions and
     *    limitations under the License.
     */
    package org.apache.ibatis.session;
    
    import java.util.Arrays;
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    import java.util.Properties;
    import java.util.Set;
    import java.util.function.BiFunction;
    
    import org.apache.ibatis.binding.MapperRegistry;
    import org.apache.ibatis.builder.CacheRefResolver;
    import org.apache.ibatis.builder.IncompleteElementException;
    import org.apache.ibatis.builder.ResultMapResolver;
    import org.apache.ibatis.builder.annotation.MethodResolver;
    import org.apache.ibatis.builder.xml.XMLStatementBuilder;
    import org.apache.ibatis.cache.Cache;
    import org.apache.ibatis.cache.decorators.FifoCache;
    import org.apache.ibatis.cache.decorators.LruCache;
    import org.apache.ibatis.cache.decorators.SoftCache;
    import org.apache.ibatis.cache.decorators.WeakCache;
    import org.apache.ibatis.cache.impl.PerpetualCache;
    import org.apache.ibatis.datasource.jndi.JndiDataSourceFactory;
    import org.apache.ibatis.datasource.pooled.PooledDataSourceFactory;
    import org.apache.ibatis.datasource.unpooled.UnpooledDataSourceFactory;
    import org.apache.ibatis.executor.BatchExecutor;
    import org.apache.ibatis.executor.CachingExecutor;
    import org.apache.ibatis.executor.Executor;
    import org.apache.ibatis.executor.ReuseExecutor;
    import org.apache.ibatis.executor.SimpleExecutor;
    import org.apache.ibatis.executor.keygen.KeyGenerator;
    import org.apache.ibatis.executor.loader.ProxyFactory;
    import org.apache.ibatis.executor.loader.cglib.CglibProxyFactory;
    import org.apache.ibatis.executor.loader.javassist.JavassistProxyFactory;
    import org.apache.ibatis.executor.parameter.ParameterHandler;
    import org.apache.ibatis.executor.resultset.DefaultResultSetHandler;
    import org.apache.ibatis.executor.resultset.ResultSetHandler;
    import org.apache.ibatis.executor.statement.RoutingStatementHandler;
    import org.apache.ibatis.executor.statement.StatementHandler;
    import org.apache.ibatis.io.VFS;
    import org.apache.ibatis.logging.Log;
    import org.apache.ibatis.logging.LogFactory;
    import org.apache.ibatis.logging.commons.JakartaCommonsLoggingImpl;
    import org.apache.ibatis.logging.jdk14.Jdk14LoggingImpl;
    import org.apache.ibatis.logging.log4j.Log4jImpl;
    import org.apache.ibatis.logging.log4j2.Log4j2Impl;
    import org.apache.ibatis.logging.nologging.NoLoggingImpl;
    import org.apache.ibatis.logging.slf4j.Slf4jImpl;
    import org.apache.ibatis.logging.stdout.StdOutImpl;
    import org.apache.ibatis.mapping.BoundSql;
    import org.apache.ibatis.mapping.Environment;
    import org.apache.ibatis.mapping.MappedStatement;
    import org.apache.ibatis.mapping.ParameterMap;
    import org.apache.ibatis.mapping.ResultMap;
    import org.apache.ibatis.mapping.ResultSetType;
    import org.apache.ibatis.mapping.VendorDatabaseIdProvider;
    import org.apache.ibatis.parsing.XNode;
    import org.apache.ibatis.plugin.Interceptor;
    import org.apache.ibatis.plugin.InterceptorChain;
    import org.apache.ibatis.reflection.DefaultReflectorFactory;
    import org.apache.ibatis.reflection.MetaObject;
    import org.apache.ibatis.reflection.ReflectorFactory;
    import org.apache.ibatis.reflection.factory.DefaultObjectFactory;
    import org.apache.ibatis.reflection.factory.ObjectFactory;
    import org.apache.ibatis.reflection.wrapper.DefaultObjectWrapperFactory;
    import org.apache.ibatis.reflection.wrapper.ObjectWrapperFactory;
    import org.apache.ibatis.scripting.LanguageDriver;
    import org.apache.ibatis.scripting.LanguageDriverRegistry;
    import org.apache.ibatis.scripting.defaults.RawLanguageDriver;
    import org.apache.ibatis.scripting.xmltags.XMLLanguageDriver;
    import org.apache.ibatis.transaction.Transaction;
    import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
    import org.apache.ibatis.transaction.managed.ManagedTransactionFactory;
    import org.apache.ibatis.type.JdbcType;
    import org.apache.ibatis.type.TypeAliasRegistry;
    import org.apache.ibatis.type.TypeHandler;
    import org.apache.ibatis.type.TypeHandlerRegistry;
    
    /**
     * @author Clinton Begin
     */
    public class Configuration {
    
      protected Environment environment;
    
      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 boolean shrinkWhitespacesInSql;
    
      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;
    
      protected Properties variables = new Properties();
      protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory();
      protected ObjectFactory objectFactory = new DefaultObjectFactory();
      protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();
    
      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 (google code)</a>
       */
      protected Class<?> configurationFactory;
    
        // 接口mapper注册器
      protected final MapperRegistry mapperRegistry = new MapperRegistry(this);
      protected final InterceptorChain interceptorChain = new InterceptorChain();
      protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry(this);
      protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
      protected final LanguageDriverRegistry languageRegistry = new LanguageDriverRegistry();
    
        // sql映射存放map，xml中的每一个映射都会保存一个到这个map
      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");
      protected final Map<String, ResultMap> resultMaps = new StrictMap<>("Result Maps collection");
      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<>();
      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<>();
    
      /*
       * 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<>();
    
      public Configuration(Environment environment) {
        this();
        this.environment = environment;
      }
    
      public Configuration() {
        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);
      }
    
      public String getLogPrefix() {
        return logPrefix;
      }
    
      public void setLogPrefix(String logPrefix) {
        this.logPrefix = logPrefix;
      }
    
      public Class<? extends Log> getLogImpl() {
        return logImpl;
      }
    
      public void setLogImpl(Class<? extends Log> logImpl) {
        if (logImpl != null) {
          this.logImpl = logImpl;
          LogFactory.useCustomLogging(this.logImpl);
        }
      }
    
      public Class<? extends VFS> getVfsImpl() {
        return this.vfsImpl;
      }
    
      public void setVfsImpl(Class<? extends VFS> vfsImpl) {
        if (vfsImpl != null) {
          this.vfsImpl = vfsImpl;
          VFS.addImplClass(this.vfsImpl);
        }
      }
    
      public boolean isCallSettersOnNulls() {
        return callSettersOnNulls;
      }
    
      public void setCallSettersOnNulls(boolean callSettersOnNulls) {
        this.callSettersOnNulls = callSettersOnNulls;
      }
    
      public boolean isUseActualParamName() {
        return useActualParamName;
      }
    
      public void setUseActualParamName(boolean useActualParamName) {
        this.useActualParamName = useActualParamName;
      }
    
      public boolean isReturnInstanceForEmptyRow() {
        return returnInstanceForEmptyRow;
      }
    
      public void setReturnInstanceForEmptyRow(boolean returnEmptyInstance) {
        this.returnInstanceForEmptyRow = returnEmptyInstance;
      }
    
      public boolean isShrinkWhitespacesInSql() {
        return shrinkWhitespacesInSql;
      }
    
      public void setShrinkWhitespacesInSql(boolean shrinkWhitespacesInSql) {
        this.shrinkWhitespacesInSql = shrinkWhitespacesInSql;
      }
    
      public String getDatabaseId() {
        return databaseId;
      }
    
      public void setDatabaseId(String databaseId) {
        this.databaseId = databaseId;
      }
    
      public Class<?> getConfigurationFactory() {
        return configurationFactory;
      }
    
      public void setConfigurationFactory(Class<?> configurationFactory) {
        this.configurationFactory = configurationFactory;
      }
    
      public boolean isSafeResultHandlerEnabled() {
        return safeResultHandlerEnabled;
      }
    
      public void setSafeResultHandlerEnabled(boolean safeResultHandlerEnabled) {
        this.safeResultHandlerEnabled = safeResultHandlerEnabled;
      }
    
      public boolean isSafeRowBoundsEnabled() {
        return safeRowBoundsEnabled;
      }
    
      public void setSafeRowBoundsEnabled(boolean safeRowBoundsEnabled) {
        this.safeRowBoundsEnabled = safeRowBoundsEnabled;
      }
    
      public boolean isMapUnderscoreToCamelCase() {
        return mapUnderscoreToCamelCase;
      }
    
      public void setMapUnderscoreToCamelCase(boolean mapUnderscoreToCamelCase) {
        this.mapUnderscoreToCamelCase = mapUnderscoreToCamelCase;
      }
    
      public void addLoadedResource(String resource) {
        loadedResources.add(resource);
      }
    
      public boolean isResourceLoaded(String resource) {
        return loadedResources.contains(resource);
      }
    
      public Environment getEnvironment() {
        return environment;
      }
    
      public void setEnvironment(Environment environment) {
        this.environment = environment;
      }
    
      public AutoMappingBehavior getAutoMappingBehavior() {
        return autoMappingBehavior;
      }
    
      public void setAutoMappingBehavior(AutoMappingBehavior autoMappingBehavior) {
        this.autoMappingBehavior = autoMappingBehavior;
      }
    
      /**
       * Gets the auto mapping unknown column behavior.
       *
       * @return the auto mapping unknown column behavior
       * @since 3.4.0
       */
      public AutoMappingUnknownColumnBehavior getAutoMappingUnknownColumnBehavior() {
        return autoMappingUnknownColumnBehavior;
      }
    
      /**
       * Sets the auto mapping unknown column behavior.
       *
       * @param autoMappingUnknownColumnBehavior
       *          the new auto mapping unknown column behavior
       * @since 3.4.0
       */
      public void setAutoMappingUnknownColumnBehavior(AutoMappingUnknownColumnBehavior autoMappingUnknownColumnBehavior) {
        this.autoMappingUnknownColumnBehavior = autoMappingUnknownColumnBehavior;
      }
    
      public boolean isLazyLoadingEnabled() {
        return lazyLoadingEnabled;
      }
    
      public void setLazyLoadingEnabled(boolean lazyLoadingEnabled) {
        this.lazyLoadingEnabled = lazyLoadingEnabled;
      }
    
      public ProxyFactory getProxyFactory() {
        return proxyFactory;
      }
    
      public void setProxyFactory(ProxyFactory proxyFactory) {
        if (proxyFactory == null) {
          proxyFactory = new JavassistProxyFactory();
        }
        this.proxyFactory = proxyFactory;
      }
    
      public boolean isAggressiveLazyLoading() {
        return aggressiveLazyLoading;
      }
    
      public void setAggressiveLazyLoading(boolean aggressiveLazyLoading) {
        this.aggressiveLazyLoading = aggressiveLazyLoading;
      }
    
      public boolean isMultipleResultSetsEnabled() {
        return multipleResultSetsEnabled;
      }
    
      public void setMultipleResultSetsEnabled(boolean multipleResultSetsEnabled) {
        this.multipleResultSetsEnabled = multipleResultSetsEnabled;
      }
    
      public Set<String> getLazyLoadTriggerMethods() {
        return lazyLoadTriggerMethods;
      }
    
      public void setLazyLoadTriggerMethods(Set<String> lazyLoadTriggerMethods) {
        this.lazyLoadTriggerMethods = lazyLoadTriggerMethods;
      }
    
      public boolean isUseGeneratedKeys() {
        return useGeneratedKeys;
      }
    
      public void setUseGeneratedKeys(boolean useGeneratedKeys) {
        this.useGeneratedKeys = useGeneratedKeys;
      }
    
      public ExecutorType getDefaultExecutorType() {
        return defaultExecutorType;
      }
    
      public void setDefaultExecutorType(ExecutorType defaultExecutorType) {
        this.defaultExecutorType = defaultExecutorType;
      }
    
      public boolean isCacheEnabled() {
        return cacheEnabled;
      }
    
      public void setCacheEnabled(boolean cacheEnabled) {
        this.cacheEnabled = cacheEnabled;
      }
    
      public Integer getDefaultStatementTimeout() {
        return defaultStatementTimeout;
      }
    
      public void setDefaultStatementTimeout(Integer defaultStatementTimeout) {
        this.defaultStatementTimeout = defaultStatementTimeout;
      }
    
      /**
       * Gets the default fetch size.
       *
       * @return the default fetch size
       * @since 3.3.0
       */
      public Integer getDefaultFetchSize() {
        return defaultFetchSize;
      }
    
      /**
       * Sets the default fetch size.
       *
       * @param defaultFetchSize
       *          the new default fetch size
       * @since 3.3.0
       */
      public void setDefaultFetchSize(Integer defaultFetchSize) {
        this.defaultFetchSize = defaultFetchSize;
      }
    
      /**
       * Gets the default result set type.
       *
       * @return the default result set type
       * @since 3.5.2
       */
      public ResultSetType getDefaultResultSetType() {
        return defaultResultSetType;
      }
    
      /**
       * Sets the default result set type.
       *
       * @param defaultResultSetType
       *          the new default result set type
       * @since 3.5.2
       */
      public void setDefaultResultSetType(ResultSetType defaultResultSetType) {
        this.defaultResultSetType = defaultResultSetType;
      }
    
      public boolean isUseColumnLabel() {
        return useColumnLabel;
      }
    
      public void setUseColumnLabel(boolean useColumnLabel) {
        this.useColumnLabel = useColumnLabel;
      }
    
      public LocalCacheScope getLocalCacheScope() {
        return localCacheScope;
      }
    
      public void setLocalCacheScope(LocalCacheScope localCacheScope) {
        this.localCacheScope = localCacheScope;
      }
    
      public JdbcType getJdbcTypeForNull() {
        return jdbcTypeForNull;
      }
    
      public void setJdbcTypeForNull(JdbcType jdbcTypeForNull) {
        this.jdbcTypeForNull = jdbcTypeForNull;
      }
    
      public Properties getVariables() {
        return variables;
      }
    
      public void setVariables(Properties variables) {
        this.variables = variables;
      }
    
      public TypeHandlerRegistry getTypeHandlerRegistry() {
        return typeHandlerRegistry;
      }
    
      /**
       * Set a default {@link TypeHandler} class for {@link Enum}.
       * A default {@link TypeHandler} is {@link org.apache.ibatis.type.EnumTypeHandler}.
       * @param typeHandler a type handler class for {@link Enum}
       * @since 3.4.5
       */
      public void setDefaultEnumTypeHandler(Class<? extends TypeHandler> typeHandler) {
        if (typeHandler != null) {
          getTypeHandlerRegistry().setDefaultEnumTypeHandler(typeHandler);
        }
      }
    
      public TypeAliasRegistry getTypeAliasRegistry() {
        return typeAliasRegistry;
      }
    
      /**
       * Gets the mapper registry.
       *
       * @return the mapper registry
       * @since 3.2.2
       */
      public MapperRegistry getMapperRegistry() {
        return mapperRegistry;
      }
    
      public ReflectorFactory getReflectorFactory() {
        return reflectorFactory;
      }
    
      public void setReflectorFactory(ReflectorFactory reflectorFactory) {
        this.reflectorFactory = reflectorFactory;
      }
    
      public ObjectFactory getObjectFactory() {
        return objectFactory;
      }
    
      public void setObjectFactory(ObjectFactory objectFactory) {
        this.objectFactory = objectFactory;
      }
    
      public ObjectWrapperFactory getObjectWrapperFactory() {
        return objectWrapperFactory;
      }
    
      public void setObjectWrapperFactory(ObjectWrapperFactory objectWrapperFactory) {
        this.objectWrapperFactory = objectWrapperFactory;
      }
    
      /**
       * Gets the interceptors.
       *
       * @return the interceptors
       * @since 3.2.2
       */
      public List<Interceptor> getInterceptors() {
        return interceptorChain.getInterceptors();
      }
    
      public LanguageDriverRegistry getLanguageRegistry() {
        return languageRegistry;
      }
    
      public void setDefaultScriptingLanguage(Class<? extends LanguageDriver> driver) {
        if (driver == null) {
          driver = XMLLanguageDriver.class;
        }
        getLanguageRegistry().setDefaultDriverClass(driver);
      }
    
      public LanguageDriver getDefaultScriptingLanguageInstance() {
        return languageRegistry.getDefaultDriver();
      }
    
      /**
       * Gets the language driver.
       *
       * @param langClass
       *          the lang class
       * @return the language driver
       * @since 3.5.1
       */
      public LanguageDriver getLanguageDriver(Class<? extends LanguageDriver> langClass) {
        if (langClass == null) {
          return languageRegistry.getDefaultDriver();
        }
        languageRegistry.register(langClass);
        return languageRegistry.getDriver(langClass);
      }
    
      /**
       * Gets the default scripting lanuage instance.
       *
       * @return the default scripting lanuage instance
       * @deprecated Use {@link #getDefaultScriptingLanguageInstance()}
       */
      @Deprecated
      public LanguageDriver getDefaultScriptingLanuageInstance() {
        return getDefaultScriptingLanguageInstance();
      }
    
      public MetaObject newMetaObject(Object object) {
        return MetaObject.forObject(object, objectFactory, objectWrapperFactory, reflectorFactory);
      }
    
      public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
        ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
        parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
        return parameterHandler;
      }
    
      public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
          ResultHandler resultHandler, BoundSql boundSql) {
        ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
        resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
        return resultSetHandler;
      }
    
      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 Executor newExecutor(Transaction transaction) {
        return newExecutor(transaction, defaultExecutorType);
      }
    
      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;
      }
    
      public void addKeyGenerator(String id, KeyGenerator keyGenerator) {
        keyGenerators.put(id, keyGenerator);
      }
    
      public Collection<String> getKeyGeneratorNames() {
        return keyGenerators.keySet();
      }
    
      public Collection<KeyGenerator> getKeyGenerators() {
        return keyGenerators.values();
      }
    
      public KeyGenerator getKeyGenerator(String id) {
        return keyGenerators.get(id);
      }
    
      public boolean hasKeyGenerator(String id) {
        return keyGenerators.containsKey(id);
      }
    
      public void addCache(Cache cache) {
        caches.put(cache.getId(), cache);
      }
    
      public Collection<String> getCacheNames() {
        return caches.keySet();
      }
    
      public Collection<Cache> getCaches() {
        return caches.values();
      }
    
      public Cache getCache(String id) {
        return caches.get(id);
      }
    
      public boolean hasCache(String id) {
        return caches.containsKey(id);
      }
    
      public void addResultMap(ResultMap rm) {
        resultMaps.put(rm.getId(), rm);
        checkLocallyForDiscriminatedNestedResultMaps(rm);
        checkGloballyForDiscriminatedNestedResultMaps(rm);
      }
    
      public Collection<String> getResultMapNames() {
        return resultMaps.keySet();
      }
    
      public Collection<ResultMap> getResultMaps() {
        return resultMaps.values();
      }
    
      public ResultMap getResultMap(String id) {
        return resultMaps.get(id);
      }
    
      public boolean hasResultMap(String id) {
        return resultMaps.containsKey(id);
      }
    
      public void addParameterMap(ParameterMap pm) {
        parameterMaps.put(pm.getId(), pm);
      }
    
      public Collection<String> getParameterMapNames() {
        return parameterMaps.keySet();
      }
    
      public Collection<ParameterMap> getParameterMaps() {
        return parameterMaps.values();
      }
    
      public ParameterMap getParameterMap(String id) {
        return parameterMaps.get(id);
      }
    
      public boolean hasParameterMap(String id) {
        return parameterMaps.containsKey(id);
      }
    
      public void addMappedStatement(MappedStatement ms) {
        mappedStatements.put(ms.getId(), ms);
      }
    
      public Collection<String> getMappedStatementNames() {
        buildAllStatements();
        return mappedStatements.keySet();
      }
    
      public Collection<MappedStatement> getMappedStatements() {
        buildAllStatements();
        return mappedStatements.values();
      }
    
      public Collection<XMLStatementBuilder> getIncompleteStatements() {
        return incompleteStatements;
      }
    
      public void addIncompleteStatement(XMLStatementBuilder incompleteStatement) {
        incompleteStatements.add(incompleteStatement);
      }
    
      public Collection<CacheRefResolver> getIncompleteCacheRefs() {
        return incompleteCacheRefs;
      }
    
      public void addIncompleteCacheRef(CacheRefResolver incompleteCacheRef) {
        incompleteCacheRefs.add(incompleteCacheRef);
      }
    
      public Collection<ResultMapResolver> getIncompleteResultMaps() {
        return incompleteResultMaps;
      }
    
      public void addIncompleteResultMap(ResultMapResolver resultMapResolver) {
        incompleteResultMaps.add(resultMapResolver);
      }
    
      public void addIncompleteMethod(MethodResolver builder) {
        incompleteMethods.add(builder);
      }
    
      public Collection<MethodResolver> getIncompleteMethods() {
        return incompleteMethods;
      }
    
      public MappedStatement getMappedStatement(String id) {
        return this.getMappedStatement(id, true);
      }
    
      public MappedStatement getMappedStatement(String id, boolean validateIncompleteStatements) {
        if (validateIncompleteStatements) {
          buildAllStatements();
        }
        return mappedStatements.get(id);
      }
    
      public Map<String, XNode> getSqlFragments() {
        return sqlFragments;
      }
    
      public void addInterceptor(Interceptor interceptor) {
        interceptorChain.addInterceptor(interceptor);
      }
    
      public void addMappers(String packageName, Class<?> superType) {
        mapperRegistry.addMappers(packageName, superType);
      }
    
      public void addMappers(String packageName) {
        mapperRegistry.addMappers(packageName);
      }
    
      public <T> void addMapper(Class<T> type) {
        mapperRegistry.addMapper(type);
      }
    
      public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
        return mapperRegistry.getMapper(type, sqlSession);
      }
    
      public boolean hasMapper(Class<?> type) {
        return mapperRegistry.hasMapper(type);
      }
    
      public boolean hasStatement(String statementName) {
        return hasStatement(statementName, true);
      }
    
      public boolean hasStatement(String statementName, boolean validateIncompleteStatements) {
        if (validateIncompleteStatements) {
          buildAllStatements();
        }
        return mappedStatements.containsKey(statementName);
      }
    
      public void addCacheRef(String namespace, String referencedNamespace) {
        cacheRefMap.put(namespace, referencedNamespace);
      }
    
      /*
       * Parses all the unprocessed statement nodes in the cache. It is recommended
       * to call this method once all the mappers are added as it provides fail-fast
       * statement validation.
       */
      protected void buildAllStatements() {
        parsePendingResultMaps();
        if (!incompleteCacheRefs.isEmpty()) {
          synchronized (incompleteCacheRefs) {
            incompleteCacheRefs.removeIf(x -> x.resolveCacheRef() != null);
          }
        }
        if (!incompleteStatements.isEmpty()) {
          synchronized (incompleteStatements) {
            incompleteStatements.removeIf(x -> {
              x.parseStatementNode();
              return true;
            });
          }
        }
        if (!incompleteMethods.isEmpty()) {
          synchronized (incompleteMethods) {
            incompleteMethods.removeIf(x -> {
              x.resolve();
              return true;
            });
          }
        }
      }
    
      private void parsePendingResultMaps() {
        if (incompleteResultMaps.isEmpty()) {
          return;
        }
        synchronized (incompleteResultMaps) {
          boolean resolved;
          IncompleteElementException ex = null;
          do {
            resolved = false;
            Iterator<ResultMapResolver> iterator = incompleteResultMaps.iterator();
            while (iterator.hasNext()) {
              try {
                iterator.next().resolve();
                iterator.remove();
                resolved = true;
              } catch (IncompleteElementException e) {
                ex = e;
              }
            }
          } while (resolved);
          if (!incompleteResultMaps.isEmpty() && ex != null) {
            // At least one result map is unresolvable.
            throw ex;
          }
        }
      }
    
      /**
       * Extracts namespace from fully qualified statement id.
       *
       * @param statementId
       *          the statement id
       * @return namespace or null when id does not contain period.
       */
      protected String extractNamespace(String statementId) {
        int lastPeriod = statementId.lastIndexOf('.');
        return lastPeriod > 0 ? statementId.substring(0, lastPeriod) : null;
      }
    
      // Slow but a one time cost. A better solution is welcome.
      protected void checkGloballyForDiscriminatedNestedResultMaps(ResultMap rm) {
        if (rm.hasNestedResultMaps()) {
          for (Map.Entry<String, ResultMap> entry : resultMaps.entrySet()) {
            Object value = entry.getValue();
            if (value instanceof ResultMap) {
              ResultMap entryResultMap = (ResultMap) value;
              if (!entryResultMap.hasNestedResultMaps() && entryResultMap.getDiscriminator() != null) {
                Collection<String> discriminatedResultMapNames = entryResultMap.getDiscriminator().getDiscriminatorMap().values();
                if (discriminatedResultMapNames.contains(rm.getId())) {
                  entryResultMap.forceNestedResultMaps();
                }
              }
            }
          }
        }
      }
    
      // Slow but a one time cost. A better solution is welcome.
      protected void checkLocallyForDiscriminatedNestedResultMaps(ResultMap rm) {
        if (!rm.hasNestedResultMaps() && rm.getDiscriminator() != null) {
          for (Map.Entry<String, String> entry : rm.getDiscriminator().getDiscriminatorMap().entrySet()) {
            String discriminatedResultMapName = entry.getValue();
            if (hasResultMap(discriminatedResultMapName)) {
              ResultMap discriminatedResultMap = resultMaps.get(discriminatedResultMapName);
              if (discriminatedResultMap.hasNestedResultMaps()) {
                rm.forceNestedResultMaps();
                break;
              }
            }
          }
        }
      }
    
    }

# spring boot 中mybatis如何注册的mapper #

#### 最终的结果：mybatis默认扫描指定包下的独立并且包含bean定义的接口 ####

1.  @MapperScan通过MapperScannerRegistrar获取mapperScan注解上面的包名创建MapperScannerConfigurer加入到SpringBoot的IOC容器中(mapper扫描配置信息，可以有多个，可以通过@MapperScans注解来声明多个)
2.  由于MapperScannerConfigurer实现了BeanDefinitionRegistryPostProcessor(会执行内部postProcessBeanDefinitionRegistry方法，这里mybatis调用了扫描指定的包)
    
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
          if (this.processPropertyPlaceHolders) {
            processPropertyPlaceHolders();
          }
        
          ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
          scanner.setAddToConfig(this.addToConfig);
          scanner.setAnnotationClass(this.annotationClass);
          scanner.setMarkerInterface(this.markerInterface);
          scanner.setSqlSessionFactory(this.sqlSessionFactory);
          scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
          scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
          scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
          scanner.setResourceLoader(this.applicationContext);
          scanner.setBeanNameGenerator(this.nameGenerator);
          scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);
          if (StringUtils.hasText(lazyInitialization)) {
            scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));
          }
           // 告诉扫描器需要扫描哪些东西
          scanner.registerFilters();
            // 扫描包
          scanner.scan(
              StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
        }
    
     *  scanner.registerFilters();重点，mybatis需要扫描哪些类出来，父类doScan调用isCandidateComponent方法(mybatisScaner进行了重写，只要独立的接口类)
        
            public void registerFilters() {
                // 标记是否自定义了扫描信息
              boolean acceptAllInterfaces = true;
            
              // 如果指定了扫描哪个注解就扫描哪个
              if (this.annotationClass != null) {
                addIncludeFilter(new AnnotationTypeFilter(this.annotationClass));
                acceptAllInterfaces = false;
              }
            
              // override AssignableTypeFilter to ignore matches on the actual marker interface
              if (this.markerInterface != null) {
                addIncludeFilter(new AssignableTypeFilter(this.markerInterface) {
                  @Override
                  protected boolean matchClassName(String className) {
                    return false;
                  }
                });
                acceptAllInterfaces = false;
              }
            
              if (acceptAllInterfaces) {
                // 如果没有自定义扫描，默认都返回true
                addIncludeFilter((metadataReader, metadataReaderFactory) -> true);
              }
            
              // exclude package-info.java
              addExcludeFilter((metadataReader, metadataReaderFactory) -> {
                String className = metadataReader.getClassMetadata().getClassName();
                return className.endsWith("package-info");
              });
            }
            
            // 这个方法表示只需要独立的接口类
            @Override
              protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
                return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
              }
     *  ClassPathMapperScanner继承了ClassPathBeanDefinitionScanner，上面就是调用了父类的scan方法，父类方法又调用了doScan，其中ClassPathMapperScanner重写了doScan，所以会走到该类的doScan，但是子类的doScan又调用了父类的doScan，**父类的doScan主要是查询当前系统中指定包下的bean定义(即使用了@service,@component等的类)**
     *      @Override
            public Set<BeanDefinitionHolder> doScan(String... basePackages) {
            
            // 调用父类的doScan方法
              Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
            
              if (beanDefinitions.isEmpty()) {
                LOGGER.warn(() -> "No MyBatis mapper was found in '" + Arrays.toString(basePackages)
                    + "' package. Please check your configuration.");
              } else {
              // 对bena定义进行处理
                processBeanDefinitions(beanDefinitions);
              }
            
              return beanDefinitions;
            }
     *  bean处理方法
        
            private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
              GenericBeanDefinition definition;
              for (BeanDefinitionHolder holder : beanDefinitions) {
                definition = (GenericBeanDefinition) holder.getBeanDefinition();
                String beanClassName = definition.getBeanClassName();
                LOGGER.debug(() -> "Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + beanClassName
                    + "' mapperInterface");
            
                // the mapper interface is the original class of the bean
                // but, the actual class of the bean is MapperFactoryBean
                  // 翻译一下：mapper接口是Bean的原始类///，但是Bean的实际类是MapperFactoryBean
                  // 因为MapperFactoryBean的构造函数需要一个入参，就是原始接口类，所以这里加入到bean定义的构造函数参数列表中去，
                  // 再反射时会将该参数传递到构造函数：org.springframework.beans.factory.support.ConstructorResolver#autowireConstructor该方法将获取下面代码存储的构造函数参数
                definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59
                  // 设置bean的实现类为MapperFactoryBean.class，即接口的具体实现是MapperFactoryBean
                definition.setBeanClass(this.mapperFactoryBeanClass);
            
                definition.getPropertyValues().add("addToConfig", this.addToConfig);
            
                boolean explicitFactoryUsed = false;
                if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
                  definition.getPropertyValues().add("sqlSessionFactory",
                      new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
                  explicitFactoryUsed = true;
                } else if (this.sqlSessionFactory != null) {
                  definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
                  explicitFactoryUsed = true;
                }
            
                if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
                  if (explicitFactoryUsed) {
                    LOGGER.warn(
                        () -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
                  }
                  definition.getPropertyValues().add("sqlSessionTemplate",
                      new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
                  explicitFactoryUsed = true;
                } else if (this.sqlSessionTemplate != null) {
                  if (explicitFactoryUsed) {
                    LOGGER.warn(
                        () -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
                  }
                  definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
                  explicitFactoryUsed = true;
                }
            
                if (!explicitFactoryUsed) {
                  LOGGER.debug(() -> "Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
                  definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
                }
                definition.setLazyInit(lazyInitialization);
              }
            }
     *  Mapper工场方法：实现了FactoryBean，可以创建指定接口的Bean
     *      public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
            
              private Class<T> mapperInterface;
            
              private boolean addToConfig = true;
            
              public MapperFactoryBean() {
                // intentionally empty
              }
            
              public MapperFactoryBean(Class<T> mapperInterface) {
                this.mapperInterface = mapperInterface;
              }
            
              /**
               * {@inheritDoc}
               */
              @Override
              protected void checkDaoConfig() {
                super.checkDaoConfig();
            
                notNull(this.mapperInterface, "Property 'mapperInterface' is required");
            
                Configuration configuration = getSqlSession().getConfiguration();
                if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {
                  try {
                      // 调用configuration的addMapper，最终会调用MapperRegistry的addMapper-调用new MapperProxyFactory<>(type)创建接口的代理，导致最终调用接口方法时调用的是代理类的接口
                    configuration.addMapper(this.mapperInterface);
                  } catch (Exception e) {
                    logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", e);
                    throw new IllegalArgumentException(e);
                  } finally {
                    ErrorContext.instance().reset();
                  }
                }
              }
            
              /**
               * {@inheritDoc}
               */
              @Override
              public T getObject() throws Exception {
                return getSqlSession().getMapper(this.mapperInterface);
              }
            
              /**
               * {@inheritDoc}
               */
              @Override
              public Class<T> getObjectType() {
                return this.mapperInterface;
              }
            
              /**
               * {@inheritDoc}
               */
              @Override
              public boolean isSingleton() {
                return true;
              }
            
              
            }