log4cplus是C++编写的开源的日志系统

（二）

本文介绍了使用log4cplus有六个步骤，并提供了一些例子引导你了解log4cplus的基本使用。
###基本使用###

使用log4cplus有六个基本步骤：

1.实例化一个appender对象
2.实例化一个layout对象
3.将layout对象绑定(attach)到appender对象
4.实例化一个logger对象,调用静态函数：log4cplus::Logger::getInstance("logger_name")
5.将appender对象绑定(attach)到logger对象，如省略此步骤，标准输出（屏幕）appender对象会绑定到logger
6.设置logger的优先级，如省略此步骤，各种有限级的消息都将被记录

下面通过一些例子来了解log4cplus的基本使用。

〖例1〗

cpp代码/*严格实现步骤1-6，appender输出到屏幕,其中的布局格式和LogLevel后面会详细解释。*/
#include<log4cpluslogger.h=""></log4cplus>
#include<log4cplusconsoleappender.h=""></log4cplus>
#include<log4cpluslayout.h=""></log4cplus>
usingnamespacelog4cplus;
usingnamespacelog4cplus::helpers;
intmain(){
/*step1:Instantiateanappenderobject*/
SharedObjectPtr_append(newConsoleAppender());
_append->setName("appendfortest");
/*step2:Instantiatealayoutobject*/
std::stringpattern="%d{%m/%d/%y%H:%M:%S}-%m[%l]%n";
std::auto_ptr_layout(newPatternLayout(pattern));
/*step3:Attachthelayoutobjecttotheappender*/
_append->setLayout(_layout);
/*step4:Instantiatealoggerobject*/
Logger_logger=Logger::getInstance("test");
/*step5:Attachtheappenderobjecttothelogger*/
_logger.addAppender(_append);
/*step6:Setapriorityforthelogger*/
_logger.setLogLevel(ALL_LOG_LEVEL);
/*logactivity*/
LOG4CPLUS_DEBUG(_logger,"ThisistheFIRSTlogmessage...")
sleep(1);
LOG4CPLUS_WARN(_logger,"ThisistheSECONDlogmessage...")
return0;
}

输出结果：
10/14/0409:06:24-ThisistheFIRSTlogmessage...[main.cpp:31]
10/14/0409:06:25-ThisistheSECONDlogmessage...[main.cpp:33]

〖例2〗
/*
简洁使用模式，appender输出到屏幕。
*/
#include<log4cpluslogger.h=""></log4cplus>
#include<log4cplusconsoleappender.h=""></log4cplus><log4cplus></log4cplus>

usingnamespacelog4cplus;
usingnamespacelog4cplus::helpers;

intmain()
{
/*step1:Instantiateanappenderobject*/
SharedAppenderPtr_append(newConsoleAppender());
_append->setName("appendtest");

/*step4:Instantiatealoggerobject*/
Logger_logger=Logger::getInstance("test");

/*step5:Attachtheappenderobjecttothelogger*/
_logger.addAppender(_append);

/*logactivity*/
LOG4CPLUS_DEBUG(_logger,"ThisistheFIRSTlogmessage...")
sleep(1);
LOG4CPLUS_WARN(_logger,"ThisistheSECONDlogmessage...")

return0;
}

输出结果：
DEBUG-ThisistheFIRSTlogmessage...
WARN-ThisistheSECONDlogmessage...

〖例3〗
/*
iostream模式，appender输出到屏幕。
*/
#include<log4cpluslogger.h=""></log4cplus>
#include<log4cplusconsoleappender.h=""></log4cplus>
#include<iomanip></iomanip>/*其实这个东东还是放到log4cplus头文件中比较合适些，个人意见：）*/usingnamespacelog4cplus;

intmain()
{
/*step1:Instantiateanappenderobject*/
SharedAppenderPtr_append(newConsoleAppender());
_append->setName("appendtest");

/*step4:Instantiatealoggerobject*/
Logger_logger=Logger::getInstance("test");

/*step5:Attachtheappenderobjecttothelogger*/
_logger.addAppender(_append);

/*logactivity*/
LOG4CPLUS_TRACE(_logger,"Thisis"<<"justat"<<"est."<<std::endl)
LOG4CPLUS_DEBUG(_logger,"Thisisabool:"<<true)
LOG4CPLUS_INFO(_logger,"Thisisachar:"<<'x')
LOG4CPLUS_WARN(_logger,"Thisisaint:"<<1000)
LOG4CPLUS_ERROR(_logger,"Thisisalong(hex):"<<std::hex<<100000000)
LOG4CPLUS_FATAL(_logger,"Thisisadouble:"<<std::setprecision(15)<<1.2345234234)

return0;
}

输出结果：
DEBUG-Thisisabool:1
INFO-Thisisachar:x
WARN-Thisisaint:1000
ERROR-Thisisalong(hex):5f5e100
FATAL-Thisisadouble:1.2345234234

〖例4〗
/*
调试模式，通过loglog来控制输出调试、警告或错误信息，appender输出到屏幕。
*/
#include<iostream></iostream>
#include<log4cplusloglog.h=""helpers=""></log4cplus>

usingnamespacelog4cplus::helpers;

voidprintMsgs(void)
{
std::cout<<"EnteringprintMsgs()..."<<std::endl;
LogLog::getLogLog()->debug("ThisisaDebugstatement...");
LogLog::getLogLog()->warn("ThisisaWarning...");
LogLog::getLogLog()->error("ThisisaError...");
std::cout<<"ExitingprintMsgs()..."<<std::endl<<std::endl;
}

