第 3 章 MybatisPlus 注入 SQL 原理分析

墨蓝 2023-01-17 15:55 551阅读 0赞

# 第 3 章 MybatisPlus 注入 SQL 原理分析 #

> **思考问题**

我们编写的 `UserMapper` 继承了 `BaseMapper<T>`，就拥有了基本的增删改查功能，这是因为 `BaseMapper` 中提供了通用的 CRUD 方法

从上面的 SQL 日志也能看出，执行 `BaseMapper` 中的方法时会发出 SQL 语句，那么这些 SQL 语句哪里来的呢？其实是 MybatisPlus 在启动时就帮我们预先加载好了 SQL 语句

## 1、MybatisPlus 的几大核心类 ##

### 1.1、Configuration ###

> **Configuration：全局配置类**

`Configuration`：MybatisPlus 全局配置对象，存储着 MybatisPlus 的全局配置

/**
     * @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 Class<?> defaultSqlProviderType;
      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://github.com/mybatis/old-google-code-issues/issues/300'>Issue 300 (google code)</a>
       */
      protected Class<?> configurationFactory;
    
      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();
    
      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<>();
        
      public Environment getEnvironment() {
        
        return environment;
      }
    
      public void setEnvironment(Environment environment) {
        
        this.environment = environment;
      }

通过`Configuration#setEnvironment(Environment environment)` 方法注入 `Environment` 对象，该对象对应着数据库环境（配置）信息，比如连接超时时间、数据源的用户名、用户密码、jdbcURL、驱动类等等

![image-20210421081537444][]

### 1.2、MappedStatement ###

> **MappedStatement：SQL 语句映射**

`MappedStatement`：一 个 `MappedStatement` 对象对应着 `Mapper` 映射接口中的一个  
`select/update/insert/delete` 方法，其主要作用是描述了接口方法对应的 SQL 语句

`MappedStatement` 类有一个 `Builder` 内部类，通过 `Builder` 类中的方法可以帮我们很方便地构造 `MappedStatement` 对象

/**
     * @author Clinton Begin
     */
    public final class MappedStatement {
        
    
      private String resource;
      private Configuration configuration;
      private String id;
      private Integer fetchSize;
      private Integer timeout;
      private StatementType statementType;
      private ResultSetType resultSetType;
      private SqlSource sqlSource;
      private Cache cache;
      private ParameterMap parameterMap;
      private List<ResultMap> resultMaps;
      private boolean flushCacheRequired;
      private boolean useCache;
      private boolean resultOrdered;
      private SqlCommandType sqlCommandType;
      private KeyGenerator keyGenerator;
      private String[] keyProperties;
      private String[] keyColumns;
      private boolean hasNestedResultMaps;
      private String databaseId;
      private Log statementLog;
      private LanguageDriver lang;
      private String[] resultSets;
    
      MappedStatement() {
        
        // constructor disabled
      }
    
      public static class Builder {
        
        private MappedStatement mappedStatement = new MappedStatement();
    
        public Builder(Configuration configuration, String id, SqlSource sqlSource, SqlCommandType sqlCommandType) {
        
          mappedStatement.configuration = configuration;
          mappedStatement.id = id;
          mappedStatement.sqlSource = sqlSource;
          mappedStatement.statementType = StatementType.PREPARED;
          mappedStatement.resultSetType = ResultSetType.DEFAULT;
          mappedStatement.parameterMap = new ParameterMap.Builder(configuration, "defaultParameterMap", null, new ArrayList<>()).build();
          mappedStatement.resultMaps = new ArrayList<>();
          mappedStatement.sqlCommandType = sqlCommandType;
          mappedStatement.keyGenerator = configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType) ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
          String logId = id;
          if (configuration.getLogPrefix() != null) {
        
            logId = configuration.getLogPrefix() + id;
          }
          mappedStatement.statementLog = LogFactory.getLog(logId);
          mappedStatement.lang = configuration.getDefaultScriptingLanguageInstance();
        }
    
        public Builder resource(String resource) {
        
          mappedStatement.resource = resource;
          return this;
        }
    
        public String id() {
        
          return mappedStatement.id;
        }
    
        public Builder parameterMap(ParameterMap parameterMap) {
        
          mappedStatement.parameterMap = parameterMap;
          return this;
        }
    
        public Builder resultMaps(List<ResultMap> resultMaps) {
        
          mappedStatement.resultMaps = resultMaps;
          for (ResultMap resultMap : resultMaps) {
        
            mappedStatement.hasNestedResultMaps = mappedStatement.hasNestedResultMaps || resultMap.hasNestedResultMaps();
          }
          return this;
        }
    
        public Builder fetchSize(Integer fetchSize) {
        
          mappedStatement.fetchSize = fetchSize;
          return this;
        }
    
        public Builder timeout(Integer timeout) {
        
          mappedStatement.timeout = timeout;
          return this;
        }
    
        public Builder statementType(StatementType statementType) {
        
          mappedStatement.statementType = statementType;
          return this;
        }
    
        public Builder resultSetType(ResultSetType resultSetType) {
        
          mappedStatement.resultSetType = resultSetType == null ? ResultSetType.DEFAULT : resultSetType;
          return this;
        }
    
        public Builder cache(Cache cache) {
        
          mappedStatement.cache = cache;
          return this;
        }
    
        public Builder flushCacheRequired(boolean flushCacheRequired) {
        
          mappedStatement.flushCacheRequired = flushCacheRequired;
          return this;
        }
    
        public Builder useCache(boolean useCache) {
        
          mappedStatement.useCache = useCache;
          return this;
        }
    
        public Builder resultOrdered(boolean resultOrdered) {
        
          mappedStatement.resultOrdered = resultOrdered;
          return this;
        }
    
        public Builder keyGenerator(KeyGenerator keyGenerator) {
        
          mappedStatement.keyGenerator = keyGenerator;
          return this;
        }
    
        public Builder keyProperty(String keyProperty) {
        
          mappedStatement.keyProperties = delimitedStringToArray(keyProperty);
          return this;
        }
    
        public Builder keyColumn(String keyColumn) {
        
          mappedStatement.keyColumns = delimitedStringToArray(keyColumn);
          return this;
        }
    
        public Builder databaseId(String databaseId) {
        
          mappedStatement.databaseId = databaseId;
          return this;
        }
    
        public Builder lang(LanguageDriver driver) {
        
          mappedStatement.lang = driver;
          return this;
        }
    
        public Builder resultSets(String resultSet) {
        
          mappedStatement.resultSets = delimitedStringToArray(resultSet);
          return this;
        }
    
        /**
         * Resul sets.
         *
         * @param resultSet
         *          the result set
         * @return the builder
         * @deprecated Use {@link #resultSets}
         */
        @Deprecated
        public Builder resulSets(String resultSet) {
        
          mappedStatement.resultSets = delimitedStringToArray(resultSet);
          return this;
        }
    
        public MappedStatement build() {
        
          assert mappedStatement.configuration != null;
          assert mappedStatement.id != null;
          assert mappedStatement.sqlSource != null;
          assert mappedStatement.lang != null;
          mappedStatement.resultMaps = Collections.unmodifiableList(mappedStatement.resultMaps);
          return mappedStatement;
        }
      }

