【mybatis plus源码解析】(二)详解SQL注入器底层原理，mybatis plus是如何实现自动注入CRUD操作

最新推荐文章于 2024-07-09 19:10:54 发布
最新推荐文章于 2024-07-09 19:10:54 发布
阅读量3.4k 收藏 13
点赞数 4
分类专栏： mybatis 源码 java 文章标签： mybatis 源码 java mybatis plus orm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35270805/article/details/123838003
版权
java 同时被 3 个专栏收录
49 篇文章 8 订阅
订阅专栏
源码
8 篇文章 4 订阅
订阅专栏
mybatis
7 篇文章 4 订阅
订阅专栏

系列文章目录

【mybatis plus源码解析】mybatis plus执行原理
【mybatis plus源码解析】(二)详解自定义SQL注入器底层原理

文章目录

前言

上篇文章介绍了【mybatis plus源码解析】mybatis plus执行原理，这回接着上篇文章，建议看完上篇文章再来看这篇，这里主要介绍相关类

一、ISqlInjector SQL自动注入器接口的相关uml图

uml图

ISqlInjector顶级接口，只做一件事

在这里插入图片描述

再来看看AbstractSqlInjector抽象类

AbstractSqlInjector类实现了inspectInject注入方法

/**
 * SQL 自动注入器
 *
 * @author hubin
 * @since 2018-04-07
 */
public abstract class AbstractSqlInjector implements ISqlInjector {

    protected final Log logger = LogFactory.getLog(this.getClass());

    @Override
    public void inspectInject(MapperBuilderAssistant builderAssistant, Class<?> mapperClass) {
    	//通过反射获取实体类对象
        Class<?> modelClass = ReflectionKit.getSuperClassGenericType(mapperClass, Mapper.class, 0);
        if (modelClass != null) {
            String className = mapperClass.toString();
            //获取mapperRegistry缓存用于对比，防止覆盖
            Set<String> mapperRegistryCache = GlobalConfigUtils.getMapperRegistryCache(builderAssistant.getConfiguration());
            if (!mapperRegistryCache.contains(className)) {
            //通过实体类对象反射方式获取信息（比如实体类上的注解）封装成TableInfo存储表信息对象
                TableInfo tableInfo = TableInfoHelper.initTableInfo(builderAssistant, modelClass);
                List<AbstractMethod> methodList = this.getMethodList(mapperClass, tableInfo);//获取要注入的方法集合
                if (CollectionUtils.isNotEmpty(methodList)) {
                    // 循环注入自定义方法
                    methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass, tableInfo));
                } else {
                    logger.debug(mapperClass.toString() + ", No effective injection method was found.");
                }
                mapperRegistryCache.add(className);
            }
        }
    }

    /**
     * <p>
     * 获取 注入的方法
     * </p>
     *
     * @param mapperClass 当前mapper
     * @return 注入的方法集合
     * @since 3.1.2 add  mapperClass
     */
    public abstract List<AbstractMethod> getMethodList(Class<?> mapperClass,TableInfo tableInfo);

}

DefaultSqlInjector默认SQL 注入器

DefaultSqlInjector实现了AbstractSqlInjector类的getMethodList方法，规定哪些方法可以实现自动注入

/**
 * SQL 默认注入器
 *
 * @author hubin
 * @since 2018-04-10
 */
public class DefaultSqlInjector extends AbstractSqlInjector {

    @Override
    public List<AbstractMethod> getMethodList(Class<?> mapperClass, TableInfo tableInfo) {
        Stream.Builder<AbstractMethod> builder = Stream.<AbstractMethod>builder()
            .add(new Insert())
            .add(new Delete())
            .add(new DeleteByMap())
            .add(new Update())
            .add(new SelectByMap())
            .add(new SelectCount())
            .add(new SelectMaps())
            .add(new SelectMapsPage())
            .add(new SelectObjs())
            .add(new SelectList())
            .add(new SelectPage());
        if (tableInfo.havePK()) {
            builder.add(new DeleteById())
                .add(new DeleteBatchByIds())
                .add(new UpdateById())
                .add(new SelectById())
                .add(new SelectBatchByIds());
        } else {
            logger.warn(String.format("%s ,Not found @TableId annotation, Cannot use Mybatis-Plus 'xxById' Method.",
                tableInfo.getEntityType()));
        }
        return builder.build().collect(toList());
    }
}

