Mybatis基础模块-日志管理

已于 2023-07-23 21:36:46 修改
阅读量906 收藏 1
点赞数
分类专栏： # MyBatis 文章标签： mybatis
于 2023-07-23 20:19:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39530821/article/details/131879618
版权

文章目录

1. 适配器模式

适配器使接口不兼容的对象可以相互合作。
在这里插入图片描述
Java的日志框架有很多，Log4j,Log4j2,Apache Commons Log,java.util.logging,slf4j等，接口不尽相同，Mybatis为了统一匹配这些框架，使用到了适配器模式。

2. Log

Mybatis自定义了日志接口：org.apache.ibatis.logging.Log。

/**
 * @author Clinton Begin
 */
public interface Log {

  boolean isDebugEnabled();

  boolean isTraceEnabled();

  void error(String s, Throwable e);

  void error(String s);

  void debug(String s);

  void trace(String s);

  void warn(String s);

}

以下为其类图：
在这里插入图片描述
上图的实现相当于adapter。

2.1 默认实现StdOutImpl

public class StdOutImpl implements Log {

  public StdOutImpl(String clazz) {
    // Do Nothing
  }

  @Override
  public boolean isDebugEnabled() {
    return true;
  }

  @Override
  public boolean isTraceEnabled() {
    return true;
  }

  @Override
  public void error(String s, Throwable e) {
    System.err.println(s);
    e.printStackTrace(System.err);
  }

  @Override
  public void error(String s) {
    System.err.println(s);
  }

  @Override
  public void debug(String s) {
    System.out.println(s);
  }

  @Override
  public void trace(String s) {
    System.out.println(s);
  }

  @Override
  public void warn(String s) {
    System.out.println(s);
  }
}

这个实现很简单，就是控制台把日志打印出来。

2.2 Log4jImpl

为了匹配Log4j，该类持有org.apache.log4j.Logger，Logger就是上图adaptee，被匹配的接口。

/**
 * @author Eduardo Macarron
 */
public class Log4jImpl implements Log {

  private static final String FQCN = Log4jImpl.class.getName();

  private final Logger log;

  public Log4jImpl(String clazz) {
    log = Logger.getLogger(clazz);
  }

  @Override
  public boolean isDebugEnabled() {
    return log.isDebugEnabled();
  }

  @Override
  public boolean isTraceEnabled() {
    return log.isTraceEnabled();
  }

  @Override
  public void error(String s, Throwable e) {
    log.log(FQCN, Level.ERROR, s, e);
  }

  @Override
  public void error(String s) {
    log.log(FQCN, Level.ERROR, s, null);
  }

  @Override
  public void debug(String s) {
    log.log(FQCN, Level.DEBUG, s, null);
  }

  @Override
  public void trace(String s) {
    log.log(FQCN, Level.TRACE, s, null);
  }

  @Override
  public void warn(String s) {
    log.log(FQCN, Level.WARN, s, null);
  }

}

3. LogFactory

LogFactory使用工厂模式，创建各类适配器。 该类用final修饰，不可继承，同时构造方法是私有的，不能通过new方法创建，像是一个工具类。


/**
 * @author Clinton Begin
 * @author Eduardo Macarron
 */
public final class LogFactory {

  /**
   * Marker to be used by logging implementations that support markers.
   */
  public static final String MARKER = "MYBATIS";

  private static Constructor<? extends Log> logConstructor;

  static {
    // 按序加载对应的日志组件，从上往下加载，上面的成功了，下面的就不会在加载了
    /**
     * tryImplementation(LogFactory::useSlf4jLogging); 等价于
     * tryImplementation(new Runnable(){
     *   void run(){
     *     useSlf4jLogging();
     *   }
     * })
     */
    tryImplementation(LogFactory::useSlf4jLogging);
    tryImplementation(LogFactory::useCommonsLogging);
    tryImplementation(LogFactory::useLog4J2Logging);
    tryImplementation(LogFactory::useLog4JLogging);
    tryImplementation(LogFactory::useJdkLogging);
    tryImplementation(LogFactory::useNoLogging);
  }

  private LogFactory() {
    // disable construction
  }

  public static Log getLog(Class<?> aClass) {
    return getLog(aClass.getName());
  }

  public static Log getLog(String logger) {
    try {
      return logConstructor.newInstance(logger);
    } catch (Throwable t) {
      throw new LogException("Error creating logger for logger " + logger + ".  Cause: " + t, t);
    }
  }

  public static synchronized void useCustomLogging(Class<? extends Log> clazz) {
    setImplementation(clazz);
  }