通过 `Builder` 类的构造器和 setter 方法注入 `MappedStatement` 对象的字段值，比如 `sqlSource`、`sqlCommandType` 等等，最后调用 `Builde#build()` 方法构造出 `MappedStatement` 对象返回给使用者

![image-20210421082212253][]

![image-20210421082518419][]

### 1.3、SqlMethod ###

> **SqlMethod：CRUD 方法对应的 SQL 类型**

`SqlMethod`：枚举对象，表示 MybatisPlus 支持的 SQL 操作

/**
     * MybatisPlus 支持 SQL 方法
     *
     * @author hubin
     * @since 2016-01-23
     */
    public enum SqlMethod {
        
        /**
         * 插入
         */
        INSERT_ONE("insert", "插入一条数据（选择字段插入）", "<script>\nINSERT INTO %s %s VALUES %s\n</script>"),
        UPSERT_ONE("upsert", "Phoenix插入一条数据（选择字段插入）", "<script>\nUPSERT INTO %s %s VALUES %s\n</script>"),
    
        /**
         * 删除
         */
        DELETE_BY_ID("deleteById", "根据ID 删除一条数据", "<script>\nDELETE FROM %s WHERE %s=#{%s}\n</script>"),
        DELETE_BY_MAP("deleteByMap", "根据columnMap 条件删除记录", "<script>\nDELETE FROM %s %s\n</script>"),
        DELETE("delete", "根据 entity 条件删除记录", "<script>\nDELETE FROM %s %s %s\n</script>"),
        DELETE_BATCH_BY_IDS("deleteBatchIds", "根据ID集合，批量删除数据", "<script>\nDELETE FROM %s WHERE %s IN (%s)\n</script>"),
    
        /**
         * 逻辑删除
         */
        LOGIC_DELETE_BY_ID("deleteById", "根据ID 逻辑删除一条数据", "<script>\nUPDATE %s %s WHERE %s=#{%s} %s\n</script>"),
        LOGIC_DELETE_BY_MAP("deleteByMap", "根据columnMap 条件逻辑删除记录", "<script>\nUPDATE %s %s %s\n</script>"),
        LOGIC_DELETE("delete", "根据 entity 条件逻辑删除记录", "<script>\nUPDATE %s %s %s %s\n</script>"),
        LOGIC_DELETE_BATCH_BY_IDS("deleteBatchIds", "根据ID集合，批量逻辑删除数据", "<script>\nUPDATE %s %s WHERE %s IN (%s) %s\n</script>"),
    
        /**
         * 修改
         */
        UPDATE_BY_ID("updateById", "根据ID 选择修改数据", "<script>\nUPDATE %s %s WHERE %s=#{%s} %s\n</script>"),
        UPDATE("update", "根据 whereEntity 条件，更新记录", "<script>\nUPDATE %s %s %s %s\n</script>"),
    
        /**
         * 逻辑删除 -> 修改
         */
        LOGIC_UPDATE_BY_ID("updateById", "根据ID 修改数据", "<script>\nUPDATE %s %s WHERE %s=#{%s} %s\n</script>"),
    
        /**
         * 查询
         */
        SELECT_BY_ID("selectById", "根据ID 查询一条数据", "SELECT %s FROM %s WHERE %s=#{%s} %s"),
        SELECT_BY_MAP("selectByMap", "根据columnMap 查询一条数据", "<script>SELECT %s FROM %s %s\n</script>"),
        SELECT_BATCH_BY_IDS("selectBatchIds", "根据ID集合，批量查询数据", "<script>SELECT %s FROM %s WHERE %s IN (%s) %s</script>"),
        SELECT_ONE("selectOne", "查询满足条件一条数据", "<script>%s SELECT %s FROM %s %s %s\n</script>"),
        SELECT_COUNT("selectCount", "查询满足条件总记录数", "<script>%s SELECT COUNT(%s) FROM %s %s %s\n</script>"),
        SELECT_LIST("selectList", "查询满足条件所有数据", "<script>%s SELECT %s FROM %s %s %s\n</script>"),
        SELECT_PAGE("selectPage", "查询满足条件所有数据（并翻页）", "<script>%s SELECT %s FROM %s %s %s\n</script>"),
        SELECT_MAPS("selectMaps", "查询满足条件所有数据", "<script>%s SELECT %s FROM %s %s %s\n</script>"),
        SELECT_MAPS_PAGE("selectMapsPage", "查询满足条件所有数据（并翻页）", "<script>\n %s SELECT %s FROM %s %s %s\n</script>"),
        SELECT_OBJS("selectObjs", "查询满足条件所有数据", "<script>%s SELECT %s FROM %s %s %s\n</script>");
    
        private final String method;
        private final String desc;
        private final String sql;
        
        SqlMethod(String method, String desc, String sql) {
        
            this.method = method;
            this.desc = desc;
            this.sql = sql;
    	}

通过 `SqlMethod` 的构造器为 Mapper 接口中的方法指定描述信息（`desc`）和 sql 语句（带占位符的 sql 语句）

![image-20210421082713764][]

### 1.4、TableInfo ###

> **TableInfo：数据库表信息**

`TableInfo`：数据库表信息 ，可以获取到数据库表相关的信息

/**
     * 数据库表反射信息
     *
     * @author hubin
     * @since 2016-01-23
     */
    @Data
    @Setter(AccessLevel.PACKAGE)
    @Accessors(chain = true)
    @SuppressWarnings("serial")
    public class TableInfo implements Constants {
        
    
        /**
         * 实体类型
         */
        private Class<?> entityType;
        /**
         * 表主键ID 类型
         */
        private IdType idType = IdType.NONE;
        /**
         * 表名称
         */
        private String tableName;
        /**
         * 表映射结果集
         */
        private String resultMap;
        /**
         * 是否是需要自动生成的 resultMap
         */
        private boolean autoInitResultMap;
        /**
         * 主键是否有存在字段名与属性名关联
         * <p>true: 表示要进行 as</p>
         */
        private boolean keyRelated;
        /**
         * 表主键ID 字段名
         */
        private String keyColumn;
        /**
         * 表主键ID 属性名
         */
        private String keyProperty;
        /**
         * 表主键ID 属性类型
         */
        private Class<?> keyType;
        /**
         * 表主键ID Sequence
         */
        private KeySequence keySequence;
        /**
         * 表字段信息列表
         */
        private List<TableFieldInfo> fieldList;
        /**
         * 命名空间 (对应的 mapper 接口的全类名)
         */
        private String currentNamespace;
        /**
         * MybatisConfiguration 标记 (Configuration内存地址值)
         */
        @Getter
        private Configuration configuration;
        /**
         * 是否开启下划线转驼峰
         * <p>
         * 未注解指定字段名的情况下,用于自动从 property 推算 column 的命名
         */
        private boolean underCamel;
        /**
         * 缓存包含主键及字段的 sql select
         */
        @Setter(AccessLevel.NONE)
        @Getter(AccessLevel.NONE)
        private String allSqlSelect;
        /**
         * 缓存主键字段的 sql select
         */
        @Setter(AccessLevel.NONE)
        @Getter(AccessLevel.NONE)
        private String sqlSelect;
        /**
         * 表字段是否启用了插入填充
         *
         * @since 3.3.0
         */
        @Getter
        @Setter(AccessLevel.NONE)
        private boolean withInsertFill;
        /**
         * 表字段是否启用了更新填充
         *
         * @since 3.3.0
         */
        @Getter
        @Setter(AccessLevel.NONE)
        private boolean withUpdateFill;
        /**
         * 表字段是否启用了逻辑删除
         *
         * @since 3.4.0
         */
        @Getter
        @Setter(AccessLevel.NONE)
        private boolean withLogicDelete;
        /**
         * 逻辑删除字段
         *
         * @since 3.4.0
         */
        @Getter
        @Setter(AccessLevel.NONE)
        private TableFieldInfo logicDeleteFieldInfo;
        /**
         * 表字段是否启用了乐观锁
         *
         * @since 3.3.1
         */
        @Getter
        @Setter(AccessLevel.NONE)
        private boolean withVersion;
        /**
         * 乐观锁字段
         *
         * @since 3.3.1
         */
        @Getter
        @Setter(AccessLevel.NONE)
        private TableFieldInfo versionFieldInfo;
    
        public TableInfo(Class<?> entityType) {
        
            this.entityType = entityType;
        }
    
        /**
         * 获得注入的 SQL Statement
         *
         * @param sqlMethod MybatisPlus 支持 SQL 方法
         * @return SQL Statement
         * @deprecated 3.4.0 如果存在的多mapper共用一个实体的情况，这里可能会出现获取命名空间错误的情况
         */
        @Deprecated
        public String getSqlStatement(String sqlMethod) {
        
            return currentNamespace + DOT + sqlMethod;
        }
    
        /**
         * 设置 Configuration
         */
        void setConfiguration(Configuration configuration) {
        
            Assert.notNull(configuration, "Error: You need Initialize MybatisConfiguration !");
            this.configuration = configuration;
            this.underCamel = configuration.isMapUnderscoreToCamelCase();
        }
    
        /**
         * 是否有主键
         *
         * @return 是否有
         */
        public boolean havePK() {
        
            return StringUtils.isNotBlank(keyColumn);
        }

通过 `TableInfo` 的构造器注入当前数据库表对应的实体类型

![image-20210421083107683][]

通过 `setConfiguration()` 方法注入 MybatisPlus 全局配置对象

![image-20210421083143692][]

### 1.5、SqlSource ###

> **SqlSource：事先可以确定的 SQL 语句**

`SqlSource`：对于事先可以确定的 SQL 语句，MybatisPlus 会将方法对应的 SQL 语句存放在 `StaticSqlSource` 中；但如果 SQL 语句需要根据条件构造器进行拼接，MybatisPlus 会将对应的 SQL 语句节点存放在 `DynamicSqlSource` 中

/**
     * @author Clinton Begin
     */
    public class StaticSqlSource implements SqlSource {
        
    
      private final String sql;
      private final List<ParameterMapping> parameterMappings;
      private final Configuration configuration;
        
        
    /**
     * @author Clinton Begin
     */
    public class DynamicSqlSource implements SqlSource {
        
    
      private final Configuration configuration;
      private final SqlNode rootSqlNode;

`DynamicSqlSource` 为代表动态 Sql 语句，动态 SQL 语句会根据 Wrapper 条件构造器动态拼接 SQL 语句

![image-20210421083343065][]

`StaticSqlSource` 为代表静态 Sql 语句，sql 字段的值用于存储静态 SQL 语句

![image-20210421083407887][]

### 1.6、SqlNode ###

> **SqlNode：SQL 节点**

`SqlNode`：对于需要条件构造器拼接的 SQL 语句，MybatisPlus 会将各 SQL 节点存放在 `SqlNode` 中，之后再根据条件进行拼接。其实现主要有：`MixedSqlNode`、`StaticTextSqlNode`、`TextSqlNode`、`ForEachSqlNode`、`VarDeclSqlNode`、`IfSqlNode`、`TrimSqlNode`、`ChooseSqlNode`

/**
     * @author Clinton Begin
     */
    public class StaticTextSqlNode implements SqlNode {
        
      private final String text;
    
      public StaticTextSqlNode(String text) {
        
        this.text = text;
      }
    
      @Override
      public boolean apply(DynamicContext context) {
        
        context.appendSql(text);
        return true;
      }
    
    }
    
    /**
     * @author Clinton Begin
     */
    public class IfSqlNode implements SqlNode {
        
      private final ExpressionEvaluator evaluator;
      private final String test;
      private final SqlNode contents;
    
      public IfSqlNode(SqlNode contents, String test) {
        
        this.test = test;
        this.contents = contents;
        this.evaluator = new ExpressionEvaluator();
      }
    
      @Override
      public boolean apply(DynamicContext context) {
        
        if (evaluator.evaluateBoolean(test, context.getBindings())) {
        
          contents.apply(context);
          return true;
        }
        return false;
      }
    
    }

`IfSqlNode` 代表 `IF` 动态节点，MybatisPlus 在处理这类节点时，会根据 `text` 条件的值，动态拼接 `contents` 中的 SQL 语句

![image-20210420231301429][]

`StaticTextSqlNode` 代表静态文本节点，MybatisPlus 在处理这类节点时，会直接将 `text` 字段值取出，拼接到 SQL 语句中

![image-20210421083548588][]

### 1.7、MapperBuilderAssistant ###

> **MapperBuilderAssistant：构建 Mappedstatements 对象**

`MapperBuilderAssistant`：用于缓存、 SQL 参数、查询方法结果集处理等。通过 `MapperBuilderAssistant` 将每一个 `mappedStatement` 添加到 `configuration` 中的 `mappedstatements` 中

/**
     * @author Clinton Begin
     */
    public class MapperBuilderAssistant extends BaseBuilder {
        
    
      private String currentNamespace;
      private final String resource;
      private Cache currentCache;
      private boolean unresolvedCacheRef; // issue #676
    
      public MapperBuilderAssistant(Configuration configuration, String resource) {
        
        super(configuration);
        ErrorContext.instance().resource(resource);
        this.resource = resource;
      }
    
      public String getCurrentNamespace() {
        
        return currentNamespace;
      }
    
      public void setCurrentNamespace(String currentNamespace) {
        
        if (currentNamespace == null) {
        
          throw new BuilderException("The mapper element requires a namespace attribute to be specified.");
        }
    
        if (this.currentNamespace != null && !this.currentNamespace.equals(currentNamespace)) {
        
          throw new BuilderException("Wrong namespace. Expected '"
              + this.currentNamespace + "' but found '" + currentNamespace + "'.");
        }
    
        this.currentNamespace = currentNamespace;
      }
    
      public String applyCurrentNamespace(String base, boolean isReference) {
        
        if (base == null) {
        
          return null;
        }
        if (isReference) {
        
          // is it qualified with any namespace yet?
          if (base.contains(".")) {
        
            return base;
          }
        } else {
        
          // is it qualified with this namespace yet?
          if (base.startsWith(currentNamespace + ".")) {
        
            return base;
          }
          if (base.contains(".")) {
        
            throw new BuilderException("Dots are not allowed in element names, please remove it from " + base);
          }
        }
        return currentNamespace + "." + base;
      }
    
      public Cache useCacheRef(String namespace) {
        
        if (namespace == null) {
        
          throw new BuilderException("cache-ref element requires a namespace attribute.");
        }
        try {
        
          unresolvedCacheRef = true;
          Cache cache = configuration.getCache(namespace);
          if (cache == null) {
        
            throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.");
          }
          currentCache = cache;
          unresolvedCacheRef = false;
          return cache;
        } catch (IllegalArgumentException e) {
        
          throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.", e);
        }
      }
    
      public Cache useNewCache(Class<? extends Cache> typeClass,
          Class<? extends Cache> evictionClass,
          Long flushInterval,
          Integer size,
          boolean readWrite,
          boolean blocking,
          Properties props) {
        
        Cache cache = new CacheBuilder(currentNamespace)
            .implementation(valueOrDefault(typeClass, PerpetualCache.class))
            .addDecorator(valueOrDefault(evictionClass, LruCache.class))
            .clearInterval(flushInterval)
            .size(size)
            .readWrite(readWrite)
            .blocking(blocking)
            .properties(props)
            .build();
        configuration.addCache(cache);
        currentCache = cache;
        return cache;
      }
    
      public ParameterMap addParameterMap(String id, Class<?> parameterClass, List<ParameterMapping> parameterMappings) {
        
        id = applyCurrentNamespace(id, false);
        ParameterMap parameterMap = new ParameterMap.Builder(configuration, id, parameterClass, parameterMappings).build();
        configuration.addParameterMap(parameterMap);
        return parameterMap;
      }
    
      public ParameterMapping buildParameterMapping(
          Class<?> parameterType,
          String property,
          Class<?> javaType,
          JdbcType jdbcType,
          String resultMap,
          ParameterMode parameterMode,
          Class<? extends TypeHandler<?>> typeHandler,
          Integer numericScale) {
        
        resultMap = applyCurrentNamespace(resultMap, true);
    
        // Class parameterType = parameterMapBuilder.type();
        Class<?> javaTypeClass = resolveParameterJavaType(parameterType, property, javaType, jdbcType);
        TypeHandler<?> typeHandlerInstance = resolveTypeHandler(javaTypeClass, typeHandler);
    
        return new ParameterMapping.Builder(configuration, property, javaTypeClass)
            .jdbcType(jdbcType)
            .resultMapId(resultMap)
            .mode(parameterMode)
            .numericScale(numericScale)
            .typeHandler(typeHandlerInstance)
            .build();
      }
    
      public ResultMap addResultMap(
          String id,
          Class<?> type,
          String extend,
          Discriminator discriminator,
          List<ResultMapping> resultMappings,
          Boolean autoMapping) {
        
        id = applyCurrentNamespace(id, false);
        extend = applyCurrentNamespace(extend, true);
    
        if (extend != null) {
        
          if (!configuration.hasResultMap(extend)) {
        
            throw new IncompleteElementException("Could not find a parent resultmap with id '" + extend + "'");
          }
          ResultMap resultMap = configuration.getResultMap(extend);
          List<ResultMapping> extendedResultMappings = new ArrayList<>(resultMap.getResultMappings());
          extendedResultMappings.removeAll(resultMappings);
          // Remove parent constructor if this resultMap declares a constructor.
          boolean declaresConstructor = false;
          for (ResultMapping resultMapping : resultMappings) {
        
            if (resultMapping.getFlags().contains(ResultFlag.CONSTRUCTOR)) {
        
              declaresConstructor = true;
              break;
            }
          }
          if (declaresConstructor) {
        
            extendedResultMappings.removeIf(resultMapping -> resultMapping.getFlags().contains(ResultFlag.CONSTRUCTOR));
          }
          resultMappings.addAll(extendedResultMappings);
        }
        ResultMap resultMap = new ResultMap.Builder(configuration, id, type, resultMappings, autoMapping)
            .discriminator(discriminator)
            .build();
        configuration.addResultMap(resultMap);
        return resultMap;
      }
    
      public Discriminator buildDiscriminator(
          Class<?> resultType,
          String column,
          Class<?> javaType,
          JdbcType jdbcType,
          Class<? extends TypeHandler<?>> typeHandler,
          Map<String, String> discriminatorMap) {
        
        ResultMapping resultMapping = buildResultMapping(
            resultType,
            null,
            column,
            javaType,
            jdbcType,
            null,
            null,
            null,
            null,
            typeHandler,
            new ArrayList<>(),
            null,
            null,
            false);
        Map<String, String> namespaceDiscriminatorMap = new HashMap<>();
        for (Map.Entry<String, String> e : discriminatorMap.entrySet()) {
        
          String resultMap = e.getValue();
          resultMap = applyCurrentNamespace(resultMap, true);
          namespaceDiscriminatorMap.put(e.getKey(), resultMap);
        }
        return new Discriminator.Builder(configuration, resultMapping, namespaceDiscriminatorMap).build();
      }
    
      public MappedStatement addMappedStatement(
          String id,
          SqlSource sqlSource,
          StatementType statementType,
          SqlCommandType sqlCommandType,
          Integer fetchSize,
          Integer timeout,
          String parameterMap,
          Class<?> parameterType,
          String resultMap,
          Class<?> resultType,
          ResultSetType resultSetType,
          boolean flushCache,
          boolean useCache,
          boolean resultOrdered,
          KeyGenerator keyGenerator,
          String keyProperty,
          String keyColumn,
          String databaseId,
          LanguageDriver lang,
          String resultSets) {
        
    
        if (unresolvedCacheRef) {
        
          throw new IncompleteElementException("Cache-ref not yet resolved");
        }
    
        id = applyCurrentNamespace(id, false);
        boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    
        MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
            .resource(resource)
            .fetchSize(fetchSize)
            .timeout(timeout)
            .statementType(statementType)
            .keyGenerator(keyGenerator)
            .keyProperty(keyProperty)
            .keyColumn(keyColumn)
            .databaseId(databaseId)
            .lang(lang)
            .resultOrdered(resultOrdered)
            .resultSets(resultSets)
            .resultMaps(getStatementResultMaps(resultMap, resultType, id))
            .resultSetType(resultSetType)
            .flushCacheRequired(valueOrDefault(flushCache, !isSelect))
            .useCache(valueOrDefault(useCache, isSelect))
            .cache(currentCache);
    
        ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
        if (statementParameterMap != null) {
        
          statementBuilder.parameterMap(statementParameterMap);
        }
    
        MappedStatement statement = statementBuilder.build();
        configuration.addMappedStatement(statement);
        return statement;
      }
    
      /**
       * Backward compatibility signature 'addMappedStatement'.
       *
       * @param id
       *          the id
       * @param sqlSource
       *          the sql source
       * @param statementType
       *          the statement type
       * @param sqlCommandType
       *          the sql command type
       * @param fetchSize
       *          the fetch size
       * @param timeout
       *          the timeout
       * @param parameterMap
       *          the parameter map
       * @param parameterType
       *          the parameter type
       * @param resultMap
       *          the result map
       * @param resultType
       *          the result type
       * @param resultSetType
       *          the result set type
       * @param flushCache
       *          the flush cache
       * @param useCache
       *          the use cache
       * @param resultOrdered
       *          the result ordered
       * @param keyGenerator
       *          the key generator
       * @param keyProperty
       *          the key property
       * @param keyColumn
       *          the key column
       * @param databaseId
       *          the database id
       * @param lang
       *          the lang
       * @return the mapped statement
       */
      public MappedStatement addMappedStatement(String id, SqlSource sqlSource, StatementType statementType,
          SqlCommandType sqlCommandType, Integer fetchSize, Integer timeout, String parameterMap, Class<?> parameterType,
          String resultMap, Class<?> resultType, ResultSetType resultSetType, boolean flushCache, boolean useCache,
          boolean resultOrdered, KeyGenerator keyGenerator, String keyProperty, String keyColumn, String databaseId,
          LanguageDriver lang) {
        
        return addMappedStatement(
          id, sqlSource, statementType, sqlCommandType, fetchSize, timeout,
          parameterMap, parameterType, resultMap, resultType, resultSetType,
          flushCache, useCache, resultOrdered, keyGenerator, keyProperty,
          keyColumn, databaseId, lang, null);
      }
    
      private <T> T valueOrDefault(T value, T defaultValue) {
        
        return value == null ? defaultValue : value;
      }
    
      private ParameterMap getStatementParameterMap(
          String parameterMapName,
          Class<?> parameterTypeClass,
          String statementId) {
        
        parameterMapName = applyCurrentNamespace(parameterMapName, true);
        ParameterMap parameterMap = null;
        if (parameterMapName != null) {
        
          try {
        
            parameterMap = configuration.getParameterMap(parameterMapName);
          } catch (IllegalArgumentException e) {
        
            throw new IncompleteElementException("Could not find parameter map " + parameterMapName, e);
          }
        } else if (parameterTypeClass != null) {
        
          List<ParameterMapping> parameterMappings = new ArrayList<>();
          parameterMap = new ParameterMap.Builder(
              configuration,
              statementId + "-Inline",
              parameterTypeClass,
              parameterMappings).build();
        }
        return parameterMap;
      }
    
      private List<ResultMap> getStatementResultMaps(
          String resultMap,
          Class<?> resultType,
          String statementId) {
        
        resultMap = applyCurrentNamespace(resultMap, true);
    
        List<ResultMap> resultMaps = new ArrayList<>();
        if (resultMap != null) {
        
          String[] resultMapNames = resultMap.split(",");
          for (String resultMapName : resultMapNames) {
        
            try {
        
              resultMaps.add(configuration.getResultMap(resultMapName.trim()));
            } catch (IllegalArgumentException e) {
        
              throw new IncompleteElementException("Could not find result map '" + resultMapName + "' referenced from '" + statementId + "'", e);
            }
          }
        } else if (resultType != null) {
        
          ResultMap inlineResultMap = new ResultMap.Builder(
              configuration,
              statementId + "-Inline",
              resultType,
              new ArrayList<>(),
              null).build();
          resultMaps.add(inlineResultMap);
        }
        return resultMaps;
      }
    
      public ResultMapping buildResultMapping(
          Class<?> resultType,
          String property,
          String column,
          Class<?> javaType,
          JdbcType jdbcType,
          String nestedSelect,
          String nestedResultMap,
          String notNullColumn,
          String columnPrefix,
          Class<? extends TypeHandler<?>> typeHandler,
          List<ResultFlag> flags,
          String resultSet,
          String foreignColumn,
          boolean lazy) {
        
        Class<?> javaTypeClass = resolveResultJavaType(resultType, property, javaType);
        TypeHandler<?> typeHandlerInstance = resolveTypeHandler(javaTypeClass, typeHandler);
        List<ResultMapping> composites;
        if ((nestedSelect == null || nestedSelect.isEmpty()) && (foreignColumn == null || foreignColumn.isEmpty())) {
        
          composites = Collections.emptyList();
        } else {
        
          composites = parseCompositeColumnName(column);
        }
        return new ResultMapping.Builder(configuration, property, column, javaTypeClass)
            .jdbcType(jdbcType)
            .nestedQueryId(applyCurrentNamespace(nestedSelect, true))
            .nestedResultMapId(applyCurrentNamespace(nestedResultMap, true))
            .resultSet(resultSet)
            .typeHandler(typeHandlerInstance)
            .flags(flags == null ? new ArrayList<>() : flags)
            .composites(composites)
            .notNullColumns(parseMultipleColumnNames(notNullColumn))
            .columnPrefix(columnPrefix)
            .foreignColumn(foreignColumn)
            .lazy(lazy)
            .build();
      }
    
      /**
       * Backward compatibility signature 'buildResultMapping'.
       *
       * @param resultType
       *          the result type
       * @param property
       *          the property
       * @param column
       *          the column
       * @param javaType
       *          the java type
       * @param jdbcType
       *          the jdbc type
       * @param nestedSelect
       *          the nested select
       * @param nestedResultMap
       *          the nested result map
       * @param notNullColumn
       *          the not null column
       * @param columnPrefix
       *          the column prefix
       * @param typeHandler
       *          the type handler
       * @param flags
       *          the flags
       * @return the result mapping
       */
      public ResultMapping buildResultMapping(Class<?> resultType, String property, String column, Class<?> javaType,
          JdbcType jdbcType, String nestedSelect, String nestedResultMap, String notNullColumn, String columnPrefix,
          Class<? extends TypeHandler<?>> typeHandler, List<ResultFlag> flags) {
        
        return buildResultMapping(
          resultType, property, column, javaType, jdbcType, nestedSelect,
          nestedResultMap, notNullColumn, columnPrefix, typeHandler, flags, null, null, configuration.isLazyLoadingEnabled());
      }

通过 `MapperBuilderAssistant` 的构造器注入全局配置对象和 Mapper 接口包路径

![image-20210421083711803][]

`MapperBuilderAssistant#addMappedStatement()` 方法通过 `MappedStatement.Builder` 类来构建 `MappedStatement` 对象，牛批牛批，出现了两个 `builder`

![image-20210421084333220][]

![image-20210421084523604][]

### 1.8、AbstractMethod ###

> **AbstractMethod：注入 SQL 语句的抽象父类**

`AbstractMethod` 是抽象的注入方法类，有个字段为 `MapperBuilderAssistant builderAssistant`。`AbstractMethod` 会调用 `builderAssistant.addMappedStatement` 方法来构建 `MappedStatement` 对象，并将该对象添加至 `configuration` 全局配置中

/**
     * 抽象的注入方法类
     *
     * @author hubin
     * @since 2018-04-06
     */
    @SuppressWarnings("serial")
    public abstract class AbstractMethod implements Constants {
        
        protected static final Log logger = LogFactory.getLog(AbstractMethod.class);
    
        protected Configuration configuration;
        protected LanguageDriver languageDriver;
        protected MapperBuilderAssistant builderAssistant;
        
        /**
         * 查询
         */
        protected MappedStatement addSelectMappedStatementForTable(Class<?> mapperClass, String id, SqlSource sqlSource,
                                                                   TableInfo table) {
        
            String resultMap = table.getResultMap();
            if (null != resultMap) {
        
                /* 返回 resultMap 映射结果集 */
                return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.SELECT, null,
                    resultMap, null, new NoKeyGenerator(), null, null);
            } else {
        
                /* 普通查询 */
                return addSelectMappedStatementForOther(mapperClass, id, sqlSource, table.getEntityType());
            }
        }
    
        /**
         * 查询
         */
        protected MappedStatement addSelectMappedStatementForOther(Class<?> mapperClass, String id, SqlSource sqlSource,
                                                                   Class<?> resultType) {
        
            return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.SELECT, null,
                null, resultType, new NoKeyGenerator(), null, null);
        }
    
        /**
         * 插入
         */
        protected MappedStatement addInsertMappedStatement(Class<?> mapperClass, Class<?> parameterType, String id,
                                                           SqlSource sqlSource, KeyGenerator keyGenerator,
                                                           String keyProperty, String keyColumn) {
        
            return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.INSERT, parameterType, null,
                Integer.class, keyGenerator, keyProperty, keyColumn);
        }
    
        /**
         * 删除
         */
        protected MappedStatement addDeleteMappedStatement(Class<?> mapperClass, String id, SqlSource sqlSource) {
        
            return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.DELETE, null,
                null, Integer.class, new NoKeyGenerator(), null, null);
        }
    
        /**
         * 更新
         */
        protected MappedStatement addUpdateMappedStatement(Class<?> mapperClass, Class<?> parameterType, String id,
                                                           SqlSource sqlSource) {
        
            return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.UPDATE, parameterType, null,
                Integer.class, new NoKeyGenerator(), null, null);
        }
    
        /**
         * 添加 MappedStatement 到 Mybatis 容器
         */
        protected MappedStatement addMappedStatement(Class<?> mapperClass, String id, SqlSource sqlSource,
                                                     SqlCommandType sqlCommandType, Class<?> parameterType,
                                                     String resultMap, Class<?> resultType, KeyGenerator keyGenerator,
                                                     String keyProperty, String keyColumn) {
        
            String statementName = mapperClass.getName() + DOT + id;
            if (hasMappedStatement(statementName)) {
        
                logger.warn(LEFT_SQ_BRACKET + statementName + "] Has been loaded by XML or SqlProvider or Mybatis's Annotation, so ignoring this injection for [" + getClass() + RIGHT_SQ_BRACKET);
                return null;
            }
            /* 缓存逻辑处理 */
            boolean isSelect = false;
            if (sqlCommandType == SqlCommandType.SELECT) {
        
                isSelect = true;
            }
            return builderAssistant.addMappedStatement(id, sqlSource, StatementType.PREPARED, sqlCommandType,
                null, null, null, parameterType, resultMap, resultType,
                null, !isSelect, isSelect, false, keyGenerator, keyProperty, keyColumn,
                configuration.getDatabaseId(), languageDriver, null);
        }

当为 `insert()` 方法注入 SQL 语句时，方法的调用链为 `AbstractMethod#addInsertMappedStatement()` \--> `AbstractMethod#addMappedStatement()` \--> `BuilderAssistant#addMappedStatement()`

当调用 `BuilderAssistant#addMappedStatement()` 时会构建 `MappedStatement` 对象，并将其添加在 `configuration` 全局配置中

![image-20210423075657958][]

![image-20210423075419523][]

![image-20210423075552144][]

## 2、注入 SQL 原理分析 ##

> **MybatisPlus MappedStatement 对象**

`userMapper` 中的 `sqlSession` \--> `sqlSessionFactory` \--> `configuration` \--> `mappedStatements` 本质是 `HashMap`，`key` 为 `String` 类型，存储 `Mapper` 接口的方法名；`value` 是 `MappedStatement` 类型，存储接口方法对应的 SQL 信息。

对于事先就能确定好的 SQL 语句，MybatisPlus 会帮我们构造好 SQL 语句，并放在 `sqlSource` \--> `sql` 字段中，此时 `sqlSource` 的类型为 `RawSqlSource`

![image-20210420222041766][]

对于事先无法确定的 SQL 语句，MybatisPlus 会帮我们构造好 SQL 语句的各个节点，并放在 `sqlSource` \--> `rootSqlSource` 字段中，此时 `sqlSource` 的类型为 `DynamicSqlSource`

![image-20210420223133311][]

> **我们倒着来推导 MybatisPlus 注入 SQL 原理分析**

`AbstractMethod` 类中定义了很多方法，比如 `addSelectMappedStatementForTable()`、`addSelectMappedStatementForOther()` 添加为查询语句添加 `MappedStatement` 映射；`addInsertMappedStatement()` 方法为插入语句添加 `MappedStatement` 映射等等

这类 `addXxxMappedStatement()` 方法最终都会调用 `AbstractMethod#addMappedStatement()` 方法，而 `AbstractMethod#addMappedStatement()` 方法最终会调用 `BuilderAssistant#addMappedStatement()` 方法构建 `MappedStatement` 对象

![image-20210420224513031][]

我们来看下 `AbstractMethod#addSelectMappedStatementForTable()` 方法，如果定义了 `table` 表的 `resultMap` 结果集映射，那么第一次则会执行 `addMappedStatement()` 方法添加结果结果集映射；第二次则会执行 `addSelectMappedStatementForOther()` \--> `addMappedStatement()` 方法添加 SQL 语句映射

/**
     * 抽象的注入方法类
     *
     * @author hubin
     * @since 2018-04-06
     */
    @SuppressWarnings("serial")
    public abstract class AbstractMethod implements Constants {
        
        protected static final Log logger = LogFactory.getLog(AbstractMethod.class);
    
        protected Configuration configuration;
        protected LanguageDriver languageDriver;
        protected MapperBuilderAssistant builderAssistant;
        
        protected MappedStatement addSelectMappedStatementForTable(Class<?> mapperClass, String id, SqlSource sqlSource,
                                                                   TableInfo table) {
        
            String resultMap = table.getResultMap();
            if (null != resultMap) {
        
                /* 返回 resultMap 映射结果集 */
                return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.SELECT, null,
                    resultMap, null, new NoKeyGenerator(), null, null);
            } else {
        
                /* 普通查询 */
                return addSelectMappedStatementForOther(mapperClass, id, sqlSource, table.getEntityType());
            }
        }
    
        /**
         * 查询
         */
        protected MappedStatement addSelectMappedStatementForOther(Class<?> mapperClass, String id, SqlSource sqlSource,
                                                                   Class<?> resultType) {
        
            return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.SELECT, null,
                null, resultType, new NoKeyGenerator(), null, null);
        }
    
        /**
         * 插入
         */
        protected MappedStatement addInsertMappedStatement(Class<?> mapperClass, Class<?> parameterType, String id,
                                                           SqlSource sqlSource, KeyGenerator keyGenerator,
                                                           String keyProperty, String keyColumn) {
        
            return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.INSERT, parameterType, null,
                Integer.class, keyGenerator, keyProperty, keyColumn);
        }
    
        /**
         * 删除
         */
        protected MappedStatement addDeleteMappedStatement(Class<?> mapperClass, String id, SqlSource sqlSource) {
        
            return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.DELETE, null,
                null, Integer.class, new NoKeyGenerator(), null, null);
        }
    
        /**
         * 更新
         */
        protected MappedStatement addUpdateMappedStatement(Class<?> mapperClass, Class<?> parameterType, String id,
                                                           SqlSource sqlSource) {
        
            return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.UPDATE, parameterType, null,
                Integer.class, new NoKeyGenerator(), null, null);
        }
    
        /**
         * 添加 MappedStatement 到 Mybatis 容器
         */
        protected MappedStatement addMappedStatement(Class<?> mapperClass, String id, SqlSource sqlSource,
                                                     SqlCommandType sqlCommandType, Class<?> parameterType,
                                                     String resultMap, Class<?> resultType, KeyGenerator keyGenerator,
                                                     String keyProperty, String keyColumn) {
        
            String statementName = mapperClass.getName() + DOT + id;
            if (hasMappedStatement(statementName)) {
        
                logger.warn(LEFT_SQ_BRACKET + statementName + "] Has been loaded by XML or SqlProvider or Mybatis's Annotation, so ignoring this injection for [" + getClass() + RIGHT_SQ_BRACKET);
                return null;
            }
            /* 缓存逻辑处理 */
            boolean isSelect = false;
            if (sqlCommandType == SqlCommandType.SELECT) {
        
                isSelect = true;
            }
            return builderAssistant.addMappedStatement(id, sqlSource, StatementType.PREPARED, sqlCommandType,
                null, null, null, parameterType, resultMap, resultType,
                null, !isSelect, isSelect, false, keyGenerator, keyProperty, keyColumn,
                configuration.getDatabaseId(), languageDriver, null);
        }