默认的注入器类治理介绍完了，里面其实做了一件事就是调用注入mapper默认实现的CRUD方法

二、注入方法相关的类

先看看UML图

在这里插入图片描述

AbstractMethod抽象方法类

/**
 * 抽象的注入方法类
 *
 * @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;

    /**
     * 方法名称
     * @since 3.5.0
     */
    protected final String methodName;

    /**
     * @see AbstractMethod#AbstractMethod(java.lang.String)
     * @since 3.5.0
     */
    @Deprecated
    public AbstractMethod() {
        methodName = null;
    }

    /**
     * @param methodName 方法名
     * @since 3.5.0
     */
    protected AbstractMethod(String methodName) {
        Assert.notNull(methodName, "方法名不能为空");
        this.methodName = methodName;
    }

    /**
     * 注入自定义方法
     */
    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);
    }

    /**
     * 是否已经存在MappedStatement
     *
     * @param mappedStatement MappedStatement
     * @return true or false
     */
    private boolean hasMappedStatement(String mappedStatement) {
        return configuration.hasStatement(mappedStatement, false);
    }

    /**
     * SQL 更新 set 语句
     *
     * @param table 表信息
     * @return sql set 片段
     */
    protected String sqlLogicSet(TableInfo table) {
        return "SET " + table.getLogicDeleteSql(false, false);
    }

    /**
     * SQL 更新 set 语句
     *
     * @param logic  是否逻辑删除注入器
     * @param ew     是否存在 UpdateWrapper 条件
     * @param table  表信息
     * @param alias  别名
     * @param prefix 前缀
     * @return sql
     */
    protected String sqlSet(boolean logic, boolean ew, TableInfo table, boolean judgeAliasNull, final String alias,
                            final String prefix) {
        String sqlScript = table.getAllSqlSet(logic, prefix);
        if (judgeAliasNull) {
            sqlScript = SqlScriptUtils.convertIf(sqlScript, String.format("%s != null", alias), true);
        }
        if (ew) {
            sqlScript += NEWLINE;
            sqlScript += convertIfEwParam(U_WRAPPER_SQL_SET, false);
        }
        sqlScript = SqlScriptUtils.convertSet(sqlScript);
        return sqlScript;
    }

    /**
     * SQL 注释
     *
     * @return sql
     */
    protected String sqlComment() {
        return convertIfEwParam(Q_WRAPPER_SQL_COMMENT, true);
    }

    /**
     * SQL 注释
     *
     * @return sql
     */
    protected String sqlFirst() {
        return convertIfEwParam(Q_WRAPPER_SQL_FIRST, true);
    }

    protected String convertIfEwParam(final String param, final boolean newLine) {
        return SqlScriptUtils.convertIf(SqlScriptUtils.unSafeParam(param),
            String.format("%s != null and %s != null", WRAPPER, param), newLine);
    }

    /**
     * SQL 查询所有表字段
     *
     * @param table        表信息
     * @param queryWrapper 是否为使用 queryWrapper 查询
     * @return sql 脚本
     */
    protected String sqlSelectColumns(TableInfo table, boolean queryWrapper) {
        /* 假设存在用户自定义的 resultMap 映射返回 */
        String selectColumns = ASTERISK;
        if (table.getResultMap() == null || table.isAutoInitResultMap()) {
            /* 未设置 resultMap 或者 resultMap 是自动构建的,视为属于mp的规则范围内 */
            selectColumns = table.getAllSqlSelect();
        }
        if (!queryWrapper) {
            return selectColumns;
        }
        return convertChooseEwSelect(selectColumns);
    }

    /**
     * SQL 查询记录行数
     *
     * @return count sql 脚本
     */
    protected String sqlCount() {
        return convertChooseEwSelect(ASTERISK);
    }

    /**
     * SQL 设置selectObj sql select
     *
     * @param table 表信息
     */
    protected String sqlSelectObjsColumns(TableInfo table) {
        return convertChooseEwSelect(table.getAllSqlSelect());
    }

    protected String convertChooseEwSelect(final String otherwise) {
        return SqlScriptUtils.convertChoose(String.format("%s != null and %s != null", WRAPPER, Q_WRAPPER_SQL_SELECT),
            SqlScriptUtils.unSafeParam(Q_WRAPPER_SQL_SELECT), otherwise);
    }

    /**
     * SQL map 查询条件
     */
    protected String sqlWhereByMap(TableInfo table) {
        if (table.isWithLogicDelete()) {
            // 逻辑删除
            String sqlScript = SqlScriptUtils.convertChoose("v == null", " ${k} IS NULL ",
                " ${k} = #{v} ");
            sqlScript = SqlScriptUtils.convertForeach(sqlScript, COLUMN_MAP, "k", "v", "AND");
            sqlScript = SqlScriptUtils.convertIf(sqlScript, String.format("%s != null and !%s.isEmpty", COLUMN_MAP, COLUMN_MAP), true);
            sqlScript += (NEWLINE + table.getLogicDeleteSql(true, true));
            sqlScript = SqlScriptUtils.convertWhere(sqlScript);
            return sqlScript;
        } else {
            String sqlScript = SqlScriptUtils.convertChoose("v == null", " ${k} IS NULL ",
                " ${k} = #{v} ");
            sqlScript = SqlScriptUtils.convertForeach(sqlScript, COLUMN_MAP, "k", "v", "AND");
            sqlScript = SqlScriptUtils.convertWhere(sqlScript);
            sqlScript = SqlScriptUtils.convertIf(sqlScript, String.format("%s != null and !%s", COLUMN_MAP,
                COLUMN_MAP_IS_EMPTY), true);
            return sqlScript;
        }
    }

    /**
     * EntityWrapper方式获取select where
     *
     * @param newLine 是否提到下一行
     * @param table   表信息
     * @return String
     */
    protected String sqlWhereEntityWrapper(boolean newLine, TableInfo table) {
        if (table.isWithLogicDelete()) {
            String sqlScript = table.getAllSqlWhere(true, true, WRAPPER_ENTITY_DOT);
            sqlScript = SqlScriptUtils.convertIf(sqlScript, String.format("%s != null", WRAPPER_ENTITY),
                true);
            sqlScript += (NEWLINE + table.getLogicDeleteSql(true, true) + NEWLINE);
            String normalSqlScript = SqlScriptUtils.convertIf(String.format("AND ${%s}", WRAPPER_SQLSEGMENT),
                String.format("%s != null and %s != '' and %s", WRAPPER_SQLSEGMENT, WRAPPER_SQLSEGMENT,
                    WRAPPER_NONEMPTYOFNORMAL), true);
            normalSqlScript += NEWLINE;
            normalSqlScript += SqlScriptUtils.convertIf(String.format(" ${%s}", WRAPPER_SQLSEGMENT),
                String.format("%s != null and %s != '' and %s", WRAPPER_SQLSEGMENT, WRAPPER_SQLSEGMENT,
                    WRAPPER_EMPTYOFNORMAL), true);
            sqlScript += normalSqlScript;
            sqlScript = SqlScriptUtils.convertChoose(String.format("%s != null", WRAPPER), sqlScript,
                table.getLogicDeleteSql(false, true));
            sqlScript = SqlScriptUtils.convertWhere(sqlScript);
            return newLine ? NEWLINE + sqlScript : sqlScript;
        } else {
            String sqlScript = table.getAllSqlWhere(false, true, WRAPPER_ENTITY_DOT);
            sqlScript = SqlScriptUtils.convertIf(sqlScript, String.format("%s != null", WRAPPER_ENTITY), true);
            sqlScript += NEWLINE;
            sqlScript += SqlScriptUtils.convertIf(String.format(SqlScriptUtils.convertIf(" AND", String.format("%s and %s", WRAPPER_NONEMPTYOFENTITY, WRAPPER_NONEMPTYOFNORMAL), false) + " ${%s}", WRAPPER_SQLSEGMENT),
                String.format("%s != null and %s != '' and %s", WRAPPER_SQLSEGMENT, WRAPPER_SQLSEGMENT,
                    WRAPPER_NONEMPTYOFWHERE), true);
            sqlScript = SqlScriptUtils.convertWhere(sqlScript) + NEWLINE;
            sqlScript += SqlScriptUtils.convertIf(String.format(" ${%s}", WRAPPER_SQLSEGMENT),
                String.format("%s != null and %s != '' and %s", WRAPPER_SQLSEGMENT, WRAPPER_SQLSEGMENT,
                    WRAPPER_EMPTYOFWHERE), true);
            sqlScript = SqlScriptUtils.convertIf(sqlScript, String.format("%s != null", WRAPPER), true);
            return newLine ? NEWLINE + sqlScript : sqlScript;
        }
    }

    protected String sqlOrderBy(TableInfo tableInfo) {
        /* 不存在排序字段，直接返回空 */
        List<TableFieldInfo> orderByFields = tableInfo.getOrderByFields();
        if (CollectionUtils.isEmpty(orderByFields)) {
            return StringPool.EMPTY;
        }
        orderByFields.sort(Comparator.comparingInt(TableFieldInfo::getOrderBySort));
        StringBuilder sql = new StringBuilder();
        sql.append(NEWLINE).append(" ORDER BY ");
        sql.append(orderByFields.stream().map(tfi -> String.format("%s %s", tfi.getColumn(),
            tfi.getOrderByType())).collect(joining(",")));
        /* 当wrapper中传递了orderBy属性，@orderBy注解失效 */
        return SqlScriptUtils.convertIf(sql.toString(), String.format("%s == null or %s", WRAPPER,
            WRAPPER_EXPRESSION_ORDER), true);
    }

    /**
     * 过滤 TableFieldInfo 集合, join 成字符串
     */
    protected String filterTableFieldInfo(List<TableFieldInfo> fieldList, Predicate<TableFieldInfo> predicate,
                                          Function<TableFieldInfo, String> function, String joiningVal) {
        Stream<TableFieldInfo> infoStream = fieldList.stream();
        if (predicate != null) {
            return infoStream.filter(predicate).map(function).collect(joining(joiningVal));
        }
        return infoStream.map(function).collect(joining(joiningVal));
    }

    /**
     * 获取乐观锁相关
     *
     * @param tableInfo 表信息
     * @return String
     */
    protected String optlockVersion(TableInfo tableInfo) {
        if (tableInfo.isWithVersion()) {
            return tableInfo.getVersionFieldInfo().getVersionOli(ENTITY, ENTITY_DOT);
        }
        return EMPTY;
    }

    /**
     * 查询
     */
    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, NoKeyGenerator.INSTANCE, null, null);
        } else {
            /* 普通查询 */
            return addSelectMappedStatementForOther(mapperClass, id, sqlSource, table.getEntityType());
        }
    }

    /**
     * 查询
     * @since 3.5.0
     */
    protected MappedStatement addSelectMappedStatementForTable(Class<?> mapperClass, SqlSource sqlSource, TableInfo table) {
        return addSelectMappedStatementForTable(mapperClass, this.methodName, sqlSource, table);
    }

    /**
     * 查询
     */
    protected MappedStatement addSelectMappedStatementForOther(Class<?> mapperClass, String id, SqlSource sqlSource,
                                                               Class<?> resultType) {
        return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.SELECT, null,
            null, resultType, NoKeyGenerator.INSTANCE, null, null);
    }

    /**
     * 查询
     *
     * @since 3.5.0
     */
    protected MappedStatement addSelectMappedStatementForOther(Class<?> mapperClass, SqlSource sqlSource, Class<?> resultType) {
        return addSelectMappedStatementForOther(mapperClass, this.methodName, sqlSource, resultType);
    }

    /**
     * 插入
     */
    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);
    }

    /**
     * 插入
     * @since 3.5.0
     */
    protected MappedStatement addInsertMappedStatement(Class<?> mapperClass, Class<?> parameterType,
                                                       SqlSource sqlSource, KeyGenerator keyGenerator,
                                                       String keyProperty, String keyColumn) {
        return addInsertMappedStatement(mapperClass, parameterType, this.methodName, sqlSource, keyGenerator, keyProperty, keyColumn);
    }


    /**
     * 删除
     */
    protected MappedStatement addDeleteMappedStatement(Class<?> mapperClass, String id, SqlSource sqlSource) {
        return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.DELETE, null,
            null, Integer.class, NoKeyGenerator.INSTANCE, null, null);
    }

    /**
     * @since 3.5.0
     */
    protected MappedStatement addDeleteMappedStatement(Class<?> mapperClass, SqlSource sqlSource) {
        return addDeleteMappedStatement(mapperClass, this.methodName, sqlSource);
    }

    /**
     * 更新
     */
    protected MappedStatement addUpdateMappedStatement(Class<?> mapperClass, Class<?> parameterType, String id,
                                                       SqlSource sqlSource) {
        return addMappedStatement(mapperClass, id, sqlSource, SqlCommandType.UPDATE, parameterType, null,
            Integer.class, NoKeyGenerator.INSTANCE, null, null);
    }

    /**
     * 更新
     *
     * @since 3.5.0
     */
    protected MappedStatement addUpdateMappedStatement(Class<?> mapperClass, Class<?> parameterType,
                                                       SqlSource sqlSource) {
        return addUpdateMappedStatement(mapperClass, parameterType, this.methodName, sqlSource);
    }

    /**
     * 添加 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 = sqlCommandType == SqlCommandType.SELECT;
        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);
    }

    /**
     * @since 3.5.0
     */
    protected MappedStatement addMappedStatement(Class<?> mapperClass, SqlSource sqlSource,
                                                 SqlCommandType sqlCommandType, Class<?> parameterType,
                                                 String resultMap, Class<?> resultType, KeyGenerator keyGenerator,
                                                 String keyProperty, String keyColumn) {
        return addMappedStatement(mapperClass, this.methodName, sqlSource, sqlCommandType, parameterType, resultMap, resultType, keyGenerator, keyProperty, keyColumn);
    }

    /**
     * 注入自定义 MappedStatement
     *
     * @param mapperClass mapper 接口
     * @param modelClass  mapper 泛型
     * @param tableInfo   数据库表反射信息
     * @return MappedStatement
     */
    public abstract MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo);

    /**
     * 获取自定义方法名，未设置采用默认方法名
     * https://gitee.com/baomidou/mybatis-plus/pulls/88
     *
     * @return method
     * @author 义陆无忧
     * @see AbstractMethod#AbstractMethod(java.lang.String)
     * @deprecated 3.5.0
     */
    @Deprecated
    public String getMethod(SqlMethod sqlMethod) {
        return StringUtils.isBlank(methodName) ? sqlMethod.getMethod() : this.methodName;
    }

}

