mybatis-plus 打印完整SQL，SQL中包含参数

最新推荐文章于 2024-03-11 15:50:48 发布
最新推荐文章于 2024-03-11 15:50:48 发布
阅读量4.1k 收藏 8
点赞数
分类专栏： mybatis plus 输出完整SQL mybatis  plus 打印完整SQL 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lovo1/article/details/107472658
版权
  • 网上一些案例，可以打印SQL,不过参数没有填充到SQL语句中，参数过多时，不利于SQL 调试
  • mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  • mybatis-plus 打印完整SQL,SQL中包含参数，重写com.baomidou.mybatisplus.core.MybatisDefaultParameterHandler.setParameters 方法即可

 

package com.baomidou.mybatisplus.core;


import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.core.incrementer.IdentifierGenerator;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.core.toolkit.GlobalConfigUtils;
import com.baomidou.mybatisplus.core.toolkit.ReflectionKit;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;

import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.mapping.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.scripting.defaults.DefaultParameterHandler;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.TypeException;
import org.apache.ibatis.type.TypeHandler;
import org.apache.ibatis.type.TypeHandlerRegistry;

import java.math.BigDecimal;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.*;


/**
 * TODO: 测试开发使用
 *
 * @author
 * @version V1.0
 * @className: MybatisDefaultParameterHandler
 * @date 2020/7/20 0020 16:27
 */
@Slf4j
public class MybatisDefaultParameterHandler extends DefaultParameterHandler {

    private final TypeHandlerRegistry typeHandlerRegistry;
    private final MappedStatement mappedStatement;
    private final Object parameterObject;
    private final BoundSql boundSql;
    private final Configuration configuration;

