log4jdbc实现慢查询sql记录

最新推荐文章于 2022-08-23 16:33:20 发布
置顶 最新推荐文章于 2022-08-23 16:33:20 发布
阅读量6.3k 收藏 4
点赞数 2
分类专栏： 日志 文章标签： log4jdbc 慢查询 sql优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ycpanda/article/details/46519941
版权
首先，明确一个概念，这个也是之前一直没怎么搞清楚的：
    log4jdbc一共有三个分支，log4jdbc是原版，最近终于加入Maven的主仓库中，fork之一是log4jdbc-remix，后来又再fork了一个 log4jdbc-log4j2 。

        github地址 ： https://github.com/arthurblake/log4jdbc
log4jdbc-remix地址 ： http://code.google.com/p/log4jdbc-remix/
log4jdbc-log4j2地址 ： https://code.google.com/p/log4jdbc-log4j2/

这次使用的是：
<dependency>
     <groupId>org.lazyluke </groupId>
     <artifactId>log4jdbc-remix </artifactId>
     <version>0.2.7 </version>
</dependency>
入门使用方法可以参考本人之前的一篇文章： http://blog.csdn.net/ycpanda/article/details/39769737

一、场景需求
目的：针对经分系统进行sql调优，一般的来说，都是非实时性系统。

通常在dev时，log4jdbc是Info level级，为了方便打印sql调试。发布到线上时，就会关闭sql打印，因为太多sql的信息了，意义不大。
然而，系统运行时，有几个功能点会加载速度比较慢，如何去优化系统性能，找到慢查询sql呢？本来想用 druid去实现的，但是好几个老系统难得去修改。然后想到，Log4jdbc-remix不是可以打印每条sql的执行时间么，如果我去反编译覆盖重写类，然后加入时间判断条件，不久OK了么？真为自己机智了一把。
INFO  jdbc.sqltiming -  SELECT xx  FROM  table R  
 {executed  in  31 msec}

二、动手修改
1、首先，找到了  Slf4jSpyLogDelegator 类，因为这个类有 
private final Logger jdbcLogger = LoggerFactory.getLogger("jdbc.audit");
private final Logger resultSetLogger = LoggerFactory.getLogger("jdbc.resultset");
private final Logger resultSetTableLogger = LoggerFactory.getLogger("jdbc.resultsettable");
private final Logger sqlOnlyLogger = LoggerFactory.getLogger("jdbc.sqlonly");
private final Logger sqlTimingLogger = LoggerFactory.getLogger("jdbc.sqltiming");
private final Logger connectionLogger = LoggerFactory.getLogger("jdbc.connection");
private final Logger debugLogger = LoggerFactory.getLogger("log4jdbc.debug");
private static String nl = System.getProperty("line.separator");

看到  jdbc.sqltiming ，就知道找到和尚庙了。然后向下翻阅，在333行处： 
public void sqlTimingOccured(Spy spy, long execTime, String methodCall, String sql)
  {
    if ((this.sqlTimingLogger.isErrorEnabled()) && ((!DriverSpy.DumpSqlFilteringOn) || (shouldSqlBeLogged(sql))))
    {
      if ((DriverSpy.SqlTimingErrorThresholdEnabled) && (execTime >= DriverSpy.SqlTimingErrorThresholdMsec))
      {
        this.sqlTimingLogger.error(buildSqlTimingDump(spy, execTime, methodCall, sql, true));
      }
      else if (this.sqlTimingLogger.isWarnEnabled())
      {
        if ((DriverSpy.SqlTimingWarnThresholdEnabled) && (execTime >= DriverSpy.SqlTimingWarnThresholdMsec))
        {
          this.sqlTimingLogger.warn(buildSqlTimingDump(spy, execTime, methodCall, sql, true));
        }
        else if (this.sqlTimingLogger.isDebugEnabled())
        {
          this.sqlTimingLogger.debug(buildSqlTimingDump(spy, execTime, methodCall, sql, true));
        }
        else if (this.sqlTimingLogger.isInfoEnabled())
        {
          this.sqlTimingLogger.info(buildSqlTimingDump(spy, execTime, methodCall, sql, false));
        }
      }
    }
  }



