MyBatis 世界上流行最广泛的SQL 映射框架，由Clinton Begin 在2002 年创建，iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。其后，捐献给了Apache基金会，成立了iBatis 项目。2010 年5 月，将代码库迁致Google Code，并更名为MyBatis。（导包名：ibatis）
MyBatis 是支持普通 SQL 查询,存储过程和高级映射的优秀持久层框架。MyBatis 消除 了几乎所有的 JDBC 代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML 或注解用于配置和原始映射,将接口和 Java 的 POJOs映射成数据库中的记录。(类似Hibernate)

问: org.apache.ibatis 和 org.mybatis 路径的日志都打印什么?

我们项目里是这么配的:

<!-- logback -->
<logger name="org.apache.ibatis"  additivity="false"  level="ERROR">
    <appender-ref ref="LOGGER-INFO" />
</logger>
<logger name="org.mybatis" additivity="false"  level="ERROR">
    <appender-ref ref="LOGGER-INFO" />
</logger>

对比一下:

org.apache.ibatis 在 mybatis 包
org.mybatis 在 mybatis-spring 包

1. ibatis 是单独的持久层, mybatis在ibatis基础上升级了一下,是半自动化的持久层, hibernate 是全自动化的持久层.
2. ibatis 封装了绝大多数的 JDBC 样板代码，使得开发者只需关注 SQL 本身，而不需要花费精力去处理例如注册驱动，创建 Connection，以及确保关闭 Connection 这样繁杂的代码.
3. mybatis在很多地方都借助于 JDK 的泛型和注解特性进行了简化,反射很强大.
4. mybatis有很多优点: 对象和数据库orm字段映射, sql和代码分离,写在xml里统一管理, 支持动态sql. 使用的时候只需要配置 SqlSessionTemplate,sqlSessionFactory,MapperScannerConfigurer, 然后写接口和映射文件就可以了.
5. 在 iBatis 中，namespace 不是必需的，且它的存在没有实际的意义。在 MyBatis 中，namespace 终于派上用场了，它使得映射文件与接口绑定变得非常自然.
6. ibatis麻烦一些,原生写法(现在都不用了,就连mybatis各种配置被mybatis-spring-boot-starter集成起来,写法更简便了,还有阿里的durid封装了数据库连接池、插件化扩展框架和SQL解析器,还支持页面监控sql执行情况,技术的迭代不断解放劳动力):

String resource = "mybatis-config.xml"; 
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); 
SqlSession session = sqlSessionFactory.openSession();    
try {      
           Employee employee = new Employee(null, "name", "1", "123@qq.com"); 
           EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);     
           mapper.addEmp(employee);               
           session.commit();    
} finally {
      session.close();    
} 

所以

基本都是通过配置日志来实现的，比如配置我们最常用的 log4j.properties 或者 logback-spring.xml 来实现.

sql的日志由org.apache.ibatis 路径打印出来,
org.mybatisSql打印的是上层操作SessionTemplate等的日志.

1.最近公司一个需求让我把每次执行的sql都保存到数据库，然而我看了一些网上的资料没有适合我的例子，下面是我自己用mybatis拦截器写的一套管理sql日志的代码；
其中保存的sql 使用Druid数据库连接池配置的打印SQL的方式，其他方式我也不太了解感兴趣的可以自己了解一下；

1.Druid的包和json的包

 		<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
 	<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>

2.数据库sql