intmain()
{
/*
LogLog类实现了debug,warn,error函数用于输出调试、警告或错误信息，
同时提供了两个方法来进一步控制所输出的信息，其中：

setInternalDebugging方法用来控制是否屏蔽输出信息中的调试信息，当输入
参数为false则屏蔽，缺省设置为false。

setQuietMode方法用来控制是否屏蔽所有输出信息，当输入参数为true则屏蔽，
缺省设置为false。

LogLog::getLogLog()->setInternalDebugging(false);
*/

printMsgs();

std::cout<<"Turningondebug..."<<std::endl;
LogLog::getLogLog()->setInternalDebugging(true);
printMsgs();

std::cout<<"Turningonquietmode..."<<std::endl;
LogLog::getLogLog()->setQuietMode(true);
printMsgs();

return0;
}

输出结果：
EnteringprintMsgs()...
log4cplus:WARNThisisaWarning...
log4cplus:ERRORThisisaError...
ExitingprintMsgs()...

Turningondebug...
EnteringprintMsgs()...
log4cplus:ThisisaDebugstatement...
log4cplus:WARNThisisaWarning...
log4cplus:ERRORThisisaError...
ExitingprintMsgs()...

Turningonquietmode...
EnteringprintMsgs()...
ExitingprintMsgs()...

需要指出的是，输出信息中总是包含"log4cplus:"前缀，有时候会感觉不爽，这是因为LogLog在实现时候死定了要这么写：

LogLog::LogLog()
:mutex(LOG4CPLUS_MUTEX_CREATE),
debugEnabled(false),
quietMode(false),
PREFIX(LOG4CPLUS_TEXT("log4cplus:")),
WARN_PREFIX(LOG4CPLUS_TEXT("log4cplus:WARN")),
ERR_PREFIX(LOG4CPLUS_TEXT("log4cplus:ERROR"))
{
}

你可以把这些前缀换成自己看着爽的提示符号，然后重新编译，hihi。除非万不得已或者实在郁闷的不行，否则还是不要这样干。

〖例5〗
/*文件模式，appender输出到文件。*/
#include<log4cplus/logger.h>
#include<log4cplus/fileappender.h>
usingnamespacelog4cplus;
intmain()
{
/*step1:Instantiateanappenderobject*/
SharedAppenderPtr_append(newFileAppender("Test.log"));
_append->setName("filelogtest");
/*step4:Instantiatealoggerobject*/
Logger_logger=Logger::getInstance("test.subtestof_filelog");
/*step5:Attachtheappenderobjecttothelogger*/
_logger.addAppender(_append);
/*logactivity*/
inti;
for(i=0;i<5;++i)
{
LOG4CPLUS_DEBUG(_logger,"Enteringloop#"<<i<<"Endline#")
}
return0;
}

输出结果（Test.log文件）：

DEBUG-Enteringloop#0Endline#
DEBUG-Enteringloop#1Endline#
DEBUG-Enteringloop#2Endline#
DEBUG-Enteringloop#3Endline#
DEBUG-Enteringloop#4Endline#

（三）

本文介绍了三种控制输出格式的布局管理器的概念和使用情况，通过掌握这些知识，可以更有效地控制log系统输出尽可能贴近你需求的信息来。

###如何控制输出消息的格式###

前面已经讲过，log4cplus通过布局器（Layouts）来控制输出的格式，log4cplus提供了三种类型的Layouts，
分别是SimpleLayout、PatternLayout、和TTCCLayout。其中：

1.SimpleLayout
是一种简单格式的布局器，在输出的原始信息之前加上LogLevel和一个"-"。

比如以下代码片段：

......

/*step1:Instantiateanappenderobject*/
SharedObjectPtr_append(newConsoleAppender());
_append->setName("appendfortest");

/*step2:Instantiatealayoutobject*/
std::auto_ptr_layout(newlog4cplus::SimpleLayout());

/*step3:Attachthelayoutobjecttotheappender*/
_append->setLayout(_layout);

/*step4:Instantiatealoggerobject*/
Logger_logger=Logger::getInstance("test");

/*step5:Attachtheappenderobjecttothelogger*/
_logger.addAppender(_append);

/*logactivity*/
LOG4CPLUS_DEBUG(_logger,"Thisisthesimpleformattedlogmessage...")

......

将打印结果：
DEBUG-Thisisthesimpleformattedlogmessage...

2.PatternLayout
是一种有词法分析功能的模式布局器，一提起模式就会想起正则表达式，这里的模式和正则表达式类似，但是
远比后者简单，能够对预定义的标识符（称为conversionspecifiers）进行解析，转换成特定格式输出。以下
代码片段演示了如何使用PatternLayout：

......

/*step1:Instantiateanappenderobject*/
SharedObjectPtr_append(newConsoleAppender());
_append->setName("appendfortest");

/*step2:Instantiatealayoutobject*/
std::stringpattern="%d{%m/%d/%y%H:%M:%S}-%m[%l]%n";
std::auto_ptr_layout(newPatternLayout(pattern));

/*step3:Attachthelayoutobjecttotheappender*/
_append->setLayout(_layout);

/*step4:Instantiatealoggerobject*/
Logger_logger=Logger::getInstance("test_logger.subtest");

/*step5:Attachtheappenderobjecttothelogger*/
_logger.addAppender(_append);

/*logactivity*/
LOG4CPLUS_DEBUG(_logger,"teststr")

......