以添加查询的 `MappedStatement` 映射为例，我们右击选择【Find Usages】，找到该方法的调用者

![image-20210420224939530][]

在 `SelectById#injectMappedStatement()` 方法中调用了 `addSelectMappedStatementForTable()` \--> `addMappedStatement()` 方法。

感觉像是每一个 `SqlMethod` 类型都对应着一个 `SelectXxx` 类，该类会继承 `AbstractMethod` 类并重写其中的 `injectMappedStatement()` 方法来构建 `MappedStatement` 对象。卧槽，模板方法设计模式

由于每个 SQL 语句对应的 SQL 语句类型、SQL 语句参数、SQL 语句节点不一样（构造 SQL 参数的行为不一致），但是构建 SQL 语句的行为是一致的，都是调用 `addSelectMappedStatementForTable()` \--> `addMappedStatement()` 方法

因此我们可以将统一的执行逻辑定义在 `AbstractMethod` 抽象父类中，在子类中构造不同的参数，然后传递给父类的方法执行，最终构建得到 `MappedStatement` 对象，秒啊秒啊

/**
     * 根据ID 查询一条数据
     *
     * @author hubin
     * @since 2018-04-06
     */
    public class SelectById extends AbstractMethod {
        
    
        @Override
        public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
        
            SqlMethod sqlMethod = SqlMethod.SELECT_BY_ID;
            SqlSource sqlSource = new RawSqlSource(configuration, String.format(sqlMethod.getSql(),
                sqlSelectColumns(tableInfo, false),
                tableInfo.getTableName(), tableInfo.getKeyColumn(), tableInfo.getKeyProperty(),
                tableInfo.getLogicDeleteSql(true, true)), Object.class);
            return this.addSelectMappedStatementForTable(mapperClass, getMethod(sqlMethod), sqlSource, tableInfo);
        }
    }
    
    /**
     * 查询满足条件总记录数
     *
     * @author hubin
     * @since 2018-04-08
     */
    public class SelectCount extends AbstractMethod {
        
    
        @Override
        public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
        
            SqlMethod sqlMethod = SqlMethod.SELECT_COUNT;
            String sql = String.format(sqlMethod.getSql(), sqlFirst(), sqlCount(), tableInfo.getTableName(),
                sqlWhereEntityWrapper(true, tableInfo), sqlComment());
            SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
            return this.addSelectMappedStatementForOther(mapperClass, getMethod(sqlMethod), sqlSource, Integer.class);
        }
    }
    
    /**
     * 查询满足条件所有数据
     *
     * @author hubin
     * @since 2018-04-06
     */
    public class SelectMaps extends AbstractMethod {
        
    
        @Override
        public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
        
            SqlMethod sqlMethod = SqlMethod.SELECT_MAPS;
            String sql = String.format(sqlMethod.getSql(), sqlFirst(), sqlSelectColumns(tableInfo, true), tableInfo.getTableName(),
                sqlWhereEntityWrapper(true, tableInfo), sqlComment());
            SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
            return this.addSelectMappedStatementForOther(mapperClass, getMethod(sqlMethod), sqlSource, Map.class);
        }
    }