有 execTime和 sql ，感觉这事要成了。正准备修改，我靠，怎么会有   execTime >= DriverSpy.SqlTimingWarnThresholdMsec   这种阈值判断？难道已经实现啦？没我用武之地？

2、转战到 DriverSpy  类 ， 心里甚是挖凉---> 
private Driver lastUnderlyingDriverRequested;
private static Map rdbmsSpecifics;
static final SpyLogDelegator log = SpyLogFactory.getSpyLogDelegator();
static String DebugStackPrefix;
static boolean TraceFromApplication;
static boolean SqlTimingWarnThresholdEnabled;
static long SqlTimingWarnThresholdMsec;
static boolean SqlTimingErrorThresholdEnabled;
static long SqlTimingErrorThresholdMsec;
static boolean DumpBooleanAsTrueFalse;
static int DumpSqlMaxLineLength;
static boolean StatementUsageWarn;
static boolean DumpSqlSelect;
static boolean DumpSqlInsert;
static boolean DumpSqlUpdate;
static boolean DumpSqlDelete;
static boolean DumpSqlCreate;
static boolean DumpSqlFilteringOn;
static boolean DumpSqlAddSemicolon;
static boolean DumpFullDebugStackTrace;
static boolean AutoLoadPopularDrivers;
static boolean TrimSql;
static boolean SuppressGetGeneratedKeysException;
static RdbmsSpecifics defaultRdbmsSpecifics = new RdbmsSpecifics();

这参数配置咋这多啊，哪里来的？ 然后向下找到356行，发现有个静态块，然后 
log.debug("... log4jdbc initializing ...");
InputStream propStream = DriverSpy.class.getResourceAsStream("/log4jdbc.properties");
Properties props = new Properties(System.getProperties());
//...下面省略了...


不多说了，已哭死。部分逻辑如下： 
//......
DebugStackPrefix = getStringOption(props, "log4jdbc.debug.stack.prefix");
TraceFromApplication = DebugStackPrefix != null;

Long thresh = getLongOption(props, "log4jdbc.sqltiming.warn.threshold");
SqlTimingWarnThresholdEnabled = thresh != null;
if (SqlTimingWarnThresholdEnabled)
{
  SqlTimingWarnThresholdMsec = thresh.longValue();
}

thresh = getLongOption(props, "log4jdbc.sqltiming.error.threshold");
SqlTimingErrorThresholdEnabled = thresh != null;
if (SqlTimingErrorThresholdEnabled)
{
  SqlTimingErrorThresholdMsec = thresh.longValue();
}

DumpBooleanAsTrueFalse = getBooleanOption(props, "log4jdbc.dump.booleanastruefalse", false);

DumpSqlMaxLineLength = getLongOption(props, "log4jdbc.dump.sql.maxlinelength", 90L).intValue();

DumpFullDebugStackTrace = getBooleanOption(props, "log4jdbc.dump.fulldebugstacktrace", false);

StatementUsageWarn = getBooleanOption(props, "log4jdbc.statement.warn", false);

DumpSqlSelect = getBooleanOption(props, "log4jdbc.dump.sql.select", true);
DumpSqlInsert = getBooleanOption(props, "log4jdbc.dump.sql.insert", true);
DumpSqlUpdate = getBooleanOption(props, "log4jdbc.dump.sql.update", true);
DumpSqlDelete = getBooleanOption(props, "log4jdbc.dump.sql.delete", true);
DumpSqlCreate = getBooleanOption(props, "log4jdbc.dump.sql.create", true);

DumpSqlFilteringOn = (!DumpSqlSelect) || (!DumpSqlInsert) || (!DumpSqlUpdate) || (!DumpSqlDelete) || (!DumpSqlCreate);

//......




折腾了半天，发现回到了原点。-_-|||
其实在
页面上都有options的说明，(为了避免大家一起爬墙，贴出来如下)：
log4jdbc-log4j2  options
property default description
log4jdbc.drivers

One or more fully qualified class names for JDBC drivers that log4jdbc should load and wrap.
 If more than one driver needs to be specified here, they should be comma separated with no spaces.