简单看个SelectById类，以这个方法为例子

/**
 * 根据ID 查询一条数据
 *
 * @author hubin
 * @since 2018-04-06
 */
public class SelectById extends AbstractMethod {

    public SelectById() {
    	//给methodName属性赋值
        super(SqlMethod.SELECT_BY_ID.getMethod());
    }

    /**
     * @param name 方法名
     * @since 3.5.0
     */
    public SelectById(String name) {
    //给methodName属性赋值
        super(name);
    }

    @Override
    public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
    //获取SqlMethod类，这是一个枚举类，下面会有介绍
        SqlMethod sqlMethod = SqlMethod.SELECT_BY_ID;
        //生成最终的SqlSource对象
        SqlSource sqlSource = new RawSqlSource(configuration, String.format(sqlMethod.getSql(),
                sqlSelectColumns(tableInfo, false),
                tableInfo.getTableName(), tableInfo.getKeyColumn(), tableInfo.getKeyProperty(),
                tableInfo.getLogicDeleteSql(true, true)), Object.class);
         //将最终封装好的MappedStatement对象加入配置类对象中
        return this.addSelectMappedStatementForTable(mapperClass, getMethod(sqlMethod), sqlSource, tableInfo);
    }
}

在这里插入图片描述

断点看看
在这里插入图片描述
可以看到sqlMethod枚举类封装了相关sql语句，短点往下
在这里插入图片描述
最终生成了封装好sql语句和参数的SqlSource对象，这里生成的是StaticSqlSource静态对象

