Log4j单独设置Mybatis sql语句日志级别

log4j自定义日志等级

log4j自定义日志等级log4j自定义日志等级，步骤如下1.继承logj的level类，定义一个自己的日志级别：public class TestLevel extends Level { public TestLevel(int level, String levelStr, int syslogEquivalent) {super(level, levelStr, syslogEquivalent);}}2.继承Filter类，定义一个自己的filter：public class MyLogFiter extends Filter {/*** Do we return ACCEPT when a match occurs. Default is* <code>false</code>, so that later filters get run by default */boolean acceptOnMatch = false;int levelMin;int levelMax;/*** Return the decision of this filter.*/@Overridepublic int decide(LoggingEvent event) {int inputLevel = event.getLevel().toInt();if (inputLevel >= levelMin && inputLevel <= levelMax) {return Filter.ACCEPT;}return Filter.DENY;}/*** Get the value of the <code>LevelMax</code> option.*/public int getLevelMax() {return levelMax;}/*** Get the value of the <code>LevelMin</code> option.*/public int getLevelMin() {return levelMin;}/*** Get the value of the <code>AcceptOnMatch</code> option.*/public boolean getAcceptOnMatch() {return acceptOnMatch;}/*** Set the <code>LevelMax</code> option.*/public void setLevelMax(int levelMax) {this.levelMax = levelMax;}/*** Set the <code>LevelMin</code> option.*/public void setLevelMin(int levelMin) {this.levelMin = levelMin;}* Set the <code>AcceptOnMatch</code> option.*/public void setAcceptOnMatch(boolean acceptOnMatch) { this.acceptOnMatch = acceptOnMatch;}}3.在不侵入log4j源代码的情况下，对log4j的logger输出进行封装，并且添加自己定义的级别的输出方法：public class Logger {private final static int priority = 40100;private final org.apache.log4j.Logger logger;private static final String FQCN;//以下为自定义的日志级别public static final Level PAY_LEVEL = new TestLevel(priority, “TEST”, SyslogAppender.LOG_LOCAL0);static {FQCN = Logger.class.getName();}private Logger(Class<?> clazz) {logger = org.apache.log4j.Logger.getLogger(clazz);}private Logger() {logger = org.apache.log4j.Logger.getRootLogger();}public static Logger getLogger(Class<?> clazz) {return new Logger(clazz);}public static Logger getRootLogger() {return new Logger();public void test(Object message) {forcedLog(logger, PAY_LEVEL, message);}public void test(Object message, Throwable t) {forcedLog(logger, PAY_LEVEL, message, t);}private static void forcedLog(org.apache.log4j.Logger logger, Level level, Object message) {logger.callAppenders(new LoggingEvent(FQCN, logger, level, message, null));}private static void forcedLog(org.apache.log4j.Logger logger, Level level, Object message, Throwable t) {logger.callAppenders(new LoggingEvent(FQCN, logger, level, message, t));}}4.修改log4j的xml配置文件,添加自定义的appender：<appender name=”TEST”><param name=”File” value=”/var/Test.log”/><param name=”Append” value=”true”/><param name=”DatePattern” value=”‘.’yyyy-MM-dd-HH”/><param name=”BufferedIO” value=”true”/><!– 8K为一个写单元–> <param name=”BufferSize” value=”8192″/> <layout><param name=”ConversionPattern”value=”%d{yyyy-MM-dd HH:mm:ss}\t%F\t%L\t%M\t%m%n”/></layout><filter class=”MyLogFiter”><param name=”LevelMin” value=”40100″/><param name=”LevelMax” value=”40100″/></filter></appender>5.在需要输出日志的地方使用封装的logger输出方法即可：logger.test(“hahaha,test”);。

log4j2动态修改日志级别及拓展性使用

log4j2动态修改⽇志级别及拓展性使⽤⼀、供参考的完整⽇志配置<?xml version="1.0" encoding="UTF-8"?><Configuration status="WARN"><Properties><property name="basePath">${sys:vmparam}</property><property name="filePath">${basePath}/app.log</property></Properties><Appenders><Console name="Console" target="SYSTEM_OUT"><PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/></Console><RollingFile name="RollingFile" fileName="${filePath}"filePattern="logs/$${date:yyyy-MM}/app-%d{yyyy-MM-dd-HH}-%i.log.gz"><Policies><TimeBasedTriggeringPolicy interval="6" modulate="true"/><SizeBasedTriggeringPolicy size="250 MB"/></Policies><DefaultRolloverStrategy max="20"/><DefaultRolloverStrategy><Delete basePath="${filePath}" maxDepth="1"><IfFileName glob="logs_*.log"/><IfLastModified age="30d"/><IfAccumulatedFileSize exceeds="100 GB"/><IfAccumulatedFileCount exceeds="10"/></Delete></DefaultRolloverStrategy></RollingFile></Appenders><Loggers><AsyncLogger name="AsyncLogger" level="trace"><appender-ref ref="Console"/><appender-ref ref="RollingFile"/></AsyncLogger><asyncRoot level="trace"><appender-ref ref="Console"/></asyncRoot><Root level="info"><AppenderRef ref="RollingFile"/></Root><logger name="org.springframework" level="INFO" additivity="false"><appender-ref ref="Console"/></logger><logger name="ty" level="warn"/><logger name="org.apache.http" level="warn"/><logger name="org.mongodb.driver" level="INFO"/><logger name="ty" level="warn"/><logger name="org.springframework.data.redis" level="INFO"/></Loggers></Configuration>⼆、动态修改⽇志级别Collection<org.apache.logging.log4j.core.Logger> current = LoggerContext.getContext(false).getLoggers();Collection<org.apache.logging.log4j.core.Logger> notcurrent = LoggerContext.getContext().getLoggers();Collection<org.apache.logging.log4j.core.Logger> allConfig = current;allConfig.addAll(notcurrent);for (org.apache.logging.log4j.core.Logger log:allConfig){log.setLevel(Level.DEBUG);}　三、⾃定义appender 以上介绍，均依赖于log4j2提供的官⽅配置，当对⽇志的业务逻辑复杂时，光靠配置也许满⾜不了需要，此时我们会想⾃⼰能操控打印的⽇志，做⽇志的路由，或保存等操作，这个时候就需要有⾃定义的appender，可以配置的就靠配置完成，不能的就⾃⼰写代码⼲预，⽽log4j2刚好提供了这样的拓展性。

log4j配置详解（非常详细）

log4j配置详解（⾮常详细）Log4J的配置⽂件(Configuration File)就是⽤来设置记录器的级别、存放器和布局的，它可接key=value格式的设置或xml格式的设置信息。

通过配置，可以创建出Log4J的运⾏环境。

1. 配置⽂件Log4J配置⽂件的基本格式如下：2. 在代码中初始化Logger:1）在程序中调⽤BasicConfigurator.configure()⽅法：给根记录器增加⼀个ConsoleAppender，输出格式通过PatternLayout设为"%-4r [%t] %-5p %c %x - %m%n"，还有根记录器的默认级别是Level.DEBUG.2）配置放在⽂件⾥，通过命令⾏参数传递⽂件名字，通过PropertyConfigurator.configure(args[x])解析并配置；3）配置放在⽂件⾥，通过环境变量传递⽂件名等信息，利⽤log4j默认的初始化过程解析并配置；4）配置放在⽂件⾥，通过应⽤服务器配置传递⽂件名等信息，利⽤⼀个特殊的servlet来完成配置。

3. 为不同的 Appender 设置⽇志输出级别：当调试系统时，我们往往注意的只是异常级别的⽇志输出，但是通常所有级别的输出都是放在⼀个⽂件⾥的，如果⽇志输出的级别是BUG！？那就慢慢去找吧。

这时我们也许会想要是能把异常信息单独输出到⼀个⽂件⾥该多好啊。

当然可以，Log4j已经提供了这样的功能，我们只需要在配置中修改Appender的Threshold就能实现,⽐如下⾯的例⼦：运⾏⼀下，看看异常信息是不是保存在了⼀个单独的⽂件error.log中。

----------------------------------------------------------------------------------------------------------------------------------------------------资料：============================================================================================= =============================================================================================== log4j.properties⽂件例⼦1.================================================================这个⽂件就是本⽂的重点，也就是log4j的配置⽂件。

Java开发日志分析工具Log4j使用详解

Java开发日志分析工具Log4j使用详解Log4j是一个用于记录应用程序运行时日志的Java开发工具。

它可以帮助开发人员更好地理解和监控应用程序的运行状态，以及解决潜在的问题。

下面将详细介绍Log4j的使用方法和功能。

一、Log4j的配置文件Log4j使用一个名为log4j.properties的配置文件来定义日志的输出格式、日志级别、输出目标等。

这个配置文件需要放在应用程序的classpath下，以便Log4j能够找到它并加载配置。

配置文件中的每一个配置项都有一个特定的名称和对应的值。

例如，可以使用"log4j.rootLogger"配置项来设置根日志记录器的级别，使用"log4j.appender.console"配置项来设置控制台输出的格式等。

二、Log4j的日志级别Log4j提供了多个日志级别，用于控制日志的输出。

这些日志级别按照严重程度递增，包括TRACE、DEBUG、INFO、WARN、ERROR和FATAL。

可以通过配置文件中的"log4j.rootLogger"配置项来设置根日志记录器的级别，从而决定哪些级别的日志会被记录。

三、Log4j的输出目标Log4j可以将日志输出到不同的目标，包括控制台、文件、数据库等。

可以通过配置文件中的"log4j.appender"配置项来设置输出目标。

常用的输出目标有：1. ConsoleAppender：将日志输出到控制台。

2. FileAppender：将日志输出到文件。

3. RollingFileAppender：将日志输出到滚动文件，可以设置文件的大小和数量，以便自动滚动日志文件。

4. JDBCAppender：将日志输出到数据库。

四、Log4j的日志格式Log4j可以自定义日志的输出格式。

可以通过配置文件中的"log4j.appender"配置项来设置输出格式。

Mybatis的Log4j日志输出问题-以及有关日志的所有问题

Mybatis的Log4j⽇志输出问题-以及有关⽇志的所有问题使⽤Mybatis的时候，有些时候能输出（主要是指sql，参数，结果）⽇志。

有些时候就不能。

⽆法输出⽇志的时候，⽆论怎么配置log4j，不管是properties的还是xml的，都不起作⽤。

有些时候，我们没做什么配置就能输出⽇志....这是⼀个让⽆数⼈烦躁的问题。

其实解决问题很容易（我过了这么久才解决，以前都⽤拦截器输出）。

这是⼀个普⼤喜奔的⽇⼦，让我们⼀起来看看如何解决mybatis的⽇志问题。

为什么说这个问题很容易解决呢？因为mybatis的⽂档写的很清楚。

为什么我们都没找到解决办法呢？因为即使看过⽂档的⼈，也未必去看Logging这⼀节。

但是这⼀节正是解决问题的关键。

已经等不及的⼩伙伴们可以直接去这⾥看⽂档：提醒最常⽤的⽅法不再这个链接中，但是这个⽂档提供了对log4j的详细配置。

本⽂下⾯的内容⼤部分是这个⽂档的Copy。

Mybatis内置的⽇志⼯⼚提供⽇志功能，具体的⽇志实现有以下⼏种⽅式：SLF4JApache Commons LoggingLog4j 2Log4jJDK logging具体选择哪个⽇志实现由MyBatis的内置⽇志⼯⼚确定。

它会使⽤最先找到的（按上⽂列举的顺序查找）。

如果⼀个都未找到，⽇志功能就会被禁⽤。

不少应⽤服务器的classpath中已经包含Commons Logging，如Tomcat和WebShpere，所以MyBatis会把它作为具体的⽇志实现。

记住这点⾮常重要。

这意味着，在诸如 WebSphere的环境中——WebSphere提供了Commons Logging的私有实现，你的Log4J配置将被忽略。

这种做法不免让⼈悲摧，MyBatis怎么能忽略你的配置呢？事实上，因Commons Logging已经存在，按优先级Log4J⾃然就被忽略了！不过，如果你的应⽤部署在⼀个包含Commons Logging的环境，⽽你⼜想⽤其他的⽇志框架，你可以根据需要调⽤如下的某⼀⽅法：eSlf4jLogging();eLog4JLogging();eJdkLogging();eCommonsLogging();eStdOutLogging();如果的确需要调⽤以上的某个⽅法，请在调⽤所有其他MyBatis⽅法前调⽤它。

Mybatis日志配置文件

Mybatis⽇志配置⽂件log4j.properties#log4j⽇志级别如下：#A：off 最⾼等级，⽤于关闭所有⽇志记录。

#B：fatal 指出每个严重的错误事件将会导致应⽤程序的退出。

#C：error 指出虽然发⽣错误事件，但仍然不影响系统的继续运⾏。

#D：warn 表明会出现潜在的错误情形。

#E：info ⼀般和在粗粒度级别上，强调应⽤程序的运⾏全程。

#F：debug ⼀般⽤于细粒度级别上，对调试应⽤程序⾮常有帮助。

#G：all 最低等级，⽤于打开所有⽇志记录。

#但log4j只建议使⽤4个级别，优先级从⾼到低分别是:#error>warn>info>debuglog4j.rootLogger =debug,systemOut,logFile#输出到控制台log4j.appender.systemOut = org.apache.log4j.ConsoleAppenderyout = org.apache.log4j.PatternLayoutyout.ConversionPattern = [%-5p][%-22d{yyyy/MM/dd HH:mm:ssS}][%l]%n%m%nlog4j.appender.systemOut.Target = System.out#输出到⽂件log4j.appender.logFile = org.apache.log4j.FileAppenderyout = org.apache.log4j.PatternLayoutyout.ConversionPattern = [%-5p][%-22d{yyyy/MM/dd HH:mm:ssS}][%l]%n%m%nlog4j.appender.logFile.File = log/log4j.loglog4j.appender.logFile.Encoding = UTF-8#将⽇志输记录到MySQL数据库#log4j.appender.logDB = org.apache.log4j.jdbc.JDBCAppender#yout = org.apache.log4j.PatternLayout#log4j.appender.logDB.Driver = com.mysql.jdbc.Driver#log4j.appender.logDB.URL = jdbc:mysql://localhost:3306/log4j?characterEncoding=utf-8#er = root#log4j.appender.logDB.Password = root#log4j.appender.logDB.Sql = INSERT INTO t_log4j(project_name,create_date,level,category,file_name,thread_name,line,all_category,message)values('mybatis','%d{yyyy-MM-ddHH:mm:ss}','%p','%c','%F','%t','%L','%l','%m')⽇志⽂件输出⽅式有三种：输出到控制台，输出到⽂件，输出到数据库。

log4j配置详解

在配置文件中这样配置的：
“
yout =className yout.Option1 = value1 … yout.OptionN = valueN
Appender
Appender用来规定日志输出的目的地是哪里，可以是控制台，文件，数据库等等。常见的Appender有以下几种：
org.apache.log4j.ConsoleAppender（控制台） org.apache.log4j.FileAppender（文件） org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件） org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件） org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
配置Logger
“
log4j.rootLogger = [ level ] , appenderName1, appenderName2, … .apache=false # 表示示Logger不会在父父Logger的appender里里输出，默认为true。
配置Layout
“
yout=className
常见的className如下：
org.apache.log4j.HTMLLayout（以HTML表格形式布局） org.apache.log4j.PatternLayout（可以灵活地指定布局模式） org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串） org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

log4j打印mybatis执行sql，将占位符换成真实的参数输出

log4j打印mybatis执⾏sql，将占位符换成真实的参数输出背景：在我⽇常码代码的时候，由于对mybatis的动态sql，⽐较依赖，并且有时候需求复杂，导致sql较长，⽽且参数众多，当出现问题是，需要将sql，放到navicat⾥⾯去执⾏查看结果，但是对于复杂的sql来说，众多的参数，⼀个⼀个替换。

当真很⿇烦，于是萌⽣出可不可以将sql直接输出，不在出线sql和参数分开的情况，可以减少很多⿇烦，在我找度娘，⼀次⼜⼀次的尝试，我还是没有发现，在log4j的配置⽂件⾥⾯。

有这个功能，所以最后萌⽣出改写源码的想法，之后我也会尝试继续寻找，有没有官⽅的API提供，本⽂讲述我⾃⼰改写源代码实现的⽅案⼀、针对DEMO搭建SSM项⽬（略）⼆、采⽤的log4j的版本(这⾥由于log的众多实现，有可能出线log4j的冲突，⽽且我也没有滤的特别清楚，所以贴出⾃⼰使⽤的log4j的版本，采⽤maven提供)[html]1. <span style="white-space:pre;"> </span>2. <dependency>3. <groupId>log4j</groupId>4. <artifactId>log4j</artifactId>5. <version>${log4j-version}</version>6. </dependency>三、⾸先实现输出mybatis输出sql1、引⼊jar包（同上）2、配置mybatis输出sql的配置项[html]1. <span style="white-space:pre;"> </span><settings>2. <setting name="logImpl" value="LOG4J" />3. </settings>3、添加logj4j.properties⽂件[plain]1. #logFile2. log4j.rootLogger=DEBUG,Console3. #Console4. log4j.appender.Console=org.apache.log4j.ConsoleAppender5. log4j.appender.console.Threshold=INFO6. log4j.appender.console.ImmediateFlush=true7. log4j.appender.Console.Target=System.out8. yout=org.apache.log4j.PatternLayout9. yout.ConversionPattern=%-5p %d{yyyy-MM-dd HH:mm:ss}[%t] %l: %x%m%n10.11. # ⽇志⽂件(logFile)12. log4j.appender.logFile=org.apache.log4j.FileAppender13. log4j.appender.logFile.Threshold=DEBUG14. # ⽴即输出15. #log4j.appender.logFile.ImmediateFlush=true16. #log4j.appender.logFile.Append=true17. #log4j.appender.logFile.File=D:/logs/log.log4j18. #yout=org.apache.log4j.PatternLayout19. #yout.ConversionPattern=%-5p %d{yyyy-MM-dd HH:mm:ss}[%t] %l: %x%m%n20.21. .apache=ERROR22. .mybatis=ERROR23. .springframework=ERROR24. #这个需要25. log4j.logger.log4jdbc.debug=ERROR26.27. log4j.logger.jdbc.audit=ERROR28. log4j.logger.jdbc.resultset=ERROR29. #这个打印SQL语句⾮常重要30. log4j.logger.jdbc.sqlonly=DEBUG31. log4j.logger.jdbc.sqltiming=ERROR32. log4j.logger.jdbc.connection=FATAL4、测试结果[plain]1. ==> Preparing: select u.id as id , as name , u.pwd as pwd from user u where u.pwd = ? and u.id = ?;2. ==> Parameters: 123(String), 1(String)3. <== Total: 0显然：参数和sql是分离的，现在要实现将参数嵌套进sql中，实现上⾯的想法通过源码的分析最后我决定动（org.apache.ibatis.logging.jdbc.BaseJdbcLogger）这个类，它的作⽤是输出最后的sql ⽅法步骤：1、找到这个类的全路径，找到源码2、在src下创建⼀个同路径下的BaseJdbcLogger类，并且将源码原封不动的贴近刚创建的类，3、找到需要修改的⽅法，我贴⼀下我准备修改的⽅法[java]1. protected void debug(String text, boolean input) {2. if (statementLog.isDebugEnabled()) {3. statementLog.debug(prefix(input) + text);4. }5. }⽬前的这个是BaseJdbcLogger.debug的源码，其中（text:是需要打印的⽂本，input:表⽰前⾯的“==>”的⽅向）经过我的修改：[java]1. /* 打印的sql */2. private static String sql = "";3. protected void debug(String text, boolean input) {4. text = text.trim();5. if (statementLog.isDebugEnabled()) {6. if(text.startsWith("Preparing:")){7. sql = text.substring(text.indexOf(":")+1);8. return ;9. }10. if(text.startsWith("Parameters:")){11. String temp = text.substring(text.indexOf(":")+1);12. String[] split = temp.split(",");13. if(split != null & split.length > 0){14. for (String string2 : split) {15. String s = string2.trim();16. sql = sql.replaceFirst("\\?", s.substring(0, s.indexOf("(")));17. }18. }19. text = "Preparing:"+ sql ;20. sql = "";21. }22. statementLog.debug(prefix(input) + text);23. }24. }最终输出结果：[plain]1. ==> Preparing: select u.id as id , as name , u.pwd as pwd from user u where u.pwd = 123 and u.id = 1;2. <== Total: 0到到最终⽬的（虽然不是最好的⽅法，mybatis应该分装相应的配置，但是我没有发现，如果有码友发现了，请告知我，谢谢）。

springboot+log4j2打印sql日志到日志文件

springboot+log4j2打印sql⽇志到⽇志⽂件框架：springboot + log4j2 ⽇志框架；在yml⽂件指定mapper接⼝包名：不⽤在yml ⽂件下添加：mybatis.configuration = org.apache.ibatis.logging.stdout.StdOutImpl该标签亲测作⽤只是在控制台输⼊sql⽇志，如果想将sql打印到⽇志⽂件中，有了它的存在，只能在控制台打印sql,⽇志⽂件是不会打印的；如图所⽰：log4j2.xml ⽂件 appenders 标签下为添加到 loggers 下：完整的 log4j2.xml 内容如下：<?xml version="1.0" encoding="UTF-8"?><configuration><properties><Property name="app_name">d:gxs-log</Property><Property name="log_path">${app_name}</Property></properties><appenders><console name="Console" target="SYSTEM_OUT"><PatternLayout pattern="[%d][%t][%p][%l] %m%n"/></console><RollingFile name="RollingFileDebug" fileName="${log_path}/debug.log"filePattern="${log_path}/$${date:yyyy-MM}/debug-%d{yyyy-MM-dd}-%i.log.gz"> <Filters><ThresholdFilter level="DEBUG"/><ThresholdFilter level="INFO" onMatch="DENY" onMismatch="NEUTRAL"/></Filters><PatternLayout pattern="[%d][%t][%p][%c:%L] %m%n"/><Policies><TimeBasedTriggeringPolicy interval="1" modulate="true"/><SizeBasedTriggeringPolicy size="2 MB"/></Policies><DefaultRolloverStrategy compressionLevel="0" max="10"/> </RollingFile><RollingFile name="RollingFileInfo" fileName="${log_path}/info.log"filePattern="${log_path}/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log.gz"> <Filters><ThresholdFilter level="INFO"/><ThresholdFilter level="WARN" onMatch="DENY" onMismatch="NEUTRAL"/></Filters><PatternLayout pattern="[%d][%t][%p][%c:%L] %m%n"/><Policies><TimeBasedTriggeringPolicy interval="1" modulate="true"/><SizeBasedTriggeringPolicy size="2 MB"/></Policies><DefaultRolloverStrategy compressionLevel="0" max="10"/> </RollingFile><RollingFile name="RollingFileWarn" fileName="${log_path}/warn.log"filePattern="${log_path}/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log.gz"> <Filters><ThresholdFilter level="WARN"/><ThresholdFilter level="ERROR" onMatch="DENY" onMismatch="NEUTRAL"/></Filters><PatternLayout pattern="[%d][%t][%p][%c:%L] %m%n"/><Policies><TimeBasedTriggeringPolicy interval="1" modulate="true"/><SizeBasedTriggeringPolicy size="2 MB"/></Policies><DefaultRolloverStrategy compressionLevel="0" max="10"/></RollingFile><RollingFile name="RollingFileError" fileName="${log_path}/error.log"filePattern="${log_path}/$${date:yyyy-MM}/error-%d{yyyy-MM-dd}-%i.log.gz"> <ThresholdFilter level="ERROR"/><PatternLayout pattern="[%d][%t][%p][%c:%L] %m%n"/><Policies><TimeBasedTriggeringPolicy interval="1" modulate="true"/><SizeBasedTriggeringPolicy size="2 MB"/></Policies><DefaultRolloverStrategy compressionLevel="0" max="10"/></RollingFile></appenders><loggers><!--若是additivity设为false，则⼦Logger 只会在⾃⼰的appender⾥输出，⽽不会在⽗Logger 的appender⾥输出。

MySQL中的日志开关与级别设置

MySQL中的日志开关与级别设置MySQL是一种常用的关系型数据库管理系统，广泛应用于Web应用程序和其他需要持久化存储数据的软件中。

在MySQL中，日志功能对于系统运维和故障排查非常重要。

本文将介绍MySQL中的日志开关与级别设置，以及各个日志类型的特点和使用场景。

一、日志的重要性日志是数据库系统中记录操作和状态的重要工具。

通过日志，我们可以了解系统的运行情况，追踪故障产生的原因，恢复数据的一致性和完整性。

在MySQL中，主要有以下几种日志类型：1. 错误日志（Error Log）：记录系统运行过程中的错误信息，比如数据库启动失败、死锁、服务器崩溃等。

错误日志对于排查故障和调优非常有帮助。

2. 查询日志（Query Log）：记录所有客户端连接到数据库系统执行的SQL语句和其执行结果。

查询日志可以用于审计、性能分析和调试。

3. 慢查询日志（Slow Query Log）：记录执行时间超过设定阈值的查询语句。

慢查询日志对于发现性能瓶颈和优化查询语句非常有用。

4. 二进制日志（Binary Log）：记录所有更改数据的语句，并以二进制格式存储。

二进制日志可以用于数据恢复、数据库复制和故障恢复。

二、日志的开关与级别设置在MySQL中，可以通过修改配置文件或使用SQL语句来开关和配置各个日志类型。

下面分别介绍各个日志类型的开关和级别设置。

1. 错误日志错误日志默认是开启的，其位置和文件名可以在配置文件中指定。

可以通过以下SQL语句查看当前错误日志的路径：```SHOW VARIABLES LIKE 'log_error';```如果需要关闭错误日志，可以在配置文件中增加或修改以下参数：```log_error = 0```2. 查询日志查询日志默认是关闭的，我们可以通过以下SQL语句开启查询日志：```SET GLOBAL general_log = 1;```开启日志后，可以通过以下SQL语句查看当前查询日志的路径：```SHOW VARIABLES LIKE 'general_log_file';```如果需要关闭查询日志，可以执行以下SQL语句：```SET GLOBAL general_log = 0;3. 慢查询日志慢查询日志默认是关闭的，我们可以通过以下SQL语句开启慢查询日志：```SET GLOBAL slow_query_log = 1;```开启日志后，可以通过以下SQL语句查看当前慢查询日志的路径：```SHOW VARIABLES LIKE 'slow_query_log_file';```如果需要关闭慢查询日志，可以执行以下SQL语句：```SET GLOBAL slow_query_log = 0;```4. 二进制日志二进制日志默认是开启的，其位置和文件名可以在配置文件中指定。

【原】配置Log4j，使得MyBatis打印出SQL语句

【原】配置Log4j，使得MyBatis打印出SQL语句【环境参数】JDK：jdk1.8.0_25IDE：Eclipse Luna Servie Release 1框架：Spring 4.1.5 + SpringMVC 4.1.5 + MyBatis 3.2.2【配置步骤】⼀、设置MyBatis的Setting（⾮必须，不同环境下，可能不需要该设置）。

在“src/main/java/resources”⽬录下，创建mybatis-config.xml⽂件，并且输⼊下列内容。

1<?xml version="1.0" encoding="UTF-8"?>2<!DOCTYPE configuration3 PUBLIC "-////DTD Config 3.0//EN"4 "/dtd/mybatis-3-config.dtd">5<configuration>6<settings>7<setting name="lazyLoadingEnabled" value="false"/>8<setting name="logImpl" value="LOG4J"/>9</settings>10</configuration>⼆、配置log4j的配置⽂件。

不同的项⽬中，log4j的配置⽂件的格式可能不同，在⼀些项⽬中，log4j的配置⽂件是XML格式的，⽐如log4j.xml；在另⼀些项⽬中，log4j 的配置⽂件是properties格式的，⽐如log4j.properties。

备注：properties格式⽂件的配置⼀般只在⽼的项⽬中存在，新的互联⽹类项⽬，⼀般都是XML格式。

log4j详细配置

Log4j详细配置
在项目实施过程中，经常需要根据日志信息进行调试，但是当大家将log4j的调试级别设置成info的时候后台会出现大量的dpp和casp的日志信息，这些是我们调试时不想看到的信息。

其实Log4j提供了细粒度的日志配置，可以将日志级别的设置详细到包和类。

具体的配置方法如下。

在我们AMS的Log4j中加入想要单独输出日志的包或者类如设置casp的单独输出级别：
.ultrapower.casp=fatal,MyTest
.ultrapower.casp=false
log4j.appender.MyTest=org.apache.log4j.RollingFileAppender
log4j.appender.MyTest.File=test.log
log4j.appender.MyTest.MaxFileSize=1000KB
log4j.appender.MyTest.MaxBackupIndex=100
yout=org.apache.log4j.PatternLayout
yout.conversionPattern=%d[%t]%-5p%c-%m<br />%n
其中.ultrapower.casp=fatal,MyTest 是定义的casp包的输出级别，
.ultrapower.casp=false 对输出日志进行控制“false”代表不输出“true”代表输出。

关于Log4j详细的参数信息大家可以参考《log4j详细配置》附件中的log4j.properties，里边对Log4j的配置参数作了详细说明。

Mybatis_09_使用Log4j打印SQL语句

Mybatis_09_使⽤Log4j打印SQL语句使⽤MyBatis执⾏增删改查之后打印SQL语句* 可以借助⼀个第三⽅的开源组件 log4j 。

* logger for java : 为java语⾔准备的⽇志⼯具，专门负责记录⽇志，很多开源框架都使⽤了该组件。

* log4j配置⽅法- 第⼀步在pom.xml⽂件中引⼊log4j依赖<dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version></dependency>- 第⼆步配置log4j的properties⽂件（放在test-->resourse下）log4j.rootLogger=DEBUG,console,FILElog4j.appender.console=org.apache.log4j.ConsoleAppenderlog4j.appender.console.threshold=INFOyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] - %c -%F(%L) -%m%nlog4j.appender.FILE=org.apache.log4j.RollingFileAppenderlog4j.appender.FILE.Append=truelog4j.appender.FILE.File=logs/log4jtest.loglog4j.appender.FILE.Threshold=INFOyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] - %c -%F(%L) -%m%nlog4j.appender.FILE.MaxFileSize=10MB- 第三步配置Mybatis核⼼配置⽂件 Mybatis-config.xml<settings><setting name="mapUnderscoreToCamelCase" value="true"/><setting name="logImpl" value="STDOUT_LOGGING"/></settings>。

解决springmvc整合Mybatis的Log4j日志输出问题

解决springmvc整合Mybatis的Log4j⽇志输出问题springmvc整合Mybatis的Log4j⽇志输出当我们进⾏web开发的时候总是看到配置的log4j⽇志在控制台⽆法显⽰mybatis的主要是指sql、参数、结果，出现这种问题有两种情况：第⼀种情况下⾯⽂档描述的mybatis本⾝内置很多种⽇志框架使⽤，所以如果我们要⽤具体哪个⽇志框架，就需要进⾏相应mybatis配置，或者就是按照mybatis本⾝规则运⾏。

配置⽅式：新增⽂件，有就直接添加mybatis-config.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configurationPUBLIC "-////DTD Config 3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><settings><setting name="logImpl" value="LOG4J"/></settings></configuration>再把这个⽂件添加到：<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="dynamicDataSource" /><property name="configLocation" value="classpath:mybatis-config.xml"></property><property name="mapperLocations" value="classpath*:com/belle/finance/**/**/daomapper/mapper/*Mapper.xml"/></bean>这样就配置好了，使⽤log4j进⾏⽇志记录不会运⾏mybatis⾃⾝规则。

自定义log4j日志级别

⾃定义log4j⽇志级别⾃定义log4j⽇志级别因为项⽬中需要输出⼀些特别的⽇志来做数据统计。

如果开启log4j提供的INFO⽇志级别，每天⽣成的⽇志⽂件就会变得越来越⼤。

这样就得写个定时任务来删除这个⽂件。

为了只输出所需的⽇志级别，唯有⾃⼰定义⼀个log4j的级别，这样⼀来就好控制了，⽽且不需要对之前的代码进⾏修改。

好了，废话不多说，上代码：1、CustomerLog[java]1. package common.log;2.3. import org.apache.log4j.Level;4. import org.apache.log4j.Logger;5. import .SyslogAppender;6.7. public class CustomerLog {8.9. /**10. * 继承Level11. * @author Sevencm12. *13. */14. private static class CustomerLogLevel extends Level{15. public CustomerLogLevel(int level, String levelStr, int syslogEquivalent) {16. super(level, levelStr, syslogEquivalent);17. }18. }19.20. /**21. * ⾃定义级别名称，以及级别范围22. */23. private static final Level CustomerLevel = new CustomerLogLevel(20050,"CUSTOMER",SyslogAppender.LOG_LOCAL0);24.25. /**26. * 使⽤⽇志打印logger中的log⽅法27. *28. * @param logger29. * @param objLogInfo30. */31. public static void customerLog(Logger logger,Object objLogInfo){32. logger.log(CustomerLevel, objLogInfo);33. }34.35.36.37. }2、Log Filter[java]1. package common.log;2.3. import org.apache.log4j.spi.Filter;4. import org.apache.log4j.spi.LoggingEvent;5.6. public class CustomerLogFilter extends Filter {7. boolean acceptOnMatch = false;8. private String levelMin;9. private String levelMax;10.11.12.13.14.15. public String getLevelMin() {16. return levelMin;17. }18.19.20.21. public void setLevelMin(String levelMin) {22. this.levelMin = levelMin;23. }24.25.26.27. public String getLevelMax() {28. return levelMax;29. }30.31.32.33. public void setLevelMax(String levelMax) {34. this.levelMax = levelMax;35. }36.37.38.39. public boolean isAcceptOnMatch() {40. return acceptOnMatch;41. }42.43.44.45. public void setAcceptOnMatch(boolean acceptOnMatch) {46. this.acceptOnMatch = acceptOnMatch;47. }48.49.50. @Override51. public int decide(LoggingEvent lgEvent) {52. int inputLevel = lgEvent.getLevel().toInt();53.54. if(inputLevel>=getLevel(levelMin) && inputLevel <= getLevel(levelMax)){55. return 0;56. }57.58. return -1;59. }60.61. private int getLevel(String level){62. level = level.toUpperCase();63. if(level.equals("CUSTOMER")){64. return LevelType.CUSTOMER.getType();65. }66. if(level.equals("OFF")){67. return LevelType.OFF.getType();68. }69. if(level.equals("FATAL")){70. return LevelType.FATAL.getType();71. }72. if(level.equals("ERROR")){73. return LevelType.ERROR.getType();74. }75. if(level.equals("INFO")){76. return .getType();77. }78. if(level.equals("WARN")){79. return LevelType.WARN.getType();80. }81. if(level.equals("DEBUG")){82. return LevelType.DEBUG.getType();83. }84. if(level.equals("ALL")){85. return LevelType.ALL.getType();86. }87. return LevelType.OFF.getType();88. }89.90. private static enum LevelType{91.92. OFF(2147483647),93.94. FATAL(50000),95.96. ERROR(40000),97.98. WARN(30000),99.100. INFO(20000),101.102. DEBUG(10000),103.104. ALL(-2147483648),105.106. CUSTOMER(20050);107.108. int type;109.110. public int getType() {111. return type;112. }113.114. private LevelType(int type) {115. this.type = type;116. }117. }118.119. }3、配置⽂件的设置：[html]1. <?xml version="1.0" encoding="UTF-8"?>2. <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">3.4. <log4j:configuration xmlns:log4j='/log4j/' >5.6.7. <appender name="Console" class="org.apache.log4j.ConsoleAppender">8. <layout class="org.apache.log4j.PatternLayout">9. <param name="ConversionPattern" value="%d [%p] %c{1} - %m%n" />10. </layout>11. 12. <filter class="common.log.CustomerLogFilter">13. <param name="levelMin" value="info" />14. <param name="levelMax" value="Customer" />15. <param name="AcceptOnMatch" value="true" />16. </filter>17. </appender>18.19. 20. <root>21. <priority value ="INFO"/>22. <appender-ref ref="Console"/>23. </root>24. </log4j:configuration>4、测试类[java]1. package common.test;2.3. import org.apache.log4j.Logger;4.5. import common.log.CustomerLog;6.7. public class Test {8. private static final Logger logger = Logger.getLogger("customer");9.10. public static void main(String[] args) {11. CustomerLog.customerLog(logger, "⾃定义⽇志级别");12. ("哈哈哈哈");13. }14. }5、运⾏结果：2014-05-24 17:22:45,647 [CUSTOMER] customer - ⾃定义⽇志级别2014-05-24 17:22:45,648 [INFO] customer - 哈哈哈哈6、通过修改[html]1. <param name="levelMin" value="info" />上⾯的 Value 值来控制⽇志的输出级别。

Mybatis-第N篇配置log4j1、log4j2打印执行的sql语句

Mybatis-第N篇配置log4j1、log4j2打印执⾏的sql语句1、log4j1配置⽬录结构：conf.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN" "/dtd/mybatis-3-config.dtd"><configuration><settings><!-- 配置⽤于控制台输出sql⽇志。

低版本的mybatis不⽀持logImpl --><setting name="logImpl" value="LOG4J"/></settings><environments default="oracle"><environment id="oracle"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value="oracle.jdbc.OracleDriver"/><property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:orcl"/><property name="username" value="scott"/><property name="password" value="12345"/></dataSource></environment><environment id="mysql"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://127.0.0.1:3306/world"/><property name="username" value="root"/><property name="password" value="12345"/></dataSource></environment></environments><mappers><mapper resource="com/lfy/mapping/empMapper.xml"/></mappers></configuration>log4j.properties#log4j-1#全局⽇志配置log4j.rootLogger=ERROR,stdout#MyBatis⽇志配置.lfy.mapping.empMapper=DEBUG#控制台输出log4j.appender.stdout=org.apache.log4j.ConsoleAppenderyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d [%t] %-5p[%c] - %m%nempMapper.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.lfy.mapping.empMapper"><select id="getEmp" parameterType="int" resultType="com.lfy.bean.Emp">select * from emp where empno=#{empno}</select></mapper>Emp.javapackage com.lfy.bean;import java.util.Date;public class Emp {private Integer empno;private String ename;private String job;private Integer mgr;private Date hireDate;private Integer sal;private Integer comm;private Integer deptno;public Integer getEmpno() {return empno;}public void setEmpno(Integer empno) {this.empno = empno;}public String getEname() {return ename;}public void setEname(String ename) {this.ename = ename;}public String getJob() {return job;}public void setJob(String job) {this.job = job;}public Integer getMgr() {return mgr;}public void setMgr(Integer mgr) {this.mgr = mgr;}public Date getHiredate() {return hireDate;}public void setHiredate(Date hiredate) {hireDate = hiredate;}public Integer getSal() {return sal;}public void setSal(Integer sal) {this.sal = sal;}public Integer getComm() {return comm;}public void setComm(Integer comm) {m = comm;}public Integer getDeptno() {return deptno;}public void setDeptno(Integer deptno) {this.deptno = deptno;}@Overridepublic String toString() {return "User=[empno="+empno+",ename="+ename+",job="+job+",mgr="+mgr+",hiredate="+hireDate+",sal="+sal+",comm="+comm+",deptno="+deptno+"]";}}MybatisTest.javapackage com.lfy.main;import java.io.InputStream;import org.apache.ibatis.session.SqlSession;import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import com.lfy.bean.Emp;/*** 使⽤log4j-1配置⽇志* @author lfy**/public class MybatisTest {public static void main(String[] args) {//mybatis的配置⽂件String resource = "conf.xml";//使⽤类加载器加载mybatis的配置⽂件（它也加载关联的映射⽂件）InputStream is = MybatisTest.class.getClassLoader().getResourceAsStream(resource);//构建sqlSession的⼯⼚SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);//使⽤MyBatis提供的Resources类加载mybatis的配置⽂件（它也加载关联的映射⽂件）//Reader reader = Resources.getResourceAsReader(resource);//构建sqlSession的⼯⼚//SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);//创建能执⾏映射⽂件中sql的sqlSessionSqlSession session = sessionFactory.openSession();/*** 映射sql的标识字符串，* com.lfy.mapping.empMapper是empMapper.xml⽂件中mapper标签的namespace属性的值，* getEmp是select标签的id属性值，通过select标签的id属性值就可以找到要执⾏的SQL*/String statement = "com.lfy.mapping.empMapper.getEmp";//映射sql的标识字符串//执⾏查询返回⼀个唯⼀user对象的sqlEmp emp = session.selectOne(statement, 7839);System.out.println(emp);}}运⾏结果：2、log4j2配置⽬录结构：conf.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN" "/dtd/mybatis-3-config.dtd"> <configuration><settings><!-- 配置⽤于控制台输出sql⽇志。

MyBatis日志

MyBatis ⽇志MyBatis ⽇志这节使⽤新项⽬ MyBatis-04（同 MyBatis-03 ），研究⼀下 MyBatis ⽇志的配置使⽤。

1. ⽇志⼯⼚以前直接使⽤ JDBC 时，如果⼀个数据库操作出现了问题，⼀般只能使⽤ sout 和 debug 来发现问题；现在 MyBatis ⽇志就是最好的帮⼿！要在 MyBatis 中使⽤⽇志，需要在 mybatis-config.xml 中进⾏配置其中，有⼏个⽐较重要的⽇志格式STDOUT_LOGGING ：标准⽇志LOG4J ：即 Java ⽇志（ Log for Java ），下⾯要⽤到的⽇志格式LOG4J2：即 LOG4J 的升级版SLF4J ：即简单⽇志门⾯( Simple Logging Facade for Java )，不是具体的⽇志解决⽅案，它只服务于各种各样的⽇志系统，以后会了解此处先使⽤标准⽇志了解⼀下⽇志的作⽤，在 mybatis-config.xml 中配置<settings><setting name="logImpl" value="STDOUT_LOGGING"/></settings>注意：这⾥的配置要完全遵守格式，⼤⼩写不能错，也不能多加空格，否则会报错！配置完⽇志后再运⾏根据 ID 查询的 Test ⽅法，控制台输出的⽇志内容为// ⽇志初始化加载 StdOutImpl 适配器Logging initialized using 'class org.apache.ibatis.logging.stdout.StdOutImpl' adapter.// ...// 打开 JDBC 连接说明 MyBatis 的本质还是 JDBC 只不过封装起来了Opening JDBC ConnectionLoading class `com.mysql.jdbc.Driver'. // ...// 获取了⼀个连接！Created connection 1263668904.// 设置事务开启Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@4b520ea8]// 执⾏的 SQL 语句看的很清楚！==> Preparing: select * from er where id = ?// 参数==> Parameters: 1(Integer)// 执⾏结果列名⾏总数<== Columns: id, name, pwd<== Row: 1, 祈鸢, 123456<== Total: 1// 测试的输出User{id=1, name='祈鸢', password='123456'}// 关闭事务Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@4b520ea8]// 关闭 JDBC 连接Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@4b520ea8]// 将获取的连接返回到连接池 pool 中！此处可以帮助理解连接池Returned connection 1263668904 to pool.从这⾥例⼦就可以看出⽇志的强⼤了，底裤都看穿了。

log4j常用4个日志级别

log4j常⽤4个⽇志级别
⾸先知道⽇志级别越⾼、打印⽇志越少
ERROR、WARN、INFO、DEBUG
ERROR 指出虽然发⽣错误事件，但仍然不影响系统的继续运⾏。

打印错误和异常信息，如果不想输出太多的⽇志，可以使⽤这个级别WARN 表明会出现潜在错误的情形，有些信息不是错误信息，但是也要给程序员的⼀些提⽰
INFO 消息在粗粒度级别上突出强调应⽤程序的运⾏过程。

打印⼀些你感兴趣的或者重要的信息，这个可以⽤于⽣产环境中输出程序运⾏的⼀些重要信息，但是不能滥⽤，避免打印过多的⽇志。

DEBUG 指出细粒度信息事件对调试应⽤程序是⾮常有帮助的，主要⽤于开发过程中打印⼀些运⾏信息。

级别由低到⾼
OFF、FATAL、ERROR、WARN、INFO、DEBUG、TRACE、 ALL。