  public static synchronized void useSlf4jLogging() {
    setImplementation(org.apache.ibatis.logging.slf4j.Slf4jImpl.class);
  }

  public static synchronized void useCommonsLogging() {
    setImplementation(org.apache.ibatis.logging.commons.JakartaCommonsLoggingImpl.class);
  }

  public static synchronized void useLog4JLogging() {
    setImplementation(org.apache.ibatis.logging.log4j.Log4jImpl.class);
  }

  public static synchronized void useLog4J2Logging() {
    setImplementation(org.apache.ibatis.logging.log4j2.Log4j2Impl.class);
  }

  public static synchronized void useJdkLogging() {
    setImplementation(org.apache.ibatis.logging.jdk14.Jdk14LoggingImpl.class);
  }

  public static synchronized void useStdOutLogging() {
    setImplementation(org.apache.ibatis.logging.stdout.StdOutImpl.class);
  }

  public static synchronized void useNoLogging() {
    setImplementation(org.apache.ibatis.logging.nologging.NoLoggingImpl.class);
  }

  private static void tryImplementation(Runnable runnable) {
    if (logConstructor == null) {
      try {
        runnable.run();
      } catch (Throwable t) {
        // ignore
      }
    }
  }

  private static void setImplementation(Class<? extends Log> implClass) {
    try {
      // 获取指定适配器的构造方法
      Constructor<? extends Log> candidate = implClass.getConstructor(String.class);
      // 实例化适配器
      Log log = candidate.newInstance(LogFactory.class.getName());
      if (log.isDebugEnabled()) {
        log.debug("Logging initialized using '" + implClass + "' adapter.");
      }
      // 初始化 logConstructor 字段
      logConstructor = candidate;
    } catch (Throwable t) {
      throw new LogException("Error setting Log implementation.  Cause: " + t, t);
    }
  }

}

4. 解析配置和应用

问题：mybatis是如何选择日志框架的。

4.1 settings配置

在这里插入图片描述
配置值包括：SLF4J ， LOG4J(deprecated since 3.5.9) ， LOG4J2 ， JDK_LOGGING |，COMMONS_LOGGING ， STDOUT_LOGGING ， NO_LOGGING。

配置的值是如何来的？
在配置对象Configuration的构造方法里面。
在这里插入图片描述

4.2 解析

XMLConfigBuilder的方法：loadCustomLogImpl().


  private void loadCustomLogImpl(Properties props) {
    // 获取 logImpl设置的 日志 类型
    Class<? extends Log> logImpl = resolveClass(props.getProperty("logImpl"));
    // 设置日志  这块代码是我们后面分析 日志 模块的 关键代码
    configuration.setLogImpl(logImpl);
  }

继续：


  public void setLogImpl(Class<? extends Log> logImpl) {
    if (logImpl != null) {
      this.logImpl = logImpl; // 记录日志的类型
      // 设置 适配选择
      LogFactory.useCustomLogging(this.logImpl);
    }
  }

继续：


  public static synchronized void useCustomLogging(Class<? extends Log> clazz) {
    setImplementation(clazz);
  }

继续：


  private static void setImplementation(Class<? extends Log> implClass) {
    try {
      // 获取指定适配器的构造方法
      Constructor<? extends Log> candidate = implClass.getConstructor(String.class);
      // 实例化适配器
      Log log = candidate.newInstance(LogFactory.class.getName());
      if (log.isDebugEnabled()) {
        log.debug("Logging initialized using '" + implClass + "' adapter.");
      }
      // 初始化 logConstructor 字段
      logConstructor = candidate;
    } catch (Throwable t) {
      throw new LogException("Error setting Log implementation.  Cause: " + t, t);
    }
  }

5. jdbc日志

有了以上的类，那mybatis是如何打印日志的？

Mybatis通过JDK动态代理的方式，将JDBC操作通过指定的日志框架打印出来。

5. 1 类图

BaseJdbcLogger

5.2 BaseJdbcLogger

BaseJdbcLogger是一个基础的抽象类。基本的属性：


  // 记录 PreparedStatement 接口中定义的常用的set*() 方法
  protected static final Set<String> SET_METHODS;
  // 记录了 Statement 接口和 PreparedStatement 接口中与执行SQL语句有关的方法
  protected static final Set<String> EXECUTE_METHODS = new HashSet<>();

  // 记录了PreparedStatement.set*() 方法设置的键值对
  private final Map<Object, Object> columnMap = new HashMap<>();
  // 记录了PreparedStatement.set*() 方法设置的键 key
  private final List<Object> columnNames = new ArrayList<>();
  // 记录了PreparedStatement.set*() 方法设置的值 Value
  private final List<Object> columnValues = new ArrayList<>();

  protected final Log statementLog;// 用于日志输出的Log对象
  protected final int queryStack;  // 记录了SQL的层数，用于格式化输出SQL