了解完上面的类，现在回头看看初始化时注入方法，不了解的可以先看我的上篇文章。

在这里插入图片描述
来看看parserInjector这个方法
在这里插入图片描述
GlobalConfigUtils.getSqlInjector(configuration)这句代码其实就是返回配置文件中设置的SqlInjector注入器，说明我们可以自定义注入器，默认注入器是DefaultSqlInjector。官方文档也正好证明这一点
在这里插入图片描述
在这里插入图片描述
最终这个方法调用了AbstractSqlInjector的inspectInject方法将CRUD相关的sql对象注入到配置中去

总结

到这里基本就介绍完了。到这里其实就能想到可以通过自定义BaseMapper，并且编写响应method对象，自定义实现ISqlInjector注入器。这样我们就能够对mybatis-plus进行扩展来实现更多的CRUD方法。后面文章我会出一片详细的

爱音乐的程序猿
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
MyBatis-Plus 使用这么方便，底层是如何处理的呢？
Java知音
06-17 316
点击关注公众号，实用技术文章及时了解文章目录Mapper 对象方法映射为 SQL 语句Mapper 操作数据库的流程前言MyBatis-plus是完全基于MyBatis开发的一个增强工具，是在MyBatis的基础上做增强的框架，为简化开发、提高效率而生。它在MyBatis原本的框架上增加了很多实用性功能，比如乐观锁插件、字段自动填充功能、分页插件、条件构造器、sql 注入...
MyBatis-Plus原理梳理
请 端正你的态度的博客
05-27 910
MyBatis-Plus 的源码涉及多个方面，包括代码生成、条件构造器、分页插件、ActiveRecord 模式、自动填充字段和 SQL 注入防护等。这些功能都是基于 MyBatis 的基础上进行增强的，因此理解 MyBatis 的工作原理对于理解 MyBatis-Plus 的源码非常有帮助。在实际开发中，你可以通过阅读 MyBatis-Plus 的源码来学习其设计思想和实现技巧，提高自己的编程能力。
一篇学懂丨三万字Mybatis Plus 详解 IService、BaseMapper、自动填充、分页查询功能Mapper 层选装件，比官方文档都细致
这里面的代码全是错的
06-20 1532
是一个MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。愿景我们的愿景是成为 MyBatis 最好的搭档，就像魂斗罗中的 1P、2P，基友搭配，效率翻倍。
【mybatis plus源码解析】(一)mybatis plus执行原理，mybatis plus是如何实现自动注入CRUD操作
爱音乐的程序猿的博客
03-29 9802
【mybatis plus源码解析】 (一)mybatis plus执行原理 (二)详解SQL注入器底层原理，mybatis plus是如何实现自动注入CRUD操作 mybatis plus源码解析。详解SQL注入器底层原理，mybatis plus是如何实现自动注入CRUD操作。通过源码看看相关类的详细解读。系列文章
MybatisPlus源码解析2：mybatis-plus启动流程之Sql注入器-SqlInjector
java_xiaoba1的博客
10-18 529
负责注入sql的核心代码@OverrideClass<?// 循环注入自定义方法} else {获取Mapper接口的泛型，也就是User.class获取mapperRegistryCache， mapperRegistryCache缓存已注入CRUD的Mapper信息初始化table信息获取modelClass(也就是User.class)的所有方法，然后调用inject方法注入sql。
【第24章】MyBatis-Plus之SQL注入器
最新发布
zjg
07-09 943
MyBatis-Plus 提供了灵活的机制来注入自定义的 SQL 方法，这通过全局配置实现。通过实现接口或继承抽象类，你可以注入自定义的通用方法到MyBatis容器中。SQL注入器允许开发者扩展和定制SQL语句的生成，以适应特定的业务逻辑和查询需求。首先，你需要定义自定义方法的SQL语句。这通常在继承了的类中完成，例如。@Override// 定义SQL语句// 第三个参数必须和baseMapper的自定义方法名一致接下来，你需要创建一个类来继承，并重写方法来注册你的自定义方法。
MyBatis Plus通用CRUD与条件构造器使用及SQL自动注入原理分析
小小默：进无止境
07-22 4718
首先根据MyBatis Plus入门实践详解 搭建好工程。然后创建数据库表与相关的类。 表结构如下： EmployeeMapper接口继承自BaseMapper<Employee> public interface EmployeeMapper extends BaseMapper<Employee> { } 这个BaseMapper是com.baomidou.mybatisplus.mapper.BaseMapper。 【1】通用插入数据 ① insert 测试代码如下： @T
【mybatis plus源码解析】(三)自定义SQL注入器，教你如何自定义扩展BaseMapper接口方法，实现更多查询
爱音乐的程序猿的博客
03-30 2569
自定义SQL注入器，教你如何自定义扩展BaseMapper接口方法，实现更多查询。 mybatis plus源码解析。详解SQL注入器底层原理，mybatis plus是如何实现自动注入CRUD操作。通过源码看看相关类的详细解读。 上篇文章介绍了【mybatis plus源码解析】mybatis plus执行原理，这回接着上篇文章，前面讲了sql注入器的原理，现在我们尝试自定义扩展一些方法。
Mybatis-Plus SQL注入器的使用
qq_42682745的博客
01-27 5832
Mybatis-Plus SQL注入器 今天看Mybatis-plus官网发现了这个SQL注入器，感觉以后有机会用上，记录一手。 重要的话说前面：MP的官网确实不友好，但是他们将示例代码都放在了gitee上：https://gitee.com/baomidou/mybatis-plus-samples/tree/master/mybatis-plus-sample-deluxe 里面基本都有示例代码，可拉取下来找些博客对着看 两篇不错的博客： 参考：Mybatis-Plus的应用场景及注入SQL原理分析 参
【SpringBoot】26、SpringBoot中整合MyBatis-Plus实现数据库操作
热门推荐
Asurplus
07-23 21万+
MyBatis 框架相信大家都用过，虽然 MyBatis 可以直接在 xml 中通过 SQL 语句操作数据库，很是灵活。但正其操作都要通过 SQL 语句进行，就必须写大量的 xml 文件，很是麻烦。于是 MyBatis-Plus 应运而生，作为 MyBatis 的增强工具，更是为我们开发效率得到了质的飞跃。 一、简介 1、MyBatis MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBa
Mybatis plus无介绍快使用，自定义sql语句CRUD增删改查附源码（二）
06-04
深入理解Mybatis Plus的源码有助于开发者更好地利用其功能，例如，可以研究条件构造器是如何生成动态SQL的，了解其在处理主键生成策略时的具体实现，以及分页查询的底层逻辑。 六、实战应用 在实际项目中，Mybatis ...
mybatis和mybatis plus比较详解
03-21
相比之下，MyBatis Plus则提供了更为丰富的功能，如自动注入基本CRUD操作、强大的条件构造器、支持Lambda形式调用等，这些特性使得开发者能够更高效地进行数据库操作。 ## 2.2 使用方式 MyBatis在使用时需要开发者...
Mybatis Plus 代码生成器的实现
08-19
Mybatis Plus 代码生成器是MyBatis Plus框架的一个强大特性，它可以帮助开发者自动生成常见的CRUD操作代码，包括实体类、Mapper接口、Mapper XML文件、Service类和服务实现类等，极大地提高了开发效率。以下是对...
mybatis-plus 源码（mybatis-plus-3.0.zip）
03-03
1. **基础概念**：MyBatis-Plus是一个轻量级的Java框架，主要功能包括自动化 CRUD（创建、读取、更新、删除）操作，支持自定义SQL、存储过程以及丰富的查询条件构造器。 2. **Entity实体类**：在MyBatis-Plus中，...
MyBatis-Plus入门+MyBatis-Plus文档手册 中文pdf高清版.rar
11-09
无侵入、损耗小、强大的CRUD操作，支持lambda 形势调用、支持多种数据库，支持主键自动生成、支持ActiveRecord模式，支持自定义全局通用操作、支持关键词自动转义，内置代码生成器、内置分页插件、内置性能分析插件...
【spring authorization server系列教程】(一)入门系列，spring authorization server简介。快速构建一个授权服务器（基于最新版本0.3.0）
爱音乐的程序猿的博客
06-07 1万+
【spring authorization server系列教程】(一)入门系列，快速构建一个授权服务器spring authorization server是spring团队最新的认证授权服务器，之前的oauth2后面会逐步弃用。不过到现在发文的时候，我看到官网已经把之前oauth2仓库废弃了。 现在spring authorization server已经到生产就绪阶段了，不过目前项目还没有完全到生产可用阶段。...
spring authorization server授权服务器教程，集成jdbc，使用版本0.2.2
爱音乐的程序猿的博客
02-25 9948
文章目录前言一、创建授权服务器1.引入库2.创建相关数据表3.配置文件4.放入官方认证html页面5.生成jks文件6.配置KeyPair7.配置AuthorizationServerConfig授权服务器配置8.配置WebSecurityConfig基础security配置三 启动项目，这里我们测试授权码模式总结 前言 spring authorization server是spring团队最新的认证授权服务器，之前的oauth2后面会逐步弃用。不过目前项目还没有到可生产阶段。 springsecuri
docker容器启动失败或者失效查看问题方法
爱音乐的程序猿的博客
07-09 8421
有时候我们docker会因为耕种原因启动失败 首先可以用 docker ps -a 查看容器状态，是否已经停止 关键命令 docker logs {容器id} 查看容器启动日志，定位问题在哪儿，然后进行处理
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值