    public MybatisDefaultParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
        super(mappedStatement, processParameter(mappedStatement, parameterObject), boundSql);
        this.mappedStatement = mappedStatement;
        this.configuration = mappedStatement.getConfiguration();
        this.typeHandlerRegistry = mappedStatement.getConfiguration().getTypeHandlerRegistry();
        this.parameterObject = parameterObject;
        this.boundSql = boundSql;
    }

    /**
     * 处理参数
     *
     * @param ms              MappedStatement
     * @param parameterObject 插入数据库对象
     * @return ignore
     */
    protected static Object processParameter(MappedStatement ms, Object parameterObject) {
        /* 只处理插入或更新操作 */
        if (parameterObject != null
                && (SqlCommandType.INSERT == ms.getSqlCommandType() || SqlCommandType.UPDATE == ms.getSqlCommandType())) {
            //检查 parameterObject
            if (ReflectionKit.isPrimitiveOrWrapper(parameterObject.getClass())
                    || parameterObject.getClass() == String.class) {
                return parameterObject;
            }
            Collection<Object> parameters = getParameters(parameterObject);
            if (null != parameters) {
                // 感觉这里可以稍微优化一下，理论上都是同一个.
                parameters.forEach(obj -> process(ms, obj));
            } else {
                process(ms, parameterObject);
            }
        }
        return parameterObject;
    }

    private static void process(MappedStatement ms, Object parameterObject) {
        if (parameterObject != null) {
            TableInfo tableInfo = null;
            Object entity = parameterObject;
            if (parameterObject instanceof Map) {
                Map<?, ?> map = (Map<?, ?>) parameterObject;
                if (map.containsKey(Constants.ENTITY)) {
                    Object et = map.get(Constants.ENTITY);
                    if (et != null) {
                        entity = et;
                        tableInfo = TableInfoHelper.getTableInfo(entity.getClass());
                    }
                }
            } else {
                tableInfo = TableInfoHelper.getTableInfo(parameterObject.getClass());
            }
            if (tableInfo != null) {
                //到这里就应该转换到实体参数对象了,因为填充和ID处理都是争对实体对象处理的,不用传递原参数对象下去.
                MetaObject metaObject = ms.getConfiguration().newMetaObject(entity);
                if (SqlCommandType.INSERT == ms.getSqlCommandType()) {
                    populateKeys(tableInfo, metaObject, entity);
                    insertFill(metaObject, tableInfo);
                } else {
                    updateFill(metaObject, tableInfo);
                }
            }
        }
    }


    /**
     * 处理正常批量插入逻辑
     * <p>
     * org.apache.ibatis.session.defaults.DefaultSqlSession$StrictMap 该类方法
     * wrapCollection 实现 StrictMap 封装逻辑
     * </p>
     *
     * @param parameter 插入数据库对象
     * @return
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    protected static Collection<Object> getParameters(Object parameter) {
        Collection<Object> parameters = null;
        if (parameter instanceof Collection) {
            parameters = (Collection) parameter;
        } else if (parameter instanceof Map) {
            Map parameterMap = (Map) parameter;
            if (parameterMap.containsKey("collection")) {
                parameters = (Collection) parameterMap.get("collection");
            } else if (parameterMap.containsKey("list")) {
                parameters = (List) parameterMap.get("list");
            } else if (parameterMap.containsKey("array")) {
                parameters = Arrays.asList((Object[]) parameterMap.get("array"));
            }
        }
        return parameters;
    }

    /**
     * 填充主键
     *
     * @param tableInfo  数据库表反射信息
     * @param metaObject 元数据对象
     * @param entity     实体信息
     */
    protected static void populateKeys(TableInfo tableInfo, MetaObject metaObject, Object entity) {
        final IdType idType = tableInfo.getIdType();
        final String keyProperty = tableInfo.getKeyProperty();
        if (StringUtils.isNotBlank(keyProperty) && null != idType && idType.getKey() >= 3) {
            final IdentifierGenerator identifierGenerator = GlobalConfigUtils.getGlobalConfig(tableInfo.getConfiguration()).getIdentifierGenerator();
            Object idValue = metaObject.getValue(keyProperty);
            if (StringUtils.checkValNull(idValue)) {
                if (idType.getKey() == IdType.ASSIGN_ID.getKey()) {
                    if (Number.class.isAssignableFrom(tableInfo.getKeyType())) {
                        metaObject.setValue(keyProperty, identifierGenerator.nextId(entity));
                    } else {
                        metaObject.setValue(keyProperty, identifierGenerator.nextId(entity).toString());
                    }
                } else if (idType.getKey() == IdType.ASSIGN_UUID.getKey()) {
                    metaObject.setValue(keyProperty, identifierGenerator.nextUUID(entity));
                }
            }
        }
    }

    protected static void insertFill(MetaObject metaObject, TableInfo tableInfo) {
        GlobalConfigUtils.getMetaObjectHandler(tableInfo.getConfiguration()).ifPresent(metaObjectHandler -> {
            if (metaObjectHandler.openInsertFill()) {
                if (tableInfo.isWithInsertFill()) {
                    metaObjectHandler.insertFill(metaObject);
                } else {
                    // 兼容旧操作 id类型为input或none的要用填充器处理一下
                    if (metaObjectHandler.compatibleFillId()) {
                        String keyProperty = tableInfo.getKeyProperty();
                        if (StringUtils.isNotBlank(keyProperty)) {
                            Object value = metaObject.getValue(keyProperty);
                            if (value == null && (IdType.NONE == tableInfo.getIdType() || IdType.INPUT == tableInfo.getIdType())) {
                                metaObjectHandler.insertFill(metaObject);
                            }
                        }
                    }
                }
            }
        });
    }

    protected static void updateFill(MetaObject metaObject, TableInfo tableInfo) {
        GlobalConfigUtils.getMetaObjectHandler(tableInfo.getConfiguration()).ifPresent(metaObjectHandler -> {
            if (metaObjectHandler.openUpdateFill() && tableInfo.isWithUpdateFill()) {
                metaObjectHandler.updateFill(metaObject);
            }
        });
    }

    @Override
    @SuppressWarnings("unchecked")
    public void setParameters(PreparedStatement ps) {
        ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();


        if (parameterMappings != null) {
            String sql = boundSql.getSql();
            List<Object> parameters = new ArrayList<>();
            for (int i = 0; i < parameterMappings.size(); i++) {
                ParameterMapping parameterMapping = parameterMappings.get(i);
                if (parameterMapping.getMode() != ParameterMode.OUT) {
                    Object value;
                    String propertyName = parameterMapping.getProperty();
                    if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
                        value = boundSql.getAdditionalParameter(propertyName);
                    } else if (parameterObject == null) {
                        value = null;
                    } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                        value = parameterObject;
                    } else {
                        MetaObject metaObject = configuration.newMetaObject(parameterObject);
                        value = metaObject.getValue(propertyName);
                    }
                    TypeHandler typeHandler = parameterMapping.getTypeHandler();
                    JdbcType jdbcType = parameterMapping.getJdbcType();
                    if (value == null && jdbcType == null) {
                        jdbcType = configuration.getJdbcTypeForNull();
                    }
                    try {
                        typeHandler.setParameter(ps, i + 1, value, jdbcType);
                        parameters.add(value);
                    } catch (TypeException | SQLException e) {
                        throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
                    }
                }
            }
            try {
                sql = handleListParameter(sql, parameters);
                System.out.println("输出完整的sql-------------------->>>" + sql);
            } catch (Exception e) {
                e.printStackTrace();
            }

        }

    }


    /**
     * 是否基本数据类型或者基本数据类型的包装类
     */
    private boolean isPrimitiveOrPrimitiveWrapper(Class<?> parameterObjectClass) {
        return parameterObjectClass.isPrimitive() ||
                (parameterObjectClass.isAssignableFrom(BigDecimal.class) || parameterObjectClass.isAssignableFrom(Byte.class) || parameterObjectClass.isAssignableFrom(Short.class) ||
                        parameterObjectClass.isAssignableFrom(Integer.class) || parameterObjectClass.isAssignableFrom(Long.class) ||
                        parameterObjectClass.isAssignableFrom(Double.class) || parameterObjectClass.isAssignableFrom(Float.class) ||
                        parameterObjectClass.isAssignableFrom(Character.class) || parameterObjectClass.isAssignableFrom(Boolean.class));
    }

    /**
     * 参数转换拼接替换
     * @param sql
     * @param col
     * @return
     */
    private String handleListParameter(String sql, Collection<?> col) {
        if (col != null && col.size() != 0) {
            for (Object obj : col) {
                String value = null;
                Class<?> objClass = obj.getClass();

                // 类型匹配输出
                if (isPrimitiveOrPrimitiveWrapper(objClass)) {
                    value = obj.toString();
                } else if (objClass.isAssignableFrom(String.class)) {
                    value = "\'" + obj.toString() + "\'";
                } else if (objClass.isAssignableFrom(Date.class)) {
                    try {
                        value = cn.hutool.core.date.DateUtil.format((Date) obj, "yyyy-MM-dd HH:mm:ss");
                        value = "to_date('" + value + "','yyyy-mm-dd hh24:mi:ss')";
                    } catch (Exception e) {
                        e.printStackTrace();
                        value = "\'" + obj.toString() + "\'";
                       
                    }
                } else {
                    //暂定吧
                    value = "\'" + obj.toString() + "\'";
                }

                sql = sql.replaceFirst("\\?", value);

            }

        }

        return sql;
    }


}

 