5.3 ConnectionLogger


/**
 * Connection proxy to add logging.
 *
 * @author Clinton Begin
 * @author Eduardo Macarron
 *
 */
public final class ConnectionLogger extends BaseJdbcLogger implements InvocationHandler {

  // 真正的Connection对象
  private final Connection connection;

  private ConnectionLogger(Connection conn, Log statementLog, int queryStack) {
    super(statementLog, queryStack);
    this.connection = conn;
  }

  /**
   * Connection 是一个数据库连接对象
   *            通过 Connection 的下一步是创建 Statement 对象
   *            Statement包含对应的子类 PreparedStatement
   *
   *            日志记录  Connection 创建 Statement 的过程
   *            同时会创建 Statement 的代理对象类增强 Statement
   *
   * @param proxy
   * @param method
   * @param params
   * @return
   * @throws Throwable
   */
  @Override
  public Object invoke(Object proxy, Method method, Object[] params)
      throws Throwable {
    try {
      // 如果是调用从Object继承过来的方法，就直接调用 toString,hashCode,equals等
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, params);
      }
      // 如果调用的是 prepareStatement方法
      if ("prepareStatement".equals(method.getName())) {
        if (isDebugEnabled()) {
          debug(" Preparing: " + removeBreakingWhitespace((String) params[0]), true);
        }
        // 创建  PreparedStatement
        PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);
        // 然后创建 PreparedStatement 的代理对象 增强
        stmt = PreparedStatementLogger.newInstance(stmt, statementLog, queryStack);
        return stmt;
        // 同上
      } else if ("prepareCall".equals(method.getName())) {
        if (isDebugEnabled()) {
          debug(" Preparing: " + removeBreakingWhitespace((String) params[0]), true);
        }
        PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);
        stmt = PreparedStatementLogger.newInstance(stmt, statementLog, queryStack);
        return stmt;
        // 同上
      } else if ("createStatement".equals(method.getName())) {
        Statement stmt = (Statement) method.invoke(connection, params);
        stmt = StatementLogger.newInstance(stmt, statementLog, queryStack);
        return stmt;
      } else {
        return method.invoke(connection, params);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }

  /**
   * Creates a logging version of a connection.
   *
   * @param conn - the original connection
   * @return - the connection with logging
   */
  public static Connection newInstance(Connection conn, Log statementLog, int queryStack) {
    InvocationHandler handler = new ConnectionLogger(conn, statementLog, queryStack);
    ClassLoader cl = Connection.class.getClassLoader();
    // 创建了 Connection的 代理对象 目的是 增强 Connection对象 给他添加了日志功能
    return (Connection) Proxy.newProxyInstance(cl, new Class[]{Connection.class}, handler);
  }

  /**
   * return the wrapped connection.
   *
   * @return the connection
   */
  public Connection getConnection() {
    return connection;
  }

}

5.4 ConnectionLogger的具体应用