我们找到上一级调用者，又回到了 `AbstractMethod#injectMappedStatement()` 方法中。在调用 `AbstractMethod#inject()` 方法时会调用 `AbstractMethod#injectMappedStatement()` 方法，该方法为抽象方法，将会被类似 `SelectXxx` 的子类重写，因此会进入子类重写的逻辑中

也就是说，当调用 `AbstractMethod#inject()` 方法时，会进入子类重写的 `injectMappedStatement()` 方法中，只要在 `injectMappedStatement()` 方法中构造 SQL 语句所需的参数，并调用 `addSelectMappedStatementForOther()` 方法，就能注入 Mapper 接口方法对应的 SQL 语句

public abstract class AbstractMethod implements Constants {
        
        protected static final Log logger = LogFactory.getLog(AbstractMethod.class);
    
        protected Configuration configuration;
        protected LanguageDriver languageDriver;
        protected MapperBuilderAssistant builderAssistant;
    
        /**
         * 注入自定义方法
         */
        public void inject(MapperBuilderAssistant builderAssistant, Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
        
            this.configuration = builderAssistant.getConfiguration();
            this.builderAssistant = builderAssistant;
            this.languageDriver = configuration.getDefaultScriptingLanguageInstance();
            /* 注入自定义方法 */
            injectMappedStatement(mapperClass, modelClass, tableInfo);
        }

我们再找到上一级调用者 `AbstractSqlInjector`，该类负责注入 Mapper 接口中每个方法所对应的 SQL 语句

/**
     * SQL 自动注入器
     *
     * @author hubin
     * @since 2018-04-07
     */
    public abstract class AbstractSqlInjector implements ISqlInjector {
        
    
        private static final Log logger = LogFactory.getLog(AbstractSqlInjector.class);
    