This option is not normally needed because most popular JDBC drivers are already loaded by default--
this should be used if one or more additional JDBC drivers that (log4jdbc doesn't already wrap) needs
to be included.
log4jdbc.auto.load.popular.drivers true Set this to false to disable the feature where popular drivers are automatically loaded. If this is false,
you must set the log4jdbc.drivers property in order to load the driver(s) you want.
log4jdbc.debug.stack.prefix

A REGEX matching the package name of your application.
The call stack will be searched down to the first occurrence of a class that has the matching REGEX.
If this is not set, the actual class that called into log4jdbc is used in the debug output
(in many cases this will be a connection pool class.) For example, setting a system property such as
this: -Dlog4jdbc.debug.stack.prefix=^com\.mycompany\.myapp.*would cause the
call stack to be searched for the first call that came from code in the com.mycompany.myapp package
or below, thus if all of your sql generating code was in code located in the com.mycompany.myapp
package or any subpackages, this would be printed in the debug information,
rather than the package name for a connection pool, object relational system, etc. 

Please note that the behavior of this property has changed as compared to the
standard log4jdbc implementation. This property is now a REGEX, instead of being just the package
prefix of the stack trace. So, for instance, if you want to target the prefix org.mypackage, the value of this
property should be: ^org\.mypackage.*.
log4jdbc.sqltiming.warn.threshold

Millisecond time value. Causes SQL that takes the number of milliseconds specified or more time to
execute to be logged at the warning level in the sqltiming log.
Note that the sqltiming log must be enabled at the warn log level for this feature to work.
Also the logged output for this setting will log with debug information that is normally only shown
when the sqltiming log is enabled at the debug level. This can help you to more quickly find
slower running SQL without adding overhead or logging for normal running SQL that
executes below the threshold level (if the logging level is set appropriately.)
log4jdbc.sqltiming.error.threshold

Millisecond time value. Causes SQL that takes the number of milliseconds specified or more time to
execute to be logged at the error level in the sqltiming log.
Note that the sqltiming log must be enabled at the error log level for this feature to work.
Also the logged output for this setting will log with debug information that is normally only shown
when the sqltiming log is enabled at the debug level.
This can help you to more quickly find slower running SQL without adding overhead or
logging for normal running SQL that executes below the threshold level
(if the logging level is set appropriately.)
log4jdbc.dump.booleanastruefalse false When dumping boolean values in SQL, dump them as 'true' or 'false'.
If this option is not set, they will be dumped as 1 or 0 as many databases
do not have a boolean type, and this allows for more portable sql dumping.
log4jdbc.dump.sql.maxlinelength 90 When dumping SQL, if this is greater than 0, than the dumped SQL will be broken up into lines that
are no longer than this value. Set this value to 0 if you don't want log4jdbc to try and break the SQL
into lines this way. In future versions of log4jdbc, this will probably default to 0.
log4jdbc.dump.fulldebugstacktrace false If dumping in debug mode, dump the full stack trace. This will result in EXTREMELY voluminous output,
but can be very useful under some circumstances when trying to track down the call chain for
generated SQL.
log4jdbc.dump.sql.select true Set this to false to suppress SQL select statements in the output.
Note that if you use the Log4j 2 logger, it is also possible to control select statements output via
the marker LOG4JDBC_SELECT (see section "Disabling some SQL operations,
or dispatching them in different files" above). The use of this property prepend the use of the marker.
log4jdbc.dump.sql.insert true Set this to false to suppress SQL insert statements in the output.
Note that if you use the Log4j 2 logger, it is also possible to control insert statements output via
the marker LOG4JDBC_INSERT (see section "Disabling some SQL operations,
or dispatching them in different files" above). The use of this property prepend the use of the marker.
log4jdbc.dump.sql.update true Set this to false to suppress SQL update statements in the output.
Note that if you use the Log4j 2 logger, it is also possible to control update statements output via
the marker LOG4JDBC_UPDATE (see section "Disabling some SQL operations,
or dispatching them in different files" above). The use of this property prepend the use of the marker.
log4jdbc.dump.sql.delete true Set this to false to suppress SQL delete statements in the output.
Note that if you use the Log4j 2 logger, it is also possible to control delete statements output
via the marker LOG4JDBC_DELETE (see section "Disabling some SQL operations,
or dispatching them in different files" above). The use of this property prepend the use of the marker.
log4jdbc.dump.sql.create true Set this to false to suppress SQL create statements in the output.
Note that if you use the Log4j 2 logger, it is also possible to control create statements output via
the marker LOG4JDBC_CREATE (see section "Disabling some SQL operations,
or dispatching them in different files" above). The use of this property prepend the use of the marker.
log4jdbc.dump.sql.addsemicolon false Set this to true to add an extra semicolon to the end of SQL in the output.
This can be useful when you want to generate SQL from a program with log4jdbc
in order to create a script to feed back into a database to run at a later time.
log4jdbc.spylogdelegator.name net.sf.log4jdbc.log.log4j2.Log4j2SpyLogDelegator The qualified class name of the SpyLogDelegator to use.
Note that if you want to use log4jdbc-log4j2 with SLF4J rather than Log4j 2,
you must set this property to: net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator.
This is a new property, not present in the standard log4jdbc implementation.
log4jdbc.statement.warn false Set this to true to display warnings (Why would you care?) in the log when
Statements are used in the log. NOTE, this was always true
in releases previous to 1.2alpha2. It is false by default starting with release 1.2 alpha 2.
log4jdbc.trim.sql true Set this to false to not trim the logged SQL. (Previous versions always trimmed the SQL.)
log4jdbc.trim.sql.extrablanklines true Set this to false to not trim extra blank lines in the logged SQL (
by default, when more than one blank line in a row occurs, the contiguou lines are collapsed
to just one blank line.) (Previous versions didn't trim extra blank lines at all.)
log4jdbc.suppress.generated.keys.exception false Set to true to ignore any exception produced by the method, Statement.getGeneratedKeys()
(Useful for using log4jdbc with Coldfusion

Of note, an additional property allows to set the name of the property file:

property default description
log4jdbc.log4j2.properties.file log4jdbc.log4j2.properties Set the name of the property file to use 


log4jdbc
property default description since
log4jdbc.drivers

One or more fully qualified class names for JDBC drivers that log4jdbc should load and wrap.
If more than one driver needs to be specified here, they should be comma separated with no spaces.
This option is not normally needed because most popular JDBC drivers are already loaded by default--
this should be used if one or more additional JDBC drivers that (log4jdbc doesn't already wrap)
needs to be included.		 1.0
log4jdbc.auto.load.popular.drivers true Set this to false to disable the feature where popular drivers are automatically loaded.
If this is false, you must set the log4jdbc.drivers property in order to load the driver(s) you want.		 1.2beta2
log4jdbc.debug.stack.prefix

The partial (or full) package prefix for the package name of your application.
The call stack will be searched down to the first occurrence of a class that has the matching prefix.
If this is not set, the actual class that called into log4jdbc is used in the debug output
(in many cases this will be a connection pool class.) For example, setting a system property
such as this: -Dlog4jdbc.debug.stack.prefix=com.mycompany.myapp Would cause
the call stack to be searched for the first call that came from code
in the com.mycompany.myapp package or below, thus if all of your sql generating code
was in code located in the com.mycompany.myapp package or any subpackages,
this would be printed in the debug information, rather than the package name for a connection pool,
object relational system, etc.		 1.0
log4jdbc.sqltiming.warn.threshold

Millisecond time value. Causes SQL that takes the number of milliseconds specified or more time
to execute to be logged at the warning level in the sqltiming log.
Note that the sqltiming log must be enabled at the warn log level for this feature to work.
 Also the logged output for this setting will log with debug information that is normally only shown
when the sqltiming log is enabled at the debug level.
This can help you to more quickly find slower running SQL without adding overhead or logging
for normal running SQL that executes below the threshold level (if the logging level is set appropriately.)		 1.1beta1
log4jdbc.sqltiming.error.threshold

Millisecond time value. Causes SQL that takes the number of milliseconds specified or more time
to execute to be logged at the error level in the sqltiming log.
Note that the sqltiming log must be enabled at the error log level for this feature to work.
Also the logged output for this setting will log with debug information that is normally only shown
when the sqltiming log is enabled at the debug level.
This can help you to more quickly find slower running SQL without adding overhead or logging
for normal running SQL that executes below the threshold level (if the logging level is set appropriately.)		 1.1beta1
log4jdbc.dump.booleanastruefalse false When dumping boolean values in SQL, dump them as 'true' or 'false'.
If this option is not set, they will be dumped as 1 or 0 as many databases do not have a boolean type,
and this allows for more portable sql dumping.		 1.2alpha1
log4jdbc.dump.sql.maxlinelength 90 When dumping SQL, if this is greater than 0, than the dumped SQL will be broken up into lines
that are no longer than this value. Set this value to 0 if you don't want log4jdbc to try
and break the SQL into lines this way. In future versions of log4jdbc, this will probably default to 0.		 1.2alpha1
log4jdbc.dump.fulldebugstacktrace false If dumping in debug mode, dump the full stack trace.
This will result in EXTREMELY voluminous output, but can be very useful under some circumstances
when trying to track down the call chain for generated SQL.		 1.2alpha1
log4jdbc.dump.sql.select true Set this to false to suppress SQL select statements in the output. 1.2alpha1
log4jdbc.dump.sql.insert true Set this to false to suppress SQL insert statements in the output. 1.2alpha1
log4jdbc.dump.sql.update true Set this to false to suppress SQL update statements in the output. 1.2alpha1
log4jdbc.dump.sql.delete true Set this to false to suppress SQL delete statements in the output. 1.2alpha1
log4jdbc.dump.sql.create true Set this to false to suppress SQL create statements in the output. 1.2alpha1
log4jdbc.dump.sql.addsemicolon false Set this to true to add an extra semicolon to the end of SQL in the output.
This can be useful when you want to generate SQL from a program with log4jdbc in order to
create a script to feed back into a database to run at a later time.		 1.2alpha1
log4jdbc.statement.warn false Set this to true to display warnings (Why would you care?) in the log when Statements are used
in the log. NOTE, this was always true in releases previous to 1.2alpha2. It is false by default
starting with release 1.2 alpha 2.		 1.2alpha2
log4jdbc.trim.sql true Set this to false to not trim the logged SQL. (Previous versions always trimmed the SQL.) 1.2beta2
log4jdbc.trim.sql.extrablanklines true Set this to false to not trim extra blank lines in the logged SQL
(by default, when more than one blank line in a row occurs, the contiguous lines are collapsed to
just one blank line.) (Previous versions didn't trim extra blank lines at all.)		 1.2
log4jdbc.suppress.generated.keys.exception false Set to true to ignore any exception produced by the method, Statement.getGeneratedKeys() 
(Useful for using log4jdbc with Coldfusion.)		 1.2beta2

so,一切都柳暗花明了。

三、如何在工程中实现
1、对于maven工程，在src/main/resources下新增一个配置文件：  log4jdbc.properties
内容如下：
#只显示含调用栈的包名的语句
#log4jdbc.debug.stack.prefix=
#这2个是在一起的,和数据库驱动有关。实际作用本人未尝试
#log4jdbc.auto.load.popular.drivers=true
#log4jdbc.drivers=
#执行时间阀值，单位为ms，将Log级别调为Warning，则只会打印执行较慢的语句
log4jdbc.sqltiming.warn.threshold= 2000
#log4jdbc.sqltiming.error.threshold=
#是把boolean记录为 'true'/'false' 还是 1/0. 默认设置为false,不启用,为了移植性.
#log4jdbc.dump.booleanastruefalse=
#输出的sql,一行最大的字符数，默认90. 以后新版可能为0
#log4jdbc.dump.sql.maxlinelength=90
#If dumping in debug mode, dump the full stack trace. 默认false
#log4jdbc.dump.fulldebugstacktrace=false
#是否记录某些类型的语句，默认true
#log4jdbc.dump.sql.select=true
#log4jdbc.dump.sql.insert=true
#log4jdbc.dump.sql.update=true
#log4jdbc.dump.sql.delete=true
#log4jdbc.dump.sql.create=true
#输出sql末尾处加入分号，默认false
#log4jdbc.dump.sql.addsemicolon=
#默认true，
#log4jdbc.trim.sql=true
#display warnings in the log when Statements are used in the log. 默认false,不是太理解
#log4jdbc.statement.warn=false
#gnore any exception produced by the method, Statement.getGeneratedKeys() .默认false
#log4jdbc.suppress.generated.keys.exception=false
在上面，只设置了warn阈值，其它默认。

2、修改日志文件配置：(本处使用的是logback)
<!-- 指定logger的设置，additivity指示是否遵循缺省的继承机制-->
<logger  name= 'jdbc.sqltiming' additivity= 'true' level= "warn" />
<logger  name= 'jdbc.audit' additivity= 'false' />
<logger  name= 'jdbc.resultset' additivity= 'false' />
<logger  name= 'jdbc.connection' additivity= 'false' />
<logger  name= 'jdbc.resultsettable' additivity= 'false' />
<logger  name= "jdbc.sqlonly" additivity= "false" />

然后，会发现工程console中，sql打印少了很多很多。
但是这种固定配置，在dev时开发时，会不方便调试，所以我们要用maven profile，进行自动打包配置。实现在dev时，level='info'，产品环境时，level='warn'。

打包请参考：
ycpanda
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
使用log4jdbc更有效的记录java sql日志.docx
12-10
使用log4jdbc更有效的记录java sql日志
springmvc+mybatis+mysql+log4jdbc+excel 实现sql日志输出和excel导出
05-09
项目使用日志框架实现sql日志完整输出，并使用springmvc和jxls分别实现excel导出
springboot log4jdbc 打印完整sql
03-04
打印完整带参数sql，不用自己去替换问号，后端省时省力。
log4jdbc3-1.2.1.jar
10-15
log4jdbc可以将数据源执行的sql将占位符?替换成字符,并以日志打印出来. log4j配置: log4j.logger.jdbc.sqltiming=INFO 详情请看: http://code.google.com/p/rapid-framework/wiki/log4jdbc 如oracle示例: 原来的sql: select * from user where birth_date = ? and username = ? and age > ? 转换后sql: select * from user where birth_date = to_date('2010-08-13','yyyy-mm-dd') and username = 'badqiu' and age > 20
SQL语句，数据库配置，JDBC使用
越看越喜欢啊
07-24 970
SQL语句入门，MySQL入门，数据库配置，SQLyog使用，JDBC入门，如何学习数据库，如何进行数据库配置，如何进行数据库远程访问
log4jdbc监控sql及执行时间
09-02
1、在应用中jdbc url最前面添加jdbc:log4；比如oracle的url就变成了jdbc:log4jdbc:oracle:thin:@x.x.x.x:1521:dbname； 2、在日志系统中设置jdbc.sqlonly、jdbc.sqltiming等日志级别，可直接将log4jdbc doc中的日志内容copy过去； 3、运行系统测试，到对应日志文件中查看SQL相关信息； zip文件里已经包括所有依赖包，除了数据库驱动。 祝大家顺利。
sqlonly,sqltiming,audit,resultset,connection
luolingling517的博客
06-01 3097
log4jdbc 用以下几个可以配置的日志种类： jdbc.sqlonly : 仅记录 SQL jdbc.sqltiming ：记录 SQL 以及耗时信息 jdbc.audit ：记录除了 ResultSet 之外的所有 JDBC 调用信息，会产生大量的记录，有利于调试跟踪具体的 JDBC 问题 jdbc.resultset ：会产生更多的记录信息，因为记录了 ResultSet 的信息 jdbc
log4jdbc记录完整的SQL信息
天行健，君子以自强不息；地势坤，君子以厚德载物。
04-27 515
阅读文本大概需要3分钟。0x01：log4jdbc的简单介绍　　使用log4jdbc在不改变原有代码的情况下，就可以日志文件中输出的SQL语句和JDBC执行耗时情况。 平时开发...
log4jdbc使用介绍
u013409283的博客
01-31 1万+
0 前言 使用java进行数据库操作时最痛苦的莫过于拼接SQL语句。在实际运行时往往需要查看实际生成的SQL语句和实际传入的参数，或许还会有查看SQL执行时间等的需求。   无论原生JDBC、dbutils、mybatis还是hibernate，使用log4j等日志框架可以看到生成的SQL，但是占位符和参数总是分开打印的。实在是不太友好。显示如下的效果: select * from
Spring+SpringMVC+MyBatis+easyUI整合优化篇（十一）数据层优化-druid监控及慢sql记录
Elinor2017的博客
04-19 434
本文提要 前文也提到过druid不仅仅是一个连接池技术，因此在将整合druid到项目中后，这一篇文章将去介绍druid的其他特性和功能，作为一个辅助工具帮助提升项目的性能，本文的重点就是两个字：监控。 我的github地址点这里 druid监控 因为已经做了整合，所以这一步较为简单，只需要在web.xml中做一下简单的Servlet配置即可。 <!--druid监控页面 --&gt...
工程项目中打印SQL的执行时间的两种方式
weishuai528的博客
03-28 2882
1.使用log4jdbc打印SQL执行时间 本人项目使用的是apollo配置文件的： 1.导入需要的maven包 <!--监控sql日志--> <dependency> <groupId>org.bgee.log4jdbc-log4j2</groupId> <artifactId&...
无效的列类型-----Spring boot+mybatis项目报错解决方案
wylink
09-01 544
ERROR [http-nio-8090-exec-8] 【jdbc.sqltiming】 1. PreparedStatement.setNull(4, 1111) java.sql.SQLException: 无效的列类型: 1111 at oracle.jdbc.driver.OracleStatement.getInternalType(OracleStatement.java:4369) at oracle.jdbc.driver.OraclePreparedStatement.setNullCr
idea打印sql的插件_mybatis打印带参数sql几种实现方式及优缺点
weixin_39520199的博客
11-28 996
@TOC 1. log4jdbclog4jdbc是google开源的用于专们打印sql日志的工具jar包，使用方法很简单。第一步：引入maven包，如下：<第二步：更改jdbc的驱动名称和连接名称，主要是标红部分：（jdbc.properties）driverClassName第三步：在logback.xml中加入如下配置，各参数说明如下：<!-- 监控sql日志输出 logger ...
Spring / Hibernate使用log4jdbc改进了SQL日志记录
最佳 Java 编程
05-22 222
Hibernate提供了开箱即用的SQL日志记录，但是这种日志记录仅显示准备好的语句，而不显示发送到数据库的实际SQL查询。 它还不会记录每个查询的执行时间，这对于性能故障排除很有用。 这篇博客文章将介绍如何设置Hibernate查询日志记录，然后将其与可以通过log4jdbc获得的日志记录进行比较。 Hibernate查询日志记录功能 Hibernate不会记录发送到数据库的实际S...
使用Log4jdbc记录JDBC操作
最佳 Java 编程
05-09 458
当我们开发任何应用程序，完成它或结束其任何模块时，我们都会开始优化过程。 大多数应用程序都包含数据库访问权限，并且如果您使用的是ORM ，则可能会使用hibernate 。 优化休眠持久层，要求准备阅读，理解和评估sql 。 如果我们对休眠配置进行概述，则应启用两个属性hibernate.format_sql和hibernate.use_sql_comments，以通过控制台打印执行的sq...
mybatis结合log4j打印SQL日志
热门推荐
无界编程
01-22 5万+
mybatis结合log4j打印SQL日志 默认的mybatis不能打印出SQL日志，不便于查看调试，需要结合log4jdbc-log4j2就可以完整的输入SQL的调试信息。pom.xml 配置maven，注意以下3个都需要 org.bgee.log4jdbc-log4j2 log4jdbc-log4j2-jdbc4.1
springboot日志，log4j加mybatis配置显示sql
焱敦的博客
08-23 1249
log4j加mybatis配置显示sql信息
springboot配置日志打印sql语句
weixin_43991475的博客
04-22 9466
方法一： 在application.properties文件增加以下配置，实现打印sql语句，推荐方法二 #是否显示sql spring.jpa.show-sql=true #是否格式化sql脚本 spring.jpa.properties.hibernate.format_sql=true #是否在 SQL 语句中输出便于调试的注释信息 spring.jpa.properties.hibernate.use_sql_comments=true #打印sql脚本的参数变量的值 logging.leve
log4jdbc日志输出完整SQL语句
小葫芦的博客
01-25 2045
1.在maven引入: &lt;dependency&gt;                                       &lt;groupId&gt;log4j&lt;/groupId&gt;                       &lt;artifactId&gt;log4j&lt;/artifactId&gt;                 &lt;version...
log4jdbc-log4j2
最新发布
07-28
log4jdbc-log4j2是一个用于在Java应用程序中记录JDBC日志的工具。它可以通过配置文件来指定使用SLF4J作为日志记录器，并且可以通过添加相关的依赖项来集成到项目中。在配置文件中，可以设置log4jdbc.spylogdelegator...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值