输出结果：
10/16/0418:51:25-teststr[main.cpp:51]

可以看出通过填写特定格式的模式字符串"pattern"，原始信息被包含到一堆有格式的信息当中了，这就使得
用户可以根据自身需要来定制显示内容。"pattern"可以包含普通字符串和预定义的标识符，其中：

（1）普通字符串，能够被直接显示的信息。
（2）预定义标识符，通过"%"与一个或多个字符共同构成预定义的标识符，能够产生出特定格式信息。

关于预定义标识符，log4cplus文档中提供了详细的格式说明，我每种都试了一下，以上述代码为例，根据不同
的pattern，各种消息格式使用情况列举如下：

（1）"%%"，转义为%,即，std::stringpattern="%%"时输出:"%"
（2）"%c"，输出logger名称，比如std::stringpattern="%c"时输出:"test_logger.subtest"，
也可以控制logger名称的显示层次，比如"%c{1}"时输出"test_logger"，其中数字表示层次。
（3）"%D"，显示本地时间，当std::stringpattern="%D"时输出:"2004-10-1618:55:45"，%d显示标准时间，
所以当std::stringpattern="%d"时输出"2004-10-1610:55:45"（因为我们是东8区，差8个小时啊）。
可以通过%d{...}定义更详细的显示格式，比如%d{%H:%M:%s}表示要显示小时:分钟：秒。大括号中可显示的
预定义标识符如下：

%a--表示礼拜几，英文缩写形式，比如"Fri"
%A--表示礼拜几，比如"Friday"
%b--表示几月份，英文缩写形式，比如"Oct"
%B--表示几月份，"October"
%c--标准的日期＋时间格式，如"SatOct1618:56:192004"
%d--表示今天是这个月的几号(1-31)"16"
%H--表示当前时刻是几时(0-23)，如"18"
%I--表示当前时刻是几时(1-12)，如"6"
%j--表示今天是哪一天(1-366)，如"290"
%m--表示本月是哪一月(1-12)，如"10"
%M--表示当前时刻是哪一分钟(0-59)，如"59"
%p--表示现在是上午还是下午，AMorPM
%q--表示当前时刻中毫秒部分(0-999)，如"237"
%Q--表示当前时刻中带小数的毫秒部分(0-999.999)，如"430.732"
%S--表示当前时刻的多少秒(0-59)，如"32"
%U--表示本周是今年的第几个礼拜，以周日为第一天开始计算(0-53)，如"41"
%w--表示礼拜几，(0-6,礼拜天为0)，如"6"
%W--表示本周是今年的第几个礼拜，以周一为第一天开始计算(0-53)，如"41"
%x--标准的日期格式，如"10/16/04"
%X--标准的时间格式，如"19:02:34"
%y--两位数的年份(0-99)，如"04"
%Y--四位数的年份，如"2004"
%Z--时区名，比如"GMT"

（4）"%F"，输出当前记录器所在的文件名称，比如std::stringpattern="%F"时输出:"main.cpp"
（5）"%L"，输出当前记录器所在的文件行号，比如std::stringpattern="%L"时输出:"51"
（6）"%l"，输出当前记录器所在的文件名称和行号，比如std::stringpattern="%L"时输出:
"main.cpp:51"
（7）"%m"，输出原始信息，比如std::stringpattern="%m"时输出:"teststr"，即上述代码中
LOG4CPLUS_DEBUG的第二个参数，这种实现机制可以确保原始信息被嵌入到带格式的信息中。
（8）"%n"，换行符，没什么好解释的
（9）"%p"，输出LogLevel，比如std::stringpattern="%p"时输出:"DEBUG"
（10）"%t"，输出记录器所在的线程ID，比如std::stringpattern="%t"时输出:"1075298944"
（11）"%x"，嵌套诊断上下文NDC(nesteddiagnosticcontext)输出，从堆栈中弹出上下文信息，NDC可以用对
不同源的log信息（同时地）交叉输出进行区分，关于NDC方面的详细介绍会在下文中提到。
（12）格式对齐，比如std::stringpattern="%-10m"时表示左对齐，宽度是10，此时会输出"teststr"，当
然其它的控制字符也可以相同的方式来使用，比如"%-12d"，"%-5p"等等（刚接触log4cplus文档时还以为
"%-5p"整个字符串代表LogLevel呢，呵呵）。

3.TTCCLayout
是在PatternLayout基础上发展的一种缺省的带格式输出的布局器，其格式由时间，线程ID，Logger和NDC组
成（consistsoftime,thread,Loggerandnesteddiagnosticcontextinformation,hencethename），
因而得名（怎么得名的？Logger里哪里有那个"C"的缩写啊！名字起得真够烂的，想扁人）。提供给那些想显示
典型的信息（一般情况下够用了）又懒得配置pattern的同志们。

TTCCLayout在构造时有机会选择显示本地时间或GMT时间，缺省是按照本地时间显示：
TTCCLayout::TTCCLayout(booluse_gmtime=false)

以下代码片段演示了如何使用TTCCLayout：

......

/*step1:Instantiateanappenderobject*/
SharedObjectPtr_append(newConsoleAppender());
_append->setName("appendfortest");

/*step2:Instantiatealayoutobject*/
std::auto_ptr_layout(newTTCCLayout());

/*step3:Attachthelayoutobjecttotheappender*/
_append->setLayout(_layout);

/*step4:Instantiatealoggerobject*/
Logger_logger=Logger::getInstance("test_logger");

/*step5:Attachtheappenderobjecttothelogger*/
_logger.addAppender(_append);