爱编程的皮皮虾
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
mybatis-plus-generator-ui:对mybatis-plus-generator进行封装，通过Web UI快速生成兼容的Spring boot，mybatis-plus框架的各类业务代码
03-20
mybatis加上发电机的用户界面 提供一致的Web UI用于生成兼容mybatis-plus框架的相关功能代码，包括Entity，Mapper，Mapper.xml，Service，Controller等，可以自定义模板以及各种输出参数，也可以通过SQL查询语句直接生成代码。 使用方法 ♡maven的相关依赖，注意范围只需要写test就可以了 < dependency> < groupId>com.github.davidfantasy</ groupId> < artifactId>mybatis-plus-generator-ui</ artifactId> < version>1.4.2</ version> < scope>test</ scope> </ dependency> 在项目的test目录新建一个启动类，代码示例
mybatisplus 打印sql 带拼接好入参的日志
weixin_42827159的博客
10-27 1650
项目中要在控制台查看sql 因为mybatis的sql总是有问号占位符 还要手动粘贴填充参数, 所以写了一个logback的日志织入 启动类上添加如下代码 System.setProperty(ClassicConstants.LOGBACK_CONTEXT_SELECTOR, "com.xxx.xxx.xxx.config.CustomDefaultContextSelector"); 其他代码如下 /** * desc: 日志实体类类 * * @author : * cre
mybatisplus开启sql打印的三种方式
qq_64680177的博客
10-20 1万+
使用： 使用mybatisplus自带的log-impl配置，使用log4j日志框架配置，使用P6spy插件这三种方法打印sql，分别介绍这三种方法的配置方法、应用场景和优缺点。
mybatis如何打印出完整sql语句
最新发布
ll1042668699的博客
03-11 821
2. 在idea中安装MyBatis Log Plugin 插件, 然后运行该插件, 之后通过mybaits做DML时就可以看到完整的sql语句。
mybatisplus打印sql语句不带问号
weixin_46005468的博客
01-04 1253
来公司实习一个多月了,学习前辈们写的代码,熟悉代码流程,但是!!! mybatisplus打印出来的语句参数都是被问号替代的,虽然下面有实际的值, 但是让我一个个去替换有点难受,于是网上百度了一波,也踩了一些坑 推荐一个很很很好用的插件SQL Params Setter 好用到什么程度呢 选中 右键 它会判断是否合法,合法在右下角会有一个成功的提示 我们只需要在我们的navicat中查询语句中粘贴即可 这样就省略了我们很多时间,好东西,冲冲冲! ...
MyBatis-Plus 分页查询以及自定义sql分页的实现
09-07
主要介绍了MyBatis-Plus 分页查询以及自定义sql分页的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
mybatis-plus配置控制台打印完整带参数SQL语句的实现
09-07
主要介绍了mybatis-plus配置控制台打印完整带参数SQL语句，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
mybatis-plus配置控制台打印完整带参数SQL语句
热门推荐
★【World Of Moshow 郑锴】★
05-28 12万+
问题背景 通常我们开发的时候，需要联合控制台和Navicat/PLSQL等工具进行语句的拼接检查，如果只是输出了一堆？？？，那么将极大降低我们的效率。因此我们需要输出完整的SQL语句以便调试。 解决方案 如果是application.yml #mybatis-plus配置控制台打印完整带参数SQL语句 mybatis-plus: configuration: log-impl: org...
打印日志sql自动填充参数拼接成完整的sql
damoneric_guo的博客
12-29 1280
把打印出来的日志copy到上个文本框，点击转换按钮，自动转换为可以执行的sql。
Mybatis 的Log4j日志输出问题 - 以及有关日志的所有问题
偶尔记一下 - mybatis.io
04-04 11万+
使用Mybatis的时候，有些时候能输出（主要是指sql，参数，结果）日志。有些时候就不能。 无法输出日志的时候，无论怎么配置log4j，不管是properties的还是xml的，都不起作用。 有些时候，我们没做什么配置就能输出日志.... 这是一个让无数人烦躁的问题。其实解决问题很容易（我过了这么久才解决，以前都用拦截器输出）。 这是一个普大喜奔的日子，让
重写mybatis配置
weixin_45818966的博客
12-12 426
Slf4j/*** @desc 监控数据源* @return*/
MyBatis-Plus 的官方示例(mybatis-plus-samples-master.zip)
05-05
本工程为 MyBatis-Plus 的官方示例，项目结构如下： mybatis-plus-sample-quickstart: 快速开始示例 mybatis-plus-sample-quickstart-springmvc: 快速开始示例（Spring MVC版本） mybatis-plus-sample-reduce-springmvc: 简化掉默认mapper类示例（Spring MVC版本） mybatis-plus-sample-generator: 代码生成器示例 mybatis-plus-sample-crud: 完整 CRUD 示例 mybatis-plus-sample-wrapper: 条件构造器示例 mybatis-plus-sample-pagination: 分页功能示例 mybatis-plus-sample-active-record: ActiveRecord示例 mybatis-plus-sample-sequence: Sequence示例 mybatis-plus-sample-execution-analysis: Sql执行分析示例
MyBatis-Plus入门+MyBatis-Plus文档手册 中文pdf高清版.rar
11-09
虽然mybatis可以直接在xml中通过SQL语句操作数据库，很是灵活。但正其操作都要通过SQL语句进行，就必须写大量的xml文件，很是麻烦。mybatis-plus就很好的解决了这个问题。 MyBatisPlus是一个Mybatis的增强工具，在 ...
springboot整合mybatis-plus打印完整SQL语句
liuerchong的博客
07-06 8555
mybatis-plus控制台打印完整带参数SQL语句 问题背景 通常我们开发的时候，需要联合控制台和Navicat/PLSQL等工具进行语句的拼接检查，如果只是输出了一堆？？？，那么将极大降低我们的效率。因此我们需要输出完整的SQL语句以便调试。 解决方案 1.Mybatis拦截器实现统计sql执行时间及打印完整sql语句 代码 import java.sql.Connection; import java.text.DateFormat; import java.util.Date; import ja
IT总结:
czx1254678152的博客
01-12 1211
IT_JAVA总结
mysql spool_用MySQL实现类似Oracle SPOOL的功能
weixin_35884854的博客
01-19 1196
在用Oracle的SQL*PLUS的时候SPOOL真是好用啊.在MySQL中如何实现呢?下面来实验说明MySQL中可以用tee参数具体实现方式有三种第一种:tee参数加入my.cnf参数文件例子:tee =/mysql/mysql_op.log注意:如果需要对client进行记录在[client]中加入第二种:命令行例子:mysql -u root -p --tee=/mysql/mysql_op...
mybatis/mybatis-plus配置输出带参数的完整sql
爱的叹息的专栏
07-01 3940
直接添加配置文件如下即可 效果 mybatis的配置
springboot 下mybatis-plus 如何打印sql日志和参数到日志文件
qq_36407469的博客
07-26 2万+
最近在使用springboot过程中用到了mybatis-plus ，需要打印sql日志和参数，网上的清一色做法是加配置。 mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl 加上去后日志确实是出来，可以看到idea控制台上将sql和参数打印出来了 SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@15b67
mybatis-plus中打印sql耗时的插件
06-03
Mybatis-plus中打印SQL耗时的插件是 PerformanceInterceptor。它是一个拦截器，可以在SQL执行前后计算执行时间，并打印SQL相关的统计信息。在Mybatis-plus中，可以通过在配置文件中配置PerformanceInterceptor来启用该插件。具体配置方式如下： ```java @Configuration public class MybatisPlusConfig { @Bean public PerformanceInterceptor performanceInterceptor() { PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor(); // 是否格式化SQL语句 performanceInterceptor.setFormat(true); // SQL语句执行超过指定毫秒数后输出日志 performanceInterceptor.setMaxTime(100); return performanceInterceptor; } } ``` 配置完成后，每次执行SQL语句时，都会在控制台输出类似以下的信息： ``` Time：41 ms - ID：com.example.mapper.UserMapper.selectList Execute SQL：SELECT * FROM user ``` 其中，Time表示SQL执行时间，ID表示SQL执行的方法名，Execute SQL表示具体执行的SQL语句。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值