在实际处理的时候，日志模块是如何工作的？

  • 执行sql之前先要获取Statement.
    SimpleExecutor的方法doQuery

  /**
   * 到了 具体的数据库操作的步骤了  JDBC
   *     Connection
   *     Statement
   *     PreparedStatement
   * @param ms
   * @param parameter
   * @param rowBounds
   * @param resultHandler
   * @param boundSql
   * @param <E>
   * @return
   * @throws SQLException
   */
  @Override
  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      // 注意，已经来到SQL处理的关键对象 StatementHandler >>  同时会完成  parameterHandler和resultSetHandler的实例化
      // 默认创建的是 PreparedStatementHandler
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      // 获取一个 Statement对象  对占位符处理
      stmt = prepareStatement(handler, ms.getStatementLog());
      // 执行查询
      return handler.query(stmt, resultHandler);
    } finally {
      // 用完就关闭
      closeStatement(stmt);
    }
  }
  • 继续看prepareStatement

  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    // 放开了日志 会创建 Connection 的代理对象
    Connection connection = getConnection(statementLog);
    // 获取 Statement 对象 ==》 PreparedStatement对象 Statement  如果放开了日志 则会创建 Statement 对应的代理对象
    stmt = handler.prepare(connection, transaction.getTimeout());
    // 为 Statement 设置参数  如果是PreparedStatement处理则会对 对应的占位符赋值
    handler.parameterize(stmt);
    return stmt;
  }
  • 继续看getConnection方法，
 protected Connection getConnection(Log statementLog) throws SQLException {
    // 获取到了真正的 Connection 对象 ? 如果有连接池管理 在此处获取的是PooledConnection 是Connection的代理对象
    Connection connection = transaction.getConnection();
    if (statementLog.isDebugEnabled()) {
      // 创建Connection的日志jdk代理对象
      return ConnectionLogger.newInstance(connection, statementLog, queryStack);
    } else {
      // 返回的是真正的Connection 没有走代理的方式
      return connection;
    }
  }
  • 再看 handler.prepare(connection, transaction.getTimeout())， 进入到instantiateStatement方法

  @Override
  protected Statement instantiateStatement(Connection connection) throws SQLException {
    String sql = boundSql.getSql();
    if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
      String[] keyColumnNames = mappedStatement.getKeyColumns();
      if (keyColumnNames == null) {
        // connection 是 日志的代理对象
        return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
      } else {
        // 在执行 prepareStatement 方法的时候会进入进入到ConnectionLogger的invoker方法中
        return connection.prepareStatement(sql, keyColumnNames);
      }
    } else if (mappedStatement.getResultSetType() == ResultSetType.DEFAULT) {
      return connection.prepareStatement(sql);
    } else {
      return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
    }
  }

在这里插入图片描述

  • 执行查询handler.query(stmt, resultHandler);

在这里插入图片描述