/*logactivity*/
LOG4CPLUS_DEBUG(_logger,"teststr")

......

输出结果：
10-16-0419:08:27,501[1075298944]DEBUGtest_logger<>-teststr

当构造TTCCLayout对象时选择GMT时间格式时：

......

/*step2:Instantiatealayoutobject*/
std::auto_ptr_layout(newTTCCLayout(true));

......

输出结果：
10-16-0411:12:47,678[1075298944]DEBUGtest_logger<>-teststr

本文介绍了控制log信息格式的相关知识，下一部分将详细介绍log信息的几种文件操作方式。

（四）

将log信息记录到文件应该说是日志系统的一个基本功能，log4cplus在此基础上，提供了更多的功能，可以按照你预先设定的大小来决定是否转储，当超过该大小，后续log信息会另存到新文件中，依次类推；或者按照日期来决定是否转储。本文将详细介绍这些用法。
###如何将log记录到文件###

我们在例5中给出了一个将log记录到文件的例子，用的是FileAppender类实现的，log4cplus提供了三个类用于
文件操作，它们是FileAppender类、RollingFileAppender类、DailyRollingFileAppender类。

1.FileAppender类

实现了基本的文件操作功能，构造函数如下：

FileAppender(constlog4cplus::tstring&filename,
LOG4CPLUS_OPEN_MODE_TYPEmode=LOG4CPLUS_FSTREAM_NAMESPACE::ios::trunc,
boolimmediateFlush=true);

filename:文件名
mode:文件类型，可选择的文件类型包括app、ate、binary、in、out、trunc，因为实际上只是对
stl的一个简单包装，呵呵，这里就不多讲了。缺省是trunc，表示将先前文件删除。
immediateFlush：缓冲刷新标志，如果为true表示每向文件写一条记录就刷新一次缓存，否则直到FileAppender
被关闭或文件缓存已满才更新文件，一般是要设置true的，比如你往文件写的过程中出现
了错误（如程序非正常退出），即使文件没有正常关闭也可以保证程序终止时刻之前的所有
记录都会被正常保存。

FileAppender类的使用情况请参考例5，这里不再赘述。

2.RollingFileAppender类

构造函数如下：
log4cplus::RollingFileAppender::RollingFileAppender(constlog4cplus::tstring&filename,
longmaxFileSize,
intmaxBackupIndex,
boolimmediateFlush)

filename:文件名
maxFileSize:文件的最大尺寸
maxBackupIndex:最大记录文件数
immediateFlush:缓冲刷新标志

RollingFileAppender类可以根据你预先设定的大小来决定是否转储，当超过该大小，后续log信息会另存到新
文件中，除了定义每个记录文件的大小之外，你还要确定在RollingFileAppender类对象构造时最多需要多少个
这样的记录文件(maxBackupIndex+1)，当存储的文件数目超过maxBackupIndex+1时，会删除最早生成的文件，
保证整个文件数目等于maxBackupIndex+1。然后继续记录，比如以下代码片段：

......

#defineLOOP_COUNT200000

SharedAppenderPtr_append(newRollingFileAppender("Test.log",5*1024,5));
_append->setName("filetest");
_append->setLayout(std::auto_ptr<layout></layout>(newTTCCLayout()));
Logger::getRoot().addAppender(_append);

Loggerroot=Logger::getRoot();
Loggertest=Logger::getInstance("test");
LoggersubTest=Logger::getInstance("test.subtest");