CREATE TABLE `sp_audit_db_log` (
  `ID` varchar(48) NOT NULL,
  `SQL_CONTENT` text COMMENT 'SQL内容',
  `IN_PARAM` varchar(256) DEFAULT NULL COMMENT 'sql入参',
  `START_TIME` datetime DEFAULT NULL COMMENT 'sql开始执行时间',
  `END_TIME` datetime DEFAULT NULL COMMENT 'sql执行结束时间',
  `COST_TIME` bigint(20) DEFAULT NULL COMMENT '执行sql耗时',
  `RESUTL_TYPE` varchar(4) DEFAULT NULL COMMENT '执行结果，01：成功；02：失败',
  `ERROR_CONTENT` varchar(512) DEFAULT NULL COMMENT '错误内容',
  `REMARK` varchar(256) DEFAULT NULL COMMENT '备注',
  PRIMARY KEY (`ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

3.实体

额，这个自己看着数据库写把；

4.拦截器代码
所用工具地址：
日期工具类：https://blog.csdn.net/qq_41988504/article/details/94734733
stringutil工具类：https://blog.csdn.net/qq_41988504/article/details/94735032

package com.xiaolc.intercept;


import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.fastjson.JSON;
import com.xiaolc.mapper.SpAuditDbLogMapper;
import com.xiaolc.model.SpAuditDbLog;
import com.xiaolc.util.DateUtils;
import com.xiaolc.util.StringUtil;
import org.apache.ibatis.cache.CacheKey;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.*;


/**
 * @Author: LiCheng
 * @Date: 2019/7/4 16:04
 */
@Intercepts({@org.apache.ibatis.plugin.Signature(
        type = Executor.class,
        method = "update",
        args = {MappedStatement.class, Object.class}),
        @Signature(type = Executor.class,
                method = "query",
                args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class,
                        CacheKey.class, BoundSql.class})})
@Component
public class ExecutorInterceptor implements Interceptor {

    @Autowired
    private SpAuditDbLogMapper spAuditDbLogMapper;

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        Object[] args = invocation.getArgs();

        MappedStatement ms = (MappedStatement) args[0];
        ms.getStatementType();
        //当前SQL使用的是哪个Mapper,即哪个Mapper类
        String mapper = ms.getResource();
        Configuration configuration = ms.getConfiguration();
        //执行当前SQL的Mapper id,其组成 [ 类型.方法 ]
        String mapperID = ms.getId();

        //获取当前执行的SQL使用哪个数据源,我这里的数据源组件使用的是Druid，如果使用c3p0或者其他,则需要查看相关API,一般来降一个项目可能会配多个数据源,但是数据源组件都会使用一个
        DruidDataSource dataSource = (DruidDataSource) configuration.getEnvironment().getDataSource();
        //获取数据库的类型[即mysql,或者oracle等等]
        Date createdTime = dataSource.getCreatedTime();
        String dbType = dataSource.getDataSourceStat().getDbType();

        //存放的是SQL的参数[它是一个实例对象]
        Object parameterObject = args[1];
        Object target = invocation.getTarget();
        StatementHandler handler = configuration.newStatementHandler((Executor) target, ms, parameterObject, RowBounds.DEFAULT, null, null);

        /**
         * commandName.startsWith(增/删/改/查)，可以得到crud的具体类型[得到的是大写的INSERT UPDATE]
         * method.getName()得到的name可能为update, query, flushStatements, commit, rollback, getTransaction, close, isClosed
         */
        String commandName = ms.getSqlCommandType().name();
        Method method = invocation.getMethod();
        String methodName = method.getName();

        BoundSql boundSql = ms.getBoundSql(parameterObject);
        //这个ParameterMapping表示当前SQL绑定的是哪些参数,及参数类型,但并不是参数本身
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        //将参数值转成json字符串
        String parameterObjects = JSON.toJSONString(boundSql.getParameterObject());


        //要拦截的SQL,通过拦截器的SQL 其不带参数
        String srcSQL = boundSql.getSql();
        //返回拼装好参数的SQL
        String retSQL = formatSQL(srcSQL, dbType, parameterObjects);
        //先执行当前的SQL方法,即通过当前拦截器的CRUD操作,因为我们要返回这个结果
        long start = System.currentTimeMillis();
        Object result = invocation.proceed();
        long end = System.currentTimeMillis();
        long time = end - start;

        //记录影响行数
        // Integer integer = Integer.valueOf(Integer.parseInt(result.toString()));
        //TODO 还可以记录参数，或者单表id操作时，记录数据操作前的状态
        //获取insertSqlLog方法
        //ms = ms.getConfiguration().getMappedStatement("insertSqlLog");
        //替换当前的参数为新的ms
        //args[0] = ms;
        //insertSqlLog 方法的参数为 log
        //args[1]=log;

        //组装自己的SQL记录类
        SpAuditDbLog spAuditDbLog = new SpAuditDbLog();
        spAuditDbLog.setId(UUID.randomUUID().toString());
        //记录SQL
        spAuditDbLog.setSqlContent(retSQL);
        //入参
        spAuditDbLog.setInParam(parameterObjects);
        //sql开始执行时间
        spAuditDbLog.setStartTime(DateUtils.dateParse(start, "yyyy-MM-dd HH:mm:ss"));
        //sql执行结束时间
        spAuditDbLog.setEndTime(DateUtils.dateParse(end, "yyyy-MM-dd HH:mm:ss"));
        //耗时
        spAuditDbLog.setCostTime(time);
        //执行结果
        spAuditDbLog.setResutlTupe(StringUtil.isNotEmpty(result) ? "01" : "02");
        SpAuditDbLog save = spAuditDbLogMapper.save(spAuditDbLog);
        //返回拦截器拦截的执行结果
        return result;
    }

    /**
     * plugin方法是拦截器用于封装目标对象的，通过该方法我们可以返回目标对象本身，也可以返回一个它的代理。
     * 当返回的是代理的时候我们可以对其中的方法进行拦截来调用intercept方法，当然也可以调用其他方法
     * 对于plugin方法而言，其实Mybatis已经为我们提供了一个实现。Mybatis中有一个叫做Plugin的类，
     * 里面有一个静态方法wrap(Object target,Interceptor interceptor)，通过该方法可以决定要返回的对象是目标对象还是对应的代理。
     */
    @Override
    public Object plugin(Object o) {
//        只拦截Executor对象,减少目标被代理的次数
        if (o instanceof Executor) {
            return Plugin.wrap(o, this);
        }
        return o;
    }

    /**
     * setProperties方法是用于在Mybatis配置文件中指定一些属性的
     * 这个方法在Configuration初始化当前的Interceptor时就会执行
     */
    @Override
    public void setProperties(Properties properties) {

    }

    /**
     * @describe: 组装SQL
     * @params:
     * @Author: LiCheng
     * @Date: 2019/7/4 15:10
     */
    public String formatSQL(String src, String dbType, String params) {
        //要传入的SQLUtils的参数集合,实际上虽然泛型是Object,但其实都是基本数据类型
        List<Object> paramList = new ArrayList();
        //有了JSON字符串我们就可以通过正则表达式得到参数了
        System.out.println(params);
        //需要注意的是这个SQLUtils是Druid数据源中的一个工具类,因为有现成的拼sql的工具,所以我就不再重复造轮子了,如果你的项目并没有使用Druid,
        //则需要将这个工具类加入到你的项目中
        String retSQL = SQLUtils.format(src, dbType, paramList);
        return retSQL;
    }
}

5.测试结果

6.不懂的或者有问题的加我qq：1269958153 欢迎一起交流

项目运行报错时，查看sql日志是非常好的排查手段，以前在spring框架下往往都是通过修改日志级别为DEBUG然后重启再次运行才生效，那么SpringBoot如何修改呢？

SpringBoot的spring-boot-starter依赖默认已经包含日志依赖，其默认使用的日志框架为logback，且默认的日志级别均为INFO，若不配置日志输出路径，默认日志信息打印在控制台。为了打印sql日志信息，我们只需把对应dao包下的日志级别改为DEBUG即可，在yaml配置文件中配置如下：

logging:
  level:
    # Map<String, String>格式，前者为对应的路径或是进程 后者为日志级别
    activitiTest.activitiTest.dao: debug

上图这种是针对本地测试或是临时修改，毕竟DEBUG级别下打印的日志会非常多，倘若生产环境下使用该级别会造成大量的垃圾日志信息，因此项目运行时一般不会这么干，所以需要在项目运行时动态修改其日志级别（无需重启），使之输出sql日志

SpringBoot动态修改日志级别

1、首先引入对应的监控工具依赖，其中包含有日志端点监控：

<!-- springBoot监控工具 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2、在yaml中配置如下：

# 配置端点信息
management:
  endpoints:
    # 关闭所有默认为true的端点
    enabled-by-default: false
    web:
      exposure:
        # 由于health端点在启动时无法扫描MongoConfig类中的mongoTemplate实例，因此此处去掉该端点 这里只留日志端点 使用post请求访问/actuator/loggers/端点名（先通过get请求访问/actuator/loggers获取所有端点名）
        # 请求体为{"configuredLevel": "DEBUG"},即可打印sql日志
        include:
        - loggers
# 端点访问路径 默认即为/actuator
#      base-path: /actuator
  endpoint:
    loggers:
      enabled: true

# 端点端口配置，默认与服务端一样
#  server:
#    port:

3、由于本文只是为了修改日志级别，因此只配了loggers端点，一般项目中往往还需要info和health端点用以监控，下面启动项目，然后使用get请求访问/actuator/loggers，会看到以下输出信息：

{
    "levels":[
        "OFF",
        "ERROR",
        "WARN",
        "INFO",
        "DEBUG",
        "TRACE"
    ],
    "loggers":{
        "ROOT":{
            "configuredLevel":"INFO",
            "effectiveLevel":"INFO"
        },
        "com":{
            "configuredLevel":null,
            "effectiveLevel":"INFO"
        },
        "com.caiyi":{
            "configuredLevel":null,
            "effectiveLevel":"INFO"
        }
        ...
    }
}

4、开始修改日志级别，使用post请求访问，例如：/actuator/loggers/com.caiyi，请求体如下：

{
  "configuredLevel": "DEBUG"
}

此时已经修改完毕，可直接访问controller层，查看日志信息，此时已有sql日志打印出：