        @Override
        public void inspectInject(MapperBuilderAssistant builderAssistant, Class<?> mapperClass) {
        
            Class<?> modelClass = extractModelClass(mapperClass);
            if (modelClass != null) {
        
                String className = mapperClass.toString();
                Set<String> mapperRegistryCache = GlobalConfigUtils.getMapperRegistryCache(builderAssistant.getConfiguration());
                if (!mapperRegistryCache.contains(className)) {
        
                    List<AbstractMethod> methodList = this.getMethodList(mapperClass);
                    if (CollectionUtils.isNotEmpty(methodList)) {
        
                        TableInfo tableInfo = TableInfoHelper.initTableInfo(builderAssistant, modelClass);
                        // 循环注入自定义方法
                        methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass, tableInfo));
                    } else {
        
                        logger.debug(mapperClass.toString() + ", No effective injection method was found.");
                    }
                    mapperRegistryCache.add(className);
                }
            }
        }

我们找到 `AbstractSqlInjector` 的实现类 `DefaultSqlInjector`，在该类中定义了 MybatisPlus 框架所支持自动注入的方法。每一个方法以类的形式呈现，比如 `SelectById`、`SelectCount` 类，这些类都会继承 `AbstractMethod` 抽象父类，并重写其中的 `injectMappedStatement()` 方法