for(inti=0;i{
NDCContextCreator_context("loop");
LOG4CPLUS_DEBUG(subTest,"Enteringloop#"<<i)
}

......

运行结果：

运行后会产生6个输出文件，Test.log、Test.log.1、Test.log.2、Test.log.3、Test.log.4、Test.log.5
其中Test.log存放着最新写入的信息，而最后一个文件中并不包含第一个写入信息，说明已经被不断更新了。
需要指出的是，这里除了Test.log之外，每个文件的大小都是200K,而不是我们想像中的5K，这是因为
log4cplus中隐含定义了文件的最小尺寸是200K，只有大于200K的设置才生效，<=200k的设置都会被认为是
200K.

3.DailyRollingFileAppender类

构造函数如下：
DailyRollingFileAppender::DailyRollingFileAppender(constlog4cplus::tstring&filename,
DailyRollingFileScheduleschedule,
boolimmediateFlush,
intmaxBackupIndex)

filename:文件名
schedule:存储频度
immediateFlush:缓冲刷新标志
maxBackupIndex:最大记录文件数

DailyRollingFileAppender类可以根据你预先设定的频度来决定是否转储，当超过该频度，后续log信息会另存
到新文件中，这里的频度包括：MONTHLY（每月）、WEEKLY（每周）、DAILY（每日）、TWICE_DAILY（每两天）、
HOURLY（每时）、MINUTELY（每分）。maxBackupIndex的含义同上所述，比如以下代码片段：

......

SharedAppenderPtr_append(newDailyRollingFileAppender("Test.log",MINUTELY,true,5));
_append->setName("filetest");
_append->setLayout(std::auto_ptr<layout></layout>(newTTCCLayout()));
Logger::getRoot().addAppender(_append);

Loggerroot=Logger::getRoot();
Loggertest=Logger::getInstance("test");
LoggersubTest=Logger::getInstance("test.subtest");

for(inti=0;i{
NDCContextCreator_context("loop");
LOG4CPLUS_DEBUG(subTest,"Enteringloop#"<<i)
}

......

运行结果：

运行后会以分钟为单位，分别生成名为Test.log.2004-10-17-03-03、Test.log.2004-10-17-03-04和
Test.log.2004-10-17-03-05这样的文件。

需要指出的是，刚看到按照频度（如HOURLY、MINUTELY）转储这样的概念，以为log4cplus提供了内部定时器，
感觉很奇怪，因为日志系统不应该主动记录，而loging事件总是应该被动触发的啊。仔细看了源代码后才知道
这里的"频度"并不是你写入文件的速度，其实是否转储的标准并不依赖你写入文件的速度，而是依赖于写入
的那一时刻是否满足了频度条件，即是否超过了以分钟、小时、周、月为单位的时间刻度，如果超过了就另存。

本部分详细介绍log信息的几种文件操作方式，下面将重点介绍一下如何有选择地控制log信息的输出。

（五）

日志系统的另一个基本功能就是能够让使用者按照自己的意愿来控制什么时候，哪些log信息可以输出。
如果能够让用户在任意时刻设置允许输出的LogLevel的信息就好了，log4cplus通过LogLevelManager、
LogLog、Filter三种方式实现了上述功能。

###优先级控制###

在研究LogLevelManager之前，首先介绍一下log4cplus中logger的存储机制，在log4cplus中，所有
logger都通过一个层次化的结构（其实内部是hash表）来组织的，有一个Root级别的logger,可以通
过以下方法获取：

Loggerroot=Logger::getRoot();

用户定义的logger都有一个名字与之对应，比如：

Loggertest=Logger::getInstance("test");

可以定义该logger的子logger:

LoggersubTest=Logger::getInstance("test.subtest");

注意Root级别的logger只有通过getRoot方法获取，Logger::getInstance("root")获得的是它的
子对象而已。有了这些具有父子关系的logger之后可分别设置其LogLevel,比如：

root.setLogLevel(...);
Test.setLogLevel(...);
subTest.setLogLevel(...);

logger的这种父子关联性会体现在优先级控制方面，log4cplus将输出的log信息按照LogLevel
（从低到高）分为：

NOT_SET_LOG_LEVEL(-1)：接受缺省的LogLevel，如果有父logger则继承它的LogLevel
ALL_LOG_LEVEL(0)：开放所有log信息输出
TRACE_LOG_LEVEL(0)：开放trace信息输出(即ALL_LOG_LEVEL)
DEBUG_LOG_LEVEL(10000)：开放debug信息输出
INFO_LOG_LEVEL(20000)：开放info信息输出
WARN_LOG_LEVEL(30000)：开放warning信息输出
ERROR_LOG_LEVEL(40000)：开放error信息输出
FATAL_LOG_LEVEL(50000)：开放fatal信息输出
OFF_LOG_LEVEL(60000)：关闭所有log信息输出

LogLevelManager负责设置logger的优先级，各个logger可以通过setLogLevel设置自己的优先级，
当某个logger的LogLevel设置成NOT_SET_LOG_LEVEL时，该logger会继承父logger的优先级，另外，
如果定义了重名的多个logger,对其中任何一个的修改都会同时改变其它logger,我们举例说明：

〖例6〗

#include"log4cplus/logger.h"
#include"log4cplus/consoleappender.h"
#include"log4cplus/loglevel.h"
#include<iostream></iostream><iostream></iostream>

usingnamespacestd;
usingnamespacelog4cplus;

intmain()
{
SharedAppenderPtr_append(newConsoleAppender());
_append->setName("test");
Logger::getRoot().addAppender(_append);
Loggerroot=Logger::getRoot();

Loggertest=Logger::getInstance("test");
LoggersubTest=Logger::getInstance("test.subtest");
LogLevelManager&llm=getLogLevelManager();

cout<<endl<<"BeforeSetting,DefaultLogLevel"<<endl;
LOG4CPLUS_FATAL(root,"root:"<<llm.toString(root.getChainedLogLevel()))
LOG4CPLUS_FATAL(root,"test:"<<llm.toString(test.getChainedLogLevel()))
LOG4CPLUS_FATAL(root,"test.subtest:"<<llm.toString(subTest.getChainedLogLevel()))

cout<<endl<<"Settingtest.subtesttoWARN"<<endl;
subTest.setLogLevel(WARN_LOG_LEVEL);
LOG4CPLUS_FATAL(root,"root:"<<llm.toString(root.getChainedLogLevel()))
LOG4CPLUS_FATAL(root,"test:"<<llm.toString(test.getChainedLogLevel()))
LOG4CPLUS_FATAL(root,"test.subtest:"<<llm.toString(subTest.getChainedLogLevel()))

cout<<endl<<"Settingtest.subtesttoTRACE"<<endl;
test.setLogLevel(TRACE_LOG_LEVEL);
LOG4CPLUS_FATAL(root,"root:"<<llm.toString(root.getChainedLogLevel()))
LOG4CPLUS_FATAL(root,"test:"<<llm.toString(test.getChainedLogLevel()))
LOG4CPLUS_FATAL(root,"test.subtest:"<<llm.toString(subTest.getChainedLogLevel()))

cout<<endl<<"Settingtest.subtesttoNO_LEVEL"<<endl;
subTest.setLogLevel(NOT_SET_LOG_LEVEL);
LOG4CPLUS_FATAL(root,"root:"<<llm.toString(root.getChainedLogLevel()))
LOG4CPLUS_FATAL(root,"test:"<<llm.toString(test.getChainedLogLevel()))
LOG4CPLUS_FATAL(root,"test.subtest:"<<llm.toString(subTest.getChainedLogLevel())<<'\n')

cout<<"createaloggertest_bak,named\"test_\",too."<<endl;
Loggertest_bak=Logger::getInstance("test");
cout<<"SettingtesttoINFO,sotest_bakalsobesettoINFO"<<endl;
test.setLogLevel(INFO_LOG_LEVEL);
LOG4CPLUS_FATAL(root,"test:"<<llm.toString(test.getChainedLogLevel()))
LOG4CPLUS_FATAL(root,"test_bak:"<<llm.toString(test_bak.getChainedLogLevel()))

return0;
}

输出结果：

BeforeSetting,DefaultLogLevel
FATAL-root:DEBUG
FATAL-test:DEBUG
FATAL-test.subtest:DEBUG

Settingtest.subtesttoWARN
FATAL-root:DEBUG
FATAL-test:DEBUG
FATAL-test.subtest:WARN

Settingtest.subtesttoTRACE
FATAL-root:DEBUG
FATAL-test:TRACE
FATAL-test.subtest:WARN

Settingtest.subtesttoNO_LEVEL
FATAL-root:DEBUG
FATAL-test:TRACE
FATAL-test.subtest:TRACE

createaloggertest_bak,named"test_",too.
SettingtesttoINFO,sotest_bakalsobesettoINFO
FATAL-test:INFO
FATAL-test_bak:INFO

下面的例子演示了如何通过设置LogLevel来控制用户的log信息输出：

〖例7〗

#include"log4cplus/logger.h"
#include"log4cplus/consoleappender.h"
#include"log4cplus/loglevel.h"
#include<iostream></iostream><iostream></iostream>

usingnamespacestd;
usingnamespacelog4cplus;

voidShowMsg(void)
{
LOG4CPLUS_TRACE(Logger::getRoot(),"info")
LOG4CPLUS_DEBUG(Logger::getRoot(),"info")
LOG4CPLUS_INFO(Logger::getRoot(),"info")
LOG4CPLUS_WARN(Logger::getRoot(),"info")
LOG4CPLUS_ERROR(Logger::getRoot(),"info")
LOG4CPLUS_FATAL(Logger::getRoot(),"info")
}

intmain()
{
SharedAppenderPtr_append(newConsoleAppender());
_append->setName("test");
_append->setLayout(std::auto_ptr<layout></layout>(newTTCCLayout()));
Loggerroot=Logger::getRoot();
root.addAppender(_append);

cout<<endl<<"all-logallowed"<<endl;
root.setLogLevel(ALL_LOG_LEVEL);
ShowMsg();

cout<<endl<<"trace-logandaboveallowed"<<endl;
root.setLogLevel(TRACE_LOG_LEVEL);
ShowMsg();

cout<<endl<<"debug-logandaboveallowed"<<endl;
root.setLogLevel(DEBUG_LOG_LEVEL);
ShowMsg();

cout<<endl<<"info-logandaboveallowed"<<endl;
root.setLogLevel(INFO_LOG_LEVEL);
ShowMsg();

cout<<endl<<"warn-logandaboveallowed"<<endl;
root.setLogLevel(WARN_LOG_LEVEL);
ShowMsg();

cout<<endl<<"error-logandaboveallowed"<<endl;
root.setLogLevel(ERROR_LOG_LEVEL);
ShowMsg();

cout<<endl<<"fatal-logandaboveallowed"<<endl;
root.setLogLevel(FATAL_LOG_LEVEL);
ShowMsg();

cout<<endl<<"logdisabled"<<endl;
root.setLogLevel(OFF_LOG_LEVEL);
ShowMsg();

return0;
}

输出结果：

all-logallowed
10-17-0410:11:40,587[1075298944]TRACEroot<>-info
10-17-0410:11:40,590[1075298944]DEBUGroot<>-info
10-17-0410:11:40,591[1075298944]INFOroot<>-info
10-17-0410:11:40,591[1075298944]WARNroot<>-info
10-17-0410:11:40,592[1075298944]ERRORroot<>-info
10-17-0410:11:40,592[1075298944]FATALroot<>-info

trace-logandaboveallowed
10-17-0410:11:40,593[1075298944]TRACEroot<>-info
10-17-0410:11:40,593[1075298944]DEBUGroot<>-info
10-17-0410:11:40,594[1075298944]INFOroot<>-info
10-17-0410:11:40,594[1075298944]WARNroot<>-info
10-17-0410:11:40,594[1075298944]ERRORroot<>-info
10-17-0410:11:40,594[1075298944]FATALroot<>-info

debug-logandaboveallowed
10-17-0410:11:40,595[1075298944]DEBUGroot<>-info
10-17-0410:11:40,595[1075298944]INFOroot<>-info
10-17-0410:11:40,596[1075298944]WARNroot<>-info
10-17-0410:11:40,596[1075298944]ERRORroot<>-info
10-17-0410:11:40,596[1075298944]FATALroot<>-info

info-logandaboveallowed
10-17-0410:11:40,597[1075298944]INFOroot<>-info
10-17-0410:11:40,597[1075298944]WARNroot<>-info
10-17-0410:11:40,597[1075298944]ERRORroot<>-info
10-17-0410:11:40,598[1075298944]FATALroot<>-info

warn-logandaboveallowed
10-17-0410:11:40,598[1075298944]WARNroot<>-info
10-17-0410:11:40,598[1075298944]ERRORroot<>-info
10-17-0410:11:40,599[1075298944]FATALroot<>-info

error-logandaboveallowed
10-17-0410:11:40,599[1075298944]ERRORroot<>-info
10-17-0410:11:40,600[1075298944]FATALroot<>-info

fatal-logandaboveallowed
10-17-0410:11:40,600[1075298944]FATALroot<>-info

logdisabled

用户也可以自行定义LogLevel，操作比较简单，首先要定义LEVEL值，比如HELLO_LOG_LEVEL定义如下：

/*DEBUG_LOG_LEVEL<HELLO_LOG_LEVEL<INFO_LOG_LEVEL*/
constLogLevelHELLO_LOG_LEVEL=15000;

然后定义以下宏即可：

/*defineMACROLOG4CPLUS_HELLO*/
#defineLOG4CPLUS_HELLO(logger,logEvent)\
if(logger.isEnabledFor(HELLO_LOG_LEVEL)){\
log4cplus::tostringstream_log4cplus_buf;\
_log4cplus_buf<<logEvent;\
logger.forcedLog(HELLO_LOG_LEVEL,_log4cplus_buf.str(),__FILE__,__LINE__);\
}

不过log4cplus没有提供给用户一个接口来实现LEVEL值与字符串的转换，所以当带格式输出LogLevel字符
串时候会显示"UNKNOWN"，不够理想。比如用TTCCLayout控制输出的结果可能会如下所示：

10-17-0411:17:51,124[1075298944]UNKNOWNroot<>-info

而不是期望的以下结果：
10-17-0411:17:51,124[1075298944]HELLOroot<>-info

要想实现第二种结果，按照log4cplus现有的接口机制，只能改其源代码后重新编译，方法是在loglevel.cxx
中加入：

#define_HELLO_STRINGLOG4CPLUS_TEXT("HELLO")

然后修改log4cplus::tstringdefaultLogLevelToStringMethod(LogLevelll)函数，增加一个判断：

caseHELLO_LOG_LEVEL:return_HELLO_STRING;

重新编译log4cplus源代码后生成库文件，再使用时即可实现满意效果。

###调试模式###

即通过loglog来控制输出调试、警告或错误信息，见例4，这里不再赘述。

###基于脚本配置来过滤log信息###

除了通过程序实现对log环境的配置之外，log4cplus通过PropertyConfigurator类实现了基于脚本配置的功能。
通过脚本可以完成对logger、appender和layout的配置，因此可以解决怎样输出，输出到哪里的问题，我将在
全文的最后一部分中提到多线程环境中如何利用脚本配置来配合实现性能测试，本节将重点介绍基脚本实现过
滤log信息的功能。

首先简单介绍一下脚本的语法规则：

包括Appender的配置语法和logger的配置语法，其中：

1.Appender的配置语法:

（1）设置名称：

/*设置方法*/
log4cplus.appender.appenderName=fully.qualified.name.of.appender.class

例如（列举了所有可能的Appender，其中SocketAppender后面会讲到）：
log4cplus.appender.append_1=log4cplus::ConsoleAppender
log4cplus.appender.append_2=log4cplus::FileAppender
log4cplus.appender.append_3=log4cplus::RollingFileAppender
log4cplus.appender.append_4=log4cplus::DailyRollingFileAppender
log4cplus.appender.append_4=log4cplus::SocketAppender

（2）设置Filter：

包括选择过滤器和设置过滤条件，可选择的过滤器包括：LogLevelMatchFilter、LogLevelRangeFilter、
和StringMatchFilter：

对LogLevelMatchFilter来说，过滤条件包括LogLevelToMatch和AcceptOnMatch（true|false），只有
当log信息的LogLevel值与LogLevelToMatch相同，且AcceptOnMatch为true时才会匹配。

LogLevelRangeFilter来说，过滤条件包括LogLevelMin、LogLevelMax和AcceptOnMatch，只有当log信息
的LogLevel在LogLevelMin、LogLevelMax之间同时AcceptOnMatch为true时才会匹配。

对StringMatchFilter来说，过滤条件包括StringToMatch和AcceptOnMatch，只有当log信息的LogLevel值
与StringToMatch对应的LogLevel值与相同，且AcceptOnMatch为true时会匹配。

过滤条件处理机制类似于IPTABLE的Responsibilitychain，（即先deny、再allow）不过执行顺序刚好相反，
后写的条件会被先执行，比如：

log4cplus.appender.append_1.filters.1=log4cplus::spi::LogLevelMatchFilter
log4cplus.appender.append_1.filters.1.LogLevelToMatch=TRACE
log4cplus.appender.append_1.filters.1.AcceptOnMatch=true
#log4cplus.appender.append_1.filters.2=log4cplus::spi::DenyAllFilter

会首先执行filters.2的过滤条件，关闭所有过滤器，然后执行filters.1，仅匹配TRACE信息。

（3）设置Layout

可以选择不设置、TTCCLayout、或PatternLayout

如果不设置，会输出简单格式的log信息。

设置TTCCLayout如下所示：
log4cplus.appender.ALL_MSGS.layout=log4cplus::TTCCLayout

设置PatternLayout如下所示：
log4cplus.appender.append_1.layout=log4cplus::PatternLayout
log4cplus.appender.append_1.layout.ConversionPattern=%d{%m/%d/%y%H:%M:%S,%Q}[%t]%-5p-%m%n

2.logger的配置语法

包括rootLogger和non-rootlogger。

对于rootLogger来说：
log4cplus.rootLogger=[LogLevel],appenderName,appenderName,...

对于non-rootlogger来说：
log4cplus.logger.logger_name=[LogLevel|INHERITED],appenderName,appenderName,...

脚本方式使用起来非常简单，只要首先加载配置即可（urconfig.properties是自行定义的配置文件）：

PropertyConfigurator::doConfigure("urconfig.properties");

下面我们通过例子体会一下log4cplus强大的基于脚本过滤log信息的功能。

〖例8〗

/*
*urconfig.properties
*/
log4cplus.rootLogger=TRACE,ALL_MSGS,TRACE_MSGS,DEBUG_INFO_MSGS,FATAL_MSGS

log4cplus.appender.ALL_MSGS=log4cplus::RollingFileAppender
log4cplus.appender.ALL_MSGS.File=all_msgs.log
log4cplus.appender.ALL_MSGS.layout=log4cplus::TTCCLayout

log4cplus.appender.TRACE_MSGS=log4cplus::RollingFileAppender
log4cplus.appender.TRACE_MSGS.File=trace_msgs.log
log4cplus.appender.TRACE_MSGS.layout=log4cplus::TTCCLayout
log4cplus.appender.TRACE_MSGS.filters.1=log4cplus::spi::LogLevelMatchFilter
log4cplus.appender.TRACE_MSGS.filters.1.LogLevelToMatch=TRACE
log4cplus.appender.TRACE_MSGS.filters.1.AcceptOnMatch=true
log4cplus.appender.TRACE_MSGS.filters.2=log4cplus::spi::DenyAllFilter

log4cplus.appender.DEBUG_INFO_MSGS=log4cplus::RollingFileAppender
log4cplus.appender.DEBUG_INFO_MSGS.File=debug_info_msgs.log
log4cplus.appender.DEBUG_INFO_MSGS.layout=log4cplus::TTCCLayout
log4cplus.appender.DEBUG_INFO_MSGS.filters.1=log4cplus::spi::LogLevelRangeFilter
log4cplus.appender.DEBUG_INFO_MSGS.filters.1.LogLevelMin=DEBUG
log4cplus.appender.DEBUG_INFO_MSGS.filters.1.LogLevelMax=INFO
log4cplus.appender.DEBUG_INFO_MSGS.filters.1.AcceptOnMatch=true
log4cplus.appender.DEBUG_INFO_MSGS.filters.2=log4cplus::spi::DenyAllFilter

log4cplus.appender.FATAL_MSGS=log4cplus::RollingFileAppender
log4cplus.appender.FATAL_MSGS.File=fatal_msgs.log
log4cplus.appender.FATAL_MSGS.layout=log4cplus::TTCCLayout
log4cplus.appender.FATAL_MSGS.filters.1=log4cplus::spi::StringMatchFilter
log4cplus.appender.FATAL_MSGS.filters.1.StringToMatch=FATAL
log4cplus.appender.FATAL_MSGS.filters.1.AcceptOnMatch=true
log4cplus.appender.FATAL_MSGS.filters.2=log4cplus::spi::DenyAllFilter

/*
*main.cpp
*/
#include<log4cpluslogger.h=""></log4cplus>
#include<log4cplusconfigurator.h=""></log4cplus>
#include<log4cplushelpers=""stringhelper.h=""></log4cplus><log4cplus></log4cplus>

usingnamespacelog4cplus;

staticLoggerlogger=Logger::getInstance("log");

voidprintDebug()
{
LOG4CPLUS_TRACE_METHOD(logger,"::printDebug()");
LOG4CPLUS_DEBUG(logger,"ThisisaDEBUGmessage");
LOG4CPLUS_INFO(logger,"ThisisaINFOmessage");
LOG4CPLUS_WARN(logger,"ThisisaWARNmessage");
LOG4CPLUS_ERROR(logger,"ThisisaERRORmessage");
LOG4CPLUS_FATAL(logger,"ThisisaFATALmessage");
}
intmain()
{
Loggerroot=Logger::getRoot();
PropertyConfigurator::doConfigure("urconfig.properties");
printDebug();

return0;
}

运行结果：

1.all_msgs.log
10-17-0414:55:25,858[1075298944]TRACElog<>-ENTER:::printDebug()
10-17-0414:55:25,871[1075298944]DEBUGlog<>-ThisisaDEBUGmessage
10-17-0414:55:25,873[1075298944]INFOlog<>-ThisisaINFOmessage
10-17-0414:55:25,873[1075298944]WARNlog<>-ThisisaWARNmessage
10-17-0414:55:25,874[1075298944]ERRORlog<>-ThisisaERRORmessage
10-17-0414:55:25,874[1075298944]FATALlog<>-ThisisaFATALmessage
10-17-0414:55:25,875[1075298944]TRACElog<>-EXIT:::printDebug()

2.trace_msgs.log
10-17-0414:55:25,858[1075298944]TRACElog<>-ENTER:::printDebug()
10-17-0414:55:25,875[1075298944]TRACElog<>-EXIT:::printDebug()

3.debug_info_msgs.log
10-17-0414:55:25,871[1075298944]DEBUGlog<>-ThisisaDEBUGmessage
10-17-0414:55:25,873[1075298944]INFOlog<>-ThisisaINFOmessage

4.fatal_msgs.log
10-17-0414:55:25,874[1075298944]FATALlog<>-ThisisaFATALmessage

本部分详细介绍了如何有选择地控制log信息的输出，最后一部分我们将介绍一下多线程、
和C/S模式下该如何操作，顺便提一下NDC的概念。