tobebetter9527
关注
专栏目录
Mybatis日志配置文件
01-11
Mybatis配置文件，这个文件直接导入到项目中就可以使用
mybatis-3-config.dtd mybatis-3-mapper.dtd
03-04
此外，还可以设置MyBatis的日志实现，以便在开发过程中方便地查看执行的SQL语句。 `mybatis-3-mapper.dtd`则是映射文件的DTD，它定义了映射文件的结构。在MyBatis中，映射文件用于编写SQL查询和结果映射，将数据库...
mybitis事务管理
zygzzp的专栏
01-20 902
1. myBatis单独使用时，使用SqlSession来处理事务：  原文：http://czj4451.iteye.com/blog/2037759 Java代码   public class MyBatisTxTest {          private static SqlSessionFactory sqlSessionFactory;       pr
MyBatis入门——基础操作（中）
最新发布
2202_76101487的博客
08-22 1693
本文主要是奖讲了nybatis的增删改查的简单语法；
MyBatis日志管理
Do_GH的博客
03-26 277
日志管理 日志管理是系统的操作的记录文件或记录文件的总和，通过打印系统运行的状态信息，可以更加快速的分析查找问题。 在Java开发中提供了两大日志接口SLF4j（Simple Logging Facade For Java）和Logback（Apache Commons Logging），通过规范接口我们可以很方便的调用接口中的方法实现各种功能。在规范的接口下，不同的厂商开发了自己的实现类例如log4j、logback、java.utils.loggind(jul)等等，现在较为常用的是logback。 l
【MyBatis】MyBatis的日志实现
小七的博客
04-01 1606
本文介绍了MyBatis的日志管理以及日志技术的原理。
mybatis日志管理实现原理详解
白话机器学习
07-04 868
else不好，7种条件判断太多了，并非优雅的编程。定义了LogException异常，该异常是日志功能的专属异常，如果你有看过mybatis其他源码的话，不难发现，其他功能也定义专属异常，比如：DataSourceException等，这是mybatis的惯用手法，主要是为了将异常细粒度的划分，以便更快定位问题。看到这里，聪明的你可能会有这样的疑问，从上图可以看出mybatis定义了8种useXXXLogging方法，但是在前面的static静态代码块中却只调用了6种，这是为什么？我们用一张图来总结一下。
spring-boot-starter-mybatis-spring-boot-2.1.2.zip
04-19
`spring-boot-starter-mybatis`是Spring Boot为MyBatis提供的一站式解决方案，它包含MyBatis核心库、MyBatis-Spring以及相关的依赖，使得开发者无需手动管理这些依赖，只需简单配置即可实现MyBatis的集成。...
spring-boot-starter-mybatis-spring-boot-2.2.0.zip
04-19
首先，`spring-boot-starter-mybatis`是Spring Boot官方提供的一个starter模块，它的主要作用是简化MyBatis在Spring Boot项目中的配置和使用。它包含了MyBatis的核心库、SqlSessionFactoryBuilder、...
spring-boot-starter-mybatis-spring-boot-1.2.1.tar.gz
04-19
在这个版本中，集成MyBatis主要依赖于`spring-boot-starter-jdbc`和`mybatis-spring-boot-starter`两个模块，它们使得MyBatis的配置变得更加简洁。 3. **MyBatis集成步骤** - 添加依赖：在`pom.xml`或`build....
spring-mybatis-spring-1.0.0-RC3.zip
04-19
3. 日志配置：为了便于调试，建议开启MyBatis的日志，查看SQL执行情况。 总之，“spring-mybatis-spring-1.0.0-RC3.zip”是一个实用的学习和开发资源，它涵盖了Spring与MyBatis整合的全过程，为开发者提供了快速...
spring+springmvc+mybatis(简单登录)+aop日志管理（学习参考）
08-23
spring+springmvc+mybatis(简单登录)+aop日志管理（学习参考）
Mybatis - 善用日志，会方便很多
key_768的博客
04-25 399
前言 前面将Mybatis的核心配置文件的标签了解了一遍 工欲善其事必先利其器 其实，很多时候都被找BUG折磨着，学会使用日志，是一个很好的习惯 Setting 日志 在Mybatis中，设置好了日志选项，就在settings标签中 一共提供了SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | ...
Java日志处理框架与Mybatis 的日志管理
qq_58258855的博客
04-21 882
一、Java日志处理框架 1. 常用的日志处理框架 对于一个应用程序来说日志记录是必不可少的一部分。线上问题追踪，错误排查，基于 日志的业务逻辑统计分析等都离不日志。 日志的管理是系统很重要的一部分，千万不可忽略其重要性。完整的日志将会在系统维 护中起着异常重要的作用。 在 Java 领域存在多种日志框架， 目前常用的日志框架包括 Log4j ， Log4j2 ，Commons Logging，Slf4j，Logback，Jul。 2. Log4j 简介 Log4j ：Log For Java(
MyBatis超详细介绍——日志
SmoMark的博客
07-20 1733
MyBatis日志 （本文作为学习笔记，了解更多请参考：MyBatis参考文档） 简单介绍 MyBatis内置了日志工厂，将日志交给以下其中一种工具作代理： SLF4J Apache Commons Logging Log4j 2 Log4j JDK logging MyBatis运行时会按照以上列举的顺序查找，然后使用第一个查找到的工具，若未找到，则日志功能将会被禁用。 T...
Mybatis日志 与 log4j的使用
weixin_64260010的博客
05-14 1322
Mybatis的日志功能是一个很重要的功能，开启日志可以在控制台打印sql语句从而检查错误提示：以下是本篇文章正文内容，下面案例可供参考Log4j ( Logger For Java ) , Java 日志的记录包。log4j中文文档。Log4j是Apache的一个开源项目通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；
mybatis日志输出控制
来一杯Java的博客
06-01 852
mybatis日志输出控制，通过配置文件控制sql语句，参数，sql查询结果输出方式
Mybatis源码分析二-如何优雅的使用主体日志
b379685397的博客
09-13 389
日志模块是mybatis中很重要的一个模块，在我们查询问题和分析sql的时候，经常会将mybatis打印sql的功能打开，但是mybatis并没有给我们提供打印日志的能力，那它是如何使用我们系统支持的日志模块进行日志打印的呢？今天我们来一探究竟。 一、日志模块需求分析 如果我们作为产品经理或者架构师，提供给开发者一个jar包 1. MyBatis 没有提供日志的实现类，需要接入第三方的日志组件，但第三方日志组件都有 各自的 Log 级别，且各不相同，而 MyBatis 统一提供了 trace、debu
日志配置【mybaits】
liudachu的博客
06-20 871
是什么slf4j 并不是一种具体的日志系统，而是为各种日志 APIs 提供一个简单统一的接口，从而使得用户能够在部署的时候配置自己所想使用的日志API。即在开发中统一按照slf4j的API进行开发，在部署时选择不同的日志系统包即可自动转换到不同的日志系统上。由上图可以这样理解：slf4j只是一个外壳，内部的具体实现都是使用的具体的日志API.比如：开发中使用的是JDK自带的日志系统，则只需slf4j-api和两个jar包；如果不想使用JDK自带的日志系统想换成Log4j，即可将换成。
深入理解MyBatis注解开发-SSM框架学习实践
这些包括junit-4.7用于单元测试，log4j-1.2.16用于日志记录，mybatis-3.2.2-sources与mybatis-3.3.0为MyBatis框架的核心包，以及mysql-connector-java-5.1.0-bin和mysql-connector-java-8.0.26为与MySQL数据库交互的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值