/**
     * SQL 默认注入器
     *
     * @author hubin
     * @since 2018-04-10
     */
    public class DefaultSqlInjector extends AbstractSqlInjector {
        
    
        @Override
        public List<AbstractMethod> getMethodList(Class<?> mapperClass) {
        
            return Stream.of(
                new Insert(),
                new Delete(),
                new DeleteByMap(),
                new DeleteById(),
                new DeleteBatchByIds(),
                new Update(),
                new UpdateById(),
                new SelectById(),
                new SelectBatchByIds(),
                new SelectByMap(),
                new SelectOne(),
                new SelectCount(),
                new SelectMaps(),
                new SelectMapsPage(),
                new SelectObjs(),
                new SelectList(),
                new SelectPage()
            ).collect(toList());
        }
    }

[image-20210421081537444]: /images/20221021/ba6d27ceff8543c6b74217efce8f1481.png
[image-20210421082212253]: /images/20221021/d06560f91a5745889e27dad1aaa2cded.png
[image-20210421082518419]: /images/20221021/4fdd6376ac704d69a9b67a84b9e86e3d.png
[image-20210421082713764]: /images/20221021/0e56a2c12ab24045b4182ff702e78f04.png
[image-20210421083107683]: /images/20221021/d1a577ce0786459ea20f26abdea8fb0a.png
[image-20210421083143692]: /images/20221021/c089aaa2170d4e74b354e5cd10328857.png
[image-20210421083343065]: /images/20221021/f141571adc5648c196a96b2d8242ae4e.png
[image-20210421083407887]: /images/20221021/5da6190caf1e49f39b56cecdb63d9a65.png
[image-20210420231301429]: /images/20221021/718ee808a419495497b3b21a7051e9a6.png
[image-20210421083548588]: /images/20221021/3e46463d08ad48a1a88dd841c9b4a5da.png
[image-20210421083711803]: /images/20221021/316415468661405b98c70eff6172f066.png
[image-20210421084333220]: /images/20221021/43b300c7533f4fa49b71184bd0303647.png
[image-20210421084523604]: /images/20221021/775192a2f5de4f7da21cbdac551474fa.png
[image-20210423075657958]: /images/20221021/b793419c90214301ba6940925ab278bc.png
[image-20210423075419523]: /images/20221021/f9918461f8a94a7789753e1e13b193f5.png
[image-20210423075552144]: /images/20221021/ca64216eff8b422eac379828799c581e.png
[image-20210420222041766]: /images/20221021/50c31979bf2f4d7891c37e908c363ea4.png
[image-20210420223133311]: /images/20221021/419c0502963846b28f1eb0f9699097af.png
[image-20210420224513031]: /images/20221021/c789c275660a4571903f0f0f5409bc86.png
[image-20210420224939530]: /images/20221021/e4750a376ed447f3b4ff85e6f53dd73d.png